parergen: fix bug in deriving itemsets

[ocean] / csrc / parsergen.mdc

diff --git a/csrc/parsergen.mdc b/csrc/parsergen.mdc
index f2bbe0151d75977dd2b2ae9f16031f4c171a5949..a6486df26025ab252fd4fc446aea2c3dda02e9aa 100644 (file)
--- a/csrc/parsergen.mdc
+++ b/csrc/parsergen.mdc
@@ -1072,6 +1072,9 @@ and we find the set of possible "first" symbols after there.  This is
 done using `add_first` above and only needs to be done once as the
 "first" sets are now stable and will not change.
 
+###### grammar fields
+       struct symset *follow;
+
 ###### follow code
 
        for (p = 0; p < g->production_count; p++) {
@@ -1121,9 +1124,6 @@ combine these two functions into a single loop.
 We now just need to create and initialise the `follow` list to get a
 complete function.
 
-###### grammar fields
-       struct symset *follow;
-
 ###### functions
        static void build_follow(struct grammar *g)
        {
@@ -1488,18 +1488,21 @@ itemsets (or merged with a pre-existing itemset).
                                continue;
                        if (pr->body[bp] != sym)
                                continue;
+
+                       bp += 1;
                        if (type >= LALR)
                                la = is->items.data[j];
-                       pos = symset_find(&newitemset, pr->head->num);
-                       if (bp + 1 == pr->body_size &&
+                       if (bp == pr->body_size &&
                            pr->precedence > 0 &&
                            pr->precedence > precedence) {
                                // new itemset is reducible and has a precedence.
                                precedence = pr->precedence;
                                assoc = pr->assoc;
                        }
+                       pos = symset_find(&newitemset, item_num(p, bp));
+
                        if (pos < 0)
-                               symset_add(&newitemset, item_num(p, bp+1), la);
+                               symset_add(&newitemset, item_num(p, bp), la);
                        else if (type >= LALR) {
                                // Need to merge la set.
                                int la2 = newitemset.data[pos];
@@ -2073,8 +2076,6 @@ The go to table is stored in a simple array of `sym` and corresponding
                }
        }
 
-###### functions
-
        static void gen_states(FILE *f, struct grammar *g)
        {
                int i;
@@ -2206,7 +2207,7 @@ transformed, and will cause an error when the code is compiled.
                        c = *name;
                }
                if (namlen == 0) {
-                       if (name == *namep)
+                       if (name == *namep || n > p->body_size)
                                return -1;
                        *namep = name;
                        return n;
@@ -2215,8 +2216,10 @@ transformed, and will cause an error when the code is compiled.
                for (i = 0; i < p->body_size; i++) {
                        if (!subseq_match(nam, namlen, p->body[i]->name))
                                continue;
-                       if (slen == 0 || p->body[i]->name.len < slen)
+                       if (slen == 0 || p->body[i]->name.len < slen) {
                                s = i;
+                               slen = p->body[i]->name.len;
+                       }
                        if (s >= 0 && p->body[i] != p->body[s] &&
                            p->body[i]->name.len == p->body[s]->name.len)
                                /* not unique, so s cannot be used */
@@ -2224,7 +2227,7 @@ transformed, and will cause an error when the code is compiled.
                }
                if (s < 0)
                        return -1;
-               if (n == 0);
+               if (n == 0)
                        n = 1;
                for (i = 0; i < p->body_size; i++)
                        if (p->body[i] == p->body[s]) {
@@ -2232,7 +2235,7 @@ transformed, and will cause an error when the code is compiled.
                                if (n == 0)
                                        break;
                        }
-               if (n > 1)
+               if (n > 0 || i == p->body_size)
                        return -1;
                *namep = name;
                return i + 1;
@@ -2303,15 +2306,15 @@ transformed, and will cause an error when the code is compiled.
 ###### functions
 
        static void gen_reduce(FILE *f, struct grammar *g, char *file,
-                              struct code_node *code)
+                              struct code_node *pre_reduce)
        {
                int i;
                fprintf(f, "#line 1 \"gen_reduce\"\n");
                fprintf(f, "static int do_reduce(int prod, void **body, struct token_config *config, void *ret)\n");
                fprintf(f, "{\n");
                fprintf(f, "\tint ret_size = 0;\n");
-               if (code)
-                       code_node_print(f, code, file);
+               if (pre_reduce)
+                       code_node_print(f, pre_reduce, file);
 
                fprintf(f, "#line 4 \"gen_reduce\"\n");
                fprintf(f, "\tswitch(prod) {\n");
@@ -2446,7 +2449,7 @@ grammar file).
                case 't':
                        tag = optarg; break;
                default:
-                       fprintf(stderr, "Usage: parsergen ...\n");
+                       fprintf(stderr, "Usage: parsergen -[05SL1R] [-t tag] [-o output] input\n");
                        exit(1);
                }
        }
@@ -2662,6 +2665,35 @@ table.
                        return -1;
        }
 
+### Memory allocation
+
+The `scanner` returns tokens in a local variable - we want them in allocated
+memory so they can live in the `asn_stack`.  Similarly the `asn` produced by
+a reduce is in a large buffer.  Both of these require some allocation and
+copying, hence `memdup` and `tok_copy`.
+
+###### parser includes
+       #include <memory.h>
+
+###### parser functions
+
+       void *memdup(void *m, int len)
+       {
+               void *ret;
+               if (len == 0)
+                       return NULL;
+               ret = malloc(len);
+               memcpy(ret, m, len);
+               return ret;
+       }
+
+       static struct token *tok_copy(struct token tk)
+       {
+               struct token *new = malloc(sizeof(*new));
+               *new = tk;
+               return new;
+       }
+
 ### The state stack.
 
 The core data structure for the parser is the stack.  This tracks all
@@ -2834,35 +2866,6 @@ before we `shift` the nonterminal in.
                return indents;
        }
 
-### Memory allocation
-
-The `scanner` returns tokens in a local variable - we want them in allocated
-memory so they can live in the `asn_stack`.  Similarly the `asn` produced by
-a reduce is in a large buffer.  Both of these require some allocation and
-copying, hence `memdup` and `tokcopy`.
-
-###### parser includes
-       #include <memory.h>
-
-###### parser functions
-
-       void *memdup(void *m, int len)
-       {
-               void *ret;
-               if (len == 0)
-                       return NULL;
-               ret = malloc(len);
-               memcpy(ret, m, len);
-               return ret;
-       }
-
-       static struct token *tok_copy(struct token tk)
-       {
-               struct token *new = malloc(sizeof(*new));
-               *new = tk;
-               return new;
-       }
-
 ### The heart of the parser.
 
 Now we have the parser.  For each token we might shift it, trigger a