packcr 0.0.4 → 0.0.7

data/lib/packcr/templates/context/source.c.erb

@@ -0,0 +1,1069 @@
+/* A packrat parser generated by PackCR <%= Packcr::VERSION %> */
+
+<%- code(:esource).each do |code| -%>
+<%=   stream.get_code_block(code, 0, @iname) -%>
+<%- end -%>
+<%- if !code(:esource).empty? -%>
+
+<%- end -%>
+#ifdef _MSC_VER
+#undef _CRT_SECURE_NO_WARNINGS
+#define _CRT_SECURE_NO_WARNINGS
+#endif /* _MSC_VER */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef _MSC_VER
+#if defined __GNUC__ && defined _WIN32 /* MinGW */
+#ifndef PCC_USE_SYSTEM_STRNLEN
+#define strnlen(str, maxlen) pcc_strnlen(str, maxlen)
+static size_t pcc_strnlen(const char *str, size_t maxlen) {
+    size_t i;
+    for (i = 0; i < maxlen && str[i]; i++);
+    return i;
+}
+#endif /* !PCC_USE_SYSTEM_STRNLEN */
+#endif /* defined __GNUC__ && defined _WIN32 */
+#endif /* !_MSC_VER */
+
+#include "<%= @hname %>"
+<%- if !code(:location).empty? -%>
+
+<%-   code(:location).each do |code| -%>
+<%=     stream.get_code_block(code, 4, @iname) -%>
+<%-   end -%>
+<%- end -%>
+
+<%- code(:source).each do |code| -%>
+<%=   stream.get_code_block(code, 0, @iname) -%>
+<%- end -%>
+#if !defined __has_attribute || defined _MSC_VER
+#define __attribute__(x)
+#endif
+
+#ifdef _MSC_VER
+#define MARK_FUNC_AS_USED __pragma(warning(suppress:4505))
+#else
+#define MARK_FUNC_AS_USED __attribute__((__unused__))
+#endif
+
+#ifndef PCC_BUFFER_MIN_SIZE
+#define PCC_BUFFER_MIN_SIZE 256
+#endif /* !PCC_BUFFER_MIN_SIZE */
+
+#ifndef PCC_ARRAY_MIN_SIZE
+#define PCC_ARRAY_MIN_SIZE 2
+#endif /* !PCC_ARRAY_MIN_SIZE */
+
+#ifndef PCC_POOL_MIN_SIZE
+#define PCC_POOL_MIN_SIZE 65536
+#endif /* !PCC_POOL_MIN_SIZE */
+
+#define PCC_DBG_EVALUATE 0
+#define PCC_DBG_MATCH    1
+#define PCC_DBG_NOMATCH  2
+
+#define PCC_VOID_VALUE (~(size_t)0)
+
+typedef enum pcc_bool_tag {
+    PCC_FALSE = 0,
+    PCC_TRUE
+} pcc_bool_t;
+
+typedef struct pcc_char_array_tag {
+    char *buf;
+    size_t max;
+    size_t len;
+} pcc_char_array_t;
+
+typedef struct pcc_range_tag {
+    size_t start;
+    size_t end;
+<%- if @location -%>
+    pcc_location_t start_loc;
+    pcc_location_t end_loc;
+<%- end -%>
+} pcc_range_t;
+
+typedef <%= value_def %>pcc_value_t;
+
+typedef <%= auxil_def %>pcc_auxil_t;
+
+<% if prefix != "pcc" -%>
+typedef <%= prefix%>_context_t pcc_context_t;
+
+<% end -%>
+typedef struct pcc_value_table_tag {
+    pcc_value_t *buf;
+    size_t max;
+    size_t len;
+} pcc_value_table_t;
+
+typedef struct pcc_value_refer_table_tag {
+    pcc_value_t **buf;
+    size_t max;
+    size_t len;
+} pcc_value_refer_table_t;
+
+typedef struct pcc_capture_tag {
+    pcc_range_t range;
+    char *string; /* mutable */
+} pcc_capture_t;
+
+typedef struct pcc_capture_table_tag {
+    pcc_capture_t *buf;
+    size_t max;
+    size_t len;
+} pcc_capture_table_t;
+
+typedef struct pcc_capture_const_table_tag {
+    const pcc_capture_t **buf;
+    size_t max;
+    size_t len;
+} pcc_capture_const_table_t;
+
+typedef struct pcc_thunk_tag pcc_thunk_t;
+typedef struct pcc_thunk_array_tag pcc_thunk_array_t;
+
+typedef void (*pcc_action_t)(pcc_context_t *, pcc_thunk_t *, pcc_value_t *);
+
+typedef enum pcc_thunk_type_tag {
+    PCC_THUNK_LEAF,
+    PCC_THUNK_NODE
+} pcc_thunk_type_t;
+
+typedef struct pcc_thunk_leaf_tag {
+    pcc_value_refer_table_t values;
+    pcc_capture_const_table_t capts;
+    pcc_capture_t capt0;
+    pcc_action_t action;
+} pcc_thunk_leaf_t;
+
+typedef struct pcc_thunk_node_tag {
+    const pcc_thunk_array_t *thunks; /* just a reference */
+    pcc_value_t *value; /* just a reference */
+} pcc_thunk_node_t;
+
+typedef union pcc_thunk_data_tag {
+    pcc_thunk_leaf_t leaf;
+    pcc_thunk_node_t node;
+} pcc_thunk_data_t;
+
+struct pcc_thunk_tag {
+    pcc_thunk_type_t type;
+    pcc_thunk_data_t data;
+};
+
+struct pcc_thunk_array_tag {
+    pcc_thunk_t **buf;
+    size_t max;
+    size_t len;
+};
+
+typedef struct pcc_thunk_chunk_tag {
+    pcc_value_table_t values;
+    pcc_capture_table_t capts;
+    pcc_thunk_array_t thunks;
+    size_t pos; /* the starting position in the character buffer */
+<%- if @location -%>
+    pcc_location_t pos_loc;
+<%- end -%>
+} pcc_thunk_chunk_t;
+
+typedef struct pcc_lr_memo_tag pcc_lr_memo_t;
+
+struct pcc_lr_memo_tag {
+    size_t offset;
+<%- if @location -%>
+    pcc_location_t offset_loc;
+<%- end -%>
+    pcc_lr_memo_t *hold;
+    pcc_thunk_chunk_t *chunk;
+    pcc_bool_t fail;
+    pcc_bool_t grow;
+};
+
+typedef struct pcc_rule_set_tag pcc_rule_set_t;
+
+typedef pcc_thunk_chunk_t *(*pcc_rule_t)(pcc_context_t *, size_t<% if @location %>, pcc_location_t<% end %>, pcc_rule_set_t*);
+
+typedef struct pcc_rule_set_tag {
+    pcc_rule_t *buf;
+    size_t max;
+    size_t len;
+} pcc_rule_set_t;
+
+typedef struct pcc_lr_memo_map_entry_tag {
+    pcc_rule_t rule;
+    pcc_lr_memo_t *memo;
+} pcc_lr_memo_map_entry_t;
+
+typedef struct pcc_lr_memo_map_tag {
+    pcc_lr_memo_map_entry_t *buf;
+    size_t max;
+    size_t len;
+} pcc_lr_memo_map_t;
+
+typedef struct pcc_lr_table_tag {
+    pcc_lr_memo_map_t **buf;
+    size_t max;
+    size_t len;
+    size_t ofs;
+} pcc_lr_table_t;
+
+typedef struct pcc_memory_entry_tag pcc_memory_entry_t;
+typedef struct pcc_memory_pool_tag pcc_memory_pool_t;
+
+struct pcc_memory_entry_tag {
+    pcc_memory_entry_t *next;
+};
+
+struct pcc_memory_pool_tag {
+    pcc_memory_pool_t *next;
+    size_t allocated;
+    size_t unused;
+};
+
+typedef struct pcc_memory_recycler_tag {
+    pcc_memory_pool_t *pool_list;
+    pcc_memory_entry_t *entry_list;
+    size_t element_size;
+} pcc_memory_recycler_t;
+
+struct <%= prefix %>_context_tag {
+    size_t buffer_start_position; /* the position in the input of the first character currently buffered */
+    size_t position_offset; /* the current parsing position in the character buffer */
+    <%- if @location -%>
+    pcc_location_t buffer_start_position_loc;
+    pcc_location_t position_offset_loc;
+    <%- end -%>
+    size_t level;
+    pcc_char_array_t buffer;
+    pcc_lr_table_t lrtable;
+    pcc_thunk_array_t thunks;
+    pcc_auxil_t auxil;
+    pcc_memory_recycler_t thunk_chunk_recycler;
+    pcc_memory_recycler_t lr_memo_recycler;
+};
+
+#ifndef PCC_ERROR
+#define PCC_ERROR(auxil) pcc_error()
+MARK_FUNC_AS_USED
+static void pcc_error(void) {
+    fprintf(stderr, "Syntax error\n");
+    exit(1);
+}
+#endif /* !PCC_ERROR */
+
+#ifndef PCC_GETCHAR
+#define PCC_GETCHAR(auxil) getchar()
+#endif /* !PCC_GETCHAR */
+
+#ifndef PCC_MALLOC
+#define PCC_MALLOC(auxil, size) pcc_malloc_e(size)
+static void *pcc_malloc_e(size_t size) {
+    void *const p = malloc(size);
+    if (p == NULL) {
+        fprintf(stderr, "Out of memory\n");
+        exit(1);
+    }
+    return p;
+}
+#endif /* !PCC_MALLOC */
+
+#ifndef PCC_REALLOC
+#define PCC_REALLOC(auxil, ptr, size) pcc_realloc_e(ptr, size)
+static void *pcc_realloc_e(void *ptr, size_t size) {
+    void *const p = realloc(ptr, size);
+    if (p == NULL) {
+        fprintf(stderr, "Out of memory\n");
+        exit(1);
+    }
+    return p;
+}
+#endif /* !PCC_REALLOC */
+
+#ifndef PCC_FREE
+#define PCC_FREE(auxil, ptr) free(ptr)
+#endif /* !PCC_FREE */
+
+#ifndef PCC_DEBUG
+#define PCC_DEBUG(auxil, event, rule, level, pos, buffer, length) ((void)0)
+#endif /* !PCC_DEBUG */
+
+static char *pcc_strndup_e(pcc_auxil_t auxil, const char *str, size_t len) {
+    const size_t m = strnlen(str, len);
+    char *const s = (char *)PCC_MALLOC(auxil, m + 1);
+    memcpy(s, str, m);
+    s[m] = '\0';
+    return s;
+}
+
+static void pcc_char_array__init(pcc_auxil_t auxil, pcc_char_array_t *array) {
+    array->len = 0;
+    array->max = 0;
+    array->buf = NULL;
+}
+
+static void pcc_char_array__add(pcc_auxil_t auxil, pcc_char_array_t *array, char ch) {
+    if (array->max <= array->len) {
+        const size_t n = array->len + 1;
+        size_t m = array->max;
+        if (m == 0) m = PCC_BUFFER_MIN_SIZE;
+        while (m < n && m != 0) m <<= 1;
+        if (m == 0) m = n;
+        array->buf = (char *)PCC_REALLOC(auxil, array->buf, m);
+        array->max = m;
+    }
+    array->buf[array->len++] = ch;
+}
+
+static void pcc_char_array__term(pcc_auxil_t auxil, pcc_char_array_t *array) {
+    PCC_FREE(auxil, array->buf);
+}
+
+static void pcc_value_table__init(pcc_auxil_t auxil, pcc_value_table_t *table) {
+    table->len = 0;
+    table->max = 0;
+    table->buf = NULL;
+}
+
+MARK_FUNC_AS_USED
+static void pcc_value_table__resize(pcc_auxil_t auxil, pcc_value_table_t *table, size_t len) {
+    if (table->max < len) {
+        size_t m = table->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < len && m != 0) m <<= 1;
+        if (m == 0) m = len;
+        table->buf = (pcc_value_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t) * m);
+        table->max = m;
+    }
+    table->len = len;
+}
+
+MARK_FUNC_AS_USED
+static void pcc_value_table__clear(pcc_auxil_t auxil, pcc_value_table_t *table) {
+    memset(table->buf, 0, sizeof(pcc_value_t) * table->len);
+}
+
+static void pcc_value_table__term(pcc_auxil_t auxil, pcc_value_table_t *table) {
+    PCC_FREE(auxil, table->buf);
+}
+
+static void pcc_value_refer_table__init(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
+    table->len = 0;
+    table->max = 0;
+    table->buf = NULL;
+}
+
+static void pcc_value_refer_table__resize(pcc_auxil_t auxil, pcc_value_refer_table_t *table, size_t len) {
+    size_t i;
+    if (table->max < len) {
+        size_t m = table->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < len && m != 0) m <<= 1;
+        if (m == 0) m = len;
+        table->buf = (pcc_value_t **)PCC_REALLOC(auxil, table->buf, sizeof(pcc_value_t *) * m);
+        table->max = m;
+    }
+    for (i = table->len; i < len; i++) table->buf[i] = NULL;
+    table->len = len;
+}
+
+static void pcc_value_refer_table__term(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
+    PCC_FREE(auxil, table->buf);
+}
+
+static void pcc_capture_table__init(pcc_auxil_t auxil, pcc_capture_table_t *table) {
+    table->len = 0;
+    table->max = 0;
+    table->buf = NULL;
+}
+
+MARK_FUNC_AS_USED
+static void pcc_capture_table__resize(pcc_auxil_t auxil, pcc_capture_table_t *table, size_t len) {
+    size_t i;
+    for (i = len; i < table->len; i++) PCC_FREE(auxil, table->buf[i].string);
+    if (table->max < len) {
+        size_t m = table->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < len && m != 0) m <<= 1;
+        if (m == 0) m = len;
+        table->buf = (pcc_capture_t *)PCC_REALLOC(auxil, table->buf, sizeof(pcc_capture_t) * m);
+        table->max = m;
+    }
+    for (i = table->len; i < len; i++) {
+        table->buf[i].range.start = 0;
+        table->buf[i].range.end = 0;
+<%- if @location -%>
+        pcc_location_init(&table->buf[i].range.start_loc);
+        pcc_location_init(&table->buf[i].range.end_loc);
+<%- end -%>
+        table->buf[i].string = NULL;
+    }
+    table->len = len;
+}
+
+static void pcc_capture_table__term(pcc_auxil_t auxil, pcc_capture_table_t *table) {
+    while (table->len > 0) {
+        table->len--;
+        PCC_FREE(auxil, table->buf[table->len].string);
+    }
+    PCC_FREE(auxil, table->buf);
+}
+
+static void pcc_capture_const_table__init(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
+    table->len = 0;
+    table->max = 0;
+    table->buf = NULL;
+}
+
+static void pcc_capture_const_table__resize(pcc_auxil_t auxil, pcc_capture_const_table_t *table, size_t len) {
+    size_t i;
+    if (table->max < len) {
+        size_t m = table->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < len && m != 0) m <<= 1;
+        if (m == 0) m = len;
+        table->buf = (const pcc_capture_t **)PCC_REALLOC(auxil, (pcc_capture_t **)table->buf, sizeof(const pcc_capture_t *) * m);
+        table->max = m;
+    }
+    for (i = table->len; i < len; i++) table->buf[i] = NULL;
+    table->len = len;
+}
+
+static void pcc_capture_const_table__term(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
+    PCC_FREE(auxil, (void *)table->buf);
+}
+
+MARK_FUNC_AS_USED
+static pcc_thunk_t *pcc_thunk__create_leaf(pcc_auxil_t auxil, pcc_action_t action, size_t valuec, size_t captc) {
+    pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
+    thunk->type = PCC_THUNK_LEAF;
+    pcc_value_refer_table__init(auxil, &thunk->data.leaf.values);
+    pcc_value_refer_table__resize(auxil, &thunk->data.leaf.values, valuec);
+    pcc_capture_const_table__init(auxil, &thunk->data.leaf.capts);
+    pcc_capture_const_table__resize(auxil, &thunk->data.leaf.capts, captc);
+    thunk->data.leaf.capt0.range.start = 0;
+    thunk->data.leaf.capt0.range.end = 0;
+<%- if @location -%>
+    pcc_location_init(&thunk->data.leaf.capt0.range.start_loc);
+    pcc_location_init(&thunk->data.leaf.capt0.range.end_loc);
+<%- end -%>
+    thunk->data.leaf.capt0.string = NULL;
+    thunk->data.leaf.action = action;
+    return thunk;
+}
+
+static pcc_thunk_t *pcc_thunk__create_node(pcc_auxil_t auxil, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
+    pcc_thunk_t *const thunk = (pcc_thunk_t *)PCC_MALLOC(auxil, sizeof(pcc_thunk_t));
+    thunk->type = PCC_THUNK_NODE;
+    thunk->data.node.thunks = thunks;
+    thunk->data.node.value = value;
+    return thunk;
+}
+
+static void pcc_thunk__destroy(pcc_auxil_t auxil, pcc_thunk_t *thunk) {
+    if (thunk == NULL) return;
+    switch (thunk->type) {
+    case PCC_THUNK_LEAF:
+        PCC_FREE(auxil, thunk->data.leaf.capt0.string);
+        pcc_capture_const_table__term(auxil, &thunk->data.leaf.capts);
+        pcc_value_refer_table__term(auxil, &thunk->data.leaf.values);
+        break;
+    case PCC_THUNK_NODE:
+        break;
+    default: /* unknown */
+        break;
+    }
+    PCC_FREE(auxil, thunk);
+}
+
+static void pcc_thunk_array__init(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
+    array->len = 0;
+    array->max = 0;
+    array->buf = NULL;
+}
+
+static void pcc_thunk_array__add(pcc_auxil_t auxil, pcc_thunk_array_t *array, pcc_thunk_t *thunk) {
+    if (array->max <= array->len) {
+        const size_t n = array->len + 1;
+        size_t m = array->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < n && m != 0) m <<= 1;
+        if (m == 0) m = n;
+        array->buf = (pcc_thunk_t **)PCC_REALLOC(auxil, array->buf, sizeof(pcc_thunk_t *) * m);
+        array->max = m;
+    }
+    array->buf[array->len++] = thunk;
+}
+
+static void pcc_thunk_array__revert(pcc_auxil_t auxil, pcc_thunk_array_t *array, size_t len) {
+    while (array->len > len) {
+        array->len--;
+        pcc_thunk__destroy(auxil, array->buf[array->len]);
+    }
+}
+
+static void pcc_thunk_array__term(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
+    while (array->len > 0) {
+        array->len--;
+        pcc_thunk__destroy(auxil, array->buf[array->len]);
+    }
+    PCC_FREE(auxil, array->buf);
+}
+
+static void pcc_memory_recycler__init(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler, size_t element_size) {
+    recycler->pool_list = NULL;
+    recycler->entry_list = NULL;
+    recycler->element_size = element_size;
+}
+
+static void *pcc_memory_recycler__supply(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler) {
+    if (recycler->entry_list) {
+        pcc_memory_entry_t *const tmp = recycler->entry_list;
+        recycler->entry_list = tmp->next;
+        return tmp;
+    }
+    if (!recycler->pool_list || recycler->pool_list->unused == 0) {
+        size_t size = PCC_POOL_MIN_SIZE;
+        if (recycler->pool_list) {
+            size = recycler->pool_list->allocated << 1;
+            if (size == 0) size = recycler->pool_list->allocated;
+        }
+        {
+            pcc_memory_pool_t *const pool = (pcc_memory_pool_t *)PCC_MALLOC(
+                auxil, sizeof(pcc_memory_pool_t) + recycler->element_size * size
+            );
+            pool->allocated = size;
+            pool->unused = size;
+            pool->next = recycler->pool_list;
+            recycler->pool_list = pool;
+        }
+    }
+    recycler->pool_list->unused--;
+    return (char *)recycler->pool_list + sizeof(pcc_memory_pool_t) + recycler->element_size * recycler->pool_list->unused;
+}
+
+static void pcc_memory_recycler__recycle(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler, void *ptr) {
+    pcc_memory_entry_t *const tmp = (pcc_memory_entry_t *)ptr;
+    tmp->next = recycler->entry_list;
+    recycler->entry_list = tmp;
+}
+
+static void pcc_memory_recycler__term(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler) {
+    while (recycler->pool_list) {
+        pcc_memory_pool_t *const tmp = recycler->pool_list;
+        recycler->pool_list = tmp->next;
+        PCC_FREE(auxil, tmp);
+    }
+}
+
+MARK_FUNC_AS_USED
+static pcc_thunk_chunk_t *pcc_thunk_chunk__create(pcc_context_t *ctx) {
+    pcc_thunk_chunk_t *const chunk = (pcc_thunk_chunk_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->thunk_chunk_recycler);
+    pcc_value_table__init(ctx->auxil, &chunk->values);
+    pcc_capture_table__init(ctx->auxil, &chunk->capts);
+    pcc_thunk_array__init(ctx->auxil, &chunk->thunks);
+    chunk->pos = 0;
+    return chunk;
+}
+
+static void pcc_thunk_chunk__destroy(pcc_context_t *ctx, pcc_thunk_chunk_t *chunk) {
+    if (chunk == NULL) return;
+    pcc_thunk_array__term(ctx->auxil, &chunk->thunks);
+    pcc_capture_table__term(ctx->auxil, &chunk->capts);
+    pcc_value_table__term(ctx->auxil, &chunk->values);
+    pcc_memory_recycler__recycle(ctx->auxil, &ctx->thunk_chunk_recycler, chunk);
+}
+
+static void pcc_rule_set__init(pcc_auxil_t auxil, pcc_rule_set_t *set) {
+    set->len = 0;
+    set->max = 0;
+    set->buf = NULL;
+}
+
+static size_t pcc_rule_set__index(pcc_auxil_t auxil, const pcc_rule_set_t *set, pcc_rule_t rule) {
+    size_t i;
+    for (i = 0; i < set->len; i++) {
+        if (set->buf[i] == rule) return i;
+    }
+    return PCC_VOID_VALUE;
+}
+
+static pcc_bool_t pcc_rule_set__add(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_rule_t rule) {
+    const size_t i = pcc_rule_set__index(auxil, set, rule);
+    if (i != PCC_VOID_VALUE) return PCC_FALSE;
+    if (set->max <= set->len) {
+        const size_t n = set->len + 1;
+        size_t m = set->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < n && m != 0) m <<= 1;
+        if (m == 0) m = n;
+        set->buf = (pcc_rule_t *)PCC_REALLOC(auxil, set->buf, sizeof(pcc_rule_t) * m);
+        set->max = m;
+    }
+    set->buf[set->len++] = rule;
+    return PCC_TRUE;
+}
+
+static void pcc_rule_set__term(pcc_auxil_t auxil, pcc_rule_set_t *set) {
+    PCC_FREE(auxil, set->buf);
+}
+
+static pcc_lr_memo_t *pcc_lr_memo__create(pcc_context_t *ctx, size_t offset<% if @location %>, pcc_location_t offset_loc<% end %>) {
+    pcc_lr_memo_t *memo = (pcc_lr_memo_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->lr_memo_recycler);
+    memo->offset = offset;
+<%- if @location -%>
+    memo->offset_loc = offset_loc;
+<%- end -%>
+    memo->chunk = NULL;
+    memo->fail = PCC_TRUE;
+    memo->grow = PCC_FALSE;
+    memo->hold = NULL;
+    return memo;
+}
+
+static void pcc_lr_memo__set_chunk(pcc_context_t *ctx, pcc_lr_memo_t *memo, pcc_thunk_chunk_t *chunk) {
+    if (memo->chunk) {
+        pcc_lr_memo_t *const a = pcc_lr_memo__create(ctx, memo->offset<% if @location %>, memo->offset_loc<% end %>);
+        a->chunk = memo->chunk;
+        a->hold = memo->hold;
+        memo->hold = a;
+    }
+    memo->chunk = chunk;
+    memo->fail = PCC_FALSE;
+}
+
+static void pcc_lr_memo__destroy(pcc_context_t *ctx, pcc_lr_memo_t *memo) {
+    while (memo != NULL) {
+        pcc_lr_memo_t *const a = memo->hold;
+        pcc_thunk_chunk__destroy(ctx, memo->chunk);
+        pcc_memory_recycler__recycle(ctx->auxil, &ctx->lr_memo_recycler, memo);
+        memo = a;
+    }
+}
+
+static void pcc_lr_memo_map__init(pcc_auxil_t auxil, pcc_lr_memo_map_t *map) {
+    map->len = 0;
+    map->max = 0;
+    map->buf = NULL;
+}
+
+static size_t pcc_lr_memo_map__index(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
+    size_t i;
+    for (i = 0; i < map->len; i++) {
+        if (map->buf[i].rule == rule) return i;
+    }
+    return PCC_VOID_VALUE;
+}
+
+static void pcc_lr_memo_map__put(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule, pcc_lr_memo_t *memo) {
+    const size_t i = pcc_lr_memo_map__index(ctx, map, rule);
+    if (i != PCC_VOID_VALUE) {
+        pcc_lr_memo__destroy(ctx, map->buf[i].memo);
+        map->buf[i].memo = memo;
+    }
+    else {
+        if (map->max <= map->len) {
+            const size_t n = map->len + 1;
+            size_t m = map->max;
+            if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+            while (m < n && m != 0) m <<= 1;
+            if (m == 0) m = n;
+            map->buf = (pcc_lr_memo_map_entry_t *)PCC_REALLOC(ctx->auxil, map->buf, sizeof(pcc_lr_memo_map_entry_t) * m);
+            map->max = m;
+        }
+        map->buf[map->len].rule = rule;
+        map->buf[map->len].memo = memo;
+        map->len++;
+    }
+}
+
+static pcc_lr_memo_t *pcc_lr_memo_map__get(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc_rule_t rule) {
+    const size_t i = pcc_lr_memo_map__index(ctx, map, rule);
+    return (i != PCC_VOID_VALUE) ? map->buf[i].memo : NULL;
+}
+
+static void pcc_lr_memo_map__term(pcc_context_t *ctx, pcc_lr_memo_map_t *map) {
+    while (map->len > 0) {
+        map->len--;
+        pcc_lr_memo__destroy(ctx, map->buf[map->len].memo);
+    }
+    PCC_FREE(ctx->auxil, map->buf);
+}
+
+static pcc_lr_memo_map_t *pcc_lr_memo_map__create(pcc_context_t *ctx) {
+    pcc_lr_memo_map_t *const memo = (pcc_lr_memo_map_t *)PCC_MALLOC(ctx->auxil, sizeof(pcc_lr_memo_map_t));
+    pcc_lr_memo_map__init(ctx->auxil, memo);
+    return memo;
+}
+
+static void pcc_lr_memo_map__destroy(pcc_context_t *ctx, pcc_lr_memo_map_t *memo) {
+    if (memo == NULL) return;
+    pcc_lr_memo_map__term(ctx, memo);
+    PCC_FREE(ctx->auxil, memo);
+}
+
+static void pcc_lr_table__init(pcc_auxil_t auxil, pcc_lr_table_t *table) {
+    table->ofs = 0;
+    table->len = 0;
+    table->max = 0;
+    table->buf = NULL;
+}
+
+static void pcc_lr_table__resize(pcc_context_t *ctx, pcc_lr_table_t *table, size_t len) {
+    size_t i;
+    for (i = len; i < table->len; i++) pcc_lr_memo_map__destroy(ctx, table->buf[i]);
+    if (table->max < len) {
+        size_t m = table->max;
+        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        while (m < len && m != 0) m <<= 1;
+        if (m == 0) m = len;
+        table->buf = (pcc_lr_memo_map_t **)PCC_REALLOC(ctx->auxil, table->buf, sizeof(pcc_lr_memo_map_t *) * m);
+        table->max = m;
+    }
+    for (i = table->len; i < len; i++) table->buf[i] = NULL;
+    table->len = len;
+}
+
+static void pcc_lr_table__set_memo(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule, pcc_lr_memo_t *memo) {
+    index += table->ofs;
+    if (index >= table->len) pcc_lr_table__resize(ctx, table, index + 1);
+    if (table->buf[index] == NULL) table->buf[index] = pcc_lr_memo_map__create(ctx);
+    pcc_lr_memo_map__put(ctx, table->buf[index], rule, memo);
+}
+
+static pcc_lr_memo_t *pcc_lr_table__get_memo(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule) {
+    index += table->ofs;
+    if (index >= table->len || table->buf[index] == NULL) return NULL;
+    return pcc_lr_memo_map__get(ctx, table->buf[index], rule);
+}
+
+static void pcc_lr_table__shift(pcc_context_t *ctx, pcc_lr_table_t *table, size_t count) {
+    size_t i;
+    if (count > table->len - table->ofs) count = table->len - table->ofs;
+    for (i = 0; i < count; i++) pcc_lr_memo_map__destroy(ctx, table->buf[table->ofs++]);
+    if (table->ofs > (table->max >> 1)) {
+        memmove(table->buf, table->buf + table->ofs, sizeof(pcc_lr_memo_map_t *) * (table->len - table->ofs));
+        table->len -= table->ofs;
+        table->ofs = 0;
+    }
+}
+
+static void pcc_lr_table__term(pcc_context_t *ctx, pcc_lr_table_t *table) {
+    while (table->len > table->ofs) {
+        table->len--;
+        pcc_lr_memo_map__destroy(ctx, table->buf[table->len]);
+    }
+    PCC_FREE(ctx->auxil, table->buf);
+}
+
+static pcc_context_t *pcc_context__create(pcc_auxil_t auxil) {
+    pcc_context_t *const ctx = (pcc_context_t *)PCC_MALLOC(auxil, sizeof(pcc_context_t));
+    ctx->buffer_start_position = 0;
+    ctx->position_offset = 0;
+<%- if @location -%>
+    pcc_location_init(&ctx->buffer_start_position_loc);
+    pcc_location_init(&ctx->position_offset_loc);
+<%- end -%>
+    ctx->level = 0;
+    pcc_char_array__init(auxil, &ctx->buffer);
+    pcc_lr_table__init(auxil, &ctx->lrtable);
+    pcc_thunk_array__init(auxil, &ctx->thunks);
+    pcc_memory_recycler__init(auxil, &ctx->thunk_chunk_recycler, sizeof(pcc_thunk_chunk_t));
+    pcc_memory_recycler__init(auxil, &ctx->lr_memo_recycler, sizeof(pcc_lr_memo_t));
+    ctx->auxil = auxil;
+    return ctx;
+}
+
+static void pcc_context__destroy(pcc_context_t *ctx) {
+    if (ctx == NULL) return;
+    pcc_thunk_array__term(ctx->auxil, &ctx->thunks);
+    pcc_lr_table__term(ctx, &ctx->lrtable);
+    pcc_char_array__term(ctx->auxil, &ctx->buffer);
+    pcc_memory_recycler__term(ctx->auxil, &ctx->thunk_chunk_recycler);
+    pcc_memory_recycler__term(ctx->auxil, &ctx->lr_memo_recycler);
+    PCC_FREE(ctx->auxil, ctx);
+}
+
+static size_t pcc_refill_buffer(pcc_context_t *ctx, size_t num) {
+    if (ctx->buffer.len >= ctx->position_offset + num) return ctx->buffer.len - ctx->position_offset;
+    while (ctx->buffer.len < ctx->position_offset + num) {
+        const int c = PCC_GETCHAR(ctx->auxil);
+        if (c < 0) break;
+        pcc_char_array__add(ctx->auxil, &ctx->buffer, (char)c);
+    }
+    return ctx->buffer.len - ctx->position_offset;
+}
+
+MARK_FUNC_AS_USED
+static void pcc_commit_buffer(pcc_context_t *ctx) {
+    memmove(ctx->buffer.buf, ctx->buffer.buf + ctx->position_offset, ctx->buffer.len - ctx->position_offset);
+    ctx->buffer.len -= ctx->position_offset;
+    ctx->buffer_start_position += ctx->position_offset;
+    pcc_lr_table__shift(ctx, &ctx->lrtable, ctx->position_offset);
+    ctx->position_offset = 0;
+<%- if @location -%>
+    ctx->buffer_start_position_loc = pcc_location_add(ctx->buffer_start_position_loc, ctx->position_offset_loc);
+    pcc_location_init(&ctx->position_offset_loc);
+<%- end -%>
+}
+
+MARK_FUNC_AS_USED
+static const char *pcc_get_capture_string(pcc_context_t *ctx, const pcc_capture_t *capt) {
+    if (capt->string == NULL)
+        ((pcc_capture_t *)capt)->string =
+            pcc_strndup_e(ctx->auxil, ctx->buffer.buf + capt->range.start, capt->range.end - capt->range.start);
+    return capt->string;
+}
+
+<% if @utf8 -%>
+static size_t pcc_get_char_as_utf32(pcc_context_t *ctx, int *out) { /* with checking UTF-8 validity */
+    int c, u;
+    size_t n;
+    if (pcc_refill_buffer(ctx, 1) < 1) return 0;
+    c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset];
+    n = (c < 0x80) ? 1 :
+        ((c & 0xe0) == 0xc0) ? 2 :
+        ((c & 0xf0) == 0xe0) ? 3 :
+        ((c & 0xf8) == 0xf0) ? 4 : 0;
+    if (n < 1) return 0;
+    if (pcc_refill_buffer(ctx, n) < n) return 0;
+    switch (n) {
+    case 1:
+        u = c;
+        break;
+    case 2:
+        u = c & 0x1f;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 1];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        if (u < 0x80) return 0;
+        break;
+    case 3:
+        u = c & 0x0f;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 1];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 2];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        if (u < 0x800) return 0;
+        break;
+    case 4:
+        u = c & 0x07;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 1];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 2];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset + 3];
+        if ((c & 0xc0) != 0x80) return 0;
+        u <<= 6; u |= c & 0x3f;
+        if (u < 0x10000 || u > 0x10ffff) return 0;
+        break;
+    default:
+        return 0;
+    }
+    if (out) *out = u;
+    return n;
+}
+
+<% end -%>
+static void pcc_grow_lr(pcc_context_t *ctx, pcc_rule_t rule, size_t offset<% if @location %>, pcc_location_t offset_loc<% end %>) {
+    while(1) {
+        const size_t old_offset = ctx->position_offset;
+        pcc_thunk_chunk_t *chunk;
+        pcc_lr_memo_t *memo;
+        pcc_rule_set_t limits;
+        ctx->position_offset = offset;
+<%- if @location -%>
+        ctx->position_offset_loc = offset_loc;
+<%- end -%>
+        pcc_rule_set__init(ctx->auxil, &limits);
+        pcc_rule_set__add(ctx->auxil, &limits, rule);
+        chunk = rule(ctx, offset<% if @location %>, offset_loc<% end %>, &limits);
+        pcc_rule_set__term(ctx->auxil, &limits);
+        if (!chunk)
+            break;
+        if (ctx->position_offset <= old_offset) {
+            pcc_thunk_chunk__destroy(ctx, chunk);
+            break;
+        }
+        memo = pcc_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+        pcc_lr_memo__set_chunk(ctx, memo, chunk);
+        memo->offset = ctx->position_offset;
+        <%- if @location -%>
+        memo->offset_loc = ctx->position_offset_loc;
+        <%- end -%>
+    }
+}
+
+MARK_FUNC_AS_USED
+static pcc_thunk_chunk_t *pcc_get_rule_thunk_chunk(pcc_context_t *ctx, pcc_rule_t rule) {
+    pcc_thunk_chunk_t *c = NULL;
+    size_t offset = ctx->position_offset;
+<%- if @location -%>
+    pcc_location_t offset_loc = ctx->position_offset_loc;
+<%- end -%>
+    pcc_lr_memo_t *a = pcc_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+
+    if (a == NULL) {
+        a = pcc_lr_memo__create(ctx, offset<% if @location %>, offset_loc<% end %>);
+        pcc_lr_table__set_memo(ctx, &ctx->lrtable, offset, rule, a);
+        c = rule(ctx, offset<% if @location %>, offset_loc<% end %>, NULL);
+        pcc_lr_memo__set_chunk(ctx, a, c);
+        a->offset = ctx->position_offset;
+<%- if @location -%>
+        a->offset_loc = ctx->position_offset_loc;
+<%- end -%>
+        if (a->grow) {
+            pcc_grow_lr(ctx, rule, offset<% if @location %>, offset_loc<% end %>);
+            a->grow = PCC_FALSE;
+            ctx->position_offset = a->offset;
+            return a->chunk;
+        }
+        return c;
+    } else if (a->fail) {
+        pcc_lr_memo__set_chunk(ctx, a, NULL);
+        a->grow = PCC_TRUE;
+        return NULL;
+    }
+    ctx->position_offset = a->offset;
+    return a->chunk;
+}
+
+MARK_FUNC_AS_USED
+static pcc_bool_t pcc_apply_rule(pcc_context_t *ctx, pcc_rule_t rule, pcc_thunk_array_t *thunks, pcc_value_t *value, size_t offset<% if @location %>, pcc_location_t offset_loc<% end %>, pcc_rule_set_t *limits) {
+    static pcc_value_t null;
+    pcc_thunk_chunk_t *c;
+    if (limits != NULL) {
+        pcc_lr_memo_t *a;
+        pcc_rule_set__add(ctx->auxil, limits, rule);
+        c = rule(ctx, offset<% if @location %>, offset_loc<% end %>, limits);
+        a = pcc_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+        if (a == NULL || ctx->position_offset <= a->offset) {
+            c = a->chunk;
+            ctx->position_offset = a->offset;
+        } else {
+            pcc_lr_memo__set_chunk(ctx, a, c);
+            a->offset = ctx->position_offset;
+        }
+    } else {
+        c = pcc_get_rule_thunk_chunk(ctx, rule);
+    }
+    if (c == NULL) return PCC_FALSE;
+    if (value == NULL) value = &null;
+    memset(value, 0, sizeof(pcc_value_t)); /* in case */
+    pcc_thunk_array__add(ctx->auxil, thunks, pcc_thunk__create_node(ctx->auxil, &c->thunks, value));
+    return PCC_TRUE;
+}
+
+MARK_FUNC_AS_USED
+static void pcc_do_action(pcc_context_t *ctx, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
+    size_t i;
+    for (i = 0; i < thunks->len; i++) {
+        pcc_thunk_t *const thunk = thunks->buf[i];
+        switch (thunk->type) {
+        case PCC_THUNK_LEAF:
+            thunk->data.leaf.action(ctx, thunk, value);
+            break;
+        case PCC_THUNK_NODE:
+            pcc_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);
+            break;
+        default: /* unknown */
+            break;
+        }
+    }
+}
+
+<%- @root.rules.each do |rule| -%>
+<%-   rule.codes.each do |code| -%>
+static void pcc_action_<%= rule.name %>_<%= code.index %>(<%= prefix %>_context_t *__pcc_ctx, pcc_thunk_t *__pcc_in, pcc_value_t *__pcc_out) {
+#define auxil (__pcc_ctx->auxil)
+#define __ (*__pcc_out)
+<%-     code.vars.each do |ref| -%>
+#define <%= ref.var %> (*__pcc_in->data.leaf.values.buf[<%= ref.index %>])
+<%      end -%>
+#define _0 pcc_get_capture_string(__pcc_ctx, &__pcc_in->data.leaf.capt0)
+#define _0s ((const size_t)(__pcc_ctx->buffer_start_position + __pcc_in->data.leaf.capt0.range.start))
+#define _0e ((const size_t)(__pcc_ctx->buffer_start_position + __pcc_in->data.leaf.capt0.range.end))
+<%-     if @location -%>
+#define _0sl ((const pcc_location_t)(pcc_location_add(__pcc_ctx->buffer_start_position_loc, __pcc_in->data.leaf.capt0.range.start_loc)))
+#define _0el ((const pcc_location_t)(pcc_location_add(__pcc_ctx->buffer_start_position_loc, __pcc_in->data.leaf.capt0.range.end_loc)))
+<%-     end -%>
+<%-     if @capture_in_code -%>
+#define _0c __pcc_in->data.leaf.capt0
+<%-     end -%>
+<%      code.capts.each do |capture| -%>
+#define _<%= capture.index + 1 %> pcc_get_capture_string(__pcc_ctx, __pcc_in->data.leaf.capts.buf[<%= capture.index %>])
+#define _<%= capture.index + 1 %>s ((const size_t)(__pcc_ctx->buffer_start_position + __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.start))
+#define _<%= capture.index + 1 %>e ((const size_t)(__pcc_ctx->buffer_start_position + __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.end))
+<%-       if @location -%>
+#define _<%= capture.index + 1 %>sl ((const pcc_location_t)(pcc_location_add(__pcc_ctx->buffer_start_position_loc, __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.start_loc)))
+#define _<%= capture.index + 1 %>el ((const pcc_location_t)(pcc_location_add(__pcc_ctx->buffer_start_position_loc, __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.end_loc)))
+<%-       end -%>
+<%-       if @capture_in_code -%>
+#define _<%= capture.index + 1 %>c (*__pcc_in->data.leaf.capts.buf[<%= capture.index %>])
+<%-       end -%>
+<%-     end -%>
+<%=     stream.get_code_block(code.code, 4, @iname) -%>
+<%-     code.capts.reverse_each do |capture| -%>
+<%-       if @location -%>
+#undef _<%= capture.index + 1 %>el
+#undef _<%= capture.index + 1 %>sl
+<%-       end -%>
+#undef _<%= capture.index + 1 %>e
+#undef _<%= capture.index + 1 %>s
+#undef _<%= capture.index + 1 %>
+<%-     end -%>
+#undef _0e
+#undef _0s
+#undef _0
+<%- code.vars.reverse_each do |ref| -%>
+#undef <%= ref.var %>
+<%-     end -%>
+#undef __
+#undef auxil
+}
+
+<%-   end -%>
+<%- end -%>
+<%- @root.rules.each do |rule| -%>
+static pcc_thunk_chunk_t *pcc_evaluate_rule_<%= rule.name %>(pcc_context_t *ctx, size_t offset<% if @location %>, pcc_location_t offset_loc<% end %>, pcc_rule_set_t *limits);
+<%- end -%>
+
+<%- @root.rules.each do |rule| -%>
+<%-   gen = ::Packcr::Generator.new(rule, @ascii, @location) -%>
+<%=   gen.generate_code(rule, 0, 0, false) -%>
+
+<%- end -%>
+<%= prefix %>_context_t *<%= prefix %>_create(<%= auxil_def %>auxil) {
+    return pcc_context__create(auxil);
+}
+
+int <%= prefix %>_parse(<%= prefix %>_context_t *ctx, <%= value_def %>*ret) {
+    size_t pos = ctx->buffer_start_position;
+<%- if !@root.rules.empty? -%>
+    if (pcc_apply_rule(ctx, pcc_evaluate_rule_<%= @root.rules[0].name %>, &ctx->thunks, ret, ctx->position_offset<% if @location %>, ctx->position_offset_loc<% end %>, NULL))
+        pcc_do_action(ctx, &ctx->thunks, ret);
+    else
+        PCC_ERROR(ctx->auxil);
+    pcc_commit_buffer(ctx);
+<%- end -%>
+    pcc_thunk_array__revert(ctx->auxil, &ctx->thunks, 0);
+    return pos != ctx->buffer_start_position && pcc_refill_buffer(ctx, 1) >= 1;
+}
+
+void <%= prefix %>_destroy(<%= prefix %>_context_t *ctx) {
+    pcc_context__destroy(ctx);
+}
+<%- if !code(:lsource).empty? -%>
+
+<%-   code(:lsource).each do |code| -%>
+<%=     stream.get_code_block(code, 0, @iname) -%>
+<%-   end -%>
+<%- end -%>