From: Ulya Trofimovich <skvadrik@gmail.com>
Date: Sun, 12 Aug 2018 19:28:09 +0000 (+0100)
Subject: Use fixed 32-bit indices in lookup tables instead of 'size_t'.
X-Git-Tag: 1.1~13
X-Git-Url: https://granicus.if.org/sourcecode?a=commitdiff_plain;h=24142df77d525eddab4110c78617f51e15e5272a;p=re2c

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 f04295e9..1313a89f 100644
--- 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 3334e9a0..78211fa2 100644
--- 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 e288a47b..b60062cd 100644
--- 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 c889effb..913088f1 100644
--- 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 330fd7b3..1178de12 100644
--- 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 7ff72e25..f45bedba 100644
--- 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 e649b9c3..7416a54f 100644
--- 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);
 }