parsergen: remove starts_line and min_prefix

Neither of these are wanted any more.

Signed-off-by: NeilBrown <neil@brown.name>

diff --git a/csrc/parsergen.mdc b/csrc/parsergen.mdc
index e74054d7996a883d59c2907e9f17ea04164e38e7..106f5f3e9f070717aac525d7a521ee159e2fb8ac 100644 (file)
--- a/csrc/parsergen.mdc
+++ b/csrc/parsergen.mdc
@@ -1177,17 +1177,6 @@ particularly for LALR where itemsets get merged, at which point they
 need to be consider for completion again.  So a `completed` flag is
 needed.
 
 need to be consider for completion again.  So a `completed` flag is
 needed.
 

-Finally, for handling `TK_out` we need to know whether productions in the
-current state started *before* the most recent indent.  A state
-doesn't usually keep details of individual productions, so we need to
-add one extra detail. `min_prefix` is the smallest non-zero number of
-symbols *before* DOT in any production in an itemset.  This will allow
-us to determine if the the most recent indent is sufficiently recent
-to cancel it against a `TK_out`.  If it was seen longer ago than the
-`min_prefix`, and if the current state cannot be reduced, then the
-indented section must have ended in the middle of a syntactic unit, so
-an error must be signaled.
-

 And now we can build the list of itemsets.  The lookup routine returns
 both a success flag and a pointer to where in the list an insert should
 happen, so we don't need to search a second time.
 And now we can build the list of itemsets.  The lookup routine returns
 both a success flag and a pointer to where in the list an insert should
 happen, so we don't need to search a second time.


@@ -1201,8 +1190,6 @@ happen, so we don't need to search a second time.
                enum assoc assoc;
                unsigned short precedence;
                char completed;
                enum assoc assoc;
                unsigned short precedence;
                char completed;

-               char starts_line;
-               int min_prefix;

        };
 
 ###### grammar fields
        };
 
 ###### grammar fields


@@ -1321,9 +1308,6 @@ so the item is ineffective.
                struct symset LA = INIT_SYMSET;
                unsigned short sn = 0;
 
                struct symset LA = INIT_SYMSET;
                unsigned short sn = 0;
 

-               if (is->min_prefix == 0 ||
-                   (bs > 0 && bs < is->min_prefix))
-                       is->min_prefix = bs;

                if (bs == pr->body_size)
                        continue;
                s = pr->body[bs];
                if (bs == pr->body_size)
                        continue;
                s = pr->body[bs];


@@ -1697,8 +1681,7 @@ Now we can report all the item sets complete with items, LA sets, and GO TO.
                for (s = 0; s < g->states; s++) {
                        int j;
                        struct itemset *is = g->statetab[s];
                for (s = 0; s < g->states; s++) {
                        int j;
                        struct itemset *is = g->statetab[s];

-                       printf("  Itemset %d:%s min prefix=%d",
-                              s, is->starts_line?" (startsline)":"", is->min_prefix);
+                       printf("  Itemset %d:", s);

                        if (is->precedence)
                                printf(" %d%s", is->precedence, assoc_names[is->assoc]);
                        printf("\n");
                        if (is->precedence)
                                printf(" %d%s", is->precedence, assoc_names[is->assoc]);
                        printf("\n");


@@ -1974,9 +1957,7 @@ The go to table is stored in a simple array of `sym` and corresponding
                short reduce_prod;
                short reduce_size;
                short reduce_sym;
                short reduce_prod;
                short reduce_size;
                short reduce_sym;

-               char starts_line;

                char newline_only;
                char newline_only;

-               short min_prefix;

                short result_size;
        };
 
                short result_size;
        };
 


@@ -2025,18 +2006,15 @@ The go to table is stored in a simple array of `sym` and corresponding
                                }
                        }
                        if (is->go_to.cnt)
                                }
                        }
                        if (is->go_to.cnt)

-                               fprintf(f, "\t[%d] = { %d, goto_",
+                               fprintf(f, "\t[%d] = { %d, goto_%d, ",

                                        i, is->go_to.cnt, i);
                        else
                                fprintf(f, "\t[%d] = { 0, NULL, ", i);
                        if (prod >= 0) {
                                struct production *pr = g->productions[prod];
                                struct symbol *hd = pr->head;
                                        i, is->go_to.cnt, i);
                        else
                                fprintf(f, "\t[%d] = { 0, NULL, ", i);
                        if (prod >= 0) {
                                struct production *pr = g->productions[prod];
                                struct symbol *hd = pr->head;

-                               fprintf(f, "%d, %d, %d, %d, %d, %d, ", prod,
-                                       pr->body_size,
-                                       pr->head->num,
-                                       is->starts_line,
-                                       is->min_prefix);
+                               fprintf(f, "%d, %d, %d, ", 
+                                       prod, pr->body_size, pr->head->num);

                                if (hd->struct_name.txt == NULL)
                                        fprintf(f, "0 },\n");
                                else
                                if (hd->struct_name.txt == NULL)
                                        fprintf(f, "0 },\n");
                                else


@@ -2045,8 +2023,7 @@ The go to table is stored in a simple array of `sym` and corresponding
                                                hd->struct_name.txt,
                                                hd->isref ? "*" : "");
                        } else
                                                hd->struct_name.txt,
                                                hd->isref ? "*" : "");
                        } else

