add antlr source code and ReadMe

[toc] / src / toc.h

diff --git a/src/toc.h b/src/toc.h
index 43ab1bad3831c508f50cf83868003b342d8860e8..c31e12b3f61d18b93f90d871e8181a4053f9bb64 100644 (file)
--- a/src/toc.h
+++ b/src/toc.h
@@ -4,8 +4,10 @@
 #include <sstream>\r
 \r
 #include "repr.h"\r
 #include <sstream>\r
 \r
 #include "repr.h"\r

+#include "generic.h"\r

 #include "typeInfo.h"\r
 \r
 #include "typeInfo.h"\r
 \r

+// print a generic vector with specified separator, optionally printing the separator at the end aswell\r

 template<typename T>\r
 std::string vectorStr (const std::vector<T> & v, const std::string & separator, bool end = false)\r
 {\r
 template<typename T>\r
 std::string vectorStr (const std::vector<T> & v, const std::string & separator, bool end = false)\r
 {\r


@@ -53,22 +55,52 @@ static std::string namespacePrefix() {
   return sstr.str();\r
 }\r
 \r
   return sstr.str();\r
 }\r
 \r

-static Program globalPrg;\r
+// mapping from generic typenames (which are just names)\r
+// to actual instantiated types\r
+static std::map<std::string, Type> currentInstantiation;\r
+\r
+// set current context so that lookups can be made correctly\r
+static std::shared_ptr<Context> globalCtx;\r
+\r

 \r
 std::ostream & operator<< (std::ostream & out, const Type & t)\r
 {\r
 \r
 std::ostream & operator<< (std::ostream & out, const Type & t)\r
 {\r

-  out << vectorStr(t.namespacePrefixes, "_", true) << t.name;\r
+  // if the typename equals one of the current generic instantiations\r
+  // print instantiated type instead\r
+  for (auto kv : currentInstantiation)\r
+  {\r
+    if (t.name == kv.first)\r
+    {\r
+      out << kv.second;\r
+      return out;\r
+    }\r
+  }\r
+  TypeInfo ti = typeType(globalCtx, t);\r
+  if (ti.isStruct)\r
+    out << "struct ";\r
+  // try finding type in current context\r
+  auto s = findStruct(t.name, t.namespacePrefixes, globalCtx);\r
+  // print prefix for either found type or the specified \r
+  // prefix if type is not found (shouldn't happen)\r
+  if (s.has_value())\r
+    out << vectorStr(std::get<1>(*s), "_", true) << t.name; \r
+  else\r
+    out << vectorStr(t.namespacePrefixes, "_", true) << t.name;\r
+\r
+  // print generic appendix\r
+  if (!t.genericInstantiation.empty())\r
+    out << genericAppendix(t.genericInstantiation);\r

 \r
   return out;\r
 }\r
 \r
   return out;\r
 }\r

-std::ostream & operator<< (std::ostream & out, const Variable & v)\r
-{\r
-  out << v.type << " ";\r

 \r
 \r

+std::string generateModifiers (std::string s, std::vector<TypeModifier> modifiers)\r
+{\r

   std::stringstream sstr;\r
   std::stringstream sstr;\r

-  std::string s = v.name;\r

 \r
 \r

-  for (auto m = v.type.modifiers.rbegin(); m != v.type.modifiers.rend(); m++)\r
+  // apply modifiers, inverted because C defines them\r
+  // the opposite direction\r
+  for (auto m = modifiers.rbegin(); m != modifiers.rend(); m++)\r

   {\r
     if (m->type == TypeModifierType::Pointer)\r
     {\r
   {\r
     if (m->type == TypeModifierType::Pointer)\r
     {\r


@@ -86,12 +118,31 @@ std::ostream & operator<< (std::ostream & out, const Variable & v)
       s = sstr.str();\r
     }\r
   }\r
       s = sstr.str();\r
     }\r
   }\r

-  out << s;\r
+\r
+  return s;\r
+}\r
+\r
+std::ostream & operator<< (std::ostream & out, const Variable & v)\r
+{\r
+  out << v.type << " ";\r
+\r
+  std::string s = v.name;\r
+  \r
+  // lookup variable and change name to reflect containing namespace\r
+  auto var = findVariable(v.name, namespaces, globalCtx);\r
+  if (var.has_value())\r
+    s = vectorStr(std::get<1>(*var), "_", true) + s;\r
+\r
+  // apply modifiers in C fashion\r
+  out << generateModifiers(s, v.type.modifiers);\r

 \r
   return out;\r
 }\r
 std::ostream & operator<< (std::ostream & out, const Body & b)\r
 {\r
 \r
   return out;\r
 }\r
 std::ostream & operator<< (std::ostream & out, const Body & b)\r
 {\r

+  b.ctx->parent = globalCtx;\r
+  globalCtx = b.ctx;\r
+\r

   indent(out);\r
   out << "{\n";\r
   indentation += 2;\r
   indent(out);\r
   out << "{\n";\r
   indentation += 2;\r


@@ -113,6 +164,8 @@ std::ostream & operator<< (std::ostream & out, const Body & b)
   indent(out, -2);\r
   out << "}\n";\r
 \r
   indent(out, -2);\r
   out << "}\n";\r
 \r

+  globalCtx = b.ctx->parent;\r
+\r

   return out;\r
 }\r
 std::ostream & operator<< (std::ostream & out, const Expr & e)\r
   return out;\r
 }\r
 std::ostream & operator<< (std::ostream & out, const Expr & e)\r


@@ -120,13 +173,33 @@ std::ostream & operator<< (std::ostream & out, const Expr & e)
   switch (e.type)\r
   {\r
   case ExprType::Func:\r
   switch (e.type)\r
   {\r
   case ExprType::Func:\r

-    out << vectorStr(e._func.namespacePrefixes, "_", true) << e._func.functionName << "(" << vectorStr(e._func.arguments, ", ") << ")"; break;\r
+  {\r
+    // print function call\r
+    auto f = findFunction(e._func.functionName, e._func.namespacePrefixes, globalCtx);\r
+\r
+    if (std::get<0>(*f).defined)\r
+      out << vectorStr(std::get<1>(*f), "_", true);\r
+\r
+    out << e._func.functionName;\r
+    if (!e._func.genericInstantiation.empty())\r
+      out << genericAppendix(e._func.genericInstantiation);\r
+    out <<"(" << vectorStr(e._func.arguments, ", ") << ")"; break;\r
+  }\r

   case ExprType::Method:\r
   {\r
   case ExprType::Method:\r
   {\r

-    TypeInfo ti = typeExpr(globalPrg, namespaces, *e._method.expr);\r
+    // get TypeInfo on the Expression that the method is called on\r
+    // then print method call\r
+    TypeInfo ti = typeExpr(globalCtx, *e._method.expr);\r

     out <<\r
       vectorStr(ti.type.namespacePrefixes, "_", true) <<\r
     out <<\r
       vectorStr(ti.type.namespacePrefixes, "_", true) <<\r

-      ti.type.name << "_" << e._method.methodName << "(" << *e._method.expr << vectorStr(e._method.arguments, ", ") << ")"; break;\r
+      ti.type.name << genericAppendix(ti.type.genericInstantiation) << "_" << e._method.methodName;\r
+    if (!e._method.genericInstantiation.empty())\r
+      out << genericAppendix(e._method.genericInstantiation);\r
+    out << "(";\r
+    if (e._method.expr->type == ExprType::Identifier)\r
+      out << "&";\r
+    out << *e._method.expr << (e._method.arguments.empty() ? "" : ", ") <<\r
+    vectorStr(e._method.arguments, ", ") << ")"; break;\r

   }\r
   case ExprType::Lit:\r
     /**/ if (e._lit.type == LitType::Int) out << e._lit._int;\r
   }\r
   case ExprType::Lit:\r
     /**/ if (e._lit.type == LitType::Int) out << e._lit._int;\r


@@ -135,9 +208,9 @@ std::ostream & operator<< (std::ostream & out, const Expr & e)
     else if (e._lit.type == LitType::Bool) out << e._lit._bool;\r
     break;\r
   case ExprType::Paren:\r
     else if (e._lit.type == LitType::Bool) out << e._lit._bool;\r
     break;\r
   case ExprType::Paren:\r

-    out << "(" << e._paren.expr << ")"; break;\r
+    out << "(" << *e._paren.expr << ")"; break;\r

   case ExprType::Dot:\r
   case ExprType::Dot:\r

-    out << *e._dot.expr << "." << e._dot.identifier; break;\r
+    out << *e._dot.expr << (e._dot.isPointer ? "->" : ".") << e._dot.identifier; break;\r

   case ExprType::PrefixOp:\r
     out << PrefixOperatorTypeStrings[(int)e._prefixOp.type] << *e._prefixOp.expr; break;\r
   case ExprType::PostfixOp:\r
   case ExprType::PrefixOp:\r
     out << PrefixOperatorTypeStrings[(int)e._prefixOp.type] << *e._prefixOp.expr; break;\r
   case ExprType::PostfixOp:\r


@@ -153,7 +226,14 @@ std::ostream & operator<< (std::ostream & out, const Expr & e)
   case ExprType::Bracket:\r
     out << *e._brackets.lexpr << "[" << *e._brackets.rexpr << "]"; break;\r
   case ExprType::Identifier:\r
   case ExprType::Bracket:\r
     out << *e._brackets.lexpr << "[" << *e._brackets.rexpr << "]"; break;\r
   case ExprType::Identifier:\r

-    out << vectorStr(e._identifier.namespacePrefixes, "_", true) << e._identifier.identifier; break;\r
+    // try variable lookup\r
+    auto v = findVariable(e._identifier.identifier, e._identifier.namespacePrefixes, globalCtx);\r
+    if (v.has_value())\r
+      out << vectorStr(std::get<1>(*v), "_", true);\r
+    else\r
+      out << vectorStr(e._identifier.namespacePrefixes, "_", true);\r
+\r
+    out << e._identifier.identifier; break;\r

   }\r
 \r
   return out;\r
   }\r
 \r
   return out;\r


@@ -196,110 +276,233 @@ std::ostream & operator<< (std::ostream & out, const Stmt & s)
 \r
 void tocFunction (std::ostream & out, const Function & f, bool stub)\r
 {\r
 \r
 void tocFunction (std::ostream & out, const Function & f, bool stub)\r
 {\r

-  out << f.returnType << " " << namespacePrefix() << f.name << " (" << vectorStr(f.parameters, ", ") << ")";\r
+  // for a function that is not defined, only the stub can be printed\r
+  if (!f.defined && !stub) return;\r

 \r
 \r

-  if (stub)\r
+  // regular function\r
+  if (f.genericTypeNames.empty())\r

   {\r
   {\r

-    out << ";\n";\r
+    out << f.returnType << " " << generateModifiers(namespacePrefix() + f.name, f.returnType.modifiers) << " (" << vectorStr(f.parameters, ", ") << ")";\r
+\r
+    if (stub)\r
+    {\r
+      out << ";\n";\r
+    }\r
+    else\r
+    {\r
+      out << "\n" << f.body;\r
+    }\r

   }\r
   }\r

+  // generic function\r

   else\r
   {\r
   else\r
   {\r

-    out << "\n" << f.body;\r
+    // print one instance per instantiation\r
+    for (auto instantiation : f.genericInstantiations)\r
+    {\r
+      // set global type mapping\r
+      for (int i = 0; i < f.genericTypeNames.size(); i++)\r
+      {\r
+        currentInstantiation[f.genericTypeNames[i]] = instantiation[i];\r
+      }\r
+\r
+      out << f.returnType << " " <<\r
+        generateModifiers(namespacePrefix() + f.name + genericAppendix(instantiation), f.returnType.modifiers) <<\r
+        " (" << vectorStr(f.parameters, ", ") << ")";\r
+\r
+      if (stub)\r
+      {\r
+        out << ";\n";\r
+      }\r
+      else\r
+      {\r
+        out << "\n" << f.body;\r
+      }\r
+\r
+      currentInstantiation.clear();\r
+    }\r

   }\r
 }\r
 void tocStruct (std::ostream & out, const Struct & s, bool stub)\r
 {\r
   }\r
 }\r
 void tocStruct (std::ostream & out, const Struct & s, bool stub)\r
 {\r

-  out << "struct " << namespacePrefix() << s.name;\r
-  if (stub)\r
+  // regular struct\r
+  if (s.genericTypeNames.empty())\r

   {\r
   {\r

-    out << ";\n";\r
+    out << "struct " << namespacePrefix() << s.name;\r
+    if (stub)\r
+    {\r
+      out << ";\n";\r
+      for (auto m : s.methods)\r
+      {\r
+        Function f = m;\r
+\r
+        // add implicit this parameter\r
+        f.parameters.insert(f.parameters.begin(),\r
+        {"this",\r
+          {\r
+            namespaces,\r
+            s.name,\r
+            {\r
+              {TypeModifierType::Pointer, false, -1}\r
+            }\r
+          }\r
+        });\r
+        out << f.returnType << " " <<\r
+          generateModifiers(namespacePrefix() + s.name + "_" + f.name, f.returnType.modifiers) <<\r
+          " (" << vectorStr(f.parameters, ", ") << ");\n";\r
+      }\r
+      return;\r
+    }\r
+    out << "\n{\n";\r
+    indentation += 2;\r
+\r
+    for (auto m : s.members)\r
+    {\r
+      indent(out);\r
+      out << m << ";\n";\r
+    }\r
+\r
+    indent(out, -2);\r
+    out << "};\n";\r
+    \r

     for (auto m : s.methods)\r
     {\r
       Function f = m;\r
     for (auto m : s.methods)\r
     {\r
       Function f = m;\r

-\r
+      \r
+      // add implicit this parameter\r

       f.parameters.insert(f.parameters.begin(),\r
       f.parameters.insert(f.parameters.begin(),\r

-      {"this",\r
-        {\r
-          namespaces,\r
-          s.name,\r
+        {"this",\r

           {\r
           {\r

-            {TypeModifierType::Pointer, false, -1}\r
+            namespaces,\r
+            s.name,\r
+            {\r
+              {TypeModifierType::Pointer, false, -1}\r
+            }\r

           }\r
           }\r

-        }\r
-      });\r
+        });\r

       out << f.returnType << " " <<\r
       out << f.returnType << " " <<\r

-        namespacePrefix() << s.name << "_" << f.name <<\r
-        " (" << vectorStr(f.parameters, ", ") << ");\n";\r
+        generateModifiers(namespacePrefix() + s.name + "_" + f.name, f.returnType.modifiers) <<\r
+        " (" << vectorStr(f.parameters, ", ") << ")\n" << f.body;\r

     }\r
     }\r

-    return;\r

   }\r
   }\r

-  out << "\n{\n";\r
-  indentation += 2;\r
-\r
-  for (auto m : s.members)\r
+  // generic struct\r
+  else\r

   {\r
   {\r

-    indent(out);\r
-    out << m << ";\n";\r
-  }\r
+    for (auto instantiation : s.genericInstantiations)\r
+    {\r
+      for (int i = 0; i < s.genericTypeNames.size(); i++)\r
+      {\r
+        currentInstantiation[s.genericTypeNames[i]] = instantiation[i];\r
+      }\r

 \r
 \r

-  indent(out, -2);\r
-  out << "};\n";\r
-  \r
-  for (auto m : s.methods)\r
-  {\r
-    Function f = m;\r
-    f.parameters.insert(f.parameters.begin(),\r
-      {"this",\r
+      out << "struct " << namespacePrefix() << s.name << genericAppendix(instantiation);\r
+      if (stub)\r
+      {\r
+        out << ";\n";\r
+        for (auto m : s.methods)\r

         {\r
         {\r

-          namespaces,\r
-          s.name,\r
-          {\r
-            {TypeModifierType::Pointer, false, -1}\r
-          }\r
+          Function f = m;\r
+\r
+        // add implicit this parameter\r
+          f.parameters.insert(f.parameters.begin(),\r
+          {"this",\r
+            {\r
+              namespaces,\r
+              s.name + genericAppendix(instantiation),\r
+              {\r
+                {TypeModifierType::Pointer, false, -1}\r
+              }\r
+            }\r
+          });\r
+          out << f.returnType << " " <<\r
+            generateModifiers(namespacePrefix() + s.name + genericAppendix(instantiation) + "_" + f.name, f.returnType.modifiers) <<\r
+            " (" << vectorStr(f.parameters, ", ") << ");\n";\r

         }\r
         }\r

-      });\r
-    out << f.returnType << " " <<\r
-    namespacePrefix() << s.name << "_" << f.name <<\r
-    " (" << vectorStr(f.parameters, ", ") << ")\n" << f.body;\r
+        return;\r
+      }\r
+      out << "\n{\n";\r
+      indentation += 2;\r
+\r
+      for (auto m : s.members)\r
+      {\r
+        indent(out);\r
+        out << m << ";\n";\r
+      }\r
+\r
+      indent(out, -2);\r
+      out << "};\n";\r
+      \r
+      for (auto m : s.methods)\r
+      {\r
+        Function f = m;\r
+        \r
+        // add implicit this parameter\r
+        f.parameters.insert(f.parameters.begin(),\r
+          {"this",\r
+            {\r
+              namespaces,\r
+              s.name + genericAppendix(instantiation),\r
+              {\r
+                {TypeModifierType::Pointer, false, -1}\r
+              }\r
+            }\r
+          });\r
+        out << f.returnType << " " <<\r
+          generateModifiers(namespacePrefix() + s.name + genericAppendix(instantiation) + "_" + f.name, f.returnType.modifiers) <<\r
+          " (" << vectorStr(f.parameters, ", ") << ")\n" << f.body;\r
+      }\r
+\r
+      currentInstantiation.clear();\r
+    }\r

   }\r
 }\r
 void tocProgram (std::ostream & out, const Program & p)\r
 {\r
   }\r
 }\r
 void tocProgram (std::ostream & out, const Program & p)\r
 {\r

-  globalPrg = p;\r
-  for (auto n : p.namespaces)\r
+  globalCtx = p.ctx;\r
+\r
+  for (auto n : p.ctx->namespaces)\r

   {\r
     tocNamespace(out, n, true);\r
   }\r
   {\r
     tocNamespace(out, n, true);\r
   }\r

-  for (auto s : p.structs)\r
+  out << "\n\n";\r
+  for (auto s : p.ctx->structs)\r

   {\r
     tocStruct(out, s, true);\r
   }\r
   {\r
     tocStruct(out, s, true);\r
   }\r

-  for (auto f : p.functions)\r
+  out << "\n\n";\r
+  for (auto f : p.ctx->functions)\r

   {\r
     tocFunction(out, f, true);\r
   }\r
   {\r
     tocFunction(out, f, true);\r
   }\r

+  out << "\n\n";\r

 \r
   for (auto v : p.ctx->variables)\r
   {\r
     out << v << ";\n";\r
   }\r
 \r
   for (auto v : p.ctx->variables)\r
   {\r
     out << v << ";\n";\r
   }\r

-  for (auto n : p.namespaces)\r
+  out << "\n\n";\r
+  for (auto n : p.ctx->namespaces)\r

   {\r
     tocNamespace(out, n, false);\r
   }\r
   {\r
     tocNamespace(out, n, false);\r
   }\r

-  for (auto s : p.structs)\r
+  out << "\n\n";\r
+  for (auto s : p.ctx->structs)\r

   {\r
     tocStruct(out, s, false);\r
   }\r
   {\r
     tocStruct(out, s, false);\r
   }\r

-  for (auto f : p.functions)\r
+  out << "\n\n";\r
+  for (auto f : p.ctx->functions)\r

   {\r
     tocFunction(out, f, false);\r
   }\r
   {\r
     tocFunction(out, f, false);\r
   }\r

+  out << "\n\n";\r

 }\r
 \r
 \r
 void tocNamespace  (std::ostream & out, const Namespace & n, bool stub)\r
 {\r
 }\r
 \r
 \r
 void tocNamespace  (std::ostream & out, const Namespace & n, bool stub)\r
 {\r

+  n.ctx->parent = globalCtx;\r
+  globalCtx = n.ctx;\r
+\r

   namespaces.push_back(n.name);\r
   if (!stub)\r
   {\r
   namespaces.push_back(n.name);\r
   if (!stub)\r
   {\r


@@ -307,18 +510,24 @@ void tocNamespace  (std::ostream & out, const Namespace & n, bool stub)
     {\r
       out << v << ";\n";\r
     }\r
     {\r
       out << v << ";\n";\r
     }\r

+    out << "\n\n";\r

   }\r
   }\r

-  for (auto n : n.namespaces)\r
+  for (auto n : n.ctx->namespaces)\r

   {\r
     tocNamespace(out, n, stub);\r
   {\r
     tocNamespace(out, n, stub);\r

+    out << "\n\n";\r

   }\r
   }\r

-  for (auto s : n.structs)\r
+  for (auto s : n.ctx->structs)\r

   {\r
     tocStruct(out, s, stub);\r
   {\r
     tocStruct(out, s, stub);\r

+    out << "\n\n";\r

   }\r
   }\r

-  for (auto f : n.functions)\r
+  for (auto f : n.ctx->functions)\r

   {\r
     tocFunction(out, f, stub);\r
   {\r
     tocFunction(out, f, stub);\r

+    out << "\n\n";\r

   }\r
   namespaces.pop_back();\r
   }\r
   namespaces.pop_back();\r

+\r
+  globalCtx = n.ctx->parent;\r

 }
\ No newline at end of file
 }
\ No newline at end of file