packcr 0.0.6 → 0.0.8

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

@@ -16,14 +16,14 @@
 
 #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) {
+#ifndef PACKCR_USE_SYSTEM_STRNLEN
+#define strnlen(str, maxlen) packcr_strnlen(str, maxlen)
+static size_t packcr_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 /* !PACKCR_USE_SYSTEM_STRNLEN */
 #endif /* defined __GNUC__ && defined _WIN32 */
 #endif /* !_MSC_VER */
 
@@ -48,260 +48,221 @@ static size_t pcc_strnlen(const char *str, size_t maxlen) {
 #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 PACKCR_BUFFER_MIN_SIZE
+#define PACKCR_BUFFER_MIN_SIZE 256
+#endif /* !PACKCR_BUFFER_MIN_SIZE */
 
-#ifndef PCC_ARRAY_MIN_SIZE
-#define PCC_ARRAY_MIN_SIZE 2
-#endif /* !PCC_ARRAY_MIN_SIZE */
+#ifndef PACKCR_ARRAY_MIN_SIZE
+#define PACKCR_ARRAY_MIN_SIZE 2
+#endif /* !PACKCR_ARRAY_MIN_SIZE */
 
-#ifndef PCC_POOL_MIN_SIZE
-#define PCC_POOL_MIN_SIZE 65536
-#endif /* !PCC_POOL_MIN_SIZE */
+#ifndef PACKCR_POOL_MIN_SIZE
+#define PACKCR_POOL_MIN_SIZE 65536
+#endif /* !PACKCR_POOL_MIN_SIZE */
 
-#define PCC_DBG_EVALUATE 0
-#define PCC_DBG_MATCH    1
-#define PCC_DBG_NOMATCH  2
+#define PACKCR_DBG_EVALUATE 0
+#define PACKCR_DBG_MATCH    1
+#define PACKCR_DBG_NOMATCH  2
 
-#define PCC_VOID_VALUE (~(size_t)0)
+#define PACKCR_VOID_VALUE (~(size_t)0)
 
-typedef enum pcc_bool_tag {
-    PCC_FALSE = 0,
-    PCC_TRUE
-} pcc_bool_t;
+typedef enum packcr_bool_tag {
+    PACKCR_FALSE = 0,
+    PACKCR_TRUE
+} packcr_bool_t;
 
-typedef struct pcc_char_array_tag {
+typedef struct packcr_char_array_tag {
     char *buf;
     size_t max;
     size_t len;
-} pcc_char_array_t;
+} packcr_char_array_t;
 
-typedef struct pcc_range_tag {
+typedef struct packcr_range_tag {
     size_t start;
     size_t end;
 <%- if @location -%>
-    pcc_location_t *start_loc_ptr;
-    pcc_location_t *end_loc_ptr;
+    packcr_location_t start_loc;
+    packcr_location_t end_loc;
 <%- end -%>
-} pcc_range_t;
+} packcr_range_t;
 
-typedef <%= value_def %>pcc_value_t;
+typedef <%= value_def %>packcr_value_t;
 
-typedef <%= auxil_def %>pcc_auxil_t;
+typedef <%= auxil_def %>packcr_auxil_t;
 
-<% if prefix != "pcc" -%>
-typedef <%= prefix%>_context_t pcc_context_t;
+<% if prefix != "packcr" -%>
+typedef <%= prefix%>_context_t packcr_context_t;
 
 <% end -%>
-typedef struct pcc_value_table_tag {
-    pcc_value_t *buf;
+typedef struct packcr_value_table_tag {
+    packcr_value_t *buf;
     size_t max;
     size_t len;
-} pcc_value_table_t;
+} packcr_value_table_t;
 
-typedef struct pcc_value_refer_table_tag {
-    pcc_value_t **buf;
+typedef struct packcr_value_refer_table_tag {
+    packcr_value_t **buf;
     size_t max;
     size_t len;
-} pcc_value_refer_table_t;
+} packcr_value_refer_table_t;
 
-typedef struct pcc_capture_tag {
-    pcc_range_t range;
+typedef struct packcr_capture_tag {
+    packcr_range_t range;
     char *string; /* mutable */
-} pcc_capture_t;
+} packcr_capture_t;
 
-typedef struct pcc_capture_table_tag {
-    pcc_capture_t *buf;
+typedef struct packcr_capture_table_tag {
+    packcr_capture_t *buf;
     size_t max;
     size_t len;
-} pcc_capture_table_t;
+} packcr_capture_table_t;
 
-typedef struct pcc_capture_const_table_tag {
-    const pcc_capture_t **buf;
+typedef struct packcr_capture_const_table_tag {
+    const packcr_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;
+} packcr_capture_const_table_t;
+
+typedef struct packcr_thunk_tag packcr_thunk_t;
+typedef struct packcr_thunk_array_tag packcr_thunk_array_t;
+
+typedef void (*packcr_action_t)(packcr_context_t *, packcr_thunk_t *, packcr_value_t *);
+
+typedef enum packcr_thunk_type_tag {
+    PACKCR_THUNK_LEAF,
+    PACKCR_THUNK_NODE
+} packcr_thunk_type_t;
+
+typedef struct packcr_thunk_leaf_tag {
+    packcr_value_refer_table_t values;
+    packcr_capture_const_table_t capts;
+    packcr_capture_t capt0;
+    packcr_action_t action;
+} packcr_thunk_leaf_t;
+
+typedef struct packcr_thunk_node_tag {
+    const packcr_thunk_array_t *thunks; /* just a reference */
+    packcr_value_t *value; /* just a reference */
+} packcr_thunk_node_t;
+
+typedef union packcr_thunk_data_tag {
+    packcr_thunk_leaf_t leaf;
+    packcr_thunk_node_t node;
+} packcr_thunk_data_t;
+
+struct packcr_thunk_tag {
+    packcr_thunk_type_t type;
+    packcr_thunk_data_t data;
 };
 
-struct pcc_thunk_array_tag {
-    pcc_thunk_t **buf;
+struct packcr_thunk_array_tag {
+    packcr_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;
+typedef struct packcr_thunk_chunk_tag {
+    packcr_value_table_t values;
+    packcr_capture_table_t capts;
+    packcr_thunk_array_t thunks;
     size_t pos; /* the starting position in the character buffer */
 <%- if @location -%>
-    pcc_location_t pos_loc;
+    packcr_location_t pos_loc;
 <%- end -%>
-} pcc_thunk_chunk_t;
+} packcr_thunk_chunk_t;
 
-typedef struct pcc_lr_entry_tag pcc_lr_entry_t;
+typedef struct packcr_lr_memo_tag packcr_lr_memo_t;
 
-typedef enum pcc_lr_answer_type_tag {
-    PCC_LR_ANSWER_LR,
-    PCC_LR_ANSWER_CHUNK
-} pcc_lr_answer_type_t;
-
-typedef union pcc_lr_answer_data_tag {
-    pcc_lr_entry_t *lr;
-    pcc_thunk_chunk_t *chunk;
-} pcc_lr_answer_data_t;
-
-typedef struct pcc_lr_answer_tag pcc_lr_answer_t;
-
-struct pcc_lr_answer_tag {
-    pcc_lr_answer_type_t type;
-    pcc_lr_answer_data_t data;
-    size_t pos; /* the absolute position in the input */
+struct packcr_lr_memo_tag {
+    size_t offset;
 <%- if @location -%>
-    pcc_location_t pos_loc;
+    packcr_location_t offset_loc;
 <%- end -%>
-    pcc_lr_answer_t *hold;
+    packcr_lr_memo_t *hold;
+    packcr_thunk_chunk_t *chunk;
+    packcr_bool_t fail;
+    packcr_bool_t grow;
 };
 
-typedef pcc_thunk_chunk_t *(*pcc_rule_t)(pcc_context_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_head_tag pcc_lr_head_t;
-
-struct pcc_lr_head_tag {
-    pcc_rule_t rule;
-    pcc_rule_set_t invol;
-    pcc_rule_set_t eval;
-    pcc_lr_head_t *hold;
-};
+typedef struct packcr_rule_set_tag packcr_rule_set_t;
 
-typedef struct pcc_lr_memo_tag {
-    pcc_rule_t rule;
-    pcc_lr_answer_t *answer;
-} pcc_lr_memo_t;
+typedef packcr_thunk_chunk_t *(*packcr_rule_t)(packcr_context_t *, size_t<% if @location %>, packcr_location_t<% end %>, packcr_rule_set_t*);
 
-typedef struct pcc_lr_memo_map_tag {
-    pcc_lr_memo_t *buf;
+typedef struct packcr_rule_set_tag {
+    packcr_rule_t *buf;
     size_t max;
     size_t len;
-} pcc_lr_memo_map_t;
+} packcr_rule_set_t;
 
-typedef struct pcc_lr_table_entry_tag {
-    pcc_lr_head_t *head; /* just a reference */
-    pcc_lr_memo_map_t memos;
-    pcc_lr_answer_t *hold_a;
-    pcc_lr_head_t *hold_h;
-} pcc_lr_table_entry_t;
+typedef struct packcr_lr_memo_map_entry_tag {
+    packcr_rule_t rule;
+    packcr_lr_memo_t *memo;
+} packcr_lr_memo_map_entry_t;
 
-typedef struct pcc_lr_table_tag {
-    pcc_lr_table_entry_t **buf;
+typedef struct packcr_lr_memo_map_tag {
+    packcr_lr_memo_map_entry_t *buf;
     size_t max;
     size_t len;
-    size_t ofs;
-} pcc_lr_table_t;
-
-struct pcc_lr_entry_tag {
-    pcc_rule_t rule;
-    pcc_thunk_chunk_t *seed; /* just a reference */
-    pcc_lr_head_t *head; /* just a reference */
-};
+} packcr_lr_memo_map_t;
 
-typedef struct pcc_lr_stack_tag {
-    pcc_lr_entry_t **buf;
+typedef struct packcr_lr_table_tag {
+    packcr_lr_memo_map_t **buf;
     size_t max;
     size_t len;
-} pcc_lr_stack_t;
+    size_t ofs;
+} packcr_lr_table_t;
 
-typedef struct pcc_memory_entry_tag pcc_memory_entry_t;
-typedef struct pcc_memory_pool_tag pcc_memory_pool_t;
+typedef struct packcr_memory_entry_tag packcr_memory_entry_t;
+typedef struct packcr_memory_pool_tag packcr_memory_pool_t;
 
-struct pcc_memory_entry_tag {
-    pcc_memory_entry_t *next;
+struct packcr_memory_entry_tag {
+    packcr_memory_entry_t *next;
 };
 
-struct pcc_memory_pool_tag {
-    pcc_memory_pool_t *next;
+struct packcr_memory_pool_tag {
+    packcr_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;
+typedef struct packcr_memory_recycler_tag {
+    packcr_memory_pool_t *pool_list;
+    packcr_memory_entry_t *entry_list;
     size_t element_size;
-} pcc_memory_recycler_t;
+} packcr_memory_recycler_t;
 
 struct <%= prefix %>_context_tag {
-    size_t pos; /* the position in the input of the first character currently buffered */
-    size_t cur; /* the current parsing position in the character buffer */
+    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 pos_loc;
-    pcc_location_t cur_loc;
+    packcr_location_t buffer_start_position_loc;
+    packcr_location_t position_offset_loc;
     <%- end -%>
     size_t level;
-    pcc_char_array_t buffer;
-    pcc_lr_table_t lrtable;
-    pcc_lr_stack_t lrstack;
-    pcc_thunk_array_t thunks;
-    pcc_auxil_t auxil;
-    pcc_memory_recycler_t thunk_chunk_recycler;
-    pcc_memory_recycler_t lr_head_recycler;
-    pcc_memory_recycler_t lr_answer_recycler;
+    packcr_char_array_t buffer;
+    packcr_lr_table_t lrtable;
+    packcr_thunk_array_t thunks;
+    packcr_auxil_t auxil;
+    packcr_memory_recycler_t thunk_chunk_recycler;
+    packcr_memory_recycler_t lr_memo_recycler;
 };
 
-#ifndef PCC_ERROR
-#define PCC_ERROR(auxil) pcc_error()
+#ifndef PACKCR_ERROR
+#define PACKCR_ERROR(auxil) packcr_error()
 MARK_FUNC_AS_USED
-static void pcc_error(void) {
+static void packcr_error(void) {
     fprintf(stderr, "Syntax error\n");
     exit(1);
 }
-#endif /* !PCC_ERROR */
+#endif /* !PACKCR_ERROR */
 
-#ifndef PCC_GETCHAR
-#define PCC_GETCHAR(auxil) getchar()
-#endif /* !PCC_GETCHAR */
+#ifndef PACKCR_GETCHAR
+#define PACKCR_GETCHAR(auxil) getchar()
+#endif /* !PACKCR_GETCHAR */
 
-#ifndef PCC_MALLOC
-#define PCC_MALLOC(auxil, size) pcc_malloc_e(size)
-static void *pcc_malloc_e(size_t size) {
+#ifndef PACKCR_MALLOC
+#define PACKCR_MALLOC(auxil, size) packcr_malloc_e(size)
+static void *packcr_malloc_e(size_t size) {
     void *const p = malloc(size);
     if (p == NULL) {
         fprintf(stderr, "Out of memory\n");
@@ -309,11 +270,11 @@ static void *pcc_malloc_e(size_t size) {
     }
     return p;
 }
-#endif /* !PCC_MALLOC */
+#endif /* !PACKCR_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) {
+#ifndef PACKCR_REALLOC
+#define PACKCR_REALLOC(auxil, ptr, size) packcr_realloc_e(ptr, size)
+static void *packcr_realloc_e(void *ptr, size_t size) {
     void *const p = realloc(ptr, size);
     if (p == NULL) {
         fprintf(stderr, "Out of memory\n");
@@ -321,267 +282,259 @@ static void *pcc_realloc_e(void *ptr, size_t size) {
     }
     return p;
 }
-#endif /* !PCC_REALLOC */
+#endif /* !PACKCR_REALLOC */
 
-#ifndef PCC_FREE
-#define PCC_FREE(auxil, ptr) free(ptr)
-#endif /* !PCC_FREE */
+#ifndef PACKCR_FREE
+#define PACKCR_FREE(auxil, ptr) free(ptr)
+#endif /* !PACKCR_FREE */
 
-#ifndef PCC_DEBUG
-#define PCC_DEBUG(auxil, event, rule, level, pos, buffer, length) ((void)0)
-#endif /* !PCC_DEBUG */
+#ifndef PACKCR_DEBUG
+#define PACKCR_DEBUG(auxil, event, rule, level, pos, buffer, length) ((void)0)
+#endif /* !PACKCR_DEBUG */
 
-static char *pcc_strndup_e(pcc_auxil_t auxil, const char *str, size_t len) {
+static char *packcr_strndup_e(packcr_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);
+    char *const s = (char *)PACKCR_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) {
+static void packcr_char_array__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_char_array__add(packcr_auxil_t auxil, packcr_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;
+        if (m == 0) m = PACKCR_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->buf = (char *)PACKCR_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 packcr_char_array__term(packcr_auxil_t auxil, packcr_char_array_t *array) {
+    PACKCR_FREE(auxil, array->buf);
 }
 
-static void pcc_value_table__init(pcc_auxil_t auxil, pcc_value_table_t *table) {
+static void packcr_value_table__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_value_table__resize(packcr_auxil_t auxil, packcr_value_table_t *table, size_t len) {
     if (table->max < len) {
         size_t m = table->max;
-        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        if (m == 0) m = PACKCR_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->buf = (packcr_value_t *)PACKCR_REALLOC(auxil, table->buf, sizeof(packcr_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 packcr_value_table__clear(packcr_auxil_t auxil, packcr_value_table_t *table) {
+    memset(table->buf, 0, sizeof(packcr_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 packcr_value_table__term(packcr_auxil_t auxil, packcr_value_table_t *table) {
+    PACKCR_FREE(auxil, table->buf);
 }
 
-static void pcc_value_refer_table__init(pcc_auxil_t auxil, pcc_value_refer_table_t *table) {
+static void packcr_value_refer_table__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_value_refer_table__resize(packcr_auxil_t auxil, packcr_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;
+        if (m == 0) m = PACKCR_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->buf = (packcr_value_t **)PACKCR_REALLOC(auxil, table->buf, sizeof(packcr_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 packcr_value_refer_table__term(packcr_auxil_t auxil, packcr_value_refer_table_t *table) {
+    PACKCR_FREE(auxil, table->buf);
 }
 
-static void pcc_capture_table__init(pcc_auxil_t auxil, pcc_capture_table_t *table) {
+static void packcr_capture_table__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_capture_table__resize(packcr_auxil_t auxil, packcr_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 @location -%>
-    for (i = len; i < table->len; i++) {
-        PCC_FREE(auxil, table->buf[i].range.start_loc_ptr);
-        PCC_FREE(auxil, table->buf[i].range.end_loc_ptr);
-    }
-<%- end -%>
+    for (i = len; i < table->len; i++) PACKCR_FREE(auxil, table->buf[i].string);
     if (table->max < len) {
         size_t m = table->max;
-        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
+        if (m == 0) m = PACKCR_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->buf = (packcr_capture_t *)PACKCR_REALLOC(auxil, table->buf, sizeof(packcr_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 -%>
-        table->buf[i].range.start_loc_ptr = (pcc_location_t *)PCC_MALLOC(auxil, sizeof(pcc_location_t));
-        table->buf[i].range.end_loc_ptr = (pcc_location_t *)PCC_MALLOC(auxil, sizeof(pcc_location_t));
-        pcc_location_init(table->buf[i].range.start_loc_ptr);
-        pcc_location_init(table->buf[i].range.end_loc_ptr);
+        packcr_location_init(&table->buf[i].range.start_loc);
+        packcr_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) {
+static void packcr_capture_table__term(packcr_auxil_t auxil, packcr_capture_table_t *table) {
     while (table->len > 0) {
         table->len--;
-        PCC_FREE(auxil, table->buf[table->len].string);
-<%- if @location -%>
-        PCC_FREE(auxil, table->buf[table->len].range.start_loc_ptr);
-        PCC_FREE(auxil, table->buf[table->len].range.end_loc_ptr);
-<%- end -%>
+        PACKCR_FREE(auxil, table->buf[table->len].string);
     }
-    PCC_FREE(auxil, table->buf);
+    PACKCR_FREE(auxil, table->buf);
 }
 
-static void pcc_capture_const_table__init(pcc_auxil_t auxil, pcc_capture_const_table_t *table) {
+static void packcr_capture_const_table__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_capture_const_table__resize(packcr_auxil_t auxil, packcr_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;
+        if (m == 0) m = PACKCR_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->buf = (const packcr_capture_t **)PACKCR_REALLOC(auxil, (packcr_capture_t **)table->buf, sizeof(const packcr_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);
+static void packcr_capture_const_table__term(packcr_auxil_t auxil, packcr_capture_const_table_t *table) {
+    PACKCR_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);
+static packcr_thunk_t *packcr_thunk__create_leaf(packcr_auxil_t auxil, packcr_action_t action, size_t valuec, size_t captc) {
+    packcr_thunk_t *const thunk = (packcr_thunk_t *)PACKCR_MALLOC(auxil, sizeof(packcr_thunk_t));
+    thunk->type = PACKCR_THUNK_LEAF;
+    packcr_value_refer_table__init(auxil, &thunk->data.leaf.values);
+    packcr_value_refer_table__resize(auxil, &thunk->data.leaf.values, valuec);
+    packcr_capture_const_table__init(auxil, &thunk->data.leaf.capts);
+    packcr_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 -%>
+    packcr_location_init(&thunk->data.leaf.capt0.range.start_loc);
+    packcr_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;
+static packcr_thunk_t *packcr_thunk__create_node(packcr_auxil_t auxil, const packcr_thunk_array_t *thunks, packcr_value_t *value) {
+    packcr_thunk_t *const thunk = (packcr_thunk_t *)PACKCR_MALLOC(auxil, sizeof(packcr_thunk_t));
+    thunk->type = PACKCR_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) {
+static void packcr_thunk__destroy(packcr_auxil_t auxil, packcr_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);
+    case PACKCR_THUNK_LEAF:
+        PACKCR_FREE(auxil, thunk->data.leaf.capt0.string);
+        packcr_capture_const_table__term(auxil, &thunk->data.leaf.capts);
+        packcr_value_refer_table__term(auxil, &thunk->data.leaf.values);
         break;
-    case PCC_THUNK_NODE:
+    case PACKCR_THUNK_NODE:
         break;
     default: /* unknown */
         break;
     }
-    PCC_FREE(auxil, thunk);
+    PACKCR_FREE(auxil, thunk);
 }
 
-static void pcc_thunk_array__init(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
+static void packcr_thunk_array__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_thunk_array__add(packcr_auxil_t auxil, packcr_thunk_array_t *array, packcr_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;
+        if (m == 0) m = PACKCR_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->buf = (packcr_thunk_t **)PACKCR_REALLOC(auxil, array->buf, sizeof(packcr_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) {
+static void packcr_thunk_array__revert(packcr_auxil_t auxil, packcr_thunk_array_t *array, size_t len) {
     while (array->len > len) {
         array->len--;
-        pcc_thunk__destroy(auxil, array->buf[array->len]);
+        packcr_thunk__destroy(auxil, array->buf[array->len]);
     }
 }
 
-static void pcc_thunk_array__term(pcc_auxil_t auxil, pcc_thunk_array_t *array) {
+static void packcr_thunk_array__term(packcr_auxil_t auxil, packcr_thunk_array_t *array) {
     while (array->len > 0) {
         array->len--;
-        pcc_thunk__destroy(auxil, array->buf[array->len]);
+        packcr_thunk__destroy(auxil, array->buf[array->len]);
     }
-    PCC_FREE(auxil, array->buf);
+    PACKCR_FREE(auxil, array->buf);
 }
 
-static void pcc_memory_recycler__init(pcc_auxil_t auxil, pcc_memory_recycler_t *recycler, size_t element_size) {
+static void packcr_memory_recycler__init(packcr_auxil_t auxil, packcr_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) {
+static void *packcr_memory_recycler__supply(packcr_auxil_t auxil, packcr_memory_recycler_t *recycler) {
     if (recycler->entry_list) {
-        pcc_memory_entry_t *const tmp = recycler->entry_list;
+        packcr_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;
+        size_t size = PACKCR_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
+            packcr_memory_pool_t *const pool = (packcr_memory_pool_t *)PACKCR_MALLOC(
+                auxil, sizeof(packcr_memory_pool_t) + recycler->element_size * size
             );
             pool->allocated = size;
             pool->unused = size;
@@ -590,464 +543,324 @@ static void *pcc_memory_recycler__supply(pcc_auxil_t auxil, pcc_memory_recycler_
         }
     }
     recycler->pool_list->unused--;
-    return (char *)recycler->pool_list + sizeof(pcc_memory_pool_t) + recycler->element_size * recycler->pool_list->unused;
+    return (char *)recycler->pool_list + sizeof(packcr_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;
+static void packcr_memory_recycler__recycle(packcr_auxil_t auxil, packcr_memory_recycler_t *recycler, void *ptr) {
+    packcr_memory_entry_t *const tmp = (packcr_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) {
+static void packcr_memory_recycler__term(packcr_auxil_t auxil, packcr_memory_recycler_t *recycler) {
     while (recycler->pool_list) {
-        pcc_memory_pool_t *const tmp = recycler->pool_list;
+        packcr_memory_pool_t *const tmp = recycler->pool_list;
         recycler->pool_list = tmp->next;
-        PCC_FREE(auxil, tmp);
+        PACKCR_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);
+static packcr_thunk_chunk_t *packcr_thunk_chunk__create(packcr_context_t *ctx) {
+    packcr_thunk_chunk_t *const chunk = (packcr_thunk_chunk_t *)packcr_memory_recycler__supply(ctx->auxil, &ctx->thunk_chunk_recycler);
+    packcr_value_table__init(ctx->auxil, &chunk->values);
+    packcr_capture_table__init(ctx->auxil, &chunk->capts);
+    packcr_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) {
+static void packcr_thunk_chunk__destroy(packcr_context_t *ctx, packcr_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);
+    packcr_thunk_array__term(ctx->auxil, &chunk->thunks);
+    packcr_capture_table__term(ctx->auxil, &chunk->capts);
+    packcr_value_table__term(ctx->auxil, &chunk->values);
+    packcr_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) {
+static void packcr_rule_set__init(packcr_auxil_t auxil, packcr_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) {
+static size_t packcr_rule_set__index(packcr_auxil_t auxil, const packcr_rule_set_t *set, packcr_rule_t rule) {
     size_t i;
     for (i = 0; i < set->len; i++) {
         if (set->buf[i] == rule) return i;
     }
-    return PCC_VOID_VALUE;
+    return PACKCR_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;
+static packcr_bool_t packcr_rule_set__add(packcr_auxil_t auxil, packcr_rule_set_t *set, packcr_rule_t rule) {
+    const size_t i = packcr_rule_set__index(auxil, set, rule);
+    if (i != PACKCR_VOID_VALUE) return PACKCR_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;
+        if (m == 0) m = PACKCR_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->buf = (packcr_rule_t *)PACKCR_REALLOC(auxil, set->buf, sizeof(packcr_rule_t) * m);
         set->max = m;
     }
     set->buf[set->len++] = rule;
-    return PCC_TRUE;
-}
-
-static pcc_bool_t pcc_rule_set__remove(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;
-    memmove(set->buf + i, set->buf + (i + 1), sizeof(pcc_rule_t) * (set->len - (i + 1)));
-    return PCC_TRUE;
+    return PACKCR_TRUE;
 }
 
-static void pcc_rule_set__clear(pcc_auxil_t auxil, pcc_rule_set_t *set) {
-    set->len = 0;
+static void packcr_rule_set__term(packcr_auxil_t auxil, packcr_rule_set_t *set) {
+    PACKCR_FREE(auxil, set->buf);
 }
 
-static void pcc_rule_set__copy(pcc_auxil_t auxil, pcc_rule_set_t *set, const pcc_rule_set_t *src) {
-    size_t i;
-    pcc_rule_set__clear(auxil, set);
-    for (i = 0; i < src->len; i++) {
-        pcc_rule_set__add(auxil, set, src->buf[i]);
-    }
-}
-
-static void pcc_rule_set__term(pcc_auxil_t auxil, pcc_rule_set_t *set) {
-    PCC_FREE(auxil, set->buf);
-}
-
-static pcc_lr_head_t *pcc_lr_head__create(pcc_context_t *ctx, pcc_rule_t rule) {
-    pcc_lr_head_t *const head = (pcc_lr_head_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->lr_head_recycler);
-    head->rule = rule;
-    pcc_rule_set__init(ctx->auxil, &head->invol);
-    pcc_rule_set__init(ctx->auxil, &head->eval);
-    head->hold = NULL;
-    return head;
-}
-
-static void pcc_lr_head__destroy(pcc_context_t *ctx, pcc_lr_head_t *head) {
-    if (head == NULL) return;
-    pcc_lr_head__destroy(ctx, head->hold);
-    pcc_rule_set__term(ctx->auxil, &head->eval);
-    pcc_rule_set__term(ctx->auxil, &head->invol);
-    pcc_memory_recycler__recycle(ctx->auxil, &ctx->lr_head_recycler, head);
-}
-
-static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr);
-
-static pcc_lr_answer_t *pcc_lr_answer__create(pcc_context_t *ctx, pcc_lr_answer_type_t type, size_t pos<% if @location %>, pcc_location_t pos_loc<% end %>) {
-    pcc_lr_answer_t *answer = (pcc_lr_answer_t *)pcc_memory_recycler__supply(ctx->auxil, &ctx->lr_answer_recycler);
-    answer->type = type;
-    answer->pos = pos;
+static packcr_lr_memo_t *packcr_lr_memo__create(packcr_context_t *ctx, size_t offset<% if @location %>, packcr_location_t offset_loc<% end %>) {
+    packcr_lr_memo_t *memo = (packcr_lr_memo_t *)packcr_memory_recycler__supply(ctx->auxil, &ctx->lr_memo_recycler);
+    memo->offset = offset;
 <%- if @location -%>
-    answer->pos_loc = pos_loc;
+    memo->offset_loc = offset_loc;
 <%- end -%>
-    answer->hold = NULL;
-    switch (answer->type) {
-    case PCC_LR_ANSWER_LR:
-        answer->data.lr = NULL;
-        break;
-    case PCC_LR_ANSWER_CHUNK:
-        answer->data.chunk = NULL;
-        break;
-    default: /* unknown */
-        PCC_FREE(ctx->auxil, answer);
-        answer = NULL;
+    memo->chunk = NULL;
+    memo->fail = PACKCR_TRUE;
+    memo->grow = PACKCR_FALSE;
+    memo->hold = NULL;
+    return memo;
+}
+
+static void packcr_lr_memo__set_chunk(packcr_context_t *ctx, packcr_lr_memo_t *memo, packcr_thunk_chunk_t *chunk) {
+    if (memo->chunk) {
+        packcr_lr_memo_t *const new_hold_memo = packcr_lr_memo__create(ctx, memo->offset<% if @location %>, memo->offset_loc<% end %>);
+        new_hold_memo->chunk = memo->chunk;
+        new_hold_memo->hold = memo->hold;
+        memo->hold = new_hold_memo;
     }
-    return answer;
+    memo->chunk = chunk;
+    memo->fail = PACKCR_FALSE;
 }
 
-static void pcc_lr_answer__set_chunk(pcc_context_t *ctx, pcc_lr_answer_t *answer, pcc_thunk_chunk_t *chunk) {
-    pcc_lr_answer_t *const a = pcc_lr_answer__create(ctx, answer->type, answer->pos<% if @location %>, answer->pos_loc<% end %>);
-    switch (answer->type) {
-    case PCC_LR_ANSWER_LR:
-        a->data.lr = answer->data.lr;
-        break;
-    case PCC_LR_ANSWER_CHUNK:
-        a->data.chunk = answer->data.chunk;
-        break;
-    default: /* unknown */
-        break;
-    }
-    a->hold = answer->hold;
-    answer->hold = a;
-    answer->type = PCC_LR_ANSWER_CHUNK;
-    answer->data.chunk = chunk;
-}
-
-static void pcc_lr_answer__destroy(pcc_context_t *ctx, pcc_lr_answer_t *answer) {
-    while (answer != NULL) {
-        pcc_lr_answer_t *const a = answer->hold;
-        switch (answer->type) {
-        case PCC_LR_ANSWER_LR:
-            pcc_lr_entry__destroy(ctx->auxil, answer->data.lr);
-            break;
-        case PCC_LR_ANSWER_CHUNK:
-            pcc_thunk_chunk__destroy(ctx, answer->data.chunk);
-            break;
-        default: /* unknown */
-            break;
-        }
-        pcc_memory_recycler__recycle(ctx->auxil, &ctx->lr_answer_recycler, answer);
-        answer = a;
+static void packcr_lr_memo__destroy(packcr_context_t *ctx, packcr_lr_memo_t *memo) {
+    while (memo != NULL) {
+        packcr_lr_memo_t *const hold_memo = memo->hold;
+        packcr_thunk_chunk__destroy(ctx, memo->chunk);
+        packcr_memory_recycler__recycle(ctx->auxil, &ctx->lr_memo_recycler, memo);
+        memo = hold_memo;
     }
 }
 
-static void pcc_lr_memo_map__init(pcc_auxil_t auxil, pcc_lr_memo_map_t *map) {
+static void packcr_lr_memo_map__init(packcr_auxil_t auxil, packcr_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) {
+static size_t packcr_lr_memo_map__index(packcr_context_t *ctx, packcr_lr_memo_map_t *map, packcr_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;
+    return PACKCR_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_answer_t *answer) {
-    const size_t i = pcc_lr_memo_map__index(ctx, map, rule);
-    if (i != PCC_VOID_VALUE) {
-        pcc_lr_answer__destroy(ctx, map->buf[i].answer);
-        map->buf[i].answer = answer;
+static void packcr_lr_memo_map__put(packcr_context_t *ctx, packcr_lr_memo_map_t *map, packcr_rule_t rule, packcr_lr_memo_t *memo) {
+    const size_t i = packcr_lr_memo_map__index(ctx, map, rule);
+    if (i != PACKCR_VOID_VALUE) {
+        packcr_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;
+            if (m == 0) m = PACKCR_ARRAY_MIN_SIZE;
             while (m < n && m != 0) m <<= 1;
             if (m == 0) m = n;
-            map->buf = (pcc_lr_memo_t *)PCC_REALLOC(ctx->auxil, map->buf, sizeof(pcc_lr_memo_t) * m);
+            map->buf = (packcr_lr_memo_map_entry_t *)PACKCR_REALLOC(ctx->auxil, map->buf, sizeof(packcr_lr_memo_map_entry_t) * m);
             map->max = m;
         }
         map->buf[map->len].rule = rule;
-        map->buf[map->len].answer = answer;
+        map->buf[map->len].memo = memo;
         map->len++;
     }
 }
 
-static pcc_lr_answer_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].answer : NULL;
+static packcr_lr_memo_t *packcr_lr_memo_map__get(packcr_context_t *ctx, packcr_lr_memo_map_t *map, packcr_rule_t rule) {
+    const size_t i = packcr_lr_memo_map__index(ctx, map, rule);
+    return (i != PACKCR_VOID_VALUE) ? map->buf[i].memo : NULL;
 }
 
-static void pcc_lr_memo_map__term(pcc_context_t *ctx, pcc_lr_memo_map_t *map) {
+static void packcr_lr_memo_map__term(packcr_context_t *ctx, packcr_lr_memo_map_t *map) {
     while (map->len > 0) {
         map->len--;
-        pcc_lr_answer__destroy(ctx, map->buf[map->len].answer);
+        packcr_lr_memo__destroy(ctx, map->buf[map->len].memo);
     }
-    PCC_FREE(ctx->auxil, map->buf);
+    PACKCR_FREE(ctx->auxil, map->buf);
 }
 
-static pcc_lr_table_entry_t *pcc_lr_table_entry__create(pcc_context_t *ctx) {
-    pcc_lr_table_entry_t *const entry = (pcc_lr_table_entry_t *)PCC_MALLOC(ctx->auxil, sizeof(pcc_lr_table_entry_t));
-    entry->head = NULL;
-    pcc_lr_memo_map__init(ctx->auxil, &entry->memos);
-    entry->hold_a = NULL;
-    entry->hold_h = NULL;
-    return entry;
+static packcr_lr_memo_map_t *packcr_lr_memo_map__create(packcr_context_t *ctx) {
+    packcr_lr_memo_map_t *const memo = (packcr_lr_memo_map_t *)PACKCR_MALLOC(ctx->auxil, sizeof(packcr_lr_memo_map_t));
+    packcr_lr_memo_map__init(ctx->auxil, memo);
+    return memo;
 }
 
-static void pcc_lr_table_entry__destroy(pcc_context_t *ctx, pcc_lr_table_entry_t *entry) {
-    if (entry == NULL) return;
-    pcc_lr_head__destroy(ctx, entry->hold_h);
-    pcc_lr_answer__destroy(ctx, entry->hold_a);
-    pcc_lr_memo_map__term(ctx, &entry->memos);
-    PCC_FREE(ctx->auxil, entry);
+static void packcr_lr_memo_map__destroy(packcr_context_t *ctx, packcr_lr_memo_map_t *memo) {
+    if (memo == NULL) return;
+    packcr_lr_memo_map__term(ctx, memo);
+    PACKCR_FREE(ctx->auxil, memo);
 }
 
-static void pcc_lr_table__init(pcc_auxil_t auxil, pcc_lr_table_t *table) {
+static void packcr_lr_table__init(packcr_auxil_t auxil, packcr_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) {
+static void packcr_lr_table__resize(packcr_context_t *ctx, packcr_lr_table_t *table, size_t len) {
     size_t i;
-    for (i = len; i < table->len; i++) pcc_lr_table_entry__destroy(ctx, table->buf[i]);
+    for (i = len; i < table->len; i++) packcr_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;
+        if (m == 0) m = PACKCR_ARRAY_MIN_SIZE;
         while (m < len && m != 0) m <<= 1;
         if (m == 0) m = len;
-        table->buf = (pcc_lr_table_entry_t **)PCC_REALLOC(ctx->auxil, table->buf, sizeof(pcc_lr_table_entry_t *) * m);
+        table->buf = (packcr_lr_memo_map_t **)PACKCR_REALLOC(ctx->auxil, table->buf, sizeof(packcr_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_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
+static void packcr_lr_table__set_memo(packcr_context_t *ctx, packcr_lr_table_t *table, size_t index, packcr_rule_t rule, packcr_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_table_entry__create(ctx);
-    table->buf[index]->head = head;
+    if (index >= table->len) packcr_lr_table__resize(ctx, table, index + 1);
+    if (table->buf[index] == NULL) table->buf[index] = packcr_lr_memo_map__create(ctx);
+    packcr_lr_memo_map__put(ctx, table->buf[index], rule, memo);
 }
 
-static void pcc_lr_table__hold_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_head_t *head) {
-    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_table_entry__create(ctx);
-    head->hold = table->buf[index]->hold_h;
-    table->buf[index]->hold_h = head;
-}
-
-static void pcc_lr_table__set_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule, pcc_lr_answer_t *answer) {
-    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_table_entry__create(ctx);
-    pcc_lr_memo_map__put(ctx, &table->buf[index]->memos, rule, answer);
-}
-
-static void pcc_lr_table__hold_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_lr_answer_t *answer) {
-    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_table_entry__create(ctx);
-    answer->hold = table->buf[index]->hold_a;
-    table->buf[index]->hold_a = answer;
-}
-
-static pcc_lr_head_t *pcc_lr_table__get_head(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index) {
-    index += table->ofs;
-    if (index >= table->len || table->buf[index] == NULL) return NULL;
-    return table->buf[index]->head;
-}
-
-static pcc_lr_answer_t *pcc_lr_table__get_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule) {
+static packcr_lr_memo_t *packcr_lr_table__get_memo(packcr_context_t *ctx, packcr_lr_table_t *table, size_t index, packcr_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]->memos, rule);
+    return packcr_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) {
+static void packcr_lr_table__shift(packcr_context_t *ctx, packcr_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_table_entry__destroy(ctx, table->buf[table->ofs++]);
+    for (i = 0; i < count; i++) packcr_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_table_entry_t *) * (table->len - table->ofs));
+        memmove(table->buf, table->buf + table->ofs, sizeof(packcr_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) {
+static void packcr_lr_table__term(packcr_context_t *ctx, packcr_lr_table_t *table) {
     while (table->len > table->ofs) {
         table->len--;
-        pcc_lr_table_entry__destroy(ctx, table->buf[table->len]);
-    }
-    PCC_FREE(ctx->auxil, table->buf);
-}
-
-static pcc_lr_entry_t *pcc_lr_entry__create(pcc_auxil_t auxil, pcc_rule_t rule) {
-    pcc_lr_entry_t *const lr = (pcc_lr_entry_t *)PCC_MALLOC(auxil, sizeof(pcc_lr_entry_t));
-    lr->rule = rule;
-    lr->seed = NULL;
-    lr->head = NULL;
-    return lr;
-}
-
-static void pcc_lr_entry__destroy(pcc_auxil_t auxil, pcc_lr_entry_t *lr) {
-    PCC_FREE(auxil, lr);
-}
-
-static void pcc_lr_stack__init(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
-    stack->len = 0;
-    stack->max = 0;
-    stack->buf = NULL;
-}
-
-static void pcc_lr_stack__push(pcc_auxil_t auxil, pcc_lr_stack_t *stack, pcc_lr_entry_t *lr) {
-    if (stack->max <= stack->len) {
-        const size_t n = stack->len + 1;
-        size_t m = stack->max;
-        if (m == 0) m = PCC_ARRAY_MIN_SIZE;
-        while (m < n && m != 0) m <<= 1;
-        if (m == 0) m = n;
-        stack->buf = (pcc_lr_entry_t **)PCC_REALLOC(auxil, stack->buf, sizeof(pcc_lr_entry_t *) * m);
-        stack->max = m;
+        packcr_lr_memo_map__destroy(ctx, table->buf[table->len]);
     }
-    stack->buf[stack->len++] = lr;
+    PACKCR_FREE(ctx->auxil, table->buf);
 }
 
-static pcc_lr_entry_t *pcc_lr_stack__pop(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
-    return stack->buf[--stack->len];
-}
-
-static void pcc_lr_stack__term(pcc_auxil_t auxil, pcc_lr_stack_t *stack) {
-    PCC_FREE(auxil, stack->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->pos = 0;
-    ctx->cur = 0;
+static packcr_context_t *packcr_context__create(packcr_auxil_t auxil) {
+    packcr_context_t *const ctx = (packcr_context_t *)PACKCR_MALLOC(auxil, sizeof(packcr_context_t));
+    ctx->buffer_start_position = 0;
+    ctx->position_offset = 0;
 <%- if @location -%>
-    pcc_location_init(&ctx->pos_loc);
-    pcc_location_init(&ctx->cur_loc);
+    packcr_location_init(&ctx->buffer_start_position_loc);
+    packcr_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_lr_stack__init(auxil, &ctx->lrstack);
-    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_head_recycler, sizeof(pcc_lr_head_t));
-    pcc_memory_recycler__init(auxil, &ctx->lr_answer_recycler, sizeof(pcc_lr_answer_t));
+    packcr_char_array__init(auxil, &ctx->buffer);
+    packcr_lr_table__init(auxil, &ctx->lrtable);
+    packcr_thunk_array__init(auxil, &ctx->thunks);
+    packcr_memory_recycler__init(auxil, &ctx->thunk_chunk_recycler, sizeof(packcr_thunk_chunk_t));
+    packcr_memory_recycler__init(auxil, &ctx->lr_memo_recycler, sizeof(packcr_lr_memo_t));
     ctx->auxil = auxil;
     return ctx;
 }
 
-static void pcc_context__destroy(pcc_context_t *ctx) {
+static void packcr_context__destroy(packcr_context_t *ctx) {
     if (ctx == NULL) return;
-    pcc_thunk_array__term(ctx->auxil, &ctx->thunks);
-    pcc_lr_stack__term(ctx->auxil, &ctx->lrstack);
-    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_head_recycler);
-    pcc_memory_recycler__term(ctx->auxil, &ctx->lr_answer_recycler);
-    PCC_FREE(ctx->auxil, ctx);
-}
-
-static size_t pcc_refill_buffer(pcc_context_t *ctx, size_t num) {
-    if (ctx->buffer.len >= ctx->cur + num) return ctx->buffer.len - ctx->cur;
-    while (ctx->buffer.len < ctx->cur + num) {
-        const int c = PCC_GETCHAR(ctx->auxil);
+    packcr_thunk_array__term(ctx->auxil, &ctx->thunks);
+    packcr_lr_table__term(ctx, &ctx->lrtable);
+    packcr_char_array__term(ctx->auxil, &ctx->buffer);
+    packcr_memory_recycler__term(ctx->auxil, &ctx->thunk_chunk_recycler);
+    packcr_memory_recycler__term(ctx->auxil, &ctx->lr_memo_recycler);
+    PACKCR_FREE(ctx->auxil, ctx);
+}
+
+static size_t packcr_refill_buffer(packcr_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 = PACKCR_GETCHAR(ctx->auxil);
         if (c < 0) break;
-        pcc_char_array__add(ctx->auxil, &ctx->buffer, (char)c);
+        packcr_char_array__add(ctx->auxil, &ctx->buffer, (char)c);
     }
-    return ctx->buffer.len - ctx->cur;
+    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->cur, ctx->buffer.len - ctx->cur);
-    ctx->buffer.len -= ctx->cur;
-    ctx->pos += ctx->cur;
-    pcc_lr_table__shift(ctx, &ctx->lrtable, ctx->cur);
-    ctx->cur = 0;
+static void packcr_commit_buffer(packcr_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;
+    packcr_lr_table__shift(ctx, &ctx->lrtable, ctx->position_offset);
+    ctx->position_offset = 0;
 <%- if @location -%>
-    ctx->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
-    pcc_location_init(&ctx->cur_loc);
+    ctx->buffer_start_position_loc = packcr_location_add(ctx->buffer_start_position_loc, ctx->position_offset_loc);
+    packcr_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) {
+static const char *packcr_get_capture_string(packcr_context_t *ctx, const packcr_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);
+        ((packcr_capture_t *)capt)->string =
+            packcr_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 */
+static size_t packcr_get_char_as_utf32(packcr_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->cur];
+    if (packcr_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;
+    if (packcr_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->cur + 1];
+        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->cur + 1];
+        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->cur + 2];
+        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->cur + 1];
+        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->cur + 2];
+        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->cur + 3];
+        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;
@@ -1060,135 +873,120 @@ static size_t pcc_get_char_as_utf32(pcc_context_t *ctx, int *out) { /* with chec
 }
 
 <% end -%>
-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) {
-    static pcc_value_t null;
-    pcc_thunk_chunk_t *c = NULL;
-    const size_t p = ctx->pos + ctx->cur;
+static void packcr_grow_lr(packcr_context_t *ctx, packcr_rule_t rule, size_t offset<% if @location %>, packcr_location_t offset_loc<% end %>) {
+    while(1) {
+        const size_t old_offset = ctx->position_offset;
+        packcr_thunk_chunk_t *chunk;
+        packcr_lr_memo_t *memo;
+        packcr_rule_set_t limits;
+        ctx->position_offset = offset;
 <%- if @location -%>
-    const pcc_location_t p_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
+        ctx->position_offset_loc = offset_loc;
 <%- end -%>
-    pcc_bool_t b = PCC_TRUE;
-    pcc_lr_answer_t *a = pcc_lr_table__get_answer(ctx, &ctx->lrtable, p, rule);
-    pcc_lr_head_t *h = pcc_lr_table__get_head(ctx, &ctx->lrtable, p);
-    if (h != NULL) {
-        if (a == NULL && rule != h->rule && pcc_rule_set__index(ctx->auxil, &h->invol, rule) == PCC_VOID_VALUE) {
-            b = PCC_FALSE;
-            c = NULL;
-        }
-        else if (pcc_rule_set__remove(ctx->auxil, &h->eval, rule)) {
-            b = PCC_FALSE;
-            c = rule(ctx);
-            a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur<% if @location %>, pcc_location_add(ctx->pos_loc, ctx->cur_loc)<% end %>);
-            a->data.chunk = c;
-            pcc_lr_table__hold_answer(ctx, &ctx->lrtable, p, a);
+        packcr_rule_set__init(ctx->auxil, &limits);
+        packcr_rule_set__add(ctx->auxil, &limits, rule);
+        chunk = rule(ctx, offset<% if @location %>, offset_loc<% end %>, &limits);
+        packcr_rule_set__term(ctx->auxil, &limits);
+        if (!chunk)
+            break;
+        if (ctx->position_offset <= old_offset) {
+            packcr_thunk_chunk__destroy(ctx, chunk);
+            break;
         }
+        memo = packcr_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+        packcr_lr_memo__set_chunk(ctx, memo, chunk);
+        memo->offset = ctx->position_offset;
+        <%- if @location -%>
+        memo->offset_loc = ctx->position_offset_loc;
+        <%- end -%>
     }
-    if (b) {
-        if (a != NULL) {
-            ctx->cur = a->pos - ctx->pos;
-<%- if @location -%>
-            ctx->cur_loc = pcc_location_sub(a->pos_loc, ctx->pos_loc);
-<%- end -%>
-            switch (a->type) {
-            case PCC_LR_ANSWER_LR:
-                if (a->data.lr->head == NULL) {
-                    a->data.lr->head = pcc_lr_head__create(ctx, rule);
-                    pcc_lr_table__hold_head(ctx, &ctx->lrtable, p, a->data.lr->head);
-                }
-                {
-                    size_t i = ctx->lrstack.len;
-                    while (i > 0) {
-                        i--;
-                        if (ctx->lrstack.buf[i]->head == a->data.lr->head) break;
-                        ctx->lrstack.buf[i]->head = a->data.lr->head;
-                        pcc_rule_set__add(ctx->auxil, &a->data.lr->head->invol, ctx->lrstack.buf[i]->rule);
-                    }
-                }
-                c = a->data.lr->seed;
-                break;
-            case PCC_LR_ANSWER_CHUNK:
-                c = a->data.chunk;
-                break;
-            default: /* unknown */
-                break;
-            }
-        }
-        else {
-            pcc_lr_entry_t *const e = pcc_lr_entry__create(ctx->auxil, rule);
-            pcc_lr_stack__push(ctx->auxil, &ctx->lrstack, e);
-            a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_LR, p<% if @location %>, p_loc<% end %>);
-            a->data.lr = e;
-            pcc_lr_table__set_answer(ctx, &ctx->lrtable, p, rule, a);
-            c = rule(ctx);
-            pcc_lr_stack__pop(ctx->auxil, &ctx->lrstack);
-            a->pos = ctx->pos + ctx->cur;
+}
+
+MARK_FUNC_AS_USED
+static packcr_thunk_chunk_t *packcr_get_rule_thunk_chunk(packcr_context_t *ctx, packcr_rule_t rule) {
+    packcr_thunk_chunk_t *c = NULL;
+    size_t offset = ctx->position_offset;
 <%- if @location -%>
-            a->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
+    packcr_location_t offset_loc = ctx->position_offset_loc;
 <%- end -%>
-            if (e->head == NULL) {
-                pcc_lr_answer__set_chunk(ctx, a, c);
-            }
-            else {
-                e->seed = c;
-                h = a->data.lr->head;
-                if (h->rule != rule) {
-                    c = a->data.lr->seed;
-                    a = pcc_lr_answer__create(ctx, PCC_LR_ANSWER_CHUNK, ctx->pos + ctx->cur<% if @location %>, pcc_location_add(ctx->pos_loc, ctx->cur_loc)<% end %>);
-                    a->data.chunk = c;
-                    pcc_lr_table__hold_answer(ctx, &ctx->lrtable, p, a);
-                }
-                else {
-                    pcc_lr_answer__set_chunk(ctx, a, a->data.lr->seed);
-                    if (a->data.chunk == NULL) {
-                        c = NULL;
-                    }
-                    else {
-                        pcc_lr_table__set_head(ctx, &ctx->lrtable, p, h);
-                        for (;;) {
-                            ctx->cur = p - ctx->pos;
+    packcr_lr_memo_t *memo = packcr_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+
+    if (memo == NULL) {
+        memo = packcr_lr_memo__create(ctx, offset<% if @location %>, offset_loc<% end %>);
+        packcr_lr_table__set_memo(ctx, &ctx->lrtable, offset, rule, memo);
+        c = rule(ctx, offset<% if @location %>, offset_loc<% end %>, NULL);
+        packcr_lr_memo__set_chunk(ctx, memo, c);
+        memo->offset = ctx->position_offset;
 <%- if @location -%>
-                            ctx->cur_loc = pcc_location_sub(p_loc, ctx->pos_loc);
+        memo->offset_loc = ctx->position_offset_loc;
 <%- end -%>
-                            pcc_rule_set__copy(ctx->auxil, &h->eval, &h->invol);
-                            c = rule(ctx);
-                            if (c == NULL || ctx->pos + ctx->cur <= a->pos) break;
-                            pcc_lr_answer__set_chunk(ctx, a, c);
-                            a->pos = ctx->pos + ctx->cur;
+        if (memo->grow) {
+            packcr_grow_lr(ctx, rule, offset<% if @location %>, offset_loc<% end %>);
+            memo->grow = PACKCR_FALSE;
+            ctx->position_offset = memo->offset;
 <%- if @location -%>
-                            a->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
+            ctx->position_offset_loc = memo->offset_loc;
 <%- end -%>
-                        }
-                        pcc_thunk_chunk__destroy(ctx, c);
-                        pcc_lr_table__set_head(ctx, &ctx->lrtable, p, NULL);
-                        ctx->cur = a->pos - ctx->pos;
+            return memo->chunk;
+        }
+        return c;
+    } else if (memo->fail) {
+        packcr_lr_memo__set_chunk(ctx, memo, NULL);
+        memo->grow = PACKCR_TRUE;
+        return NULL;
+    }
+    ctx->position_offset = memo->offset;
 <%- if @location -%>
-                        ctx->cur_loc = pcc_location_sub(a->pos_loc, ctx->pos_loc);
+    ctx->position_offset_loc = memo->offset_loc;
 <%- end -%>
-                        c = a->data.chunk;
-                    }
-                }
+    return memo->chunk;
+}
+
+MARK_FUNC_AS_USED
+static packcr_bool_t packcr_apply_rule(packcr_context_t *ctx, packcr_rule_t rule, packcr_thunk_array_t *thunks, packcr_value_t *value, size_t offset<% if @location %>, packcr_location_t offset_loc<% end %>, packcr_rule_set_t *limits) {
+    static packcr_value_t null;
+    packcr_thunk_chunk_t *c;
+    if (limits != NULL) {
+        packcr_lr_memo_t *memo;
+        packcr_rule_set__add(ctx->auxil, limits, rule);
+        c = rule(ctx, offset<% if @location %>, offset_loc<% end %>, limits);
+        memo = packcr_lr_table__get_memo(ctx, &ctx->lrtable, offset, rule);
+        if (memo == NULL || ctx->position_offset <= memo->offset) {
+            if (memo) {
+                c = memo->chunk;
+                ctx->position_offset = memo->offset;
+                <%- if @location -%>
+                ctx->position_offset_loc = memo->offset_loc;
+                <%- end -%>
             }
+        } else {
+            packcr_lr_memo__set_chunk(ctx, memo, c);
+            memo->offset = ctx->position_offset;
+            <%- if @location -%>
+            memo->offset_loc = ctx->position_offset_loc;
+            <%- end -%>
         }
+    } else {
+        c = packcr_get_rule_thunk_chunk(ctx, rule);
     }
-    if (c == NULL) return PCC_FALSE;
+    if (c == NULL) return PACKCR_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;
+    memset(value, 0, sizeof(packcr_value_t)); /* in case */
+    packcr_thunk_array__add(ctx->auxil, thunks, packcr_thunk__create_node(ctx->auxil, &c->thunks, value));
+    return PACKCR_TRUE;
 }
 
 MARK_FUNC_AS_USED
-static void pcc_do_action(pcc_context_t *ctx, const pcc_thunk_array_t *thunks, pcc_value_t *value) {
+static void packcr_do_action(packcr_context_t *ctx, const packcr_thunk_array_t *thunks, packcr_value_t *value) {
     size_t i;
     for (i = 0; i < thunks->len; i++) {
-        pcc_thunk_t *const thunk = thunks->buf[i];
+        packcr_thunk_t *const thunk = thunks->buf[i];
         switch (thunk->type) {
-        case PCC_THUNK_LEAF:
+        case PACKCR_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);
+        case PACKCR_THUNK_NODE:
+            packcr_do_action(ctx, thunk->data.node.thunks, thunk->data.node.value);
             break;
         default: /* unknown */
             break;
@@ -1198,32 +996,32 @@ static void pcc_do_action(pcc_context_t *ctx, const pcc_thunk_array_t *thunks, p
 
 <%- @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)
+static void packcr_action_<%= rule.name %>_<%= code.index %>(<%= prefix %>_context_t *__packcr_ctx, packcr_thunk_t *__packcr_in, packcr_value_t *__packcr_out) {
+#define auxil (__packcr_ctx->auxil)
+#define __ (*__packcr_out)
 <%-     code.vars.each do |ref| -%>
-#define <%= ref.var %> (*__pcc_in->data.leaf.values.buf[<%= ref.index %>])
+#define <%= ref.var %> (*__packcr_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->pos + __pcc_in->data.leaf.capt0.range.start))
-#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
+#define _0 packcr_get_capture_string(__packcr_ctx, &__packcr_in->data.leaf.capt0)
+#define _0s ((const size_t)(__packcr_ctx->buffer_start_position + __packcr_in->data.leaf.capt0.range.start))
+#define _0e ((const size_t)(__packcr_ctx->buffer_start_position + __packcr_in->data.leaf.capt0.range.end))
 <%-     if @location -%>
-#define _0sl ((const pcc_location_t)(pcc_location_add(__pcc_ctx->pos_loc, *__pcc_in->data.leaf.capt0.range.start_loc_ptr)))
-#define _0el ((const pcc_location_t)(pcc_location_add(__pcc_ctx->pos_loc, *__pcc_in->data.leaf.capt0.range.end_loc_ptr)))
+#define _0sl ((const packcr_location_t)(packcr_location_add(__packcr_ctx->buffer_start_position_loc, __packcr_in->data.leaf.capt0.range.start_loc)))
+#define _0el ((const packcr_location_t)(packcr_location_add(__packcr_ctx->buffer_start_position_loc, __packcr_in->data.leaf.capt0.range.end_loc)))
 <%-     end -%>
 <%-     if @capture_in_code -%>
-#define _0c __pcc_in->data.leaf.capt0
+#define _0c __packcr_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->pos + __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.start))
-#define _<%= capture.index + 1 %>e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.end))
+#define _<%= capture.index + 1 %> packcr_get_capture_string(__packcr_ctx, __packcr_in->data.leaf.capts.buf[<%= capture.index %>])
+#define _<%= capture.index + 1 %>s ((const size_t)(__packcr_ctx->buffer_start_position + __packcr_in->data.leaf.capts.buf[<%= capture.index %>]->range.start))
+#define _<%= capture.index + 1 %>e ((const size_t)(__packcr_ctx->buffer_start_position + __packcr_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->pos_loc, *__pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.start_loc_ptr)))
-#define _<%= capture.index + 1 %>el ((const pcc_location_t)(pcc_location_add(__pcc_ctx->pos_loc, *__pcc_in->data.leaf.capts.buf[<%= capture.index %>]->range.end_loc_ptr)))
+#define _<%= capture.index + 1 %>sl ((const packcr_location_t)(packcr_location_add(__packcr_ctx->buffer_start_position_loc, __packcr_in->data.leaf.capts.buf[<%= capture.index %>]->range.start_loc)))
+#define _<%= capture.index + 1 %>el ((const packcr_location_t)(packcr_location_add(__packcr_ctx->buffer_start_position_loc, __packcr_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 %>])
+#define _<%= capture.index + 1 %>c (*__packcr_in->data.leaf.capts.buf[<%= capture.index %>])
 <%-       end -%>
 <%-     end -%>
 <%=     stream.get_code_block(code.code, 4, @iname) -%>
@@ -1249,40 +1047,33 @@ static void pcc_action_<%= rule.name %>_<%= code.index %>(<%= prefix %>_context_
 <%-   end -%>
 <%- end -%>
 <%- @root.rules.each do |rule| -%>
-static pcc_thunk_chunk_t *pcc_evaluate_rule_<%= rule.name %>(pcc_context_t *ctx);
+static packcr_thunk_chunk_t *packcr_evaluate_rule_<%= rule.name %>(packcr_context_t *ctx, size_t offset<% if @location %>, packcr_location_t offset_loc<% end %>, packcr_rule_set_t *limits);
 <%- end -%>
 
 <%- @root.rules.each do |rule| -%>
-static pcc_thunk_chunk_t *pcc_evaluate_rule_<%= rule.name %>(pcc_context_t *ctx) {
-    pcc_thunk_chunk_t *const chunk = pcc_thunk_chunk__create(ctx);
-    chunk->pos = ctx->cur;
-<%-   if @location -%>
-    chunk->pos_loc = ctx->cur_loc;
-<%-   end -%>
 <%-   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);
+    return packcr_context__create(auxil);
 }
 
 int <%= prefix %>_parse(<%= prefix %>_context_t *ctx, <%= value_def %>*ret) {
-    size_t pos = ctx->pos;
+    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))
-        pcc_do_action(ctx, &ctx->thunks, ret);
+    if (packcr_apply_rule(ctx, packcr_evaluate_rule_<%= @root.rules[0].name %>, &ctx->thunks, ret, ctx->position_offset<% if @location %>, ctx->position_offset_loc<% end %>, NULL))
+        packcr_do_action(ctx, &ctx->thunks, ret);
     else
-        PCC_ERROR(ctx->auxil);
-    pcc_commit_buffer(ctx);
+        PACKCR_ERROR(ctx->auxil);
+    packcr_commit_buffer(ctx);
 <%- end -%>
-    pcc_thunk_array__revert(ctx->auxil, &ctx->thunks, 0);
-    return pos != ctx->pos && pcc_refill_buffer(ctx, 1) >= 1;
+    packcr_thunk_array__revert(ctx->auxil, &ctx->thunks, 0);
+    return pos != ctx->buffer_start_position && packcr_refill_buffer(ctx, 1) >= 1;
 }
 
 void <%= prefix %>_destroy(<%= prefix %>_context_t *ctx) {
-    pcc_context__destroy(ctx);
+    packcr_context__destroy(ctx);
 }
 <%- if !code(:lsource).empty? -%>