Add base classes for generic codegen classes

Author: adazem009

src/engine/internal/codegen/CMakeLists.txt

@@ -4,7 +4,10 @@ target_sources(scratchcpp
     icodebuilderfactory.h
     codebuilderfactory.cpp
     codebuilderfactory.h
+    instructionbase.h
     instruction.h
+    instructionlistbase.cpp
+    instructionlistbase.h
     instructionlist.h
 )
 

src/engine/internal/codegen/instruction.h

@@ -2,109 +2,23 @@
 
 #pragma once
 
-#include <scratchcpp/compiler.h>
+#include "instructionbase.h"
 
 namespace libscratchcpp
 {
 
-class BlockPrototype;
-
 template<typename TInstruction, typename TRegister>
-struct Instruction
+struct Instruction : public InstructionBase
 {
-        enum class Type
-        {
-            FunctionCall,
-            Add,
-            Sub,
-            Mul,
-            Div,
-            Random,
-            RandomInt,
-            CmpEQ,
-            CmpGT,
-            CmpLT,
-            StrCmpEQCS, // case sensitive
-            StrCmpEQCI, // case insensitive
-            And,
-            Or,
-            Not,
-            Mod,
-            Round,
-            Abs,
-            Floor,
-            Ceil,
-            Sqrt,
-            Sin,
-            Cos,
-            Tan,
-            Asin,
-            Acos,
-            Atan,
-            Ln,
-            Log10,
-            Exp,
-            Exp10,
-            StringConcat,
-            StringChar,
-            StringLength,
-            Select,
-            CreateLocalVariable,
-            WriteLocalVariable,
-            ReadLocalVariable,
-            WriteVariable,
-            ReadVariable,
-            ClearList,
-            RemoveListItem,
-            AppendToList,
-            InsertToList,
-            ListReplace,
-            GetListContents,
-            GetListItem,
-            GetListSize,
-            GetListItemIndex,
-            ListContainsItem,
-            Yield,
-            BeginIf,
-            BeginElse,
-            EndIf,
-            BeginRepeatLoop,
-            LoopIndex,
-            BeginWhileLoop,
-            BeginRepeatUntilLoop,
-            BeginLoopCondition,
-            EndLoop,
-            Stop,
-            ThreadStop,
-            InvalidateTarget,
-            CallProcedure,
-            ProcedureArg,
-            Print
-        };
+        using Type = InstructionBase::Type;
+        using InstructionBase::InstructionBase; // inherit constructor
+
+        inline TInstruction *getPrevious() { return static_cast<TInstruction *>(previous); }
 
-        Instruction(Type type, bool loopCondition) :
-            type(type),
-            loopCondition(loopCondition)
-        {
-        }
+        inline TInstruction *getNext() { return static_cast<TInstruction *>(next); }
 
-        Type type;
-        std::string functionName;
         std::vector<std::pair<Compiler::StaticType, TRegister *>> args; // target type, register
         TRegister *functionReturnReg = nullptr;
-        bool functionTargetArg = false;                                  // whether to add target ptr to function parameters
-        bool functionCtxArg = false;                                     // whether to add execution context ptr to function parameters
-        Variable *targetVariable = nullptr;                              // for variables
-        List *targetList = nullptr;                                      // for lists
-        Compiler::StaticType targetType = Compiler::StaticType::Unknown; // variable or list type (before read/write operation)
-        BlockPrototype *procedurePrototype = nullptr;
-        size_t procedureArgIndex = 0;
-        bool loopCondition = false; // whether the instruction is part of a loop condition
-
-        // Linked list
-        TInstruction *previous = nullptr;
-        TInstruction *next = nullptr;
-        std::shared_ptr<TInstruction> _next; // ensure items are not deleted
 };
 
 } // namespace libscratchcpp

src/engine/internal/codegen/instructionbase.h

@@ -0,0 +1,107 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#pragma once
+
+#include <scratchcpp/compiler.h>
+
+namespace libscratchcpp
+{
+
+class BlockPrototype;
+
+struct InstructionBase
+{
+        enum class Type
+        {
+            FunctionCall,
+            Add,
+            Sub,
+            Mul,
+            Div,
+            Random,
+            RandomInt,
+            CmpEQ,
+            CmpGT,
+            CmpLT,
+            StrCmpEQCS, // case sensitive
+            StrCmpEQCI, // case insensitive
+            And,
+            Or,
+            Not,
+            Mod,
+            Round,
+            Abs,
+            Floor,
+            Ceil,
+            Sqrt,
+            Sin,
+            Cos,
+            Tan,
+            Asin,
+            Acos,
+            Atan,
+            Ln,
+            Log10,
+            Exp,
+            Exp10,
+            StringConcat,
+            StringChar,
+            StringLength,
+            Select,
+            CreateLocalVariable,
+            WriteLocalVariable,
+            ReadLocalVariable,
+            WriteVariable,
+            ReadVariable,
+            ClearList,
+            RemoveListItem,
+            AppendToList,
+            InsertToList,
+            ListReplace,
+            GetListContents,
+            GetListItem,
+            GetListSize,
+            GetListItemIndex,
+            ListContainsItem,
+            Yield,
+            BeginIf,
+            BeginElse,
+            EndIf,
+            BeginRepeatLoop,
+            LoopIndex,
+            BeginWhileLoop,
+            BeginRepeatUntilLoop,
+            BeginLoopCondition,
+            EndLoop,
+            Stop,
+            ThreadStop,
+            InvalidateTarget,
+            CallProcedure,
+            ProcedureArg,
+            Print
+        };
+
+        InstructionBase(Type type, bool loopCondition) :
+            type(type),
+            loopCondition(loopCondition)
+        {
+        }
+
+        Type type;
+        std::string functionName;
+        bool functionTargetArg = false;                                  // whether to add target ptr to function parameters
+        bool functionCtxArg = false;                                     // whether to add execution context ptr to function parameters
+        Variable *targetVariable = nullptr;                              // for variables
+        List *targetList = nullptr;                                      // for lists
+        Compiler::StaticType targetType = Compiler::StaticType::Unknown; // variable or list type (before read/write operation)
+        BlockPrototype *procedurePrototype = nullptr;
+        size_t procedureArgIndex = 0;
+        bool loopCondition = false; // whether the instruction is part of a loop condition
+
+        // Linked list
+        InstructionBase *previous = nullptr;
+        InstructionBase *next = nullptr;
+        std::shared_ptr<InstructionBase> _next; // ensure items are not deleted
+};
+
+} // namespace libscratchcpp

