Add InstructionList class and cleaning #5

Author: JonathSpirit

include/C_compilerData.hpp

@@ -63,7 +63,7 @@ struct CompilerData
 {
     codeg::StringDecomposer _decomposer;
 
-    std::list<codeg::Instruction*> _instructions;
+    codeg::InstructionList _instructions;
     codeg::ReservedList _reservedKeywords;
 
     codeg::PoolList _pools;

include/C_instruction.hpp

@@ -18,6 +18,8 @@
 #define C_INSTRUCTION_H_INCLUDED
 
 #include "C_stringDecomposer.hpp"
+#include <forward_list>
+#include <memory>
 
 namespace codeg
 {
@@ -66,21 +68,37 @@ extern const char* ReadableStringBinaryOpcodes[];
 
 struct CompilerData;
 
-/// --------- Instructions ---------
-
 class Instruction
 {
-protected:
-    Instruction();
-    virtual ~Instruction();
-
 public:
+    Instruction() = default;
+    virtual ~Instruction() = default;
+
     virtual std::string getName() const = 0;
 
     virtual void compile(const codeg::StringDecomposer& input, codeg::CompilerData& data) = 0;
     virtual void compileDefinition(const codeg::StringDecomposer& input, codeg::CompilerData& data);
 };
 
+class InstructionList
+{
+public:
+    using InstructionListType = std::forward_list<std::unique_ptr<codeg::Instruction> >;
+
+    InstructionList() = default;
+    ~InstructionList() = default;
+
+    void clear();
+
+    void push(codeg::Instruction* newInstruction);
+    codeg::Instruction* get(const std::string& name) const;
+
+private:
+    codeg::InstructionList::InstructionListType g_data;
+};
+
+/// --------- Instructions ---------
+
 class Instruction_set : public Instruction
 {
     /**

src/C_instruction.cpp

@@ -67,14 +67,34 @@ const char* ReadableStringBinaryOpcodes[]=
 
 ///Instruction
 
-Instruction::Instruction(){}
-Instruction::~Instruction(){}
-
 void Instruction::compileDefinition(const codeg::StringDecomposer& input, codeg::CompilerData& data)
 {
     data._functions.back().addLine(input._cleaned);
 }
 
+///InstructionList
+
+void InstructionList::clear()
+{
+    this->g_data.clear();
+}
+
+void InstructionList::push(codeg::Instruction* newInstruction)
+{
+    this->g_data.push_front( std::unique_ptr<codeg::Instruction>(newInstruction) );
+}
+codeg::Instruction* InstructionList::get(const std::string& name) const
+{
+    for (auto& valPtr : this->g_data)
+    {
+        if (valPtr.get()->getName() == name)
+        {
+            return valPtr.get();
+        }
+    }
+    return nullptr;
+}
+
 ///Instruction_set
 Instruction_set::Instruction_set(){}
 Instruction_set::~Instruction_set(){}

src/C_keyword.cpp

@@ -52,13 +52,10 @@ bool Keyword::process(const std::string& str, const codeg::KeywordTypes& wantedT
     }
 
     ///Instruction
-    for (auto&& value : data._instructions)
+    if ( data._instructions.get(str) != nullptr )
     {
-        if (value->getName() == str)
-        {
-            this->_type = codeg::KeywordTypes::KEYWORD_INSTRUCTION;
-            return this->_type == wantedType;
-        }
+        this->_type = codeg::KeywordTypes::KEYWORD_INSTRUCTION;
+        return this->_type == wantedType;
     }
 
     ///Replacing with an existing macro

src/main.cpp

@@ -211,36 +211,35 @@ int main(int argc, char **argv)
     data._reservedKeywords.push("end_def");
 
     ///Instructions
-    data._instructions.push_back(new codeg::Instruction_set());
-    data._instructions.push_back(new codeg::Instruction_unset());
-    data._instructions.push_back(new codeg::Instruction_var());
-    data._instructions.push_back(new codeg::Instruction_label());
-    data._instructions.push_back(new codeg::Instruction_jump());
-    data._instructions.push_back(new codeg::Instruction_restart());
-    data._instructions.push_back(new codeg::Instruction_affect());
-    data._instructions.push_back(new codeg::Instruction_get());
-    data._instructions.push_back(new codeg::Instruction_write());
-    data._instructions.push_back(new codeg::Instruction_choose());
-    data._instructions.push_back(new codeg::Instruction_do());
-    data._instructions.push_back(new codeg::Instruction_tick());
-    data._instructions.push_back(new codeg::Instruction_brut());
-    data._instructions.push_back(new codeg::Instruction_function());
-    data._instructions.push_back(new codeg::Instruction_if());
-    data._instructions.push_back(new codeg::Instruction_else());
-    data._instructions.push_back(new codeg::Instruction_ifnot());
-    data._instructions.push_back(new codeg::Instruction_end());
-    data._instructions.push_back(new codeg::Instruction_call());
-    data._instructions.push_back(new codeg::Instruction_clock());
-    data._instructions.push_back(new codeg::Instruction_pool());
-    data._instructions.push_back(new codeg::Instruction_import());
-    data._instructions.push_back(new codeg::Instruction_definition());
-    data._instructions.push_back(new codeg::Instruction_enddef());
+    data._instructions.push(new codeg::Instruction_set());
+    data._instructions.push(new codeg::Instruction_unset());
+    data._instructions.push(new codeg::Instruction_var());
+    data._instructions.push(new codeg::Instruction_label());
+    data._instructions.push(new codeg::Instruction_jump());
+    data._instructions.push(new codeg::Instruction_restart());
+    data._instructions.push(new codeg::Instruction_affect());
+    data._instructions.push(new codeg::Instruction_get());
+    data._instructions.push(new codeg::Instruction_write());
+    data._instructions.push(new codeg::Instruction_choose());
+    data._instructions.push(new codeg::Instruction_do());
+    data._instructions.push(new codeg::Instruction_tick());
+    data._instructions.push(new codeg::Instruction_brut());
+    data._instructions.push(new codeg::Instruction_function());
+    data._instructions.push(new codeg::Instruction_if());
+    data._instructions.push(new codeg::Instruction_else());
+    data._instructions.push(new codeg::Instruction_ifnot());
+    data._instructions.push(new codeg::Instruction_end());
+    data._instructions.push(new codeg::Instruction_call());
+    data._instructions.push(new codeg::Instruction_clock());
+    data._instructions.push(new codeg::Instruction_pool());
+    data._instructions.push(new codeg::Instruction_import());
+    data._instructions.push(new codeg::Instruction_definition());
+    data._instructions.push(new codeg::Instruction_enddef());
 
     ///Code
     data._code.resize(65536);
 
     std::string readedLine;
-    bool validInstruction = false;
 
     try
     {
@@ -253,28 +252,21 @@ int main(int argc, char **argv)
 
             if (data._decomposer._keywords.size() > 0)
             {
-                validInstruction = false;
-
-                for (auto&& instruction : data._instructions)
-                {
-                    if (instruction->getName() == data._decomposer._keywords[0])
-                    {
-                        validInstruction = true;
-
-                        if ( data._writeLinesIntoDefinition )
-                        {//Compile in a definition (detect the end_def keyword)
-                            instruction->compileDefinition(data._decomposer, data);
-                        }
-                        else
-                        {//Compile
-                            instruction->compile(data._decomposer, data);
-                        }
-                        break;
+                codeg::Instruction* instruction = data._instructions.get( data._decomposer._keywords[0] );
+
+                if (instruction != nullptr)
+                {//Instruction founded
+                    if ( data._writeLinesIntoDefinition )
+                    {//Compile in a definition (detect the end_def keyword)
+                        instruction->compileDefinition(data._decomposer, data);
+                    }
+                    else
+                    {//Compile
+                        instruction->compile(data._decomposer, data);
                     }
                 }
-
-                if (!validInstruction)
-                {
+                else
+                {//Bad instruction
                     throw codeg::FatalError("unknown instruction \""+data._decomposer._keywords[0]+"\"");
                 }
             }