Somewhat fixed weird issue during module renaming.

The "fix" is very weird (see VariableState.cpp:55 and following) and still seems to lead to a segfault upon program termination...

src/ir/Module.cpp

@@ -12,6 +12,10 @@
 #include <sstream>
 #include <iostream>
 
+#include "log4cplus/logger.h"
+#include "log4cplus/loggingmacros.h"
+extern log4cplus::Logger logger;
+
 namespace storm {
 
 namespace ir {
@@ -37,29 +41,30 @@ Module::Module(std::string moduleName,
 
 Module::Module(const Module& module, const std::string& moduleName, const std::map<std::string, std::string>& renaming, std::shared_ptr<VariableAdder> adder)
 	: moduleName(moduleName) {
+	LOG4CPLUS_DEBUG(logger, "Start renaming " << module.moduleName << " to " << moduleName);
 	this->booleanVariables.reserve(module.booleanVariables.size());
 	for (BooleanVariable it: module.booleanVariables) {
 		if (renaming.count(it.getName()) > 0) {
 			this->booleanVariablesToIndexMap[renaming.at(it.getName())] = adder->addBooleanVariable(renaming.at(it.getName()), it.getInitialValue());
-		} else std::cerr << "ERROR: " << moduleName << "." << it.getName() << " was not renamed!" << std::endl;
+		} else LOG4CPLUS_ERROR(logger, moduleName << "." << it.getName() << " was not renamed!");
 	}
 	this->integerVariables.reserve(module.integerVariables.size());
 	for (IntegerVariable it: module.integerVariables) {
 		if (renaming.count(it.getName()) > 0) {
 			this->integerVariablesToIndexMap[renaming.at(it.getName())] = adder->addIntegerVariable(renaming.at(it.getName()), it.getLowerBound(), it.getUpperBound(), it.getInitialValue());
-		} else std::cerr << "ERROR: " << moduleName << "." << it.getName() << " was not renamed!" << std::endl;
+		} else LOG4CPLUS_ERROR(logger, moduleName << "." << it.getName() << " was not renamed!");
 	}
 	this->booleanVariables.reserve(module.booleanVariables.size());
 	for (BooleanVariable it: module.booleanVariables) {
 		if (renaming.count(it.getName()) > 0) {
 			this->booleanVariables.emplace_back(it, renaming.at(it.getName()), renaming, this->booleanVariablesToIndexMap, this->integerVariablesToIndexMap);
-		} else std::cerr << "ERROR: " << moduleName << "." << it.getName() << " was not renamed!" << std::endl;
+		} else LOG4CPLUS_ERROR(logger, moduleName << "." << it.getName() << " was not renamed!");
 	}
 	this->integerVariables.reserve(module.integerVariables.size());
 	for (IntegerVariable it: module.integerVariables) {
 		if (renaming.count(it.getName()) > 0) {
 			this->integerVariables.emplace_back(it, renaming.at(it.getName()), renaming, this->booleanVariablesToIndexMap, this->integerVariablesToIndexMap);
-		} else std::cerr << "ERROR: " << moduleName << "." << it.getName() << " was not renamed!" << std::endl;
+		} else LOG4CPLUS_ERROR(logger, moduleName << "." << it.getName() << " was not renamed!");
 	}
 	
 	this->commands.reserve(module.commands.size());
@@ -67,6 +72,8 @@ Module::Module(const Module& module, const std::string& moduleName, const std::m
 		this->commands.emplace_back(cmd, renaming, this->booleanVariablesToIndexMap, this->integerVariablesToIndexMap);
 	}
 	this->collectActions();
+
+	LOG4CPLUS_DEBUG(logger, "Finished renaming...");
 }
 
 // Return the number of boolean variables.

src/ir/expressions/BinaryExpression.h

@@ -10,6 +10,7 @@
 
 #include "src/ir/expressions/BaseExpression.h"
 #include <memory>
