Use fixed 32-bit indices in lookup tables instead of 'size_t'.

diff --git a/re2c/src/dfa/closure.h b/re2c/src/dfa/closure.h
index f04295e91530d8dfe3c787f7d1159d293528fcf1..1313a89f529c9566a9194d31197c8b0e2b9ca906 100644 (file)
--- a/re2c/src/dfa/closure.h
+++ b/re2c/src/dfa/closure.h
@@ -23,7 +23,7 @@ typedef slab_allocator_t<> allocator_t;
 struct clos_t
 {
        nfa_state_t *state;
-       size_t tvers; // vector of tag versions (including lookahead tags)
+       uint32_t tvers; // vector of tag versions (including lookahead tags)
        hidx_t ttran; // history of transition tags
        hidx_t tlook; // history of lookahead tags
        uint32_t origin;

diff --git a/re2c/src/dfa/determinization.cc b/re2c/src/dfa/determinization.cc
index 3334e9a0b57f6fbba9d4efbd66ad42d2e9144698..78211fa2e126dbf48add3a27b5bfd019312e5579 100644 (file)
--- a/re2c/src/dfa/determinization.cc
+++ b/re2c/src/dfa/determinization.cc
@@ -150,7 +150,8 @@ void warn_nondeterministic_tags(const kernels_t &kernels,
        for (size_t i = 0; i < nkrn; ++i) {
                const kernel_t *k = kernels[i];
                nfa_state_t **s = k->state;
-               const size_t n = k->size, *v = k->tvers;
+               const size_t n = k->size;
+               const uint32_t *v = k->tvers;
 
                for (size_t u = 0; u < n;) {
                        const size_t r = s[u]->rule;

diff --git a/re2c/src/dfa/find_state.cc b/re2c/src/dfa/find_state.cc
index e288a47b8484479b8974a3478bb07d8baebb2114..b60062cd4615a812b49c94e47fe8ac752a79af54 100644 (file)
--- a/re2c/src/dfa/find_state.cc
+++ b/re2c/src/dfa/find_state.cc
@@ -123,7 +123,7 @@ kernel_t *make_new_kernel(size_t size, allocator_t &alc)
        k->size = size;
        k->prectbl = NULL;
        k->state = alc.alloct<nfa_state_t*>(size);
-       k->tvers = alc.alloct<size_t>(size);
+       k->tvers = alc.alloct<uint32_t>(size);
        k->tlook = alc.alloct<hidx_t>(size);
        return k;
 }

diff --git a/re2c/src/dfa/find_state.h b/re2c/src/dfa/find_state.h
index c889effb478bbecabcce075b32795754c63fc701..913088f18655c38ad80a6b71b0c196b2db175656 100644 (file)
--- a/re2c/src/dfa/find_state.h
+++ b/re2c/src/dfa/find_state.h
@@ -27,7 +27,7 @@ struct kernel_t
        size_t size;
        const prectable_t *prectbl;
        nfa_state_t **state;
-       size_t *tvers; // tag versions
+       uint32_t *tvers; // tag versions
        hidx_t *tlook; // lookahead tags
 
        FORBID_COPY(kernel_t);

diff --git a/re2c/src/dfa/tagpool.cc b/re2c/src/dfa/tagpool.cc
index 330fd7b39b365034528eb34454cf75093029d2b5..1178de1212049a542830c8b56d2f0a00e1d33fcc 100644 (file)
--- a/re2c/src/dfa/tagpool.cc
+++ b/re2c/src/dfa/tagpool.cc
@@ -38,35 +38,35 @@ Tagpool::~Tagpool()
 {
        delete[] buffer;
        const size_t n = lookup.size();
-       for (size_t i = 0; i < n; ++i) {
+       for (uint32_t i = 0; i < n; ++i) {
                free(const_cast<tagver_t*>(lookup[i]));
        }
 }
 
 
-size_t Tagpool::insert_const(tagver_t ver)
+uint32_t Tagpool::insert_const(tagver_t ver)
 {
        std::fill(buffer, buffer + ntags, ver);
        return insert(buffer);
 }
 
 
-size_t Tagpool::insert_succ(tagver_t fst)
+uint32_t Tagpool::insert_succ(tagver_t fst)
 {
-       for (size_t i = 0; i < ntags; ++i) {
+       for (uint32_t i = 0; i < ntags; ++i) {
                buffer[i] = fst++;
        }
        return insert(buffer);
 }
 
 
-size_t Tagpool::insert(const tagver_t *tags)
+uint32_t Tagpool::insert(const tagver_t *tags)
 {
        const size_t size = ntags * sizeof(tagver_t);
        const uint32_t hash = hash32(0, tags, size);
 
        eqtag_t eq(ntags);
-       const size_t idx = lookup.find_with(hash, tags, eq);
+       const uint32_t idx = lookup.find_with(hash, tags, eq);
        if (idx != taglookup_t::NIL) {
                return idx;
        }
@@ -77,7 +77,7 @@ size_t Tagpool::insert(const tagver_t *tags)
 }
 
 
-const tagver_t *Tagpool::operator[](size_t idx) const
+const tagver_t *Tagpool::operator[](uint32_t idx) const
 {
        return lookup[idx];
 }

diff --git a/re2c/src/dfa/tagpool.h b/re2c/src/dfa/tagpool.h
index 7ff72e25f77cb044603f0e4b22b1a7e6945438d1..f45bedbaa60e82ce09366e39c82fafeb77c91b79 100644 (file)
--- a/re2c/src/dfa/tagpool.h
+++ b/re2c/src/dfa/tagpool.h
@@ -38,10 +38,10 @@ public:
 
        Tagpool(const opt_t *o, size_t n);
        ~Tagpool();
-       size_t insert_const(tagver_t ver);
-       size_t insert_succ(tagver_t fst);
-       size_t insert(const tagver_t *tags);
-       const tagver_t *operator[](size_t idx) const;
+       uint32_t insert_const(tagver_t ver);
+       uint32_t insert_succ(tagver_t fst);
+       uint32_t insert(const tagver_t *tags);
+       const tagver_t *operator[](uint32_t idx) const;
        FORBID_COPY(Tagpool);
 };
 

diff --git a/re2c/src/util/lookup.h b/re2c/src/util/lookup.h
index e649b9c383804bde9d4df46aaadc5ae922029da0..7416a54f68b9349dc76f8e2aa6f5147584cf12b2 100644 (file)
--- a/re2c/src/util/lookup.h
+++ b/re2c/src/util/lookup.h
@@ -2,6 +2,7 @@
 #define _RE2C_UTIL_LOOKUP_
 
 #include "src/util/c99_stdint.h"
+#include <assert.h>
 #include <limits>
 #include <map>
 #include <vector>
@@ -17,37 +18,37 @@ namespace re2c
 template<typename data_t, typename hash_t = uint32_t>
 struct lookup_t
 {
-       static const size_t NIL;
+       static const uint32_t NIL;
 
 private:
        struct elem_t
        {
-               size_t next;
+               uint32_t next;
                data_t data;
 
-               elem_t(size_t n, const data_t &d)
+               elem_t(uint32_t n, const data_t &d)
                        : next(n), data(d) {}
        };
 
        std::vector<elem_t> elems;
-       std::map<hash_t, size_t> lookup;
+       std::map<hash_t, uint32_t> lookup;
 
 public:
        lookup_t();
-       size_t size() const;
-       data_t& operator[](size_t idx);
-       const data_t& operator[](size_t idx) const;
-       size_t push(hash_t hash, const data_t &data);
-       template<typename pred_t> size_t find_with(hash_t hash, const data_t &data, pred_t &pred) const;
-       template<typename pred_t> size_t find_next_with(size_t prev, const data_t &data, pred_t &pred) const;
+       uint32_t size() const;
+       data_t& operator[](uint32_t idx);
+       const data_t& operator[](uint32_t idx) const;
+       uint32_t push(hash_t hash, const data_t &data);
+       template<typename pred_t> uint32_t find_with(hash_t hash, const data_t &data, pred_t &pred) const;
+       template<typename pred_t> uint32_t find_next_with(uint32_t prev, const data_t &data, pred_t &pred) const;
 
 private:
-       size_t head(hash_t) const;
-       template<typename pred_t> size_t find(size_t next, const data_t &data, pred_t &pred) const;
+       uint32_t head(hash_t) const;
+       template<typename pred_t> uint32_t find(uint32_t next, const data_t &data, pred_t &pred) const;
 };
 
 template<typename data_t, typename hash_t>
-const size_t lookup_t<data_t, hash_t>::NIL = std::numeric_limits<size_t>::max();
+const uint32_t lookup_t<data_t, hash_t>::NIL = ~0u;
 
 template<typename data_t, typename hash_t>
 lookup_t<data_t, hash_t>::lookup_t()
@@ -56,34 +57,35 @@ lookup_t<data_t, hash_t>::lookup_t()
 {}
 
 template<typename data_t, typename hash_t>
-size_t lookup_t<data_t, hash_t>::size() const
+uint32_t lookup_t<data_t, hash_t>::size() const
 {
-       return elems.size();
+       return static_cast<uint32_t>(elems.size());
 }
 
 template<typename data_t, typename hash_t>
-data_t& lookup_t<data_t, hash_t>::operator[](size_t idx)
+data_t& lookup_t<data_t, hash_t>::operator[](uint32_t idx)
 {
        return elems[idx].data;
 }
 
 template<typename data_t, typename hash_t>
-const data_t& lookup_t<data_t, hash_t>::operator[](size_t idx) const
+const data_t& lookup_t<data_t, hash_t>::operator[](uint32_t idx) const
 {
        return elems[idx].data;
 }
 
 template<typename data_t, typename hash_t>
-size_t lookup_t<data_t, hash_t>::head(hash_t h) const
+uint32_t lookup_t<data_t, hash_t>::head(hash_t h) const
 {
-       typename std::map<hash_t, size_t>::const_iterator x = lookup.find(h);
+       typename std::map<hash_t, uint32_t>::const_iterator x = lookup.find(h);
        return x == lookup.end() ? NIL : x->second;
 }
 
 template<typename data_t, typename hash_t>
-size_t lookup_t<data_t, hash_t>::push(hash_t hash, const data_t &data)
+uint32_t lookup_t<data_t, hash_t>::push(hash_t hash, const data_t &data)
 {
-       const size_t idx = elems.size();
+       assert(elems.size() < NIL);
+       const uint32_t idx = static_cast<uint32_t>(elems.size());
        elems.push_back(elem_t(head(hash), data));
        lookup[hash] = idx;
        return idx;
@@ -91,9 +93,9 @@ size_t lookup_t<data_t, hash_t>::push(hash_t hash, const data_t &data)
 
 template<typename data_t, typename hash_t>
 template<typename pred_t>
-size_t lookup_t<data_t, hash_t>::find(size_t next, const data_t &data, pred_t &pred) const
+uint32_t lookup_t<data_t, hash_t>::find(uint32_t next, const data_t &data, pred_t &pred) const
 {
-       for (size_t i = next; i != NIL;) {
+       for (uint32_t i = next; i != NIL;) {
                const elem_t &e = elems[i];
                if (pred(e.data, data)) {
                        return i;
@@ -105,14 +107,14 @@ size_t lookup_t<data_t, hash_t>::find(size_t next, const data_t &data, pred_t &p
 
 template<typename data_t, typename hash_t>
 template<typename pred_t>
-size_t lookup_t<data_t, hash_t>::find_with(hash_t hash, const data_t &data, pred_t &pred) const
+uint32_t lookup_t<data_t, hash_t>::find_with(hash_t hash, const data_t &data, pred_t &pred) const
 {
        return find(head(hash), data, pred);
 }
 
 template<typename data_t, typename hash_t>
 template<typename pred_t>
-size_t lookup_t<data_t, hash_t>::find_next_with(size_t prev, const data_t &data, pred_t &pred) const
+uint32_t lookup_t<data_t, hash_t>::find_next_with(uint32_t prev, const data_t &data, pred_t &pred) const
 {
        return find(elems[prev].next, data, pred);
 }