Merge pull request #67 from leonardt/ifdef-decl

leonardt · web-flow · commit 72b212d65e14 · 2021-08-31T10:56:18.000-07:00
Add support for Declaration inside IfMacro nodes
diff --git a/include/verilogAST.hpp b/include/verilogAST.hpp
@@ -645,19 +645,46 @@ class ModuleInstantiation : public StructuralStatement {
   ~ModuleInstantiation(){};
 };
 
+class Declaration : public Node {
+ public:
+  std::string decl;
+  std::variant<std::unique_ptr<Identifier>, std::unique_ptr<Index>,
+               std::unique_ptr<Slice>, std::unique_ptr<Vector>>
+      value;
+
+  Declaration(std::variant<std::unique_ptr<Identifier>, std::unique_ptr<Index>,
+                           std::unique_ptr<Slice>, std::unique_ptr<Vector>>
+                  value,
+              std::string decl)
+      : decl(decl), value(std::move(value)){};
+
+  std::string toString();
+  virtual ~Declaration() = default;
+};
+
 class IfMacro : public StructuralStatement {
   virtual std::string getMacroString() = 0;
 
  public:
   std::string condition_str;
-  std::vector<std::unique_ptr<StructuralStatement>> true_body;
-  std::vector<std::unique_ptr<StructuralStatement>> else_body;
+  std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                           std::unique_ptr<Declaration>>>
+      true_body;
+  std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                           std::unique_ptr<Declaration>>>
+      else_body;
   IfMacro(std::string condition_str,
-          std::vector<std::unique_ptr<StructuralStatement>> true_body)
+          std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                   std::unique_ptr<Declaration>>>
+              true_body)
       : condition_str(condition_str), true_body(std::move(true_body)){};
   IfMacro(std::string condition_str,
-          std::vector<std::unique_ptr<StructuralStatement>> true_body,
-          std::vector<std::unique_ptr<StructuralStatement>> else_body)
+          std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                   std::unique_ptr<Declaration>>>
+              true_body,
+          std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                   std::unique_ptr<Declaration>>>
+              else_body)
       : condition_str(condition_str),
         true_body(std::move(true_body)),
         else_body(std::move(else_body)){};
@@ -670,12 +697,18 @@ class IfDef : public IfMacro {
 
  public:
   IfDef(std::string condition_str,
-        std::vector<std::unique_ptr<StructuralStatement>> body)
+        std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                 std::unique_ptr<Declaration>>>
+            body)
       : IfMacro(condition_str, std::move(body)){};
   IfDef(std::string condition_str,
-        std::vector<std::unique_ptr<StructuralStatement>> true_body,
-        std::vector<std::unique_ptr<StructuralStatement>> else_body)
-     : IfMacro(condition_str, std::move(true_body), std::move(else_body)){};
+        std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                 std::unique_ptr<Declaration>>>
+            true_body,
+        std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                 std::unique_ptr<Declaration>>>
+            else_body)
+      : IfMacro(condition_str, std::move(true_body), std::move(else_body)){};
   ~IfDef(){};
 };
 
@@ -684,32 +717,21 @@ class IfNDef : public IfMacro {
 
  public:
   IfNDef(std::string condition_str,
-         std::vector<std::unique_ptr<StructuralStatement>> body)
+         std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                  std::unique_ptr<Declaration>>>
+             body)
       : IfMacro(condition_str, std::move(body)){};
   IfNDef(std::string condition_str,
-         std::vector<std::unique_ptr<StructuralStatement>> true_body,
-         std::vector<std::unique_ptr<StructuralStatement>> else_body)
+         std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                  std::unique_ptr<Declaration>>>
+             true_body,
+         std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                                  std::unique_ptr<Declaration>>>
+             else_body)
       : IfMacro(condition_str, std::move(true_body), std::move(else_body)){};
   ~IfNDef(){};
 };
 
