Rename Ref -> Op

src/CMakeLists.txt

@@ -1,8 +1,8 @@
 add_library(sirit
     ../include/sirit/sirit.h
     sirit.cpp
-	ref.cpp
-	ref.h
+	op.cpp
+	op.h
     stream.cpp
     stream.h
     operand.cpp

src/op.cpp

@@ -7,35 +7,35 @@
 #include <cassert>
 #include "common_types.h"
 #include "operand.h"
-#include "ref.h"
+#include "op.h"
 
 namespace Sirit {
 
-Ref::Ref(spv::Op opcode_, u32 id_, const Ref* result_type_) 
+Op::Op(spv::Op opcode_, u32 id_, const Op* result_type_) 
     : opcode(opcode_), id(id_), result_type(result_type_) {
     operand_type = OperandType::Ref;
 }
 
-Ref::~Ref() = default;
+Op::~Op() = default;
 
-void Ref::Fetch(Stream& stream) const {
+void Op::Fetch(Stream& stream) const {
     assert(id != UINT32_MAX);
     stream.Write(id);
 }
 
-u16 Ref::GetWordCount() const {
+u16 Op::GetWordCount() const {
     return 1;
 }
 
-bool Ref::operator==(const Operand& other) const {
+bool Op::operator==(const Operand& other) const {
     if (operand_type != other.GetType()) {
         return false;
     }
-    const Ref& ref = dynamic_cast<const Ref&>(other);
-    if (ref.opcode == opcode && result_type == ref.result_type &&
-        operands.size() == ref.operands.size()) {
+    const Op& op = dynamic_cast<const Op&>(other);
+    if (op.opcode == opcode && result_type == op.result_type &&
+        operands.size() == op.operands.size()) {
         for (std::size_t i{}; i < operands.size(); i++) {
-            if (*operands[i] != *ref.operands[i]) {
+            if (*operands[i] != *op.operands[i]) {
                 return false;
             }
         }
@@ -44,7 +44,7 @@ bool Ref::operator==(const Operand& other) const {
     return false;
 }
 
-void Ref::Write(Stream& stream) const {
+void Op::Write(Stream& stream) const {
     stream.Write(static_cast<u16>(opcode));
     stream.Write(WordCount());
 
@@ -59,30 +59,30 @@ void Ref::Write(Stream& stream) const {
     }
 }
 
-void Ref::Add(Operand* operand) {
+void Op::Add(Operand* operand) {
     Add(static_cast<const Operand*>(operand));
     operand_store.push_back(std::unique_ptr<Operand>(operand));
 }
 
-void Ref::Add(const Operand* operand) {
+void Op::Add(const Operand* operand) {
     operands.push_back(operand);
 }
 
-void Ref::Add(u32 integer) {
+void Op::Add(u32 integer) {
     Add(new LiteralInteger(integer));
 }
 
-void Ref::Add(const std::string& string) {
+void Op::Add(const std::string& string) {
     Add(new LiteralString(string));
 }
 
-void Ref::Add(const std::vector<const Ref*>& ids) {
-    for (const Ref* ref : ids) {
-        Add(ref);
+void Op::Add(const std::vector<const Op*>& ids) {
+    for (const Op* op : ids) {
+        Add(op);
     }
 }
 
-u16 Ref::WordCount() const {
+u16 Op::WordCount() const {
     u16 count{1};
     if (result_type) {
         count++;

src/op.h

@@ -13,10 +13,10 @@
 
 namespace Sirit {
 
-class Ref : public Operand {
+class Op : public Operand {
 public:
-    explicit Ref(spv::Op opcode, u32 id = UINT32_MAX, const Ref* result_type = nullptr);
-    ~Ref();
+    explicit Op(spv::Op opcode, u32 id = UINT32_MAX, const Op* result_type = nullptr);
+    ~Op();
 
     virtual void Fetch(Stream& stream) const;
     virtual u16 GetWordCount() const;
@@ -33,14 +33,14 @@ public:
 
     void Add(const std::string& string);
 
-    void Add(const std::vector<const Ref*>& ids);
+    void Add(const std::vector<const Op*>& ids);
 
 private:
     u16 WordCount() const;
 
     spv::Op opcode;
 
-    const Ref* result_type;
+    const Op* result_type;
 
     u32 id;
 

src/sirit.cpp

@@ -8,16 +8,16 @@
 #include <cassert>
 #include "sirit/sirit.h"
 #include "common_types.h"
-#include "ref.h"
+#include "op.h"
 #include "stream.h"
 
 namespace Sirit {
 
 template<typename T>
-static void WriteEnum(Stream& stream, spv::Op op, T value) {
-    Ref ref{op};
-    ref.Add(static_cast<u32>(value));
-    ref.Write(stream);
+static void WriteEnum(Stream& stream, spv::Op opcode, T value) {
+    Op op{opcode};
+    op.Add(static_cast<u32>(value));
+    op.Write(stream);
 }
 
 Module::Module() {}
@@ -42,7 +42,7 @@ std::vector<u8> Module::Assembly() const {
 
     // TODO write ext inst imports
 
-    Ref memory_model_ref{spv::Op::OpMemoryModel};
+    Op memory_model_ref{spv::Op::OpMemoryModel};
     memory_model_ref.Add(static_cast<u32>(addressing_model));
     memory_model_ref.Add(static_cast<u32>(memory_model));
     memory_model_ref.Write(stream);
@@ -79,74 +79,75 @@ void Module::SetMemoryModel(spv::AddressingModel addressing_model, spv::MemoryMo
     this->memory_model = memory_model;
 }
 
-void Module::AddEntryPoint(spv::ExecutionModel execution_model, const Ref* entry_point,
-                           const std::string& name, const std::vector<const Ref*>& interfaces) {
-    Ref* op{new Ref(spv::Op::OpEntryPoint)};
+void Module::AddEntryPoint(spv::ExecutionModel execution_model, const Op* entry_point,
+                           const std::string& name, const std::vector<const Op*>& interfaces) {
+    Op* op{new Op(spv::Op::OpEntryPoint)};
     op->Add(static_cast<u32>(execution_model));
     op->Add(entry_point);
     op->Add(name);
     op->Add(interfaces);
-    entry_points.push_back(std::unique_ptr<Ref>(op));
+    entry_points.push_back(std::unique_ptr<Op>(op));
 }
 
-const Ref* Module::TypeVoid() {
-    return AddDeclaration(new Ref(spv::Op::OpTypeVoid, bound));
+const Op* Module::TypeVoid() {
+    return AddDeclaration(new Op(spv::Op::OpTypeVoid, bound));
 }
 
-const Ref* Module::TypeFunction(const Ref* return_type, const std::vector<const Ref*>& arguments) {
-    Ref* type_func{new Ref(spv::Op::OpTypeFunction, bound)};
+const Op* Module::TypeFunction(const Op* return_type, const std::vector<const Op*>& arguments) {
+    Op* type_func{new Op(spv::Op::OpTypeFunction, bound)};
     type_func->Add(return_type);
-    for (const Ref* arg : arguments) {
+    for (const Op* arg : arguments) {
         type_func->Add(arg);
     }
     return AddDeclaration(type_func);
 }
 
-void Module::Add(const Ref* ref) {
-    assert(ref);
-    code.push_back(ref);
+const Op* Module::Emit(const Op* op) {
+    assert(op);
+    code.push_back(op);
+    return op;
 }
 
-const Ref* Module::EmitFunction(const Ref* result_type, spv::FunctionControlMask function_control,
-                                const Ref* function_type) {
-    Ref* op{new Ref{spv::Op::OpFunction, bound++, result_type}};
+const Op* Module::Function(const Op* result_type, spv::FunctionControlMask function_control,
+                            const Op* function_type) {
+    Op* op{new Op{spv::Op::OpFunction, bound++, result_type}};
     op->Add(static_cast<u32>(function_control));
     op->Add(function_type);
     return AddCode(op);
 }
 
-const Ref* Module::EmitLabel() {
+const Op* Module::Label() {
     return AddCode(spv::Op::OpLabel, bound++);
 }
 
-const Ref* Module::EmitReturn() {
+const Op* Module::Return() {
     return AddCode(spv::Op::OpReturn);
 }
 
-const Ref* Module::EmitFunctionEnd() {
+const Op* Module::FunctionEnd() {
     return AddCode(spv::Op::OpFunctionEnd);
 }
 
-const Ref* Module::AddCode(Ref* ref) {
-    code_store.push_back(std::unique_ptr<Ref>(ref));
-    return ref;
+const Op* Module::AddCode(Op* op) {
+    code_store.push_back(std::unique_ptr<Op>(op));
+    return op;
 }
 
-const Ref* Module::AddCode(spv::Op opcode, u32 id) {
-    return AddCode(new Ref{opcode, id});
+const Op* Module::AddCode(spv::Op opcode, u32 id) {
+    return AddCode(new Op{opcode, id});
 }
 
-const Ref* Module::AddDeclaration(Ref* ref) {
+const Op* Module::AddDeclaration(Op* op) {
     const auto& found{std::find_if(declarations.begin(), declarations.end(), [=](const auto& other) {
-        return *other == *ref;
+        return *other == *op;
     })};
     if (found != declarations.end()) {
-        delete ref;
+        delete op;
         return found->get();
     } else {
-        declarations.push_back(std::unique_ptr<Ref>(ref));
+        declarations.push_back(std::unique_ptr<Op>(op));
         bound++;
-        return ref;
+        return op;
     }
 }