add antlr source code and ReadMe

[toc] / src / visit.h

diff --git a/src/visit.h b/src/visit.h
index 0cfb9e6036b7442cb7a0896ff9ea8a11c465117d..279a4fcab65084e7835aa0bc030958179d1fcb51 100644 (file)
--- a/src/visit.h
+++ b/src/visit.h
@@ -4,26 +4,30 @@
 \r
 #include <functional>\r
 \r
 \r
 #include <functional>\r
 \r

+// struct with callback functions for all relevant types\r
+// tree can be walked selectively by providing only\r
+// needed callbacks\r

 struct Visitor {\r
 struct Visitor {\r

-  std::function<void(const Type &, const std::vector<std::string> & namespaces)> onType = [](auto, auto){};\r
-  std::function<void(const Expr &, const std::vector<std::string> & namespaces)> onExpr = [](auto, auto){};\r
-  std::function<void(const Stmt &, const std::vector<std::string> & namespaces)> onStmt = [](auto, auto){};\r
-  std::function<void(const Body &, const std::vector<std::string> & namespaces)> onBody = [](auto, auto){};\r
-  std::function<void(const Function &, const std::vector<std::string> & namespaces)> onFunction = [](auto, auto){};\r
-  std::function<void(const Variable &, const std::vector<std::string> & namespaces)> onVariable = [](auto, auto){};\r
-  std::function<void(const StructMember<Function> &, const std::vector<std::string> & namespaces)> onStructMethod = [](auto, auto){};\r
-  std::function<void(const StructMember<Variable> &, const std::vector<std::string> & namespaces)> onStructMember = [](auto, auto){};\r
-  std::function<void(const Struct &, const std::vector<std::string> & namespaces)> onStruct = [](auto, auto){};\r
-  std::function<void(const Namespace &, const std::vector<std::string> & namespaces)> onNamespace = [](auto, auto){};\r
-  std::function<void(const Program &, const std::vector<std::string> & namespaces)> onProgram = [](auto, auto){};\r
+  std::function<void(const Type &, const std::shared_ptr<Context> ctx)>                   onType = [](auto, auto){};\r
+  std::function<void(const Expr &, const std::shared_ptr<Context> ctx)>                   onExpr = [](auto, auto){};\r
+  std::function<void(const Stmt &, const std::shared_ptr<Context> ctx)>                   onStmt = [](auto, auto){};\r
+  std::function<void(const Body &, const std::shared_ptr<Context> ctx)>                   onBody = [](auto, auto){};\r
+  std::function<void(const Function &, const std::shared_ptr<Context> ctx)>               onFunction = [](auto, auto){};\r
+  std::function<void(const Variable &, const std::shared_ptr<Context> ctx)>               onVariable = [](auto, auto){};\r
+  std::function<void(const StructMember<Function> &, const std::shared_ptr<Context> ctx)> onStructMethod = [](auto, auto){};\r
+  std::function<void(const StructMember<Variable> &, const std::shared_ptr<Context> ctx)> onStructMember = [](auto, auto){};\r
+  std::function<void(const Struct &, const std::shared_ptr<Context> ctx)>                 onStruct = [](auto, auto){};\r
+  std::function<void(const Namespace &, const std::shared_ptr<Context> ctx)>              onNamespace = [](auto, auto){};\r
+  std::function<void(const Program &, const std::shared_ptr<Context> ctx)>                onProgram = [](auto, auto){};\r

 };\r
 \r
 #define VISIT(XS) for (auto x : XS) visit(x);\r
 \r
 };\r
 \r
 #define VISIT(XS) for (auto x : XS) visit(x);\r
 \r

