packcr 0.0.6 → 0.0.7

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

@@ -81,8 +81,8 @@ typedef struct pcc_range_tag {
     size_t start;
     size_t end;
 <%- if @location -%>
-    pcc_location_t *start_loc_ptr;
-    pcc_location_t *end_loc_ptr;
+    pcc_location_t start_loc;
+    pcc_location_t end_loc;
 <%- end -%>
 } pcc_range_t;
 
@@ -171,31 +171,22 @@ typedef struct pcc_thunk_chunk_tag {
 <%- end -%>
 } pcc_thunk_chunk_t;
 
-typedef struct pcc_lr_entry_tag pcc_lr_entry_t;
+typedef struct pcc_lr_memo_tag pcc_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 pcc_lr_memo_tag {
+    size_t offset;
 <%- if @location -%>
-    pcc_location_t pos_loc;
+    pcc_location_t offset_loc;
 <%- end -%>
-    pcc_lr_answer_t *hold;
+    pcc_lr_memo_t *hold;
+    pcc_thunk_chunk_t *chunk;
+    pcc_bool_t fail;
+    pcc_bool_t grow;
 };
 
-typedef pcc_thunk_chunk_t *(*pcc_rule_t)(pcc_context_t *);
+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;
@@ -203,52 +194,24 @@ typedef struct pcc_rule_set_tag {
     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 pcc_lr_memo_tag {
+typedef struct pcc_lr_memo_map_entry_tag {
     pcc_rule_t rule;
-    pcc_lr_answer_t *answer;
-} pcc_lr_memo_t;
+    pcc_lr_memo_t *memo;
+} pcc_lr_memo_map_entry_t;
 
 typedef struct pcc_lr_memo_map_tag {
-    pcc_lr_memo_t *buf;
+    pcc_lr_memo_map_entry_t *buf;
     size_t max;
     size_t len;
 } pcc_lr_memo_map_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 pcc_lr_table_tag {
-    pcc_lr_table_entry_t **buf;
+    pcc_lr_memo_map_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 */
-};
-
-typedef struct pcc_lr_stack_tag {
-    pcc_lr_entry_t **buf;
-    size_t max;
-    size_t len;
-} pcc_lr_stack_t;
-
 typedef struct pcc_memory_entry_tag pcc_memory_entry_t;
 typedef struct pcc_memory_pool_tag pcc_memory_pool_t;
 
@@ -269,21 +232,19 @@ typedef struct pcc_memory_recycler_tag {
 } pcc_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;
+    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_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;
+    pcc_memory_recycler_t lr_memo_recycler;
 };
 
 #ifndef PCC_ERROR
@@ -424,12 +385,6 @@ 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 @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 -%>
     if (table->max < len) {
         size_t m = table->max;
         if (m == 0) m = PCC_ARRAY_MIN_SIZE;
@@ -442,10 +397,8 @@ static void pcc_capture_table__resize(pcc_auxil_t auxil, pcc_capture_table_t *ta
         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);
+        pcc_location_init(&table->buf[i].range.start_loc);
+        pcc_location_init(&table->buf[i].range.end_loc);
 <%- end -%>
         table->buf[i].string = NULL;
     }
@@ -456,10 +409,6 @@ static void pcc_capture_table__term(pcc_auxil_t auxil, pcc_capture_table_t *tabl
     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 -%>
     }
     PCC_FREE(auxil, table->buf);
 }
@@ -498,6 +447,10 @@ static pcc_thunk_t *pcc_thunk__create_leaf(pcc_auxil_t auxil, pcc_action_t actio
     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;
@@ -655,103 +608,40 @@ static pcc_bool_t pcc_rule_set__add(pcc_auxil_t auxil, pcc_rule_set_t *set, pcc_
     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;
-}
-
-static void pcc_rule_set__clear(pcc_auxil_t auxil, pcc_rule_set_t *set) {
-    set->len = 0;
-}
-
-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 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 -%>
-    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 = 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;
     }
-    return answer;
+    memo->chunk = chunk;
+    memo->fail = PCC_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 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;
     }
 }
 
