Fixes for bugs revealed by _GLIBCXX_ASSERTIONS and _ITERATOR_DEBUG_LEVEL=2

Author: TinoDidriksen

CMakeLists.txt

@@ -132,13 +132,24 @@ if(NOT ENABLE_PROFILING)
 endif()
 
 if(WIN32)
-	add_definitions(-DUNICODE -D_UNICODE -D_SECURE_SCL=0 -D_ITERATOR_DEBUG_LEVEL=0 -D_CRT_SECURE_NO_DEPRECATE -DWIN32_LEAN_AND_MEAN -DVC_EXTRALEAN -DNOMINMAX -D_SILENCE_CXX20_CISO646_REMOVED_WARNING -D_USE_MATH_DEFINES)
+	add_definitions(-DUNICODE -D_UNICODE -D_CRT_SECURE_NO_DEPRECATE -DWIN32_LEAN_AND_MEAN -DVC_EXTRALEAN -DNOMINMAX -D_SILENCE_CXX20_CISO646_REMOVED_WARNING -D_USE_MATH_DEFINES)
+	if(CMAKE_BUILD_TYPE STREQUAL "Release")
+		add_definitions(-D_SECURE_SCL=0 -D_ITERATOR_DEBUG_LEVEL=0)
+	else()
+		add_definitions(-D_SECURE_SCL=1 -D_ITERATOR_DEBUG_LEVEL=2)
+	endif()
+
 	include_directories("include/getopt" "include/wordexp")
 else()
 	add_definitions(-D_POSIX_C_SOURCE=200112 -DBOOST_NO_CXX98_FUNCTION_BASE=1)
+	if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+		add_definitions(-D_GLIBCXX_ASSERTIONS)
+	endif()
 	set(POPEN_PLUS_CPP "../include/posix/popen_plus.cpp" "../include/posix/popen_plus.hpp")
+
 	include_directories("include/posix")
 endif()
+
 if(EMSCRIPTEN)
 	include_directories("include/wordexp")
 	set(CMAKE_EXECUTABLE_SUFFIX ".js")

src/GrammarApplicator.hpp

