Merge pull request #57 from EdwardPalmer99/EdwardPalmer99/add-benchmarking-and-casts

AnyObject

Author: EdwardPalmer99

src/environment/Scope.cpp

@@ -8,6 +8,7 @@
  */
 
 #include "Scope.hpp"
+#include "AnyObject.hpp"
 #include "Exceptions.hpp"
 #include <cassert>
 
@@ -22,7 +23,7 @@ Scope::Scope(const Scope *_parent)
 }
 
 
-BaseObject::Ptr Scope::getOptionalNamedObject(const std::string &name) const
+AnyObject::Ptr Scope::getOptionalNamedObject(const std::string &name) const
 {
     // Try in our scope (to handle variable shadowing).
     auto iter = linkedObjectForName.find(name);
@@ -42,9 +43,9 @@ BaseObject::Ptr Scope::getOptionalNamedObject(const std::string &name) const
 }
 
 
-BaseObject::Ptr Scope::getNamedObject(const std::string &name) const
+AnyObject::Ptr Scope::getNamedObject(const std::string &name) const
 {
-    BaseObject::Ptr obj = getOptionalNamedObject(name);
+    AnyObject::Ptr obj = getOptionalNamedObject(name);
     if (!obj)
     {
         ThrowException("undefined variable " + name);
@@ -60,7 +61,7 @@ bool Scope::hasNamedObject(const std::string &name) const
 }
 
 
-void Scope::linkObject(const std::string &name, BaseObject::Ptr object)
+void Scope::linkObject(const std::string &name, AnyObject::Ptr object)
 {
     assert(object != nullptr);
 

src/environment/Scope.hpp

@@ -8,8 +8,7 @@
  */
 
 #pragma once
-#include "BaseObject.hpp"
-#include <new>
+#include <memory>
 #include <string>
 #include <unordered_map>
 #include <vector>
@@ -28,30 +27,10 @@ class Scope
     /// Get a named object ("variable") in our scope or an outer scope. We work
     /// outwards from our scope to handle variable shadowing correctly. If the
     /// object is not found, return nullptr.
-    BaseObject::Ptr getOptionalNamedObject(const std::string &name) const;
+    std::shared_ptr<class AnyObject> getOptionalNamedObject(const std::string &name) const;
 
     /// Similar to getOptionalObject but has a check to ensure pointer is valid.
-    BaseObject::Ptr getNamedObject(const std::string &name) const;
-
-    /// Get an object from the scope and cast to a subclass.
-    template <typename TObject>
-    std::shared_ptr<TObject> getNamedObject(const std::string &name) const
-    {
-        auto objectPtr = getNamedObject(name);
-        return std::static_pointer_cast<TObject>(objectPtr);
-    }
-
-    template <typename TObject>
-    std::shared_ptr<TObject> getOptionalNamedObject(const std::string &name) const
-    {
-        BaseObject::Ptr obj = getOptionalNamedObject(name);
-        if (!obj)
-        {
-            return nullptr;
-        }
-
-        return std::static_pointer_cast<TObject>(obj);
-    }
+    std::shared_ptr<class AnyObject> getNamedObject(const std::string &name) const;
 
     /// Returns non-const reference to parent scope.
     inline Scope *parentScope() { return parent; }
@@ -60,13 +39,13 @@ class Scope
     void setParentScope(Scope *parent_) { parent = parent_; }
 
     /// Create a link between a variable name and an object in this scope.
-    void linkObject(const std::string &name, BaseObject::Ptr object);
+    void linkObject(const std::string &name, std::shared_ptr<class AnyObject> object);
 
 private:
     /// Stores a mapping from the variable name to a pointer to the object. These
     /// are only linked objects defined in this scope. This enables variable
     /// shadowing.
-    std::unordered_map<std::string, BaseObject::Ptr> linkedObjectForName;
+    std::unordered_map<std::string, std::shared_ptr<class AnyObject>> linkedObjectForName;
 
     Scope *parent{nullptr};
 };

src/eucleia.cpp

@@ -19,7 +19,7 @@ int main(int argc, const char *argv[])
         CLIParser parser("eucleia");
 
         parser.addFlagArg("--help", "display available options");
-        parser.addFlagArg("--trace", "logs everything!");
+        parser.addFlagArg("--trace", "logs everything!"); /* TODO: - enable user to set different log levels or disable */
 
         parser.addPositionalArg("fileName");
         parser.parseArgs(argc, argv);

src/interpreter/EucleiaInterpreter.cpp

@@ -6,9 +6,8 @@
 //
 
 #include "EucleiaInterpreter.hpp"
-#include "BaseObject.hpp"
+
 #include "FileParser.hpp"
-#include "Objects.hpp"
 #include "Scope.hpp"
 #include <iostream>
 

src/lexer/CharStream.cpp

@@ -14,6 +14,7 @@
 #include "Stringify.hpp"
 #include <algorithm>
 #include <cstring>
+#include <filesystem>
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -172,5 +173,5 @@ unsigned int CharStream::endCol(unsigned int lineNum) const
 
 std::string CharStream::location() const
 {
-    return eucleia::stringify("File \"%s\", Ln %d, Col %d", path.c_str(), line, col);
+    return eucleia::stringify("(%s:%d:%d)", path.filename().c_str(), line, col);
 }

src/lexer/CharStream.hpp

@@ -8,6 +8,7 @@
  */
 
 #pragma once
+#include <filesystem>
 #include <string>
 #include <unordered_map>
 
@@ -59,8 +60,7 @@ class CharStream
 private:
     unsigned int endCol(unsigned int lineNum) const;
 
-
-    const std::string path;
+    const std::filesystem::path path;
 
     char *base{nullptr};
     char *ptr{nullptr};

src/lexer/Token.cpp

@@ -0,0 +1,38 @@
+/**
+ * @file Token.cpp
+ * @author Edward Palmer
+ * @date 2025-05-24
+ *
+ * @copyright Copyright (c) 2025
+ *
+ */
+
+#include "Token.hpp"
+
+
+std::string Token::typeToString() const /* TODO: - more efficient to have a static maps and return a reference to string */
+{
+    switch (_type)
+    {
+        case NotSet:
+            return "NotSet";
+        case EndOfFile:
+            return "EndOfFile";
+        case Punctuation:
+            return "Punctuation";
+        case Keyword:
+            return "Keyword";
+        case Variable:
+            return "Variable";
+        case String:
+            return "String";
+        case Operator:
+            return "Operator";
+        case Int:
+            return "Int";
+        case Float:
+            return "Float";
+        default:
+            ThrowException("Unknown token type");
+    }
+}

src/lexer/Token.hpp

@@ -31,6 +31,8 @@ class Token : public std::string
         Float
     };
 
