Nicer output with '--dump-dfa-raw' and '--posix-captures'.

Don't add closure items to "shadowed" set if there is an identical
"unshadowed" item: otherwise Goldberg-Radzik algorithm generates too much
"shadowed" items and the output becomes too noisy.

diff --git a/re2c/src/dfa/closure.cc b/re2c/src/dfa/closure.cc
index 3791f79157e62692e7c3b90aeb5d092cc752395d..23e61b483bcde806072e20972e7bda94fee77dee 100644 (file)
--- a/re2c/src/dfa/closure.cc
+++ b/re2c/src/dfa/closure.cc
@@ -12,7 +12,7 @@ static void closure_posix(const closure_t &clos1, closure_t &clos,
        closure_t *shadow, Tagpool &tagpool, const std::vector<Tag> &tags);
 static void closure_leftmost(const closure_t &clos1, closure_t &clos,
        closure_t *shadow, Tagpool &tagpool);
-static bool better(const clos_t &c1, const clos_t &c2, Tagpool &tagpool, const std::vector<Tag> &tags);
+static int32_t compare_posix(const clos_t &c1, const clos_t &c2, Tagpool &tagpool, const std::vector<Tag> &tags);
 static void prune(closure_t &clos, std::valarray<Rule> &rules);
 static void lower_lookahead_to_transition(closure_t &clos);
 static tcmd_t *generate_versions(closure_t &clos, const std::vector<Tag> &tags,
@@ -93,12 +93,11 @@ static void enqueue(clos_t x, std::stack<nfa_state_t*> &bstack, closure_t &done,
        if (i == NOCLOS) {
                i = static_cast<uint32_t>(done.size());
                done.push_back(x);
-       } else if (better(done[i], x, tagpool, tags)) {
-               if (shadow) shadow->push_back(done[i]);
-               done[i] = x;
        } else {
-               if (shadow) shadow->push_back(x);
-               return;
+               const int32_t cmp = compare_posix(x, done[i], tagpool, tags);
+               if (cmp < 0) std::swap(x, done[i]);
+               if (shadow && cmp != 0) shadow->push_back(x);
+               if (cmp >= 0) return;
        }
 
        if (n->status != GOR_TOPSORT) {
@@ -207,11 +206,11 @@ void closure_posix(const closure_t &init, closure_t &done,
  * with the highest priority (see note [closure items are sorted by rule]).
  */
 
-bool better(const clos_t &c1, const clos_t &c2,
+int32_t compare_posix(const clos_t &c1, const clos_t &c2,
        Tagpool &tagpool, const std::vector<Tag> &tags)
 {
        if (tagpool.ntags == 0
-               || (c1.order == c2.order && c1.tlook == c2.tlook)) return false;
+               || (c1.order == c2.order && c1.tlook == c2.tlook)) return 0;
 
        tagtree_t &h = tagpool.history;
        for (size_t t = 0; t < tagpool.ntags; ++t) {
@@ -221,10 +220,9 @@ bool better(const clos_t &c1, const clos_t &c2,
                        o1 = tagpool[c1.order][t],
                        o2 = tagpool[c2.order][t];
                const int32_t cmp = h.compare_histories(i1, i2, o1, o2, t, orbit(tags[t]));
-               if (cmp < 0) return false;
-               if (cmp > 0) return true;
+               if (cmp != 0) return cmp;
        }
-       return false;
+       return 0;
 }
 
 void closure_leftmost(const closure_t &init, closure_t &done,

diff --git a/re2c/src/dfa/dump.cc b/re2c/src/dfa/dump.cc
index bc67c525c49c9e2a6f832e5d39aded2a237963ea..e512833ed787d27d28067bf5f5790f0eaa6125be 100644 (file)
--- a/re2c/src/dfa/dump.cc
+++ b/re2c/src/dfa/dump.cc
@@ -69,19 +69,14 @@ void dump_dfa_t::closure_tags(cclositer_t c)
 
        const hidx_t l = c->tlook;
        const tagver_t *vers = tagpool[c->tvers];
-       const tagver_t *ords = tagpool[c->order];
+//     const tagver_t *ords = tagpool[c->order];
        const size_t ntag = tagpool.ntags;
 
        for (size_t t = 0; t < ntag; ++t) {
                fprintf(stderr, " %s%d", tagname(dfa.tags[t]), abs(vers[t]));
-               if (tagpool.opts->posix_captures) {
-                       const tagver_t o = ords[t];
-                       if (o == TAGVER_BOTTOM) {
-                               fprintf(stderr, "[?]");
-                       } else {
-                               fprintf(stderr, "[%d]", o);
-                       }
-               }
+//             if (tagpool.opts->posix_captures) {
+//                     fprintf(stderr, "[%d]", ords[t]);
+//             }
        }
 
        if (l != HROOT) {