Hid internals of skeleton paths under construction.

diff --git a/re2c/src/codegen/skeleton/path.cc b/re2c/src/codegen/skeleton/path.cc
index e83b507e6a2ddd3653a165910c525cf185a1732a..adb62bdf71ebb116b78c1c6447248f96063f2e63 100644 (file)
--- a/re2c/src/codegen/skeleton/path.cc
+++ b/re2c/src/codegen/skeleton/path.cc
@@ -3,38 +3,58 @@
 namespace re2c
 {
 
-Path::Path (const chars_t & cs, size_t l, rule_rank_t r)
-       : chars (cs)
-       , length (l)
-       , rule (r)
+path_t::path_t ()
+       : arcs ()
+       , rule (rule_rank_t::none ())
+       , rule_pos (0)
 {}
 
-void Path::update (rule_rank_t r)
+size_t path_t::len () const
+{
+       return arcs.size ();
+}
+
+size_t path_t::len_matching () const
+{
+       return rule_pos;
+}
+
+rule_rank_t path_t::match () const
+{
+       return rule;
+}
+
+uint32_t path_t::operator [] (size_t i) const
+{
+       return arcs[i];
+}
+
+void path_t::update (rule_rank_t r)
 {
        if (!r.is_none ())
        {
-               length = chars.size ();
                rule = r;
+               rule_pos = arcs.size ();
        }
 }
 
-void Path::extend (rule_rank_t r, uint32_t c)
+void path_t::extend (rule_rank_t r, uint32_t c)
 {
        update (r);
-       chars.push_back (c);
+       arcs.push_back (c);
 }
 
-void Path::append (const Path * p)
+void path_t::append (const path_t * p)
 {
        if (!p->rule.is_none ())
        {
-               length = chars.size () + p->length;
                rule = p->rule;
+               rule_pos = arcs.size () + p->rule_pos;
        }
-       const size_t sz = p->chars.size ();
+       const size_t sz = p->arcs.size ();
        for (size_t i = 0; i < sz; ++i)
        {
-               chars.push_back (p->chars[i]);
+               arcs.push_back (p->arcs[i]);
        }
 }
 

diff --git a/re2c/src/codegen/skeleton/path.h b/re2c/src/codegen/skeleton/path.h
index 6aaa4a836bdfcd57694c1cbec62b2594351fa607..29539f043be1ce6d618a80d86b864c388a237d77 100644 (file)
--- a/re2c/src/codegen/skeleton/path.h
+++ b/re2c/src/codegen/skeleton/path.h
@@ -9,18 +9,21 @@
 namespace re2c
 {
 
-struct Path
+class path_t
 {
-       typedef std::vector<uint32_t> chars_t;
-
-       chars_t chars;
-       size_t length;
+       std::vector<uint32_t> arcs;
        rule_rank_t rule;
-
-       Path (const chars_t & cs, size_t l, rule_rank_t r);
+       size_t rule_pos;
+
+public:
+       path_t ();
+       size_t len () const;
+       size_t len_matching () const;
+       rule_rank_t match () const;
+       uint32_t operator [] (size_t i) const;
        void update (rule_rank_t r);
        void extend (rule_rank_t r, uint32_t c);
-       void append (const Path * p);
+       void append (const path_t * p);
 };
 
 } // namespace re2c

diff --git a/re2c/src/codegen/skeleton/skeleton.cc b/re2c/src/codegen/skeleton/skeleton.cc
index 6cb75bff5e9395aa6ed9a9d9bc52ffa8f827d2ab..c8af5425e8d9992735a1ffe4b0c2037d7d6886c7 100644 (file)
--- a/re2c/src/codegen/skeleton/skeleton.cc
+++ b/re2c/src/codegen/skeleton/skeleton.cc
@@ -26,7 +26,8 @@ Node::Node (const State * s, const s2n_map & s2n)
        if (is_final)
        {
                path_len_init = true;
-               path = new Path (Path::chars_t (), 0, rule);
+               path = new path_t;
+               path->update (rule);
        }
        else
        {
@@ -147,7 +148,7 @@ arccount_t Node::estimate_size_cover (arccount_t wid, arccount_t len)
        }
 }
 