src/engine/internal/codegen/instructionlist.h

@@ -2,77 +2,27 @@
 
 #pragma once
 
-#include <memory>
-#include <functional>
-
-#include "test_export.h"
+#include "instructionlistbase.h"
 
 namespace libscratchcpp
 {
 
 template<typename TInstruction>
-class LIBSCRATCHCPP_TEST_EXPORT InstructionList
+class InstructionList : public InstructionListBase
 {
     public:
-        InstructionList() = default;
-        InstructionList(const InstructionList &) = delete;
-
-        inline TInstruction *first() const { return m_first.get(); }
-
-        inline TInstruction *last() const { return m_last.get(); }
-
-        inline bool empty() const { return !first(); }
-
-        inline bool containsInstruction(TInstruction *ins) const
-        {
-            TInstruction *ptr = m_first.get();
-
-            while (ptr) {
-                if (ptr == ins)
-                    return true;
-
-                ptr = ptr->next;
-            }
+        inline TInstruction *first() const { return static_cast<TInstruction *>(InstructionListBase::first()); }
 
-            return false;
-        }
-
-        inline bool containsInstruction(std::function<bool(const TInstruction *)> func) const
-        {
-            TInstruction *ptr = m_first.get();
-
-            while (ptr) {
-                if (func(ptr))
-                    return true;
+        inline TInstruction *last() const { return static_cast<TInstruction *>(InstructionListBase::last()); }
 
-                ptr = ptr->next;
-            }
+        bool containsInstruction(InstructionBase *ins) const { return InstructionListBase::containsInstruction(ins); }
 
-            return false;
-        }
-
-        inline void addInstruction(std::shared_ptr<TInstruction> ins)
+        bool containsInstruction(std::function<bool(const TInstruction *)> func) const
         {
-            if (!(m_first && m_last)) {
-                assert(!m_first && !m_last);
-
-                m_first = ins;
-                m_last = ins;
-
-                ins->previous = nullptr;
-                ins->next = nullptr;
-                ins->_next = nullptr;
-            } else {
-                m_last->next = ins.get();
-                m_last->_next = ins;
-                ins->previous = m_last.get();
-                m_last = ins;
-            }
+            return InstructionListBase::containsInstruction([&](const InstructionBase *i) { return func(static_cast<const TInstruction *>(i)); });
         }
 
-    private:
-        std::shared_ptr<TInstruction> m_first;
-        std::shared_ptr<TInstruction> m_last;
+        void addInstruction(std::shared_ptr<TInstruction> ins) { return InstructionListBase::addInstruction(std::move(ins)); }
 };
 
 } // namespace libscratchcpp

src/engine/internal/codegen/instructionlistbase.cpp

@@ -0,0 +1,50 @@
+#include "instructionlistbase.h"
+
+using namespace libscratchcpp;
+
+bool InstructionListBase::containsInstruction(InstructionBase *ins) const
+{
+    InstructionBase *ptr = m_first.get();
+
+    while (ptr) {
+        if (ptr == ins)
+            return true;
+
+        ptr = ptr->next;
+    }
+
+    return false;
+}
+
+bool InstructionListBase::containsInstruction(std::function<bool(const InstructionBase *)> func) const
+{
+    InstructionBase *ptr = m_first.get();
+
+    while (ptr) {
+        if (func(ptr))
+            return true;
+
+        ptr = ptr->next;
+    }
+
+    return false;
+}
+
+void InstructionListBase::addInstruction(std::shared_ptr<InstructionBase> ins)
+{
+    if (!(m_first && m_last)) {
+        assert(!m_first && !m_last);
+
+        m_first = ins;
+        m_last = ins;
+
+        ins->previous = nullptr;
+        ins->next = nullptr;
+        ins->_next = nullptr;
+    } else {
+        m_last->next = ins.get();
+        m_last->_next = ins;
+        ins->previous = m_last.get();
+        m_last = ins;
+    }
+}