+    std::string typeToString() const;
+
     /* Constructors */
     Token(Type type) : _type(type) {}
     Token(std::string &value, Type type = NotSet) : std::string(value), _type(type) {}
@@ -115,4 +117,4 @@ Token Tokens::dequeue()
     pop();
 
     return next;
-}
+}

src/lexer/Tokenizer.cpp

@@ -24,7 +24,7 @@ Tokens Tokenizer::buildTokens(const std::string &path)
     while (!stream.isLast())
     {
         Token token = buildNextToken(stream);
-        log().debug(stream.location() + ": " + token);
+        log().debug("Parsed '" + token + "' => " + token.typeToString() + " " + stream.location());
 
         if (token.type() != Token::EndOfFile)
             tokens.push(std::move(token));

src/nodes/AddVariableNode.cpp

@@ -8,14 +8,17 @@
  */
 
 #include "AddVariableNode.hpp"
-#include "ArrayObject.hpp"
-#include "FloatObject.hpp"
-#include "IntObject.hpp"
+#include "Exceptions.hpp"
 #include "ObjectFactory.hpp"
-#include "StringObject.hpp"
 
+AddVariableNode::AddVariableNode(std::string name, AnyObject::Type type)
+    : LookupVariableNode(std::move(name)),
+      _variableType(type)
+{
+    setType(NodeType::AddVariable);
+}
 
-BaseObject::Ptr AddVariableNode::evaluate(Scope &scope)
+AnyObject::Ptr AddVariableNode::evaluate(Scope &scope)
 {
     /* TODO: - add support for functions (to enable passing to other functions, etc) */
     auto objectPtr = ObjectFactory::allocate(_variableType);
@@ -26,39 +29,25 @@ BaseObject::Ptr AddVariableNode::evaluate(Scope &scope)
 
 
 /// Type checking.
-bool AddVariableNode::passesAssignmentTypeCheck(const BaseObject &assignObject) const
+bool AddVariableNode::passesAssignmentTypeCheck(const AnyObject &assignObject) const
 {
-    switch (_variableType)
-    {
-        case ObjectType::Int:
-            return assignObject.isObjectType<IntObject>();
-        case ObjectType::Float:
-            return assignObject.isObjectType<FloatObject>();
-        case ObjectType::Bool:
-            return assignObject.isObjectType<BoolObject>();
-        case ObjectType::String:
-            return assignObject.isObjectType<StringObject>();
-        case ObjectType::Array:
-            return assignObject.isObjectType<ArrayObject>();
-        default:
-            return false;
-    }
+    return assignObject.isType(_variableType);
 }
 
 
 std::string AddVariableNode::description() const
 {
     switch (_variableType)
     {
-        case ObjectType::Bool:
+        case AnyObject::Bool:
             return "Bool";
-        case ObjectType::Int:
+        case AnyObject::Int:
             return "Int";
-        case ObjectType::Float:
+        case AnyObject::Float:
             return "Float";
-        case ObjectType::String:
+        case AnyObject::String:
             return "String";
-        case ObjectType::Array:
+        case AnyObject::Array:
             return "Array";
         default:
             return "Unknown";
@@ -68,50 +57,23 @@ std::string AddVariableNode::description() const
 
 AddReferenceVariableNode::AddReferenceVariableNode(std::string referenceName_,
                                                    std::string boundName_,
-                                                   ObjectType boundType_)
+                                                   AnyObject::Type boundType_)
     : AddVariableNode(boundName_, boundType_),
       referenceName(referenceName_)
 {
 }
 
 
-BaseObject::Ptr AddReferenceVariableNode::evaluate(Scope &scope)
+AnyObject::Ptr AddReferenceVariableNode::evaluate(Scope &scope)
 {
     // 1. Lookup the object associated with the variable name defined in this
     // scope or a parent scope (no issue with lifetimes such as to be bound
     // object going out of scope before our reference.
-    BaseObject::Ptr boundObject = scope.getNamedObject(name());
-
-    // 2. Type checking. The type of the reference must match that of the bound
-    // object.
-    bool passesTypeChecking{false};
-
-    // TODO: - add type checking for classes and struct references.
-    switch (_variableType)
-    {
-        case ObjectType::Int:
-            passesTypeChecking = boundObject->isObjectType<IntObject>();
-            break;
-        case ObjectType::Float:
-            passesTypeChecking = boundObject->isObjectType<FloatObject>();
-            break;
-        case ObjectType::String:
-            passesTypeChecking = boundObject->isObjectType<StringObject>();
-            break;
-        case ObjectType::Bool:
-            passesTypeChecking = boundObject->isObjectType<StringObject>();
-            break;
-        case ObjectType::Array:
-            passesTypeChecking = boundObject->isObjectType<ArrayObject>();
-            break;
-        case ObjectType::Struct:
-        case ObjectType::Class:
-        default:
-            passesTypeChecking = true;
-            break; // No type checking currently!
-    }
+    AnyObject::Ptr boundObject = scope.getNamedObject(name());
 
-    if (!passesTypeChecking)
+    // TODO: - this will not work for classes/structs since they could point to different types.
+    // 2. Type checking. The type of the reference must match that of the bound object.
+    if (!passesAssignmentTypeCheck(*boundObject))
     {
         ThrowException("Cannot bind reference " + referenceName + " to variable " + name() + ". Types do not match!");
     }