-void Node::generate_paths_all (const std::vector<Path> & prefixes, std::vector<Path> & results)
+void Node::generate_paths_all (const std::vector<path_t> & prefixes, std::vector<path_t> & results)
 {
        const size_t wid = prefixes.size ();
        if (end ())
@@ -163,7 +164,7 @@ void Node::generate_paths_all (const std::vector<Path> & prefixes, std::vector<P
                local_inc _ (loop);
                for (arcs_t::iterator i = arcs.begin (); i != arcs.end (); ++i)
                {
-                       std::vector<Path> zs;
+                       std::vector<path_t> zs;
                        for (size_t j = 0; j < wid; ++j)
                        {
                                const size_t new_wid = i->second.size ();
@@ -178,7 +179,7 @@ void Node::generate_paths_all (const std::vector<Path> & prefixes, std::vector<P
        }
 }
 
-void Node::generate_paths_cover (const std::vector<Path> & prefixes, std::vector<Path> & results)
+void Node::generate_paths_cover (const std::vector<path_t> & prefixes, std::vector<path_t> & results)
 {
        const size_t wid = prefixes.size ();
        if (path != NULL)
@@ -195,7 +196,7 @@ void Node::generate_paths_cover (const std::vector<Path> & prefixes, std::vector
                size_t w = 0;
                for (wrap_iter i (arcs); !i.end () || w < wid; ++i)
                {
-                       std::vector<Path> zs;
+                       std::vector<path_t> zs;
                        const size_t new_wid = i->second.size ();
                        for (size_t j = 0; j < new_wid; ++j)
                        {
@@ -208,7 +209,8 @@ void Node::generate_paths_cover (const std::vector<Path> & prefixes, std::vector
                                w += new_wid;
                                if (path == NULL)
                                {
-                                       path = new Path (Path::chars_t (1, i->second[0]), 0, rule);
+                                       path = new path_t;
+                                       path->extend (rule, i->second[0]);
                                        path->append (i->first->path);
                                }
                        }
@@ -245,10 +247,10 @@ Skeleton::~Skeleton ()
        operator delete (nodes);
 }
 
-void Skeleton::generate_paths (std::vector<Path> & results)
+void Skeleton::generate_paths (std::vector<path_t> & results)
 {
-       std::vector<Path> prefixes;
-       prefixes.push_back (Path (Path::chars_t (), 0, rule_rank_t::none ()));
+       std::vector<path_t> prefixes;
+       prefixes.push_back (path_t ());
 
        if (nodes->estimate_size_all (arccount_t (1u), arccount_t (0u)).overflow ())
        {
@@ -296,7 +298,7 @@ void Skeleton::emit_data (DataFile & o)
        o.file << indent (ind) << "YYCTYPE data [] =\n";
        o.file << indent (ind) << "{\n";
 
-       std::vector<Path> ys;
+       std::vector<path_t> ys;
        generate_paths (ys);
 
        const size_t count = ys.size ();
@@ -304,18 +306,19 @@ void Skeleton::emit_data (DataFile & o)
        size_t max_len = 0;
        for (size_t i = 0; i < count; ++i)
        {
-               if (max_len < ys[i].chars.size ())
+               const size_t len = ys[i].len ();
+               if (max_len < len)
                {
-                       max_len = ys[i].chars.size ();
+                       max_len = len;
                }
        }
        for (size_t i = 0; i < count; ++i)
        {
                o.file << indent (ind + 1);
-               const size_t len = ys[i].chars.size ();
+               const size_t len = ys[i].len ();
                for (size_t j = 0 ; j < len; ++j)
                {
-                       prtChOrHex (o.file, ys[i].chars[j]);
+                       prtChOrHex (o.file, ys[i][j]);
                        o.file << ",";
                }
                o.file << "\n";
@@ -342,8 +345,8 @@ void Skeleton::emit_data (DataFile & o)
        o.file << indent (ind) << "{\n";
        for (size_t i = 0; i < count; ++i)
        {
-               const size_t new_pos = pos + ys[i].chars.size ();
-               o.file << indent (ind + 1) << "Result (" << pos + ys[i].length << "," << new_pos << "," << ys[i].rule << "),\n";
+               const size_t new_pos = pos + ys[i].len ();
+               o.file << indent (ind + 1) << "Result (" << pos + ys[i].len_matching () << "," << new_pos << "," << ys[i].match () << "),\n";
                pos = new_pos;
        }
        o.file << indent (ind) << "};\n";

diff --git a/re2c/src/codegen/skeleton/skeleton.h b/re2c/src/codegen/skeleton/skeleton.h
index 3a624db25b62e381fe49f63777b46cc49e13131f..d36993b11b676dcabd21246ecd70d7f20c358649 100644 (file)
--- a/re2c/src/codegen/skeleton/skeleton.h
+++ b/re2c/src/codegen/skeleton/skeleton.h
@@ -40,15 +40,15 @@ struct Node
        // stuff for constructing path cover (for large graphs)
        bool path_len_init;
        arccount_t path_len;
-       Path * path;
+       path_t * path;
 
        Node (const State * s, const s2n_map & s2n);
        ~Node ();
        bool end () const;
        arccount_t estimate_size_all (arccount_t inarcs, arccount_t len);
        arccount_t estimate_size_cover (arccount_t inarcs, arccount_t len);
-       void generate_paths_all (const std::vector<Path> & prefixes, std::vector<Path> & results);
-       void generate_paths_cover (const std::vector<Path> & prefixes, std::vector<Path> & results);
+       void generate_paths_all (const std::vector<path_t> & prefixes, std::vector<path_t> & results);
+       void generate_paths_cover (const std::vector<path_t> & prefixes, std::vector<path_t> & results);
        arccount_t generate_paths_default (const multipath_t & prefix, std::vector<multipath_t> & paths);
 
        FORBID_COPY (Node);
@@ -60,7 +60,7 @@ struct Skeleton
 
        Skeleton (const DFA & dfa);
        ~Skeleton ();
-       void generate_paths (std::vector<Path> & results);
+       void generate_paths (std::vector<path_t> & results);
        void warn_undefined_control_flow (uint32_t line, const std::string & cond);
        void emit_data (DataFile & o);