Merged 'ir/tagpool.{h,cc}' files into 'ir/tag.{h,cc}' files.

diff --git a/re2c/Makefile.am b/re2c/Makefile.am
index 36b6ee66c128a4c7e19c3ab4301c179f60ca420b..5d46e447947e95dcc7b97c49fe08f650cf43601b 100644 (file)
--- a/re2c/Makefile.am
+++ b/re2c/Makefile.am
@@ -40,7 +40,6 @@ SRC_HDR = \
        src/ir/compile.h \
        src/ir/rule.h \
        src/ir/tag.h \
-       src/ir/tagpool.h \
        src/ir/skeleton/path.h \
        src/ir/skeleton/skeleton.h \
        src/globals.h \
@@ -118,7 +117,6 @@ SRC = \
        src/ir/skeleton/maxpath.cc \
        src/ir/skeleton/skeleton.cc \
        src/ir/tag.cc \
-       src/ir/tagpool.cc \
        src/main.cc \
        src/parse/code.cc \
        src/parse/input.cc \

diff --git a/re2c/src/ir/dfa/dfa.h b/re2c/src/ir/dfa/dfa.h
index ef3e63e4fba7c2d0592213b81dfc295e7d3b5125..25616143288ee2d6dad1f1c431b697f77e03013c 100644 (file)
--- a/re2c/src/ir/dfa/dfa.h
+++ b/re2c/src/ir/dfa/dfa.h
@@ -8,7 +8,7 @@
 
 #include "src/ir/regexp/regexp.h"
 #include "src/ir/rule.h"
-#include "src/ir/tagpool.h"
+#include "src/ir/tag.h"
 #include "src/util/forbid_copy.h"
 
 namespace re2c

diff --git a/re2c/src/ir/nfa/nfa.h b/re2c/src/ir/nfa/nfa.h
index 5d4f24e44a67bcaf831d8ab41338637bbb1b12e4..be376179c536726770976eaee61bcba86e599a19 100644 (file)
--- a/re2c/src/ir/nfa/nfa.h
+++ b/re2c/src/ir/nfa/nfa.h
@@ -8,7 +8,7 @@
 
 #include "src/ir/regexp/regexp.h"
 #include "src/ir/rule.h"
-#include "src/ir/tagpool.h"
+#include "src/ir/tag.h"
 #include "src/util/forbid_copy.h"
 
 namespace re2c

diff --git a/re2c/src/ir/rule.h b/re2c/src/ir/rule.h
index 35a3098bc7924597037f53f3cafa2d6e7b15fe14..b1dd91d60fd3e648400d3c8cc39002b7d0790f00 100644 (file)
--- a/re2c/src/ir/rule.h
+++ b/re2c/src/ir/rule.h
@@ -6,7 +6,6 @@
 #include <vector>
 
 #include "src/ir/tag.h"
-#include "src/ir/tagpool.h"
 #include "src/parse/code.h"
 #include "src/parse/loc.h"
 #include "src/util/forbid_copy.h"

diff --git a/re2c/src/ir/tag.cc b/re2c/src/ir/tag.cc
index 6e49d7ead732a8c4c7772a6b9ad408cb43bbbd4f..0f5ebf820b3a9deede6c527965e3e502bdacb5c1 100644 (file)
--- a/re2c/src/ir/tag.cc
+++ b/re2c/src/ir/tag.cc
@@ -1,11 +1,26 @@
+#include <assert.h>
 #include <limits>
+#include <stdlib.h> // malloc
+#include <string.h> // memcpy, memcmp
 
 #include "src/ir/rule.h"
 #include "src/ir/tag.h"
+#include "src/util/hash32.h"
 
 namespace re2c
 {
 
+struct eqtag_t
+{
+       size_t ntags;
+
+       explicit eqtag_t(size_t n): ntags(n) {}
+       inline bool operator()(const bool *x, const bool *y)
+       {
+               return memcmp(x, y, ntags * sizeof(bool)) == 0;
+       }
+};
+
 const size_t Tag::NONE = std::numeric_limits<size_t>::max();
 
 Tag::Tag()
@@ -31,4 +46,106 @@ void init_fix_tag(Tag &tag, size_t r, const std::string *n, size_t b, size_t d)
        tag.fix.dist = d;
 }
 
