Use 'std::valarray' instead of 'std::vector' to avoid copy semantics.

Had to rename 'INFINITY' to 'SCC_INF': inclusion of '<valarray.h>'
pulled '<math.h>' and introduced name collision.

diff --git a/re2c/src/ir/adfa/adfa.cc b/re2c/src/ir/adfa/adfa.cc
index 16d59a98b23f5df369dbe2cecaed74a85da3a6bb..414e1d6d672e3789986034761e377952ab6fbf83 100644 (file)
--- a/re2c/src/ir/adfa/adfa.cc
+++ b/re2c/src/ir/adfa/adfa.cc
@@ -35,8 +35,8 @@ DFA::DFA
        , ubChar(charset.back())
        , nStates(0)
        , head(NULL)
-       , contexts(dfa.contexts)
        , rules(dfa.rules)
+       , contexts(dfa.contexts)
 
        // statistics
        , max_fill (0)

diff --git a/re2c/src/ir/adfa/adfa.h b/re2c/src/ir/adfa/adfa.h
index 6e6fe970780260ea75d8f59c181710515e45f2a5..f8279028543f86285af16d545242308648af8a6f 100644 (file)
--- a/re2c/src/ir/adfa/adfa.h
+++ b/re2c/src/ir/adfa/adfa.h
@@ -5,6 +5,7 @@
 #include "src/util/c99_stdint.h"
 #include <set>
 #include <string>
+#include <valarray>
 
 #include "src/codegen/go.h"
 #include "src/codegen/label.h"
@@ -67,8 +68,8 @@ public:
        uint32_t ubChar;
        uint32_t nStates;
        State * head;
+       std::valarray<Rule> &rules;
        std::vector<CtxVar> &contexts;
-       std::vector<Rule> &rules;
 
        // statistics
        size_t max_fill;

diff --git a/re2c/src/ir/dfa/determinization.cc b/re2c/src/ir/dfa/determinization.cc
index e0c7dcb069ff0e1c045a9dbf381d080e9b0fd955..cad20b0c80e04d47e0c88cc87adfe4382364a8f8 100644 (file)
--- a/re2c/src/ir/dfa/determinization.cc
+++ b/re2c/src/ir/dfa/determinization.cc
@@ -94,8 +94,8 @@ dfa_t::dfa_t(
        const std::string &cond)
        : states()
        , nchars(charset.size() - 1) // (n + 1) bounds for n ranges
-       , contexts(nfa.contexts)
        , rules(nfa.rules)