-                               fprintf(f, "-1, -1, -1, %d, %d, -1 },\n",
-                                       is->starts_line, is->min_prefix);
+                               fprintf(f, "-1, -1, -1, -1 },\n");

                }
                fprintf(f, "};\n\n");
        }
                }
                fprintf(f, "};\n\n");
        }


@@ -2703,11 +2680,6 @@ stack is empty, it always chooses zero as the next state.
 So `shift` finds the next state.  If that succeeds it extends the
 allocations if needed and pushes all the information onto the stacks.
 
 So `shift` finds the next state.  If that succeeds it extends the
 allocations if needed and pushes all the information onto the stacks.
 

-Newlines are permitted after a `starts_line` state until an internal
-indent.  If the new frame has neither a `starts_line` state nor an
-indent, newlines are permitted if the previous stack frame permitted
-them.
-

 ###### parser functions
 
        static int shift(struct parser *p,
 ###### parser functions
 
        static int shift(struct parser *p,


@@ -2733,15 +2705,6 @@ them.
                next.sym = sym;
                next.indents = indents;
                next.state = newstate;
                next.sym = sym;
                next.indents = indents;
                next.state = newstate;

-               if (states[newstate].starts_line)
-                       next.newline_permitted = 1;
-               else if (indents)
-                       next.newline_permitted = 0;
-               else if (p->tos)
-                       next.newline_permitted =
-                               p->stack[p->tos-1].newline_permitted;
-               else
-                       next.newline_permitted = 0;

 
                if (!start_of_line) {
                        if (p->tos)
 
                if (!start_of_line) {
                        if (p->tos)


@@ -2900,8 +2863,6 @@ checks if a given token is in any of these look-ahead sets.
                                tos->indents += 1;
                                tos->since_newline = 0;
                                tos->since_indent = 0;
                                tos->indents += 1;
                                tos->since_newline = 0;
                                tos->since_indent = 0;

-                               if (!states[tos->state].starts_line)
-                                       tos->newline_permitted = 0;

                                free(tk);
                                tk = NULL;
                                parser_trace_action(trace, "Record");
                                free(tk);
                                tk = NULL;
                                parser_trace_action(trace, "Record");


@@ -2911,7 +2872,7 @@ checks if a given token is in any of these look-ahead sets.
                                if (states[tos->state].reduce_size >= 0 &&
                                    states[tos->state].reduce_size <= tos->since_indent)
                                        goto force_reduce;
                                if (states[tos->state].reduce_size >= 0 &&
                                    states[tos->state].reduce_size <= tos->since_indent)
                                        goto force_reduce;

-                               if (states[tos->state].min_prefix >= tos->since_indent) {
+                               if (1) {

                                        // OK to cancel
                                        struct frame *in = tos - tos->since_indent;
                                        in->indents -= 1;
                                        // OK to cancel
                                        struct frame *in = tos - tos->since_indent;
                                        in->indents -= 1;


@@ -2924,15 +2885,9 @@ checks if a given token is in any of these look-ahead sets.
                                                        in->since_indent = 0;
                                                        in->newline_permitted = 0;
                                                }
                                                        in->since_indent = 0;
                                                        in->newline_permitted = 0;
                                                }

-                                               if (states[in->state].starts_line)
-                                                       in->newline_permitted = 1;

                                                while (in < tos) {
                                                        in += 1;
                                                        in->since_indent = in[-1].since_indent + 1;
                                                while (in < tos) {
                                                        in += 1;
                                                        in->since_indent = in[-1].since_indent + 1;

-                                                       if (states[in->state].starts_line)
-                                                               in->newline_permitted = 1;
-                                                       else
-                                                               in->newline_permitted = in[-1].newline_permitted;

                                                }
                                        }
                                        free(tk);
                                                }
                                        }
                                        free(tk);


@@ -3089,15 +3044,6 @@ end inside square brackets.
                [TK_newline]      = "NEWLINE",
                [TK_eof]          = "$eof",
        };
                [TK_newline]      = "NEWLINE",
                [TK_eof]          = "$eof",
        };

-       static void parser_trace_state(FILE *trace, struct frame *f, const struct state states[])
-       {
-               fprintf(trace, "(%d", f->state);
-               if (states[f->state].starts_line)
-                       fprintf(trace, "s");
-               if (f->newline_permitted)
-                       fprintf(trace, "n%d", f->since_newline);
-               fprintf(trace, ") ");
-       }

 
        void parser_trace(FILE *trace, struct parser *p,
                          struct token *tk, const struct state states[],
 
        void parser_trace(FILE *trace, struct parser *p,
                          struct token *tk, const struct state states[],


@@ -3125,7 +3071,7 @@ end inside square brackets.
                                        fputs("/", trace);
                                fputs(" ", trace);
                        }
                                        fputs("/", trace);
                                fputs(" ", trace);
                        }

-                       parser_trace_state(trace, f, states);
+                       fprintf(trace, "(%d) ", f->state);

                }
                fprintf(trace, "[");
                if (tk->num < TK_reserved &&
                }
                fprintf(trace, "[");
                if (tk->num < TK_reserved &&