+Tagpool::Tagpool(size_t n)
+       : lookup()
+       , buffer(new bool[n * 3])
+       , ntags(n)
+       , buffer1(&buffer[n * 1])
+       , buffer2(&buffer[n * 2])
+{
+       // all-zero tag configuration must have static number zero
+       std::fill(buffer, buffer + ntags, false);
+       assert(ZERO_TAGS == insert(buffer));
+}
+
+Tagpool::~Tagpool()
+{
+       delete[] buffer;
+       const size_t n = lookup.size();
+       for (size_t i = 0; i < n; ++i) {
+               free(const_cast<bool*>(lookup[i]));
+       }
+}
+
+size_t Tagpool::insert(const bool *tags)
+{
+       const size_t size = ntags * sizeof(bool);
+       const uint32_t hash = hash32(0, tags, size);
+
+       eqtag_t eq(ntags);
+       const size_t idx = lookup.find_with(hash, tags, eq);
+       if (idx != taglookup_t::NIL) {
+               return idx;
+       }
+
+       bool *copy = static_cast<bool*>(malloc(size));
+       memcpy(copy, tags, size);
+       return lookup.push(hash, copy);
+}
+
+const bool *Tagpool::operator[](size_t idx) const
+{
+       return lookup[idx];
+}
+
+size_t Tagpool::orl(size_t t, size_t o)
+{
+       if (t == o || o == 0) {
+               return t;
+       } else if (t == ZERO_TAGS) {
+               return o;
+       }
+
+       const bool *tags = operator[](t);
+       const bool *ortags = operator[](o);
+       for (size_t i = 0; i < ntags; ++i) {
+               buffer[i] = tags[i] | ortags[i];
+       }
+       return insert(buffer);
+}
+
+size_t Tagpool::andl(size_t t, size_t a)
+{
+       if (t == a) {
+               return t;
+       } else if (t == ZERO_TAGS || a == ZERO_TAGS) {
+               return ZERO_TAGS;
+       }
+
+       const bool *tags = operator[](t);
+       const bool *andtags = operator[](a);
+       for (size_t i = 0; i < ntags; ++i) {
+               buffer[i] = tags[i] & andtags[i];
+       }
+       return insert(buffer);
+}
+
+size_t Tagpool::andlinv(size_t t, size_t a)
+{
+       if (a == ZERO_TAGS) {
+               return t;
+       } else if (t == ZERO_TAGS || t == a) {
+               return ZERO_TAGS;
+       }
+
+       const bool *tags = operator[](t);
+       const bool *andinvtags = operator[](a);
+       for (size_t i = 0; i < ntags; ++i) {
+               buffer[i] = tags[i] & ~andinvtags[i];
+       }
+       return insert(buffer);
+}
+
+size_t Tagpool::subst(size_t t, const size_t *represent)
+{
+       const bool *tags = operator[](t);
+       memset(buffer, 0, ntags * sizeof(bool));
+       for (size_t i = 0; i < ntags; ++i) {
+               if (tags[i]) {
+                       buffer[represent[i]] = true;
+               }
+       }
+       return insert(buffer);
+}
+
 } // namespace re2c

diff --git a/re2c/src/ir/tag.h b/re2c/src/ir/tag.h
index b9fbdfc8da61776d912a4c312a55c11b454f888f..9b981eba5a100ea33b16b15237ff37734ecff887 100644 (file)
--- a/re2c/src/ir/tag.h
+++ b/re2c/src/ir/tag.h
@@ -3,7 +3,7 @@
 
 #include <string>
 
-#include "src/ir/tagpool.h"
+#include "src/util/lookup.h"
 #include "src/util/forbid_copy.h"
 
 namespace re2c
@@ -36,6 +36,31 @@ struct Tag
 void init_var_tag(Tag &tag, size_t r, const std::string *n, size_t o);
 void init_fix_tag(Tag &tag, size_t r, const std::string *n, size_t b, size_t d);
 