-class Declaration : public Node {
- public:
-  std::string decl;
-  std::variant<std::unique_ptr<Identifier>, std::unique_ptr<Index>,
-               std::unique_ptr<Slice>, std::unique_ptr<Vector>>
-      value;
-
-  Declaration(std::variant<std::unique_ptr<Identifier>, std::unique_ptr<Index>,
-                           std::unique_ptr<Slice>, std::unique_ptr<Vector>>
-                  value,
-              std::string decl)
-      : decl(decl), value(std::move(value)){};
-
-  std::string toString();
-  virtual ~Declaration() = default;
-};
-
 class Wire : public Declaration {
  public:
   Wire(std::variant<std::unique_ptr<Identifier>, std::unique_ptr<Index>,
diff --git a/src/transformer.cpp b/src/transformer.cpp
@@ -244,12 +244,16 @@ std::unique_ptr<InlineVerilog> Transformer::visit(
 }
 
 std::unique_ptr<IfMacro> Transformer::visit(std::unique_ptr<IfMacro> node) {
-  std::vector<std::unique_ptr<StructuralStatement>> new_true_body;
+  std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                           std::unique_ptr<Declaration>>>
+      new_true_body;
   for (auto&& item : node->true_body) {
     new_true_body.push_back(this->visit(std::move(item)));
   }
   node->true_body = std::move(new_true_body);
-  std::vector<std::unique_ptr<StructuralStatement>> new_else_body;
+  std::vector<std::variant<std::unique_ptr<StructuralStatement>,
+                           std::unique_ptr<Declaration>>>
+      new_else_body;
   for (auto&& item : node->else_body) {
     new_else_body.push_back(this->visit(std::move(item)));
   }
diff --git a/src/verilogAST.cpp b/src/verilogAST.cpp
@@ -413,12 +413,12 @@ std::string IfMacro::toString() {
   std::string s = this->getMacroString();
   s += this->condition_str + "\n";
   for (auto &statement : this->true_body) {
-    s += statement->toString() + "\n";
+    s += variant_to_string(statement) + "\n";
   }
   if (this->else_body.size() > 0) {
     s += "`else\n";
     for (auto &statement : this->else_body) {
-      s += statement->toString() + "\n";
+      s += variant_to_string(statement) + "\n";
     }
   }
   return s + "`endif";
diff --git a/tests/assign_inliner.cpp b/tests/assign_inliner.cpp
@@ -661,10 +661,14 @@ TEST(InlineAssignTests, TestInstConn) {
           "inner_module", std::move(parameters), "inner_module_inst",
           std::move(connections));
 
-  std::vector<std::unique_ptr<vAST::StructuralStatement>> if_def_true_body;
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
+      if_def_true_body;
   if_def_true_body.push_back(std::move(module_inst));
 
-  std::vector<std::unique_ptr<vAST::StructuralStatement>> if_def_false_body;
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
+      if_def_false_body;
   if_def_false_body.push_back(std::make_unique<vAST::ContinuousAssign>(
       vAST::make_id("y"), vAST::make_num("0")));
 
@@ -766,7 +770,9 @@ TEST(InlineAssignTests, TestNoInlineIndex) {
   body.push_back(std::make_unique<vAST::ContinuousAssign>(vAST::make_id("y"),
                                                           vAST::make_id("i1")));
 
-  std::vector<std::unique_ptr<vAST::StructuralStatement>> if_n_def_body;
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
+      if_n_def_body;
   if_n_def_body.push_back(std::make_unique<vAST::ContinuousAssign>(
       vAST::make_id("o1"),
       std::make_unique<vAST::Index>(vAST::make_id("y"), vAST::make_num("0"))));
diff --git a/tests/basic.cpp b/tests/basic.cpp
@@ -757,11 +757,12 @@ TEST(BasicTests, TestIfDef) {
                                                 std::move(parameters),
                                                 instance_name,
                                                 make_simple_connections());
-  std::vector<std::unique_ptr<vAST::StructuralStatement>>
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
       body;
   body.push_back(std::move(module_inst));
   vAST::IfDef if_def("ASSERT_ON", std::move(body));
-  EXPECT_EQ(if_def.toString(), 
+  EXPECT_EQ(if_def.toString(),
             "`ifdef ASSERT_ON\n"
             "test_module #(\n"
             "    .param0(0),\n"
@@ -786,11 +787,12 @@ TEST(BasicTests, TestIfDefInvert) {
                                                 std::move(parameters),
                                                 instance_name,
                                                 make_simple_connections());
-  std::vector<std::unique_ptr<vAST::StructuralStatement>>
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
       body;
   body.push_back(std::move(module_inst));
   vAST::IfNDef if_def("ASSERT_ON", std::move(body));
-  EXPECT_EQ(if_def.toString(), 
+  EXPECT_EQ(if_def.toString(),
             "`ifndef ASSERT_ON\n"
             "test_module #(\n"
             "    .param0(0),\n"
@@ -811,7 +813,8 @@ TEST(BasicTests, TestIfDefElse) {
                                                 make_simple_params(),
                                                 "test_module_inst0",
                                                 make_simple_connections());
-  std::vector<std::unique_ptr<vAST::StructuralStatement>>
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
       true_body;
   true_body.push_back(std::move(module_inst0));
 
@@ -820,11 +823,12 @@ TEST(BasicTests, TestIfDefElse) {
                                                 make_simple_params(),
                                                 "test_module_inst1",
                                                 make_simple_connections());
-  std::vector<std::unique_ptr<vAST::StructuralStatement>>
+  std::vector<std::variant<std::unique_ptr<vAST::StructuralStatement>,
+                           std::unique_ptr<vAST::Declaration>>>
       else_body;
   else_body.push_back(std::move(module_inst1));
   vAST::IfNDef if_def("ASSERT_ON", std::move(true_body), std::move(else_body));
-  EXPECT_EQ(if_def.toString(), 
+  EXPECT_EQ(if_def.toString(),
             "`ifndef ASSERT_ON\n"
             "test_module #(\n"
             "    .param0(0),\n"

Original file line number	Diff line number	Diff line change
`@@ -244,12 +244,16 @@ std::unique_ptr<InlineVerilog> Transformer::visit(`
`244`	`244`	`}`
`245`	`245`
`246`	`246`	`std::unique_ptr<IfMacro> Transformer::visit(std::unique_ptr<IfMacro> node) {`
`247`		`- std::vector<std::unique_ptr<StructuralStatement>> new_true_body;`
	`247`	`+ std::vector<std::variant<std::unique_ptr<StructuralStatement>,`
	`248`	`+ std::unique_ptr<Declaration>>>`
	`249`	`+ new_true_body;`
`248`	`250`	`for (auto&& item : node->true_body) {`
`249`	`251`	`new_true_body.push_back(this->visit(std::move(item)));`
`250`	`252`	`}`
`251`	`253`	`node->true_body = std::move(new_true_body);`
`252`		`- std::vector<std::unique_ptr<StructuralStatement>> new_else_body;`
	`254`	`+ std::vector<std::variant<std::unique_ptr<StructuralStatement>,`
	`255`	`+ std::unique_ptr<Declaration>>>`
	`256`	`+ new_else_body;`
`253`	`257`	`for (auto&& item : node->else_body) {`
`254`	`258`	`new_else_body.push_back(this->visit(std::move(item)));`
`255`	`259`	`}`
Original file line number	Diff line number	Diff line change
`@@ -413,12 +413,12 @@ std::string IfMacro::toString() {`
`413`	`413`	`std::string s = this->getMacroString();`
`414`	`414`	`s += this->condition_str + "\n";`
`415`	`415`	`for (auto &statement : this->true_body) {`
`416`		`- s += statement->toString() + "\n";`
	`416`	`+ s += variant_to_string(statement) + "\n";`
`417`	`417`	`}`
`418`	`418`	`if (this->else_body.size() > 0) {`
`419`	`419`	s += "`else\n";
`420`	`420`	`for (auto &statement : this->else_body) {`
`421`		`- s += statement->toString() + "\n";`
	`421`	`+ s += variant_to_string(statement) + "\n";`
`422`	`422`	`}`
`423`	`423`	`}`
`424`	`424`	return s + "`endif";