+#include <iostream>
 
 namespace storm {
 
@@ -21,7 +22,11 @@ class BinaryExpression : public BaseExpression {
 public:
 	BinaryExpression(ReturnType type, std::shared_ptr<BaseExpression> left, std::shared_ptr<BaseExpression> right)
 		: BaseExpression(type), left(left), right(right) {
-
+		if (left == nullptr || right == nullptr) {
+			std::cerr << "BinaryExpression" << std::endl;
+			if (left != nullptr) std::cerr << "\tleft: " << left->toString() << std::endl;
+			if (right != nullptr) std::cerr << "\tright: " << right->toString() << std::endl;
+		}
 	}
 
 	std::shared_ptr<BaseExpression> const& getLeft() const {

src/ir/expressions/VariableExpression.h

@@ -26,9 +26,11 @@ public:
 			std::shared_ptr<BaseExpression> upperBound = std::shared_ptr<storm::ir::expressions::BaseExpression>(nullptr))
 			: BaseExpression(type), index(index), variableName(variableName),
 			  lowerBound(lowerBound), upperBound(upperBound) {
+		std::cerr << "Creating " << this << std::endl;
 	}
 
 	virtual ~VariableExpression() {
+		std::cerr << "Destroying " << this << std::endl;
 	}
 
 	virtual std::shared_ptr<BaseExpression> clone(const std::map<std::string, std::string>& renaming, const std::map<std::string, uint_fast64_t>& bools, const std::map<std::string, uint_fast64_t>& ints) {

src/parser/PrismParser.cpp

@@ -26,7 +26,6 @@
 #include <iomanip>
 #include <limits>
 
-
 #include "log4cplus/logger.h"
 #include "log4cplus/loggingmacros.h"
 extern log4cplus::Logger logger;
@@ -69,7 +68,7 @@ namespace parser {
 		this->state->moduleNames_.add(name, name);
 		Module* old = this->state->moduleMap_.find(oldname);
 		if (old == nullptr) {
-			std::cerr << "Renaming module failed: module " << oldname << " does not exist!" << std::endl;
+			LOG4CPLUS_ERROR(logger, "Renaming module failed: module " << oldname << " does not exist!");
 			throw "Renaming module failed";
 		}
 		Module res(*old, name, mapping, this->state);
@@ -236,7 +235,16 @@ PrismParser::PrismGrammar::PrismGrammar() : PrismParser::PrismGrammar::base_type
 	}
 	
 	void PrismParser::PrismGrammar::prepareForSecondRun() {
+		LOG4CPLUS_INFO(logger, "Preparing parser for second run.");
+		this->state->getIntegerVariable("d1");
+		this->state->getIntegerVariable("d2");
+		this->state->getIntegerVariable("s1");
+		this->state->getIntegerVariable("s2");
 		this->state->prepareForSecondRun();
+		this->state->getIntegerVariable("d1");
+		this->state->getIntegerVariable("d2");
+		this->state->getIntegerVariable("s1");
+		this->state->getIntegerVariable("s2");
 		prism::BooleanExpressionGrammar::secondRun();
 		prism::ConstBooleanExpressionGrammar::secondRun();
 		prism::ConstDoubleExpressionGrammar::secondRun();

src/parser/PrismParser/BooleanExpressionGrammar.cpp

@@ -33,7 +33,7 @@ namespace prism {
 	}
 
 	void BooleanExpressionGrammar::prepareSecondRun() {
-		booleanVariableExpression = this->state->booleanVariables_;
+		booleanVariableExpression %= this->state->booleanVariables_;
 		booleanVariableExpression.name("boolean variable");
 	}
 

src/parser/PrismParser/Includes.h

@@ -33,5 +33,9 @@ typedef boost::spirit::unused_type Unused;
 using namespace storm::ir;
 using namespace storm::ir::expressions;
 
+#include "log4cplus/logger.h"
+#include "log4cplus/loggingmacros.h"
+extern log4cplus::Logger logger;
+
 #endif	/* BOOSTINCLUDES_H */
 

src/parser/PrismParser/IntegerExpressionGrammar.cpp

@@ -27,7 +27,7 @@ namespace prism {
 	}
 
 	void IntegerExpressionGrammar::prepareSecondRun() {
-		integerVariableExpression = this->state->integerVariables_;
+		integerVariableExpression %= this->state->integerVariables_;
 		integerVariableExpression.name("integer variable");
 	}
 

src/parser/PrismParser/VariableState.cpp

@@ -0,0 +1,135 @@
+#include "VariableState.h"
+
+namespace storm {
+namespace parser {
+namespace prism {
+
+using namespace storm::ir;
+using namespace storm::ir::expressions;
+
+template<typename T>
+struct SymbolDump {
+	SymbolDump(std::ostream& out) : out(out) {}
+	void operator() (std::basic_string<char> s, T elem) {
+		this->out << "\t" << s << " -> " << elem << std::endl;
+	}
+private:
+	std::ostream& out;
+};
+template<typename T>
+std::ostream& operator<<(std::ostream& out, qi::symbols<char, T>& symbols) {
+	out << "Dumping symbol table" << std::endl;
+	SymbolDump<T> dump(out);
+	symbols.for_each(dump);
+	return out;
+}
+
+
+VariableState::VariableState(bool firstRun)
+		: firstRun(firstRun), keywords(), nextBooleanVariableIndex(0), nextIntegerVariableIndex(0) {
+}
+
+uint_fast64_t VariableState::addBooleanVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> init) {
+	if (firstRun) {
+		std::shared_ptr<VariableExpression> varExpr = std::shared_ptr<VariableExpression>(new VariableExpression(storm::ir::expressions::BaseExpression::bool_, this->nextBooleanVariableIndex, name));
+		LOG4CPLUS_DEBUG(logger, "Adding boolean variable " << name << " with new id " << this->nextBooleanVariableIndex);
+		this->booleanVariables_.add(name, varExpr);
+		this->booleanVariableNames_.add(name, name);
+		this->nextBooleanVariableIndex++;
+		return varExpr->getVariableIndex();
+	} else {
+		std::shared_ptr<VariableExpression> res = this->booleanVariables_.at(name);
+		if (res != nullptr) {
+			return res->getVariableIndex();
+		} else {
+			LOG4CPLUS_ERROR(logger, "Boolean variable " << name << " was not created in first run.");
+			return 0;
+		}
+	}
+}
+
+uint_fast64_t VariableState::addIntegerVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> lower, const std::shared_ptr<storm::ir::expressions::BaseExpression> upper, const std::shared_ptr<storm::ir::expressions::BaseExpression> init) {
+	if (firstRun) {
+		std::shared_ptr<VariableExpression> varExpr = std::shared_ptr<VariableExpression>(new VariableExpression(storm::ir::expressions::BaseExpression::int_, this->nextIntegerVariableIndex, name, lower, upper));
+		LOG4CPLUS_DEBUG(logger, "Adding integer variable " << name << " with new id " << this->nextIntegerVariableIndex);
+		this->integerVariables_.add(name, varExpr);
+		LOG4CPLUS_DEBUG(logger, "Int variables: " << this->integerVariables_);
+		this->integerVariables_.at(name) = varExpr;
+		LOG4CPLUS_DEBUG(logger, "Int variables: " << this->integerVariables_);
+		this->integerVariableNames_.add(name, name);
+		this->nextIntegerVariableIndex++;
+		return varExpr->getVariableIndex();
+	} else {
+		std::shared_ptr<VariableExpression> res = this->integerVariables_.at(name);
+		if (res != nullptr) {
+			return res->getVariableIndex();
+		} else {
+
+			LOG4CPLUS_ERROR(logger, "Integer variable " << name << " was not created in first run.");
+			return 0;
+		}
+	}
+}
+
+std::shared_ptr<VariableExpression> VariableState::getBooleanVariable(const std::string& name) {
+	std::shared_ptr<VariableExpression> res = this->booleanVariables_.at(name);
+	if (res != nullptr) {
+		LOG4CPLUS_DEBUG(logger, "Getting boolean variable " << name << ", was found at " << res);
+		return res;
+	} else {
+		if (firstRun) {
+			LOG4CPLUS_DEBUG(logger, "Getting boolean variable " << name << ", was not yet created.");
+			return std::shared_ptr<VariableExpression>(new VariableExpression(BaseExpression::bool_, std::numeric_limits<uint_fast64_t>::max(), "bool", std::shared_ptr<BaseExpression>(nullptr), std::shared_ptr<BaseExpression>(nullptr)));
+		} else {
+			LOG4CPLUS_ERROR(logger, "Getting boolean variable " << name << ", but was not found. This variable does not exist.");
+			return std::shared_ptr<VariableExpression>(nullptr);
+		}
+	}
+}
+
+std::shared_ptr<VariableExpression> VariableState::getIntegerVariable(const std::string& name) {
+	std::shared_ptr<VariableExpression> res = this->integerVariables_.at(name);
+	if (res != nullptr) {
+		LOG4CPLUS_DEBUG(logger, "Getting integer variable " << name << ", was found at " << res);
+		return res;
+	} else {
+		if (firstRun) {
+			LOG4CPLUS_DEBUG(logger, "Getting integer variable " << name << ", was not yet created.");
+			return std::shared_ptr<VariableExpression>(new VariableExpression(BaseExpression::int_, std::numeric_limits<uint_fast64_t>::max(), "int", std::shared_ptr<BaseExpression>(nullptr), std::shared_ptr<BaseExpression>(nullptr)));
+		} else {
+			LOG4CPLUS_ERROR(logger, "Getting integer variable " << name << ", but was not found. This variable does not exist.");
+			return std::shared_ptr<VariableExpression>(nullptr);
+		}
+	}
+}
+
+void VariableState::startModule() {
+	this->localBooleanVariables_.clear();
+	this->localIntegerVariables_.clear();
+}
+
+bool VariableState::isFreeIdentifier(std::string& s) const {
+	if (this->integerVariableNames_.find(s) != nullptr) return false;
+	if (this->allConstantNames_.find(s) != nullptr) return false;
+	if (this->labelNames_.find(s) != nullptr) return false;
+	if (this->moduleNames_.find(s) != nullptr) return false;
+	if (this->keywords.find(s) != nullptr) return false;
+	return true;
+}
+bool VariableState::isIdentifier(std::string& s) const {
+	if (this->allConstantNames_.find(s) != nullptr) return false;
+	if (this->keywords.find(s) != nullptr) return false;
+	return true;
+}
+
+void VariableState::prepareForSecondRun() {
+	integerConstants_.clear();
+	booleanConstants_.clear();
+	doubleConstants_.clear();
+	allConstantNames_.clear();
+	this->firstRun = false;
+}
+
+}
+}
+}

src/parser/PrismParser/VariableState.h

@@ -11,6 +11,7 @@
 #include "src/ir/IR.h"
 #include "Includes.h"
 #include "Tokens.h"
+#include <iostream>
 
 namespace storm {
 namespace parser {
@@ -19,14 +20,15 @@ namespace prism {
 using namespace storm::ir;
 using namespace storm::ir::expressions;
 
+template<typename T>
+std::ostream& operator<<(std::ostream& out, qi::symbols<char, T>& symbols);
 
 struct VariableState : public storm::ir::VariableAdder {
 
 public:
-	VariableState(bool firstRun = true)
-			: firstRun(firstRun), keywords(), nextBooleanVariableIndex(0), nextIntegerVariableIndex(0) {
-	}
+	VariableState(bool firstRun = true);
 
+public:
 	bool firstRun;
 	keywordsStruct keywords;
 
@@ -43,102 +45,21 @@ public:
 	// A structure representing the identity function over identifier names.
 	struct variableNamesStruct : qi::symbols<char, std::string> { } integerVariableNames_, booleanVariableNames_, commandNames_, labelNames_, allConstantNames_, moduleNames_,
 			localBooleanVariables_, localIntegerVariables_, assignedLocalBooleanVariables_, assignedLocalIntegerVariables_;
+public:
+	uint_fast64_t addBooleanVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> init);
+
+	uint_fast64_t addIntegerVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> lower, const std::shared_ptr<storm::ir::expressions::BaseExpression> upper, const std::shared_ptr<storm::ir::expressions::BaseExpression> init);
+
+	std::shared_ptr<VariableExpression> getBooleanVariable(const std::string& name);
+
+	std::shared_ptr<VariableExpression> getIntegerVariable(const std::string& name);
+
+	void startModule();
+
+	bool isFreeIdentifier(std::string& s) const;
+	bool isIdentifier(std::string& s) const;
 
-	uint_fast64_t addBooleanVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> init) {
-		if (firstRun) {
-			std::shared_ptr<VariableExpression> varExpr = std::shared_ptr<VariableExpression>(new VariableExpression(storm::ir::expressions::BaseExpression::bool_, this->nextBooleanVariableIndex, name));
-			this->booleanVariables_.add(name, varExpr);
-			this->booleanVariableNames_.add(name, name);
-			this->nextBooleanVariableIndex++;
-			return varExpr->getVariableIndex();
-		} else {
-			std::shared_ptr<VariableExpression> res = this->booleanVariables_.at(name);
-			if (res != nullptr) {
-				return res->getVariableIndex();
-			} else {
-				std::cerr << "Variable " << name << " was not created in first run" << std::endl;
-				return 0;
-			}
-		}
-	}
-
-	uint_fast64_t addIntegerVariable(const std::string& name, const std::shared_ptr<storm::ir::expressions::BaseExpression> lower, const std::shared_ptr<storm::ir::expressions::BaseExpression> upper, const std::shared_ptr<storm::ir::expressions::BaseExpression> init) {
-		//std::cerr << "adding integer variable " << name << std::endl;
-		if (firstRun) {
-			std::shared_ptr<VariableExpression> varExpr = std::shared_ptr<VariableExpression>(new VariableExpression(storm::ir::expressions::BaseExpression::int_, this->nextIntegerVariableIndex, name, lower, upper));
-			this->integerVariables_.add(name, varExpr);
-			this->integerVariableNames_.add(name, name);
-			this->nextIntegerVariableIndex++;
-			return varExpr->getVariableIndex();
-		} else {
-			std::shared_ptr<VariableExpression> res = this->integerVariables_.at(name);
-			if (res != nullptr) {
-				return res->getVariableIndex();
-			} else {
-				std::cerr << "Variable " << name << " was not created in first run" << std::endl;
-				return 0;
-			}
-		}
-	}
-
-	std::shared_ptr<VariableExpression> getBooleanVariable(const std::string& name) {
-		std::shared_ptr<VariableExpression> res = this->booleanVariables_.at(name);
-		if (res != nullptr) {
-			return res;
-		} else {
-			if (firstRun) {
-				return std::shared_ptr<VariableExpression>(new VariableExpression(BaseExpression::bool_, std::numeric_limits<uint_fast64_t>::max(), "bool", std::shared_ptr<BaseExpression>(nullptr), std::shared_ptr<BaseExpression>(nullptr)));
-			} else {
-				std::cerr << "bool Variable " << name << " was not created in first run" << std::endl;
-				return std::shared_ptr<VariableExpression>(nullptr);
-			}
-		}
-	}
-
-	std::shared_ptr<VariableExpression> getIntegerVariable(const std::string& name) {
-		//std::cerr << "getting integer variable " << name << std::endl;
-		std::shared_ptr<VariableExpression> res = this->integerVariables_.at(name);
-		if (res != nullptr) {
-			return res;
-		} else {
-			if (firstRun) {
-				return std::shared_ptr<VariableExpression>(new VariableExpression(BaseExpression::int_, std::numeric_limits<uint_fast64_t>::max(), "int", std::shared_ptr<BaseExpression>(nullptr), std::shared_ptr<BaseExpression>(nullptr)));
-			} else {
-				std::cerr << "int Variable " << name << " was not created in first run" << std::endl;
-				return std::shared_ptr<VariableExpression>(nullptr);
-			}
-		}
-	}
-
-	void startModule() {
-		//std::cerr << "starting new module" << std::endl;
-		this->localBooleanVariables_.clear();
-		this->localIntegerVariables_.clear();
-	}
-
-	bool isFreeIdentifier(std::string& s) const {
-		//std::cerr << "Checking if " << s << " is free" << std::endl;
-		if (this->integerVariableNames_.find(s) != nullptr) return false;
-		if (this->allConstantNames_.find(s) != nullptr) return false;
-		if (this->labelNames_.find(s) != nullptr) return false;
-		if (this->moduleNames_.find(s) != nullptr) return false;
-		if (this->keywords.find(s) != nullptr) return false;
-		return true;
-	}
-	bool isIdentifier(std::string& s) const {
-		//std::cerr << "Checking if " << s << " is identifier" << std::endl;
-		if (this->allConstantNames_.find(s) != nullptr) return false;
-		if (this->keywords.find(s) != nullptr) return false;
-		return true;
-	}
-
-	void prepareForSecondRun() {
-		integerConstants_.clear();
-		booleanConstants_.clear();
-		doubleConstants_.clear();
-		allConstantNames_.clear();
-		this->firstRun = false;
-	}
+	void prepareForSecondRun();
 };
 
 }