+static const size_t ZERO_TAGS = 0;
+
+struct Tagpool
+{
+private:
+       typedef lookup_t<const bool*> taglookup_t;
+       taglookup_t lookup;
+       bool *buffer;
+
+public:
+       const size_t ntags;
+       bool *buffer1;
+       bool *buffer2;
+
+       explicit Tagpool(size_t n);
+       ~Tagpool();
+       size_t insert(const bool *tags);
+       size_t orl(size_t t, size_t o);
+       size_t andl(size_t t, size_t a);
+       size_t andlinv(size_t t, size_t a);
+       size_t subst(size_t t, const size_t *represent);
+       const bool *operator[](size_t idx) const;
+       FORBID_COPY(Tagpool);
+};
+
 /* must be packed */
 struct tagcmd_t
 {

diff --git a/re2c/src/ir/tagpool.cc b/re2c/src/ir/tagpool.cc
deleted file mode 100644 (file)
index ffd0b3e..0000000
--- a/re2c/src/ir/tagpool.cc
+++ /dev/null
@@ -1,111 +0,0 @@
-#include <assert.h>
-
-#include "src/ir/tagpool.h"
-#include "src/util/hash32.h"
-
-namespace re2c
-{
-
-Tagpool::Tagpool(size_t n)
-       : lookup()
-       , buffer(new bool[n * 3])
-       , ntags(n)
-       , buffer1(&buffer[n * 1])
-       , buffer2(&buffer[n * 2])
-{
-       // all-zero tag configuration must have static number zero
-       std::fill(buffer, buffer + ntags, false);
-       assert(ZERO_TAGS == insert(buffer));
-}
-
-Tagpool::~Tagpool()
-{
-       delete[] buffer;
-       const size_t n = lookup.size();
-       for (size_t i = 0; i < n; ++i) {
-               free(const_cast<bool*>(lookup[i]));
-       }
-}
-
-size_t Tagpool::insert(const bool *tags)
-{
-       const size_t size = ntags * sizeof(bool);
-       const uint32_t hash = hash32(0, tags, size);
-
-       eqtag_t eq(ntags);
-       const size_t idx = lookup.find_with(hash, tags, eq);
-       if (idx != taglookup_t::NIL) {
-               return idx;
-       }
-
-       bool *copy = static_cast<bool*>(malloc(size));
-       memcpy(copy, tags, size);
-       return lookup.push(hash, copy);
-}
-
-const bool *Tagpool::operator[](size_t idx) const
-{
-       return lookup[idx];
-}
-
-size_t Tagpool::orl(size_t t, size_t o)
-{
-       if (t == o || o == 0) {
-               return t;
-       } else if (t == ZERO_TAGS) {
-               return o;
-       }
-
-       const bool *tags = operator[](t);
-       const bool *ortags = operator[](o);
-       for (size_t i = 0; i < ntags; ++i) {
-               buffer[i] = tags[i] | ortags[i];
-       }
-       return insert(buffer);
-}
-
-size_t Tagpool::andl(size_t t, size_t a)
-{
-       if (t == a) {
-               return t;
-       } else if (t == ZERO_TAGS || a == ZERO_TAGS) {
-               return ZERO_TAGS;
-       }
-
-       const bool *tags = operator[](t);
-       const bool *andtags = operator[](a);
-       for (size_t i = 0; i < ntags; ++i) {
-               buffer[i] = tags[i] & andtags[i];
-       }
-       return insert(buffer);
-}
-
-size_t Tagpool::andlinv(size_t t, size_t a)
-{
-       if (a == ZERO_TAGS) {
-               return t;
-       } else if (t == ZERO_TAGS || t == a) {
-               return ZERO_TAGS;
-       }
-
-       const bool *tags = operator[](t);
-       const bool *andinvtags = operator[](a);
-       for (size_t i = 0; i < ntags; ++i) {
-               buffer[i] = tags[i] & ~andinvtags[i];
-       }
-       return insert(buffer);
-}
-
-size_t Tagpool::subst(size_t t, const size_t *represent)
-{
-       const bool *tags = operator[](t);
-       memset(buffer, 0, ntags * sizeof(bool));
-       for (size_t i = 0; i < ntags; ++i) {
-               if (tags[i]) {
-                       buffer[represent[i]] = true;
-               }
-       }
-       return insert(buffer);
-}
-
-} // namespace re2c

diff --git a/re2c/src/ir/tagpool.h b/re2c/src/ir/tagpool.h
deleted file mode 100644 (file)
index 5f032ba..0000000
--- a/re2c/src/ir/tagpool.h
+++ /dev/null
@@ -1,51 +0,0 @@
-#ifndef _RE2C_IR_TAGPOOL_
-#define _RE2C_IR_TAGPOOL_
-
-#include <stdlib.h> // malloc
-#include <string.h> // memcpy, memcmp
-
-#include "src/util/lookup.h"
-#include "src/util/forbid_copy.h"
-
-namespace re2c
-{
-
-static const size_t ZERO_TAGS = 0;
-
-struct eqtag_t
-{
-       size_t ntags;
-
-       explicit eqtag_t(size_t n): ntags(n) {}
-       inline bool operator()(const bool *x, const bool *y)
-       {
-               return memcmp(x, y, ntags * sizeof(bool)) == 0;
-       }
-};
-
-struct Tagpool
-{
-private:
-       typedef lookup_t<const bool*> taglookup_t;
-       taglookup_t lookup;
-       bool *buffer;
-
-public:
-       const size_t ntags;
-       bool *buffer1;
-       bool *buffer2;
-
-       explicit Tagpool(size_t n);
-       ~Tagpool();
-       size_t insert(const bool *tags);
-       size_t orl(size_t t, size_t o);
-       size_t andl(size_t t, size_t a);
-       size_t andlinv(size_t t, size_t a);
-       size_t subst(size_t t, const size_t *represent);
-       const bool *operator[](size_t idx) const;
-       FORBID_COPY(Tagpool);
-};
-
-} // namespace re2c
-
-#endif // _RE2C_IR_TAGPOOL_