Save variable in IR

Author: kornilova203

bindgen/CMakeLists.txt

@@ -50,6 +50,10 @@ add_executable(bindgen
   ir/LiteralDefine.h
   ir/VarDefine.cpp
   ir/VarDefine.h
+  ir/Variable.cpp
+  ir/Variable.h
+  ir/PossibleVarDefine.cpp
+  ir/PossibleVarDefine.h
 )
 
 set_target_properties(bindgen

bindgen/ir/IR.cpp

@@ -40,12 +40,11 @@ void IR::addLiteralDefine(std::string name, std::string literal,
 
 void IR::addPossibleVarDefine(const std::string &macroName,
                               const std::string &varName) {
-    possibleVarDefines.emplace_back(macroName, varName, "", false);
+    possibleVarDefines.emplace_back(macroName, varName);
 }
 
-void IR::addVarDefine(const std::string &macroName, const std::string &varName,
-                      const std::string &type, bool isConst) {
-    varDefines.emplace_back(macroName, varName, type, isConst);
+void IR::addVarDefine(std::string name, Variable *variable) {
+    varDefines.emplace_back(name, variable);
 }
 
 bool IR::libObjEmpty() const {
@@ -284,9 +283,22 @@ void IR::filterByName(std::vector<T> &declarations, const std::string &name) {
 
 std::string IR::getDefineForVar(const std::string &varName) const {
     for (const auto &varDefine : possibleVarDefines) {
-        if (varDefine.getVarName() == varName) {
+        if (varDefine.getVariableName() == varName) {
             return varDefine.getName();
         }
     }
     return "";
 }
+
+Variable *IR::addVariable(const std::string &name, const std::string &type,
+                          bool isConst) {
+    Variable *variable = new Variable(name, type, isConst);
+    variables.push_back(variable);
+    return variable;
+}
+
+IR::~IR() {
+    for (auto variable : variables) {
+        std::free(variable);
+    }
+}

bindgen/ir/IR.h

@@ -4,6 +4,7 @@
 #include "Enum.h"
 #include "Function.h"
 #include "LiteralDefine.h"
+#include "PossibleVarDefine.h"
 #include "Struct.h"
 #include "TypeDef.h"
 #include "VarDefine.h"
@@ -16,6 +17,8 @@ class IR {
     explicit IR(std::string libName, std::string linkName,
                 std::string objectName, std::string packageName);
 
+    ~IR();
+
     void addFunction(std::string name, std::vector<Parameter> parameters,
                      std::string, bool isVariadic);
 
@@ -36,8 +39,10 @@ class IR {
     void addPossibleVarDefine(const std::string &macroName,
                               const std::string &varName);
 
-    void addVarDefine(const std::string &macroName, const std::string &varName,
-                      const std::string &type, bool isConst);
+    void addVarDefine(std::string name, Variable *variable);
+
+    Variable *addVariable(const std::string &name, const std::string &type,
+                          bool isConst);
 
     /**
      * @return true if there are no functions, types,
@@ -134,8 +139,9 @@ class IR {
     std::vector<Union> unions;
     std::vector<Enum> enums;
     std::vector<LiteralDefine> literalDefines;
-    std::vector<VarDefine> possibleVarDefines;
+    std::vector<PossibleVarDefine> possibleVarDefines;
     std::vector<VarDefine> varDefines;
+    std::vector<Variable *> variables;
     bool generated = false; // generate type defs only once
     std::string packageName;
 };

bindgen/ir/PossibleVarDefine.cpp

@@ -0,0 +1,7 @@
+#include "PossibleVarDefine.h"
+
+PossibleVarDefine::PossibleVarDefine(const std::string &name,
+                                     const std::string &variableName)
+    : Define(name), variableName(variableName) {}
+
+std::string PossibleVarDefine::getVariableName() const { return variableName; }

bindgen/ir/PossibleVarDefine.h

@@ -0,0 +1,19 @@
+#ifndef SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H
+#define SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H
+
+#include "Define.h"
+
+/**
+ * Stores name of possible variable.
+ */
+class PossibleVarDefine : public Define {
+  public:
+    PossibleVarDefine(const std::string &name, const std::string &variableName);
+
+    std::string getVariableName() const;
+
+  private:
+    std::string variableName;
+};
+
+#endif // SCALA_NATIVE_BINDGEN_POSSIBLEVARDEFINE_H

bindgen/ir/VarDefine.cpp

@@ -1,23 +1,17 @@
 #include "VarDefine.h"
 
-VarDefine::VarDefine(std::string name, std::string varName, std::string type,
-                     bool isConst)
-    : Define(std::move(name)), varName(std::move(varName)),
-      type(std::move(type)), isConst(isConst) {}
-
-std::string VarDefine::getVarName() const { return varName; }
-
-std::string VarDefine::getType() const { return type; }
+VarDefine::VarDefine(std::string name, Variable *variable)
+    : Define(std::move(name)), variable(variable) {}
 
 llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
                               const VarDefine &varDefine) {
-    s << "  @name(\"" << varDefine.getVarName() << "\")\n";
-    if (varDefine.isConst) {
+    s << "  @name(\"" << varDefine.variable->getName() << "\")\n";
+    if (varDefine.variable->getIsConst()) {
         s << "  val ";
     } else {
         s << "  def ";
     }
-    s << varDefine.getName() << ": " << varDefine.getType()
+    s << varDefine.getName() << ": " << varDefine.variable->getType()
       << " = native.extern\n";
     return s;
 }

bindgen/ir/VarDefine.h

@@ -2,24 +2,21 @@
 #define SCALA_NATIVE_BINDGEN_VARDEFINE_H
 
 #include "Define.h"
+#include "Variable.h"
 #include <llvm/Support/raw_ostream.h>
 
+/**
+ * Stores a pointer to Variable instance from IR
+ */
 class VarDefine : public Define {
   public:
-    VarDefine(std::string name, std::string varName, std::string type,
-              bool isConst);
-
-    std::string getVarName() const;
-
-    std::string getType() const;
+    VarDefine(std::string name, Variable *variable);
 
     friend llvm::raw_ostream &operator<<(llvm::raw_ostream &s,
                                          const VarDefine &varDefine);
 
   private:
-    std::string varName;
-    std::string type;
-    bool isConst;
+    Variable *variable;
 };
 
 #endif // SCALA_NATIVE_BINDGEN_VARDEFINE_H

bindgen/ir/Variable.cpp

@@ -0,0 +1,7 @@
+#include "Variable.h"
+
+Variable::Variable(const std::string &name, const std::string &type,
+                   bool isConst)
+    : TypeAndName(name, type), isConst(isConst) {}
+
+bool Variable::getIsConst() { return isConst; }

bindgen/ir/Variable.h

@@ -0,0 +1,16 @@
+#ifndef SCALA_NATIVE_BINDGEN_VARIABLE_H
+#define SCALA_NATIVE_BINDGEN_VARIABLE_H
+
+#include "TypeAndName.h"
+
+class Variable : public TypeAndName {
+  public:
+    Variable(const std::string &name, const std::string &type, bool isConst);
+
+    bool getIsConst();
+
+  private:
+    bool isConst;
+};
+
+#endif // SCALA_NATIVE_BINDGEN_VARIABLE_H

bindgen/visitor/TreeVisitor.cpp

@@ -162,15 +162,16 @@ void TreeVisitor::handleStruct(clang::RecordDecl *record, std::string name) {
 
 bool TreeVisitor::VisitVarDecl(clang::VarDecl *varDecl) {
     if (!varDecl->isThisDeclarationADefinition()) {
+        std::string variableName = varDecl->getName().str();
+        std::string type =
+            handleReservedWords(typeTranslator.Translate(varDecl->getType()));
+        Variable *variable = ir.addVariable(
+            variableName, type, varDecl->getType().isConstQualified());
         /* check if there is a macro for the variable.
          * Macros were saved by DefineFinder */
-        std::string varName = varDecl->getName().str();
-        std::string macroName = ir.getDefineForVar(varName);
+        std::string macroName = ir.getDefineForVar(variableName);
         if (!macroName.empty()) {
-            std::string type = handleReservedWords(
-                typeTranslator.Translate(varDecl->getType()));
-            ir.addVarDefine(macroName, varName, type,
-                            varDecl->getType().isConstQualified());
+            ir.addVarDefine(macroName, variable);
         }
     }
     return true;