Substitute template class with non-template, as only one specialization is used.

diff --git a/re2c/src/codegen/skeleton/generate_data.cc b/re2c/src/codegen/skeleton/generate_data.cc
index 34cd3c40601d1dd3599cbd529d6d99fe87349c0f..b62e18a96763f816c8fc090b448f1efdb6b825be 100644 (file)
--- a/re2c/src/codegen/skeleton/generate_data.cc
+++ b/re2c/src/codegen/skeleton/generate_data.cc
@@ -9,7 +9,7 @@ namespace re2c
 {
 
 template <typename cunit_t, typename key_t>
-       static Node::covers_t cover_one (FILE * input, FILE * keys, const multipath_t & path);
+       static Node::covers_t cover_one (FILE * input, FILE * keys, const path_t & path);
 
 /*
  * note [generating skeleton path cover]
@@ -41,12 +41,12 @@ template <typename cunit_t, typename key_t>
  *
  */
 template <typename cunit_t, typename key_t>
-       Node::covers_t Node::cover (multipath_t & prefix, FILE * input, FILE * keys)
+       Node::covers_t Node::cover (path_t & prefix, FILE * input, FILE * keys)
 {
        covers_t size = covers_t::from32(0u);
        if (end () && suffix == NULL)
        {
-               suffix = new multipath_t (rule, ctx);
+               suffix = new path_t (rule, ctx);
        }
        if (suffix != NULL)
        {
@@ -58,7 +58,7 @@ template <typename cunit_t, typename key_t>
                local_inc _ (loop);
                for (arcs_t::iterator i = arcs.begin (); i != arcs.end (); ++i)
                {
-                       multipath_t new_prefix = prefix;
+                       path_t new_prefix = prefix;
                        new_prefix.extend (i->first->rule, i->first->ctx, &i->second);
                        size = size + i->first->cover<cunit_t, key_t> (new_prefix, input, keys);
                        if (size.overflow ())
@@ -67,7 +67,7 @@ template <typename cunit_t, typename key_t>
                        }
                        if (i->first->suffix != NULL && suffix == NULL)
                        {
-                               suffix = new multipath_t (rule, ctx);
+                               suffix = new path_t (rule, ctx);
                                suffix->extend (i->first->rule, i->first->ctx, &i->second);
                                suffix->append (i->first->suffix);
                        }
@@ -79,7 +79,7 @@ template <typename cunit_t, typename key_t>
 template <typename cunit_t, typename key_t>
        void Skeleton::generate_paths_cunit_key (FILE * input, FILE * keys)
 {
-       multipath_t prefix (nodes->rule, nodes->ctx);
+       path_t prefix (nodes->rule, nodes->ctx);
        if (nodes->cover<cunit_t, key_t> (prefix, input, keys).overflow ())
        {
                warning
@@ -154,7 +154,7 @@ template <typename key_t>
 }
 
 template <typename cunit_t, typename key_t>
-       static Node::covers_t cover_one (FILE * input, FILE * keys, const multipath_t & path)
+       static Node::covers_t cover_one (FILE * input, FILE * keys, const path_t & path)
 {
        const size_t len = path.len ();
 

diff --git a/re2c/src/codegen/skeleton/path.h b/re2c/src/codegen/skeleton/path.h
index d31ff9b3f7e2a26b1114a67c4497d2f72bd44c45..66ef599f29adbbc20e16ce8a6a432ad0373d55a1 100644 (file)
--- a/re2c/src/codegen/skeleton/path.h
+++ b/re2c/src/codegen/skeleton/path.h
@@ -28,10 +28,13 @@ struct rule_t
        }
 };
 
-template <typename arc_t>
-class generic_path_t
+class path_t
 {
-       std::vector<arc_t> arcs;
+public:
+       typedef std::vector<uint32_t> arc_t;
+
+private:
+       std::vector<const arc_t *> arcs;
 
        rule_t rule;
        size_t rule_pos;
@@ -40,7 +43,7 @@ class generic_path_t
        size_t ctx_pos;
 
 public:
-       explicit generic_path_t (rule_t r, bool c)
+       explicit path_t (rule_t r, bool c)
                : arcs ()
                , rule (r)
                , rule_pos (0)
@@ -61,11 +64,11 @@ public:
        {
                return rule.rank;
        }
-       const arc_t & operator [] (size_t i) const
+       const arc_t * operator [] (size_t i) const
        {
                return arcs[i];
        }
-       void extend (rule_t r, bool c, const arc_t & a)
+       void extend (rule_t r, bool c, const arc_t * a)
        {
                arcs.push_back (a);
                if (!r.rank.is_none ())
@@ -79,7 +82,7 @@ public:
                        ctx_pos = arcs.size ();
                }
        }
-       void append (const generic_path_t<arc_t> * p)
+       void append (const path_t * p)
        {
                if (!p->rule.rank.is_none ())
                {
@@ -95,11 +98,6 @@ public:
        }
 };
 
-typedef generic_path_t<uint32_t> path_t;
-
-typedef std::vector<uint32_t> multiarc_t;
-typedef generic_path_t<const multiarc_t *> multipath_t;
-
 } // namespace re2c
 
 #endif // _RE2C_CODEGEN_SKELETON_PATH_

diff --git a/re2c/src/codegen/skeleton/skeleton.h b/re2c/src/codegen/skeleton/skeleton.h
index 961423112fc54055c9674c2645ef647ed97cc244..979491f65b2cd3a46e7cde465c0403228ef5064a 100644 (file)
--- a/re2c/src/codegen/skeleton/skeleton.h
+++ b/re2c/src/codegen/skeleton/skeleton.h
@@ -52,7 +52,7 @@ struct Node
        typedef u32lim_t<1024 * 1024 * 64> nakeds_t; // ~64Mb
 
        typedef std::map<const State *, Node *> s2n_map;
-       typedef std::map<Node *, multiarc_t> arcs_t;
+       typedef std::map<Node *, path_t::arc_t> arcs_t;
        typedef std::map<Node *, way_arc_t> arcsets_t;
        typedef local_increment_t<uint8_t> local_inc;
 
@@ -79,7 +79,7 @@ struct Node
        std::set<rule_t> reachable;
 
        // path to end node (for constructing path cover)
-       multipath_t * suffix;
+       path_t * suffix;
 
        Node ();
        void init (const State * s, const s2n_map & s2n);
@@ -88,7 +88,7 @@ struct Node
        void calc_dist ();
        void calc_reachable ();
        template <typename cunit_t, typename key_t>
-               covers_t cover (multipath_t & prefix, FILE * input, FILE * keys);
+               covers_t cover (path_t & prefix, FILE * input, FILE * keys);
        nakeds_t naked_ways (const way_t & prefix, std::vector<way_t> & ways);
 
        FORBID_COPY (Node);