@@ -261,7 +261,7 @@ class GrammarApplicator {
 	Rule* current_rule = nullptr;
 	std::vector<Rule_Context> context_stack;
 	std::vector<CohortSet*> cohortsets;
-	std::vector<CohortSet::const_iterator*> rocits;
+	std::vector<size_t*> rocits;
 
 	ReadingSpec get_attach_to();
 	Cohort* get_mark();

src/GrammarApplicator_runRules.cpp

@@ -79,23 +79,23 @@ bool GrammarApplicator::updateRuleToCohorts(Cohort& c, const uint32_t& rsit) {
 	}
 	if (!csi.empty()) {
 		auto cap = cohortset.capacity();
-		std::vector<CohortSet::const_iterator*> ends;
-		std::vector<std::pair<CohortSet::const_iterator*,Cohort*>> chs;
+		std::vector<size_t*> ends;
+		std::vector<std::pair<size_t*,Cohort*>> chs;
 		for (size_t i = 0; i < csi.size(); ++i) {
-			if (*rocits[csi[i]] == cohortset.end()) {
+			if (*rocits[csi[i]] >= cohortset.size()) {
 				ends.push_back(rocits[csi[i]]);
 			}
 			else {
-				chs.push_back(std::pair(rocits[csi[i]], **rocits[csi[i]]));
+				chs.push_back(std::pair(rocits[csi[i]], cohortset.at(*rocits[csi[i]])));
 			}
 		}
 		cohortset.insert(&c);
 		for (auto it : ends) {
-			*it = cohortset.end();
+			*it = cohortset.size();
 		}
 		if (cap != cohortset.capacity()) {
 			for (auto& it : chs) {
-				*it.first = cohortset.find(it.second);
+				*it.first = cohortset.find_n(it.second);
 			}
 		}
 	}
@@ -375,9 +375,9 @@ bool GrammarApplicator::runSingleRule(SingleWindow& current, const Rule& rule, R
 	if (debug_level > 1) {
 		std::cerr << "DEBUG: " << cohortset->size() << "/" << current.cohorts.size() << " = " << double(cohortset->size()) / double(current.cohorts.size()) << std::endl;
 	}
-	for (auto rocit = cohortset->cbegin(); (!cohortset->empty()) && (rocit != cohortset->cend());) {
+	for (size_t rocit = 0; rocit < cohortset->size();) {
 		rocits.back() = &rocit;
-		Cohort* cohort = *rocit;
+		Cohort* cohort = cohortset->at(rocit);
 		++rocit;
 
 		finish_reading_loop = true;
@@ -529,14 +529,10 @@ bool GrammarApplicator::runSingleRule(SingleWindow& current, const Rule& rule, R
 			cohortset = &current.rule_to_cohorts[rule.number];
 			override_cohortset();
 			cohortsets.back() = cohortset;
-			if (get_apply_to().cohort->type & (CT_REMOVED | CT_IGNORED)) {
-				rocit = cohortset->lower_bound(current.cohorts[get_apply_to().cohort->local_number]);
-			}
-			else {
-				rocit = cohortset->find(current.cohorts[get_apply_to().cohort->local_number]);
-				if (rocit != cohortset->end()) {
-					++rocit;
-				}
+			auto gac = get_apply_to().cohort;
+			rocit = gac->local_number;
+			if (!(gac->type & (CT_REMOVED | CT_IGNORED)) && rocit < cohortset->size()) {
+				++rocit;
 			}
 		};
 
@@ -790,7 +786,7 @@ bool GrammarApplicator::runSingleRule(SingleWindow& current, const Rule& rule, R
 		if (num_active == 0 && (num_iff == 0 || rule.type != K_IFF)) {
 			if (!matched_target) {
 				--rocit;                         // We have already incremented rocit earlier, so take one step back...
-				rocit = cohortset->erase(rocit); // ...and one step forward again
+				cohortset->erase(rocit); // ...and one step forward again
 			}
 			context_stack.pop_back();
 			continue;
@@ -1223,7 +1219,7 @@ uint32_t GrammarApplicator::runRulesOnSingleWindow(SingleWindow& current, const
 				}
 				else if (current.next) {
 					current.next->text = current.text_post + current.next->text;
-					current.next->all_cohorts.insert(current.previous->all_cohorts.begin() + 1, current.all_cohorts.begin() + 1, current.all_cohorts.end());
+					current.next->all_cohorts.insert(current.next->all_cohorts.begin() + 1, current.all_cohorts.begin() + 1, current.all_cohorts.end());
 				}
 				current.all_cohorts.clear();
 
@@ -1755,9 +1751,9 @@ uint32_t GrammarApplicator::runRulesOnSingleWindow(SingleWindow& current, const
 						cCohort->relations.swap(get_apply_to().cohort->relations);
 
 						std::pair<SingleWindow**, size_t> swss[3] = {
-							std::make_pair(&gWindow->previous[0], gWindow->previous.size()),
+							std::make_pair(gWindow->previous.data(), gWindow->previous.size()),
 							std::make_pair(&gWindow->current, static_cast<size_t>(1)),
-							std::make_pair(&gWindow->next[0], gWindow->next.size()),
+							std::make_pair(gWindow->next.data(), gWindow->next.size()),
 						};
 						for (auto sws : swss) {
 							for (size_t sw = 0; sw < sws.second; ++sw) {

src/MathParser.hpp

@@ -95,7 +95,7 @@ inline void MathParser::eval_add_sub(double& result) {
 	UChar op = 0;
 	double temp = 0;
 	eval_mul_div(result);
-	while ((op = token[0]) == '+' || op == '-') {
+	while (!token.empty() && ((op = token[0]) == '+' || op == '-')) {
 		get_token();
 		eval_mul_div(temp);
 		switch (op) {
@@ -113,7 +113,7 @@ inline void MathParser::eval_mul_div(double& result) {
 	UChar op = 0;
 	double temp = 0;
 	eval_exp(result);
-	while ((op = token[0]) == '*' || op == '/') {
+	while (!token.empty() && ((op = token[0]) == '*' || op == '/')) {
 		get_token();
 		eval_exp(temp);
 		switch (op) {
@@ -130,7 +130,7 @@ inline void MathParser::eval_mul_div(double& result) {
 inline void MathParser::eval_exp(double& result) {
 	double temp = 0;
 	eval_unary(result);
-	while (token[0] == '^') {
+	while (!token.empty() && token[0] == '^') {
 		get_token();
 		eval_unary(temp);
 		result = pow(result, temp);

src/interval_vector.hpp

@@ -172,10 +172,26 @@ class interval_vector {
 	}
 
 	bool insert(T t) {
+		if (elements.empty()) {
+			elements.emplace_back(interval(t));
+			return true;
+		}
 		auto it = std::lower_bound(elements.begin(), elements.end(), t);
 		if (it != elements.end() && t >= it->lb && t <= it->ub) {
 			return false;
 		}
+		if (it == elements.begin()) {
+			if (it->ub + 1 == t) {
+				++it->ub;
+			}
+			else if (it->lb - 1 == t) {
+				--it->lb;
+			}
+			else {
+				elements.insert(it, interval(t));
+			}
+			return true;
+		}
 		auto pr = it - 1;
 		if (it != elements.begin() && pr->ub + 1 == t) {
 			++pr->ub;

src/sorted_vector.hpp

@@ -81,7 +81,11 @@ class sorted_vector {
 		//*/
 		iterator it = std::lower_bound(elements.begin(), elements.end(), t, comp);
 		size_t at = std::distance(elements.begin(), it);
-		if (it == elements.end() || comp(*it, t) || comp(t, *it)) {
+		if (it == elements.end()) {
+			elements.emplace_back(t);
+			return std::make_pair(elements.begin() + at, true);
+		}
+		if (comp(*it, t) || comp(t, *it)) {
 			elements.insert(it, t);
 			return std::make_pair(elements.begin() + at, true);
 		}
@@ -142,6 +146,10 @@ class sorted_vector {
 		return elements.erase(elements.begin() + o);
 	}
 
+	void erase(size_type i) {
+		elements.erase(elements.begin() + i);
+	}
+
 	template<typename It>
 	void erase(It b, It e) {
 		for (; b != e; ++b) {
@@ -166,7 +174,12 @@ class sorted_vector {
 		return it;
 	}
 
-	size_t count(T t) const {
+	size_type find_n(T t) const {
+		auto it = find(t);
+		return std::distance(elements.begin(), it);
+	}
+
+	size_type count(T t) const {
 		return (find(t) != end());
 	}
 
@@ -214,6 +227,10 @@ class sorted_vector {
 		return elements.back();
 	}
 
+	T& at(size_type i) {
+		return elements[i];
+	}
+
 	iterator lower_bound(T t) {
 		return std::lower_bound(elements.begin(), elements.end(), t, comp);
 	}