Added files

Author: aelfimow

Instruction.cpp

@@ -0,0 +1,29 @@
+#include <string>
+#include "Instruction.h"
+
+Instruction::Instruction(const std::string &mnem) :
+    m_str { "" }
+{
+    m_str = mnem;
+}
+
+Instruction::Instruction(const std::string &mnem, const std::string &op) :
+    m_str { "" }
+{
+    m_str = mnem + " " + op;
+}
+
+Instruction::Instruction(const std::string &mnem, const std::string &op1, const std::string &op2) :
+    m_str { "" }
+{
+    m_str = mnem + " " + op2 + ", " + op1;
+}
+
+std::string Instruction::to_str() const
+{
+    return m_str;
+}
+
+Instruction::~Instruction()
+{
+}

Instruction.h

@@ -0,0 +1,27 @@
+#ifdef INSTRUCTION_H
+#error Already included
+#else
+#define INSTRUCTION_H
+
+class Instruction
+{
+    public:
+        explicit Instruction(const std::string &mnem);
+        explicit Instruction(const std::string &mnem, const std::string &op);
+        explicit Instruction(const std::string &mnem, const std::string &op1, const std::string &op2);
+
+        Instruction() = delete;
+        Instruction(const Instruction &instance) = delete;
+        Instruction(const Instruction &&instance) = delete;
+        Instruction &operator=(const Instruction &instance) = delete;
+        Instruction &operator=(const Instruction &&instance) = delete;
+
+        std::string to_str() const;
+
+        ~Instruction();
+
+    private:
+        std::string m_str;
+};
+
+#endif

Instruction_AAA.cpp

@@ -0,0 +1,19 @@
+#include <string>
+#include "Instruction.h"
+#include "asmstream.h"
+#include "Instruction_AAA.h"
+
+Instruction_AAA::Instruction_AAA(asmstream &s) :
+    m_asmout(s)
+{
+}
+
+void Instruction_AAA::operator()()
+{
+    Instruction instr { "aaa" };
+    m_asmout << instr;
+}
+
+Instruction_AAA::~Instruction_AAA()
+{
+}

Instruction_AAA.h

@@ -0,0 +1,25 @@
+#ifdef INSTRUCTION_AAA_H
+#error Already included
+#else
+#define INSTRUCTION_AAA_H
+
+class Instruction_AAA
+{
+    public:
+        Instruction_AAA(asmstream &s);
+
+        Instruction_AAA() = delete;
+        Instruction_AAA(const Instruction_AAA &instance) = delete;
+        Instruction_AAA(const Instruction_AAA &&instance) = delete;
+        Instruction_AAA &operator=(const Instruction_AAA &instance) = delete;
+        Instruction_AAA &operator=(const Instruction_AAA &&instance) = delete;
+
+        void operator()();
+
+        ~Instruction_AAA();
+
+    private:
+        asmstream &m_asmout;
+};
+
+#endif

Instruction_AAD.cpp

@@ -0,0 +1,26 @@
+#include <string>
+#include "imm8.h"
+#include "Instruction.h"
+#include "asmstream.h"
+#include "Instruction_AAD.h"
+
+Instruction_AAD::Instruction_AAD(asmstream &s) :
+    m_asmout(s)
+{
+}
+
+void Instruction_AAD::operator()()
+{
+    Instruction instr { "aad" };
+    m_asmout << instr;
+}
+
+void Instruction_AAD::operator()(const imm8 &op1)
+{
+    Instruction instr { "aad", op1.to_str() };
+    m_asmout << instr;
+}
+
+Instruction_AAD::~Instruction_AAD()
+{
+}

Instruction_AAD.h

@@ -0,0 +1,26 @@
+#ifdef INSTRUCTION_AAD_H
+#error Already included
+#else
+#define INSTRUCTION_AAD_H
+
+class Instruction_AAD
+{
+    public:
+        Instruction_AAD(asmstream &s);
+
+        Instruction_AAD() = delete;
+        Instruction_AAD(const Instruction_AAD &instance) = delete;
+        Instruction_AAD(const Instruction_AAD &&instance) = delete;
+        Instruction_AAD &operator=(const Instruction_AAD &instance) = delete;
+        Instruction_AAD &operator=(const Instruction_AAD &&instance) = delete;
+
+        void operator()();
+        void operator()(const imm8 &op1);
+
+        ~Instruction_AAD();
+
+    private:
+        asmstream &m_asmout;
+};
+
+#endif

Instruction_AAM.cpp

@@ -0,0 +1,26 @@
+#include <string>
+#include "imm8.h"
+#include "Instruction.h"
+#include "asmstream.h"
+#include "Instruction_AAM.h"
+
+Instruction_AAM::Instruction_AAM(asmstream &s) :
+    m_asmout(s)
+{
+}
+
+void Instruction_AAM::operator()()
+{
+    Instruction instr { "aam" };
+    m_asmout << instr;
+}
+
+void Instruction_AAM::operator()(const imm8 &op1)
+{
+    Instruction instr { "aam", op1.to_str() };
+    m_asmout << instr;
+}
+
+Instruction_AAM::~Instruction_AAM()
+{
+}

Instruction_AAM.h

@@ -0,0 +1,26 @@
+#ifdef INSTRUCTION_AAM_H
+#error Already included
+#else
+#define INSTRUCTION_AAM_H
+
+class Instruction_AAM
+{
+    public:
+        Instruction_AAM(asmstream &s);
+
+        Instruction_AAM() = delete;
+        Instruction_AAM(const Instruction_AAM &instance) = delete;
+        Instruction_AAM(const Instruction_AAM &&instance) = delete;
+        Instruction_AAM &operator=(const Instruction_AAM &instance) = delete;
+        Instruction_AAM &operator=(const Instruction_AAM &&instance) = delete;
+
+        void operator()();
+        void operator()(const imm8 &op1);
+
+        ~Instruction_AAM();
+
+    private:
+        asmstream &m_asmout;
+};
+
+#endif

Instruction_AAS.cpp

@@ -0,0 +1,19 @@
+#include <string>
+#include "Instruction.h"
+#include "asmstream.h"
+#include "Instruction_AAS.h"
+
+Instruction_AAS::Instruction_AAS(asmstream &s) :
+    m_asmout(s)
+{
+}
+
+void Instruction_AAS::operator()()
+{
+    Instruction instr { "aas" };
+    m_asmout << instr;
+}
+
+Instruction_AAS::~Instruction_AAS()
+{
+}

Instruction_AAS.h

@@ -0,0 +1,25 @@
+#ifdef INSTRUCTION_AAS_H
+#error Already included
+#else
+#define INSTRUCTION_AAS_H
+
+class Instruction_AAS
+{
+    public:
+        Instruction_AAS(asmstream &s);
+
+        Instruction_AAS() = delete;
+        Instruction_AAS(const Instruction_AAS &instance) = delete;
+        Instruction_AAS(const Instruction_AAS &&instance) = delete;
+        Instruction_AAS &operator=(const Instruction_AAS &instance) = delete;
+        Instruction_AAS &operator=(const Instruction_AAS &&instance) = delete;
+
+        void operator()();
+
+        ~Instruction_AAS();
+
+    private:
+        asmstream &m_asmout;
+};
+
+#endif