+       , contexts(nfa.contexts)
 {
        std::map<size_t, std::set<size_t> > s2rules;
        ord_hash_set_t kernels;

diff --git a/re2c/src/ir/dfa/dfa.h b/re2c/src/ir/dfa/dfa.h
index 71d99af47e3f534397300f66ba9aa2898a18e506..494b43af7f0eb0c6025f96808cbb46bcdd840020 100644 (file)
--- a/re2c/src/ir/dfa/dfa.h
+++ b/re2c/src/ir/dfa/dfa.h
@@ -2,6 +2,7 @@
 #define _RE2C_IR_DFA_DFA_
 
 #include "src/util/c99_stdint.h"
+#include <valarray>
 #include <vector>
 #include <set>
 
@@ -40,8 +41,8 @@ struct dfa_t
 
        std::vector<dfa_state_t*> states;
        const size_t nchars;
+       std::valarray<Rule> &rules;
        std::vector<CtxVar> &contexts;
-       std::vector<Rule> &rules;
 
        dfa_t(const nfa_t &nfa, const charset_t &charset,
                uint32_t line, const std::string &cond);

diff --git a/re2c/src/ir/dfa/fillpoints.cc b/re2c/src/ir/dfa/fillpoints.cc
index f4488ea75bf46c376eea2baaabbea2268233cc30..9a0b8394590513b779d5bbc833f2cee8fe56c1d0 100644 (file)
--- a/re2c/src/ir/dfa/fillpoints.cc
+++ b/re2c/src/ir/dfa/fillpoints.cc
@@ -7,8 +7,8 @@
 namespace re2c
 {
 
-static const size_t INFINITY = std::numeric_limits<size_t>::max();
-static const size_t UNDEFINED = INFINITY - 1;
+static const size_t SCC_INF = std::numeric_limits<size_t>::max();
+static const size_t SCC_UND = SCC_INF - 1;
 
 static bool loopback(size_t node, size_t narcs, const size_t *arcs)
 {
@@ -37,13 +37,13 @@ static bool loopback(size_t node, size_t narcs, const size_t *arcs)
  * We use lowlink to hold different kinds of information:
  *   - values in range [0 .. stack size] mean that this node is on stack
  *     (link to a node with the smallest index reachable from this one)
- *   - UNDEFINED means that this node has not been visited yet
- *   - INFINITY means that this node has already been popped off stack
+ *   - SCC_UND means that this node has not been visited yet
+ *   - SCC_INF means that this node has already been popped off stack
  *
  * We use stack size (rather than topological sort index) as unique index
  * of a node on stack. This is safe because indices of nodes on stack are
  * still unique and less than indices of nodes that have been popped off
- * stack (INFINITY).
+ * stack (SCC_INF).
  *
  */
 static void scc(
@@ -63,7 +63,7 @@ static void scc(
                const size_t j = arcs[c];
                if (j != dfa_t::NIL)
                {
-                       if (lowlink[j] == UNDEFINED)
+                       if (lowlink[j] == SCC_UND)
                        {
                                scc(dfa, stack, lowlink, trivial, j);
                        }
@@ -87,7 +87,7 @@ static void scc(
                {
                        j = stack.top();
                        stack.pop();
-                       lowlink[j] = INFINITY;
+                       lowlink[j] = SCC_INF;
                }
                while (j != i);
        }
@@ -99,7 +99,7 @@ static void calc_fill(
        std::vector<size_t> &fill,
        size_t i)
 {
-       if (fill[i] == UNDEFINED)
+       if (fill[i] == SCC_UND)
        {
                fill[i] = 0;
                const size_t *arcs = dfa.states[i]->arcs;
@@ -129,13 +129,13 @@ void fillpoints(const dfa_t &dfa, std::vector<size_t> &fill)
 
        // find DFA states that belong to non-trivial SCC
        std::stack<size_t> stack;
-       std::vector<size_t> lowlink(size, UNDEFINED);
+       std::vector<size_t> lowlink(size, SCC_UND);
        std::vector<bool> trivial(size, false);
        scc(dfa, stack, lowlink, trivial, 0);
 
        // for each DFA state, calculate YYFILL argument:
        // maximal path length to the next YYFILL state
-       fill.resize(size, UNDEFINED);
+       fill.resize(size, SCC_UND);
        calc_fill(dfa, trivial, fill, 0);
 
        // The following states must trigger YYFILL:

diff --git a/re2c/src/ir/nfa/nfa.cc b/re2c/src/ir/nfa/nfa.cc
index cb4500a9811fa45ca6c3ae3c2f5355513d761683..b464609468fb8e88554d6e1b1bfc3d90a4649f95 100644 (file)
--- a/re2c/src/ir/nfa/nfa.cc
+++ b/re2c/src/ir/nfa/nfa.cc
@@ -120,7 +120,8 @@ static bool nullable(const RegExp *re)
 
 static nfa_state_t *compile_rule(
        const RegExpRule *rule,
-       nfa_t &nfa)
+       nfa_t &nfa,
+       size_t nrule)
 {
        const std::vector<const RegExp*> &rs = rule->regexps;
        const std::vector<const std::string*> &ctxnames = rule->ctxnames;
@@ -149,10 +150,11 @@ static nfa_state_t *compile_rule(
                }
        }
 
+       Rule &r = nfa.rules[nrule];
+       r.info = rule->info;
+
        nfa_state_t *t = &nfa.states[nfa.size++];
-       const size_t nrule = nfa.rules.size();
        t->fin(nrule);
-       Rule r(rule->info);
 
        std::vector<size_t> &ctxvar = r.ctxvar;
        std::vector<CtxFix> &ctxfix = r.ctxfix;
@@ -191,8 +193,6 @@ static nfa_state_t *compile_rule(
        }
        r.nullable = null;
 
-       nfa.rules.push_back(r);
-
        return t;
 }
 
@@ -203,10 +203,10 @@ static nfa_state_t *compile_rules(
        nfa_state_t *s = NULL;
        const size_t nrs = rs.size();
        if (nrs > 0) {
-               s = compile_rule(rs[0], nfa);
+               s = compile_rule(rs[0], nfa, 0);
                for (size_t i = 1; i < nrs; ++i) {
                        nfa_state_t *q = &nfa.states[nfa.size++];
-                       q->alt(s, compile_rule(rs[i], nfa));
+                       q->alt(s, compile_rule(rs[i], nfa, i));
                        s = q;
                }
        }
@@ -217,7 +217,7 @@ nfa_t::nfa_t(const std::vector<const RegExpRule*> &rs)
        : max_size(calc_size_all(rs))
        , size(0)
        , states(new nfa_state_t[max_size])
-       , rules(*new std::vector<Rule>)
+       , rules(*new std::valarray<Rule>(rs.size()))
        , contexts(*new std::vector<CtxVar>)
        , root(compile_rules(rs, *this))
 {}

diff --git a/re2c/src/ir/nfa/nfa.h b/re2c/src/ir/nfa/nfa.h
index 916a4c808c3c2d0ea2fd7221b4b79d4ec27e43ef..daaedee1fbe4ab5417c83e6eab7f16dc6b4ade0f 100644 (file)
--- a/re2c/src/ir/nfa/nfa.h
+++ b/re2c/src/ir/nfa/nfa.h
@@ -3,6 +3,7 @@
 
 #include <stddef.h>
 #include "src/util/c99_stdint.h"
+#include <valarray>
 #include <vector>
 
 #include "src/ir/rule.h"
@@ -82,7 +83,7 @@ struct nfa_t
        const size_t max_size;
        size_t size;
        nfa_state_t *states;
-       std::vector<Rule> &rules;
+       std::valarray<Rule> &rules;
        std::vector<CtxVar> &contexts;
        nfa_state_t *root;
 

diff --git a/re2c/src/ir/rule.h b/re2c/src/ir/rule.h
index f2cb790738a912748f466914e8fa0edae9b59149..9fb7ff7e89ea1659eae7f56f6d12ee21075b0af9 100644 (file)
--- a/re2c/src/ir/rule.h
+++ b/re2c/src/ir/rule.h
@@ -43,8 +43,8 @@ struct Rule
        std::set<uint32_t> shadow;
        bool reachable;
 
-       explicit Rule(const RuleInfo *i)
-               : info(i)
+       Rule()
+               : info(NULL)
                , ctxvar()
                , ctxfix()
                , trail()
@@ -52,28 +52,8 @@ struct Rule
                , shadow()
                , reachable(false)
        {}
-       Rule (const Rule &rule)
-               : info(rule.info)
-               , ctxvar(rule.ctxvar)
-               , ctxfix(rule.ctxfix)
-               , trail(rule.trail)
-               , nullable(rule.nullable)
-               , shadow(rule.shadow)
-               , reachable(rule.reachable)
-       {}
-       Rule& operator=(const Rule &rule)
-       {
-               info = rule.info;
-               ctxvar = rule.ctxvar;
-               ctxfix = rule.ctxfix;
-               trail = rule.trail;
-               nullable = rule.nullable;
-               shadow = rule.shadow;
-               reachable = rule.reachable;
-               return *this;
-       }
 
-//     FORBID_COPY(Rule);
+       FORBID_COPY(Rule);
 };
 
 } // namespace re2c

diff --git a/re2c/src/ir/skeleton/skeleton.h b/re2c/src/ir/skeleton/skeleton.h
index cd84008196680f98f15eedc472638098461758d9..3690d6313ee573bac2072540f830d8d191902779 100644 (file)
--- a/re2c/src/ir/skeleton/skeleton.h
+++ b/re2c/src/ir/skeleton/skeleton.h
@@ -7,6 +7,7 @@
 #include <map>
 #include <set>
 #include <string>
+#include <valarray>
 #include <vector>
 #include <utility>
 
@@ -55,7 +56,7 @@ struct Skeleton
        Node *nodes;
 
        size_t sizeof_key;
-       std::vector<Rule> &rules;
+       std::valarray<Rule> &rules;
        const size_t defrule;
        std::vector<CtxVar> &contexts;
 

diff --git a/re2c/src/ir/skeleton/unreachable_nullable.cc b/re2c/src/ir/skeleton/unreachable_nullable.cc
index 6e7bfcecb60a583824080956a48496422908a075..5bbb49513ba36ae9ed1f9953e6f01339f756aaaa 100644 (file)
--- a/re2c/src/ir/skeleton/unreachable_nullable.cc
+++ b/re2c/src/ir/skeleton/unreachable_nullable.cc
@@ -44,7 +44,7 @@ void warn_unreachable_nullable_rules(const Skeleton &skel)
        std::vector<std::set<size_t> > reachs(nnodes);
        calc_reachable(skel, loops, reachs, 0);
 
-       std::vector<Rule> &rules = skel.rules;
+       std::valarray<Rule> &rules = skel.rules;
        const size_t nrules = rules.size();
 
        for (size_t i = 0; i < nnodes; ++i) {