remove celltype

src/vm/includes/Cell.h

@@ -11,19 +11,12 @@
 #include <sstream>
 #include <string>
 #include <utility>
-enum class CellType {
-    NUMATOM,
-    STRATOM,
-    CONS
-};
 
 using CellValType = int64_t;
 
 struct Cell {
-    explicit Cell(CellType type) : _type(type) {}
     virtual ~Cell() = 0;
 
-    CellType _type;
     std::atomic<bool> _live = false;
 
     virtual void print(std::ostream &out) = 0;
@@ -31,7 +24,7 @@ struct Cell {
 
 struct NumAtomCell : public Cell {
     NumAtomCell() = delete;
-    explicit NumAtomCell(CellValType val) : Cell(CellType::NUMATOM), _val(val) {}
+    explicit NumAtomCell(CellValType val) : _val(val) {}
 
     CellValType _val;
 
@@ -42,7 +35,7 @@ struct NumAtomCell : public Cell {
 
 struct StrAtomCell : public Cell {
     StrAtomCell() = delete;
-    explicit StrAtomCell(std::string val) : Cell(CellType::STRATOM), _val(std::move(val)) {}
+    explicit StrAtomCell(std::string val) : _val(std::move(val)) {}
 
     std::string _val;
 
@@ -52,9 +45,8 @@ struct StrAtomCell : public Cell {
 };
 
 struct ConsCell : public Cell {
-    ConsCell() : Cell(CellType::CONS) {}
+    explicit ConsCell(Cell *car) : _car(car) {}
-    explicit ConsCell(Cell *car) : Cell(CellType::CONS), _car(car) {}
+    ConsCell(Cell *car, Cell *cdr) : _car(car), _cdr(cdr) {}
-    ConsCell(Cell *car, Cell *cdr) : Cell(CellType::CONS), _car(car), _cdr(cdr) {}
 
     std::atomic<Cell *> _car = nullptr;
     std::atomic<Cell *> _cdr = nullptr;
@@ -62,7 +54,7 @@ struct ConsCell : public Cell {
     void print(std::ostream &out) override {
         std::stringstream res;
         if (_car) {
-            if (_car.load()->_type == CellType::CONS) {
+            if (dynamic_cast<ConsCell *>(_car.load())) {
                 res << "(";
                 _car.load()->print(res);
                 res << ")";
@@ -71,7 +63,7 @@ struct ConsCell : public Cell {
             }
         }
         if (_cdr) {
-            if (_cdr.load()->_type == CellType::CONS) {
+            if (dynamic_cast<ConsCell *>(_cdr.load())) {
                 res << " ";
                 _cdr.load()->print(res);
             } else {

src/vm/includes/Handle.h

@@ -24,15 +24,11 @@ public:
     bool operator==(const Handle &rhs) const {
         if (_target == rhs._target) {
             return true;
-        } else if ((_target != nullptr && rhs._target != nullptr) && (_target->_type == rhs._target->_type)) {
+        } else if ((_target != nullptr && rhs._target != nullptr) && (typeid(_target) == typeid(rhs._target))) {
-            if (_target->_type == CellType::NUMATOM) {
+            if (auto p = dynamic_cast<NumAtomCell *>(_target)) {
                 return dynamic_cast<NumAtomCell &>(*_target)._val == dynamic_cast<NumAtomCell &>(*rhs._target)._val;
-            } else if (_target->_type == CellType::STRATOM) {
+            } else if (auto p = dynamic_cast<StrAtomCell *>(_target)) {
                 return dynamic_cast<StrAtomCell &>(*_target)._val == dynamic_cast<StrAtomCell &>(*rhs._target)._val;
-            } else if (_target->_type == CellType::CONS) {
-                // This is questionable
-                return dynamic_cast<ConsCell &>(*_target)._car == dynamic_cast<ConsCell &>(*rhs._target)._car &&
-                       dynamic_cast<ConsCell &>(*_target)._cdr == dynamic_cast<ConsCell &>(*rhs._target)._cdr;
             }
         }
         return false;
@@ -45,18 +41,23 @@ public:
     CellValType val() { return dynamic_cast<NumAtomCell &>(*_target)._val; }
     std::string_view strval() { return dynamic_cast<StrAtomCell &>(*_target)._val; }
 
-    CellType type() const {
+    bool num() const {
-        if (!_target) return CellType::CONS;
+        return dynamic_cast<NumAtomCell *>(_target) != nullptr;
-        return _target->_type;
+    }
+    bool str() const {
+        return dynamic_cast<StrAtomCell *>(_target) != nullptr;
     }
 
     bool atom() const {
-        return type() != CellType::CONS;
+        if (!_target) return false;
+        return dynamic_cast<ConsCell *>(_target) == nullptr;
     }
 
     bool null() {
         if (!_target) return true;
-        if (type() == CellType::CONS && car() == nullptr && cdr() == nullptr) return true;
+        if (auto p = dynamic_cast<ConsCell *>(_target)) {
+            return car() == nullptr && cdr() == nullptr;
+        }
         return false;
     }
 

src/vm/src/Compiler.cpp

@@ -34,10 +34,10 @@ Handle Compiler::compile(Handle src, Handle fake_env, Handle suffix) {
     if (expr.null()) {
         out.append(Handle("NIL"));
     } else if (expr.atom()) {
-        if (expr.type() == CellType::NUMATOM) {
+        if (expr.num()) {
             out.append(Handle("LDC"));
             out.append(expr);
-        } else if (expr.type() == CellType::STRATOM) {
+        } else if (expr.str()) {
             Handle idx = findIndex(expr, fake_env);
             if (idx == nullptr) {
                 out.append(Handle("LDC"));

src/vm/src/MemoryContext.cpp

@@ -87,13 +87,12 @@ void MemoryContext::gc_thread_entry() {
                 //                    std::cerr << out.str();
                 //                }
 
-                if (c->_type == CellType::CONS) {
+                if (auto cc = dynamic_cast<ConsCell *>(c)) {
-                    ConsCell &cc = dynamic_cast<ConsCell &>(*c);
                     //                                        {std::stringstream out; out  << "processing car " << cc._car << "\n"; std::cerr<<out.str();}
-                    toVisit.emplace(cc._car);
+                    toVisit.emplace(cc->_car);
                     //                    {std::stringstream out; out  << "real car " << toVisit.back() << "\n"; std::cerr<<out.str();}
                     //                    {std::stringstream out; out  << "processing cdr " << cc._cdr << "\n"; std::cerr<<out.str();}
-                    toVisit.emplace(cc._cdr);
+                    toVisit.emplace(cc->_cdr);
                     //                    {std::stringstream out; out  << "real cdr " << toVisit.back() << "\n"; std::cerr<<out.str();}
                 }
             }