@@ -769,11 +659,11 @@ static size_t pcc_lr_memo_map__index(pcc_context_t *ctx, pcc_lr_memo_map_t *map,
     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_answer_t *answer) {
+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_answer__destroy(ctx, map->buf[i].answer);
-        map->buf[i].answer = answer;
+        pcc_lr_memo__destroy(ctx, map->buf[i].memo);
+        map->buf[i].memo = memo;
     }
     else {
         if (map->max <= map->len) {
@@ -782,43 +672,38 @@ static void pcc_lr_memo_map__put(pcc_context_t *ctx, pcc_lr_memo_map_t *map, pcc
             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_t *)PCC_REALLOC(ctx->auxil, map->buf, sizeof(pcc_lr_memo_t) * m);
+            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].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) {
+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].answer : NULL;
+    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_answer__destroy(ctx, map->buf[map->len].answer);
+        pcc_lr_memo__destroy(ctx, map->buf[map->len].memo);
     }
     PCC_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 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_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 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) {
@@ -830,67 +715,38 @@ static void pcc_lr_table__init(pcc_auxil_t auxil, pcc_lr_table_t *table) {
 
 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_table_entry__destroy(ctx, table->buf[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_table_entry_t **)PCC_REALLOC(ctx->auxil, table->buf, sizeof(pcc_lr_table_entry_t *) * m);
+        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_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);
-    table->buf[index]->head = head;
-}
-
-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) {
+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_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;
+    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_answer_t *pcc_lr_table__get_answer(pcc_context_t *ctx, pcc_lr_table_t *table, size_t index, pcc_rule_t rule) {
+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]->memos, rule);
+    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_table_entry__destroy(ctx, table->buf[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_table_entry_t *) * (table->len - table->ofs));
+        memmove(table->buf, table->buf + table->ofs, sizeof(pcc_lr_memo_map_t *) * (table->len - table->ofs));
         table->len -= table->ofs;
         table->ofs = 0;
     }
@@ -899,66 +755,25 @@ static void pcc_lr_table__shift(pcc_context_t *ctx, pcc_lr_table_t *table, size_
 static void pcc_lr_table__term(pcc_context_t *ctx, pcc_lr_table_t *table) {
     while (table->len > table->ofs) {
         table->len--;
-        pcc_lr_table_entry__destroy(ctx, table->buf[table->len]);
+        pcc_lr_memo_map__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;
-    }
-    stack->buf[stack->len++] = lr;
-}
-
-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;
+    ctx->buffer_start_position = 0;
+    ctx->position_offset = 0;
 <%- if @location -%>
-    pcc_location_init(&ctx->pos_loc);
-    pcc_location_init(&ctx->cur_loc);
+    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_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));
+    pcc_memory_recycler__init(auxil, &ctx->lr_memo_recycler, sizeof(pcc_lr_memo_t));
     ctx->auxil = auxil;
     return ctx;
 }
@@ -966,35 +781,33 @@ static pcc_context_t *pcc_context__create(pcc_auxil_t auxil) {
 static void pcc_context__destroy(pcc_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_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->cur + num) return ctx->buffer.len - ctx->cur;
-    while (ctx->buffer.len < ctx->cur + 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->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;
+    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->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
-    pcc_location_init(&ctx->cur_loc);
+    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 -%>
 }
 
@@ -1011,7 +824,7 @@ static size_t pcc_get_char_as_utf32(pcc_context_t *ctx, int *out) { /* with chec
     int c, u;
     size_t n;
     if (pcc_refill_buffer(ctx, 1) < 1) return 0;
-    c = (int)(unsigned char)ctx->buffer.buf[ctx->cur];
+    c = (int)(unsigned char)ctx->buffer.buf[ctx->position_offset];
     n = (c < 0x80) ? 1 :
         ((c & 0xe0) == 0xc0) ? 2 :
         ((c & 0xf0) == 0xe0) ? 3 :
@@ -1024,30 +837,30 @@ static size_t pcc_get_char_as_utf32(pcc_context_t *ctx, int *out) { /* with chec
         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,116 +873,87 @@ 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 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 -%>
-    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);
+        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 -%>
     }
-    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;
-<%- if @location -%>
-            a->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_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;
-<%- if @location -%>
-                            ctx->cur_loc = pcc_location_sub(p_loc, ctx->pos_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;
+}
+
+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 -%>
-                            a->pos_loc = pcc_location_add(ctx->pos_loc, ctx->cur_loc);
+    pcc_location_t offset_loc = ctx->position_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;
+    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 -%>
-                        ctx->cur_loc = pcc_location_sub(a->pos_loc, ctx->pos_loc);
+        a->offset_loc = ctx->position_offset_loc;
 <%- end -%>
-                        c = a->data.chunk;
-                    }
-                }
-            }
+        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;
@@ -1205,22 +989,22 @@ static void pcc_action_<%= rule.name %>_<%= code.index %>(<%= prefix %>_context_
 #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->pos + __pcc_in->data.leaf.capt0.range.start))
-#define _0e ((const size_t)(__pcc_ctx->pos + __pcc_in->data.leaf.capt0.range.end))
+#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->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 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->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 %>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->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 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 %>])
@@ -1249,19 +1033,12 @@ 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 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| -%>
-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) {
@@ -1269,16 +1046,16 @@ static pcc_thunk_chunk_t *pcc_evaluate_rule_<%= rule.name %>(pcc_context_t *ctx)
 }
 
 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))
+    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->pos && pcc_refill_buffer(ctx, 1) >= 1;
+    return pos != ctx->buffer_start_position && pcc_refill_buffer(ctx, 1) >= 1;
 }
 
 void <%= prefix %>_destroy(<%= prefix %>_context_t *ctx) {