Add float parse capability to expreval

- somewhat extensive rewrite of expreval to make it dynamic dispatch based
- ... which allows us to use typeswitches
- and using the above, add `.float` and `.double` assembler directives

src/assembler/assembler.h

@@ -472,7 +472,10 @@ class Assembler : public AssemblerBase {
         errors.push_back(*err);
         continue;
       } else {
-        symbolValue = std::get<ExprEvalVT>(exprRes);
+        auto valuePtr = dynamic_cast<IntRes *>(exprRes->get());
+        assert(valuePtr &&
+               "Expected integer result from expression evaluation");
+        symbolValue = valuePtr->v;
       }
 
       if (!linkRequest.fieldRequest.relocation.isEmpty()) {

src/assembler/assemblerbase.cpp

@@ -44,7 +44,7 @@ ExprEvalRes AssemblerBase::evalExpr(const Location &location,
 
   auto symbolValue = relativeMap.find(expr);
   if (symbolValue != relativeMap.end()) {
-    return symbolValue->second;
+    return ExprEvalRes(std::make_shared<IntRes>(symbolValue->second));
   } else {
     return evaluate(location, expr, &relativeMap);
   }

src/assembler/assemblererror.h

@@ -99,12 +99,25 @@ struct Result : public std::variant<Error, T> {
     return std::get<Error>(*this); // Make compiler happy
   }
 
+  const T &operator*() { return value(); }
+  const T *operator->() { return &value(); }
+
   bool isError() const { return std::holds_alternative<Error>(*this); }
   bool isResult() const { return std::holds_alternative<T>(*this); }
 
   // Convenience function for a default constructed value of T.
   static T def() { return std::monostate(); }
 };
 
+// Free functions for determining whether a Result is an error or not.
+template <typename T>
+static bool failed(const Result<T> &res) {
+  return res.isError();
+}
+template <typename T>
+static bool succeeded(const Result<T> &res) {
+  return res.isResult();
+}
+
 } // namespace Assembler
 } // namespace Ripes