Merge branch 'master' of somweyr.de:ousia

1 files changed, 174 insertions, 18 deletions

diff --git a/src/core/parser/ParserScope.cpp b/src/core/parser/ParserScope.cpp
index 0de0dbf..c7a9f2a 100644
--- a/src/core/parser/ParserScope.cpp
+++ b/src/core/parser/ParserScope.cpp
@@ -18,6 +18,7 @@
 
 #include <core/common/Exceptions.hpp>
 #include <core/common/Utils.hpp>
+#include <core/model/Typesystem.hpp>
 
 #include "ParserScope.hpp"
 
@@ -31,12 +32,13 @@ ParserScopeBase::ParserScopeBase(const NodeVector<Node> &nodes) : nodes(nodes)
 {
 }
 
-Rooted<Node> ParserScopeBase::resolve(const std::vector<std::string> &path,
-                                      const Rtti &type, Logger &logger)
+Rooted<Node> ParserScopeBase::resolve(const Rtti &type,
+                                      const std::vector<std::string> &path,
+                                      Logger &logger)
 {
 	// Go up the stack and try to resolve the
 	for (auto it = nodes.rbegin(); it != nodes.rend(); it++) {
-		std::vector<ResolutionResult> res = (*it)->resolve(path, type);
+		std::vector<ResolutionResult> res = (*it)->resolve(type, path);
 
 		// Abort if the object could not be resolved
 		if (res.empty()) {
@@ -79,14 +81,14 @@ bool DeferredResolution::resolve(
 	// Fork the logger to prevent error messages from being shown if we actively
 	// ignore the resolution result
 	LoggerFork loggerFork = logger.fork();
-	Rooted<Node> res = scope.resolve(path, type, loggerFork);
+	Rooted<Node> res = scope.resolve(type, path, loggerFork);
 	if (res != nullptr) {
 		if (!ignore.count(res.get())) {
 			loggerFork.commit();
 			try {
 				// Push the location onto the logger default location stack
 				GuardedLogger loggerGuard(logger, *owner);
-				resultCallback(res, logger);
+				resultCallback(res, owner, logger);
 			}
 			catch (LoggableException ex) {
 				logger.log(ex);
@@ -99,6 +101,16 @@ bool DeferredResolution::resolve(
 	return false;
 }
 
+void DeferredResolution::fail(Logger &logger)
+{
+	try {
+		resultCallback(nullptr, owner, logger);
+	}
+	catch (LoggableException ex) {
+		logger.log(ex);
+	}
+}
+
 /* Class ParserScope */
 
 ParserScope::ParserScope(const NodeVector<Node> &nodes,
@@ -227,29 +239,29 @@ bool ParserScope::getFlag(ParserFlag flag)
 	return false;
 }
 
-bool ParserScope::resolve(const std::vector<std::string> &path,
-                          const Rtti &type, Logger &logger,
+bool ParserScope::resolve(const Rtti &type,
+                          const std::vector<std::string> &path,
+                          Handle<Node> owner, Logger &logger,
                           ResolutionImposterCallback imposterCallback,
-                          ResolutionResultCallback resultCallback,
-                          Handle<Node> owner)
+                          ResolutionResultCallback resultCallback)
 {
-	if (!resolve(path, type, logger, resultCallback, owner)) {
-		resultCallback(imposterCallback(), logger);
+	if (!resolve(type, path, owner, logger, resultCallback)) {
+		resultCallback(imposterCallback(), owner, logger);
 		return false;
 	}
 	return true;
 }
 
-bool ParserScope::resolve(const std::vector<std::string> &path,
-                          const Rtti &type, Logger &logger,
-                          ResolutionResultCallback resultCallback,
-                          Handle<Node> owner)
+bool ParserScope::resolve(const Rtti &type,
+                          const std::vector<std::string> &path,
+                          Handle<Node> owner, Logger &logger,
+                          ResolutionResultCallback resultCallback)
 {
 	// Try to directly resolve the node
-	Rooted<Node> res = ParserScopeBase::resolve(path, type, logger);
+	Rooted<Node> res = ParserScopeBase::resolve(type, path, logger);
 	if (res != nullptr && !awaitingResolution.count(res.get())) {
 		try {
-			resultCallback(res, logger);
+			resultCallback(res, owner, logger);
 		}
 		catch (LoggableException ex) {
 			logger.log(ex, *owner);
@@ -266,6 +278,149 @@ bool ParserScope::resolve(const std::vector<std::string> &path,
 	return false;
 }
 
+bool ParserScope::resolveType(const std::vector<std::string> &path,
+                              Handle<Node> owner, Logger &logger,
+                              ResolutionResultCallback resultCallback)
+{
+	// Check whether the given path denotes an array, if yes recursively resolve
+	// the inner type and wrap it in an array type (this allows multi
+	// dimensional arrays).
+	if (!path.empty()) {
+		const std::string &last = path.back();
+		if (last.size() >= 2 && last.substr(last.size() - 2, 2) == "[]") {
+			// Type ends with "[]", remove this from the last element in the
+			// list
+			std::vector<std::string> p = path;
+			p.back() = p.back().substr(0, last.size() - 2);
+
+			// Resolve the rest of the type
+			return resolveType(p, owner, logger,
+			                   [resultCallback](Handle<Node> resolved,
+			                                    Handle<Node> owner,
+			                                    Logger &logger) {
+				if (resolved != nullptr) {
+					Rooted<ArrayType> arr{new ArrayType{resolved.cast<Type>()}};
+					resultCallback(arr, owner, logger);
+				} else {
+					resultCallback(nullptr, owner, logger);
+				}
+			});
+		}
+	}
+
+	// Requested type is not an array, call the usual resolve function
+	return resolve(RttiTypes::Type, path, owner, logger, resultCallback);
+}
+
+bool ParserScope::resolveType(const std::string &name, Handle<Node> owner,
+                              Logger &logger,
+                              ResolutionResultCallback resultCallback)
+{
+	return resolveType(Utils::split(name, '.'), owner, logger, resultCallback);
+}
+
+bool ParserScope::resolveTypeWithValue(const std::vector<std::string> &path,
+                                       Handle<Node> owner, Variant &value,
+                                       Logger &logger,
+                                       ResolutionResultCallback resultCallback)
+{
+	// Fork the parser scope -- constants need to be resolved in the same
+	// context as this resolve call
+	std::shared_ptr<ParserScope> scope = std::make_shared<ParserScope>(fork());
+
+	return resolveType(
+	    path, owner, logger,
+	    [=](Handle<Node> resolved, Handle<Node> owner, Logger &logger) mutable {
+		    // Abort if the lookup failed
+		    if (resolved == nullptr) {
+			    resultCallback(resolved, owner, logger);
+			    return;
+		    }
+
+		    // Fetch the type reference and the manager reference
+		    Rooted<Type> type = resolved.cast<Type>();
+		    Manager *mgr = &type->getManager();
+
+		    // The type has been resolved, try to resolve magic values as
+		    // constants and postpone calling the callback function until
+		    // all magic values have been resolved
+		    std::shared_ptr<bool> isAsync = std::make_shared<bool>(false);
+		    std::shared_ptr<int> magicCount = std::make_shared<int>(0);
+		    type->build(value, logger, [=](Variant &magicValue, bool isValid,
+		                                   ManagedUid innerTypeUid) mutable {
+			    // Fetch the inner type
+			    Rooted<Type> innerType =
+			        dynamic_cast<Type *>(mgr->getManaged(innerTypeUid));
+			    if (innerType == nullptr) {
+				    return;
+			    }
+
+			    // Fetch a pointer at the variant
+			    Variant *magicValuePtr = &magicValue;
+
+			    // Increment the number of encountered magic values
+			    (*magicCount)++;
+
+			    // Try to resolve the value as constant
+			    std::string constantName = magicValue.asMagic();
+			    scope->resolve<Constant>(constantName, owner, logger,
+			                             [=](Handle<Node> resolved,
+			                                 Handle<Node> owner,
+			                                 Logger &logger) mutable {
+				    if (resolved != nullptr) {
+					    // Make sure the constant is of the correct inner type
+					    Rooted<Constant> constant = resolved.cast<Constant>();
+					    Rooted<Type> constantType = constant->getType();
+					    if (constantType != innerType) {
+						    logger.error(
+						        std::string("Expected value of type \"") +
+						            innerType->getName() +
+						            std::string("\" but found constant \"") +
+						            constant->getName() +
+						            std::string(" of type \"") +
+						            constantType->getName() + "\" instead.",
+						        *owner);
+					    } else if (!isValid) {
+						    logger.error("Identifier \"" + constantName +
+						                     "\" is not a valid " +
+						                     innerType->getName(),
+						                 *owner);
+					    }
+
+					    // Nevertheless, no matter what happened, set the value
+					    // of the original magic variant to the given constant
+					    *magicValuePtr = constant->getValue();
+				    }
+
+				    // Decrement the number of magic values, call the callback
+				    // function if all magic values have been resolved
+				    (*magicCount)--;
+				    if ((*magicCount) == 0 && (*isAsync)) {
+					    resultCallback(resolved, owner, logger);
+				    }
+				});
+			});
+
+		    // Now we are asynchronous
+		    (*isAsync) = true;
+
+		    // Directly call the callback function if there were no magic values
+		    // involved
+		    if ((*magicCount) == 0) {
+			    resultCallback(resolved, owner, logger);
+		    }
+		});
+}
+
+bool ParserScope::resolveTypeWithValue(const std::string &name,
+                                       Handle<Node> owner, Variant &value,
+                                       Logger &logger,
+                                       ResolutionResultCallback resultCallback)
+{
+	return resolveTypeWithValue(Utils::split(name, '.'), owner, value, logger,
+	                            resultCallback);
+}
+
 bool ParserScope::performDeferredResolution(Logger &logger)
 {
 	// Repeat the resolution process as long as something has changed in the
@@ -304,7 +459,8 @@ bool ParserScope::performDeferredResolution(Logger &logger)
 
 	// Output error messages for all elements for which resolution did not
 	// succeed.
-	for (const auto &failed : deferred) {
+	for (auto &failed : deferred) {
+		failed.fail(logger);
 		logger.error(std::string("Could not resolve ") + failed.type.name +
 		                 std::string(" \"") + Utils::join(failed.path, ".") +
 		                 std::string("\""),