+// simply walk IR by recursively calling functions for all children\r

 struct Visit {\r
 private:\r
   Visitor v;\r
 struct Visit {\r
 private:\r
   Visitor v;\r

-  std::vector<std::string> namespaces;\r
+  std::shared_ptr<Context> ctx;\r

 public:\r
   Visit(Visitor v)\r
   {\r
 public:\r
   Visit(Visitor v)\r
   {\r


@@ -31,11 +35,11 @@ public:
   }\r
   void visit(const Type & x)\r
   {\r
   }\r
   void visit(const Type & x)\r
   {\r

-    v.onType(x, namespaces);\r
+    v.onType(x, ctx);\r

   }\r
   void visit(const Expr & x)\r
   {\r
   }\r
   void visit(const Expr & x)\r
   {\r

-    v.onExpr(x, namespaces);\r
+    v.onExpr(x, ctx);\r

 \r
     switch (x.type)\r
     {\r
 \r
     switch (x.type)\r
     {\r


@@ -79,7 +83,7 @@ public:
   }\r
   void visit(const Stmt & x)\r
   {\r
   }\r
   void visit(const Stmt & x)\r
   {\r

-    v.onStmt(x, namespaces);\r
+    v.onStmt(x, ctx);\r

 \r
     switch (x.type)\r
     {\r
 \r
     switch (x.type)\r
     {\r


@@ -126,66 +130,74 @@ public:
   }\r
   void visit(const Body & x)\r
   {\r
   }\r
   void visit(const Body & x)\r
   {\r

-    v.onBody(x, namespaces);\r
+    v.onBody(x, ctx);\r
+\r
+    ctx = x.ctx;\r

 \r
     VISIT(x.ctx->variables)\r
     VISIT(x.statements)\r
 \r
     VISIT(x.ctx->variables)\r
     VISIT(x.statements)\r

+\r
+    ctx = ctx->parent;\r

   }\r
   void visit(const Namespace & x)\r
   {\r
   }\r
   void visit(const Namespace & x)\r
   {\r

-    v.onNamespace(x, namespaces);\r
+    v.onNamespace(x, ctx);\r
+    \r
+    ctx = x.ctx;\r

 \r
 \r

-    namespaces.push_back(x.name);\r
-\r
-    VISIT(x.namespaces)\r
+    VISIT(x.ctx->namespaces)\r

     VISIT(x.ctx->variables)\r
     VISIT(x.ctx->variables)\r

-    VISIT(x.structs)\r
-    VISIT(x.functions)\r
+    VISIT(x.ctx->structs)\r
+    VISIT(x.ctx->functions)\r

 \r
 \r

-    namespaces.pop_back();\r
+    ctx = ctx->parent;\r

   }\r
   void visit(const Variable & x)\r
   {\r
   }\r
   void visit(const Variable & x)\r
   {\r

-    v.onVariable(x, namespaces);\r
+    v.onVariable(x, ctx);\r

     visit(x.type);\r
   }\r
   void visit(const Function & x)\r
   {\r
     visit(x.type);\r
   }\r
   void visit(const Function & x)\r
   {\r

-    v.onFunction(x, namespaces);\r
+    v.onFunction(x, ctx);\r

 \r
     if (x.defined) {\r
 \r
     if (x.defined) {\r

-      visit(x.body);\r

       for (auto v : x.parameters)\r
         visit(v.type);\r
       for (auto v : x.parameters)\r
         visit(v.type);\r

+      visit(x.body);\r

     }\r
   }\r
   void visit(const StructMember<Function> & x)\r
   {\r
     }\r
   }\r
   void visit(const StructMember<Function> & x)\r
   {\r

-    v.onStructMethod(x, namespaces);\r
+    v.onStructMethod(x, ctx);\r

 \r
     visit(x.t);\r
   }\r
   void visit(const StructMember<Variable> & x)\r
   {\r
 \r
     visit(x.t);\r
   }\r
   void visit(const StructMember<Variable> & x)\r
   {\r

-    v.onStructMember(x, namespaces);\r
+    v.onStructMember(x, ctx);\r

 \r
     visit(x.t);\r
   }\r
   void visit(const Struct & x)\r
   {\r
 \r
     visit(x.t);\r
   }\r
   void visit(const Struct & x)\r
   {\r

-    v.onStruct(x, namespaces);\r
+    v.onStruct(x, ctx);\r

 \r
     VISIT(x.members)\r
     VISIT(x.methods)\r
   }\r
   void visit(const Program & x)\r
   {\r
 \r
     VISIT(x.members)\r
     VISIT(x.methods)\r
   }\r
   void visit(const Program & x)\r
   {\r

-    v.onProgram(x, namespaces);\r
+    v.onProgram(x, ctx);\r
+\r
+    ctx = x.ctx;\r

 \r
 \r

-    VISIT(x.namespaces)\r
+    VISIT(x.ctx->namespaces)\r

     VISIT(x.ctx->variables)\r
     VISIT(x.ctx->variables)\r

-    VISIT(x.structs)\r
-    VISIT(x.functions)\r
+    VISIT(x.ctx->structs)\r
+    VISIT(x.ctx->functions)\r
+\r
+    ctx = nullptr;\r

   }\r
 };\r
 \r
   }\r
 };\r
 \r