X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/71a20a4f3d4e5f5278f7d004af710af89dfd7ebc..7f83e1b208e87e3808b268303bb633a8fda203f5:/src/toc.h?ds=sidebyside

diff --git a/src/toc.h b/src/toc.h
index e4f36e5..43ab1ba 100644
--- a/src/toc.h
+++ b/src/toc.h
@@ -4,32 +4,36 @@
 #include <sstream>
 
 #include "repr.h"
+#include "typeInfo.h"
 
 template<typename T>
-std::ostream & operator<< (std::ostream & out, const std::vector<T> & v)
+std::string vectorStr (const std::vector<T> & v, const std::string & separator, bool end = false)
 {
-  bool comma = false;
+  std::stringstream sstr;
+
+  bool putSeparator = false;
   for (auto t : v)
   {
-    if (comma) out << ", ";
-    else comma = true;
-    out << t;
+    if (putSeparator) sstr << separator;
+    else putSeparator = true;
+    sstr << t;
   }
-  return out;
+  if (end && !v.empty())
+    sstr << separator;
+
+  return sstr.str();
 }
 
 std::ostream & operator<< (std::ostream & out, const Type & t);
 std::ostream & operator<< (std::ostream & out, const Variable & v);
 std::ostream & operator<< (std::ostream & out, const Body & b);
-std::ostream & operator<< (std::ostream & out, const UnaryOperatorExpr & o);
-std::ostream & operator<< (std::ostream & out, const BinaryOperatorExpr & o);
-std::ostream & operator<< (std::ostream & out, const TernaryOperatorExpr & o);
 std::ostream & operator<< (std::ostream & out, const Expr & e);
 std::ostream & operator<< (std::ostream & out, const Stmt & s);
 
 void tocFunction (std::ostream & out, const Function & f, bool stub);
 void tocStruct   (std::ostream & out, const Struct & s, bool stub);
 void tocProgram  (std::ostream & out, const Program & p);
+void tocNamespace  (std::ostream & out, const Namespace & n, bool stub);
 
 static const int TAB_WIDTH = 2;
 static int indentation = 0;
@@ -39,9 +43,21 @@ static void indent(std::ostream & out, int change = 0)
   out << std::string(indentation, ' ');
 }
 
+static std::vector<std::string> namespaces;
+static std::string namespacePrefix() {
+  std::stringstream sstr;
+  for (auto n : namespaces)
+  {
+    sstr << n << "_";
+  }
+  return sstr.str();
+}
+
+static Program globalPrg;
+
 std::ostream & operator<< (std::ostream & out, const Type & t)
 {
-  out << t.name;
+  out << vectorStr(t.namespacePrefixes, "_", true) << t.name;
 
   return out;
 }
@@ -80,7 +96,7 @@ std::ostream & operator<< (std::ostream & out, const Body & b)
   out << "{\n";
   indentation += 2;
 
-  for (auto v : b.variables)
+  for (auto v : b.ctx->variables)
   {
     indent(out);
     out << v << ";\n";
@@ -99,62 +115,46 @@ std::ostream & operator<< (std::ostream & out, const Body & b)
 
   return out;
 }
-std::ostream & operator<< (std::ostream & out, const UnaryOperatorExpr & o)
-{
-  if (o.type == UnaryOperatorType::IncrementPost || o.type == UnaryOperatorType::DecrementPost)
-  {
-    out << UnaryOperatorTypeStrings[(int)o.type] << *o.expr;
-  }
-  else
-  {
-    out << *o.expr << UnaryOperatorTypeStrings[(int)o.type];
-  }
-
-  return out;
-}
-std::ostream & operator<< (std::ostream & out, const BinaryOperatorExpr & o)
-{
-  out << *o.lexpr << " " << BinaryOperatorTypeStrings[(int)o.type] << " " << *o.rexpr;
-
-  return out;
-}
-std::ostream & operator<< (std::ostream & out, const TernaryOperatorExpr & o)
-{
-  out << *o.lexpr << " ? " << *o.rexprTrue << " : " << *o.rexprFalse;
-
-  return out;
-}
 std::ostream & operator<< (std::ostream & out, const Expr & e)
 {
-  if (e.parenthesized)
-    out << "(";
-
   switch (e.type)
   {
   case ExprType::Func:
-    out << e._func.functionName << "(" << e._func.arguments << ")"; break;
+    out << vectorStr(e._func.namespacePrefixes, "_", true) << e._func.functionName << "(" << vectorStr(e._func.arguments, ", ") << ")"; break;
+  case ExprType::Method:
+  {
+    TypeInfo ti = typeExpr(globalPrg, namespaces, *e._method.expr);
+    out <<
+      vectorStr(ti.type.namespacePrefixes, "_", true) <<
+      ti.type.name << "_" << e._method.methodName << "(" << *e._method.expr << vectorStr(e._method.arguments, ", ") << ")"; break;
+  }
   case ExprType::Lit:
     /**/ if (e._lit.type == LitType::Int) out << e._lit._int;
     else if (e._lit.type == LitType::Decimal) out << e._lit._decimal;
     else if (e._lit.type == LitType::String) out << e._lit._string;
     else if (e._lit.type == LitType::Bool) out << e._lit._bool;
     break;
-  case ExprType::Identifier:
-    out << e._identifier.name; break;
-  case ExprType::Brackets:
-    out << *e._brackets.lexpr << "[" << *e._brackets.rexpr << "]"; break;
+  case ExprType::Paren:
+    out << "(" << e._paren.expr << ")"; break;
   case ExprType::Dot:
-    out << *e._dot.expr << "." << e._dot.ident.name; break;
-  case ExprType::UnaryOperator:
-    out << e._unaryOperator; break;
-  case ExprType::BinaryOperator:
-    out << e._binaryOperator; break;
-  case ExprType::TernaryOperator:
-    out << e._ternaryOperator; break;
+    out << *e._dot.expr << "." << e._dot.identifier; break;
+  case ExprType::PrefixOp:
+    out << PrefixOperatorTypeStrings[(int)e._prefixOp.type] << *e._prefixOp.expr; break;
+  case ExprType::PostfixOp:
+    out << *e._postfixOp.expr << PostfixOperatorTypeStrings[(int)e._postfixOp.type]; break;
+  case ExprType::BinaryOp:
+    out << *e._binaryOp.lexpr <<
+    " " << BinaryOperatorTypeStrings[(int)e._binaryOp.type] << " " <<
+    *e._binaryOp.rexpr; break;
+  case ExprType::TernaryOp:
+    out << *e._ternaryOp.lexpr <<
+      " ? " << *e._ternaryOp.rexprTrue <<
+      " : " << *e._ternaryOp.rexprFalse; break;
+  case ExprType::Bracket:
+    out << *e._brackets.lexpr << "[" << *e._brackets.rexpr << "]"; break;
+  case ExprType::Identifier:
+    out << vectorStr(e._identifier.namespacePrefixes, "_", true) << e._identifier.identifier; break;
   }
-  
-  if (e.parenthesized)
-    out << ")";
 
   return out;
 }
@@ -165,7 +165,7 @@ std::ostream & operator<< (std::ostream & out, const Stmt & s)
   case StmtType::If:
     out << "if (" << s._if.condition << ")\n" << s._if.body; break;
   case StmtType::Switch:
-    out << "switch (" << s._switch.ident.name << ")\n{\n";
+    out << "switch (" << s._switch.ident << ")\n{\n";
     for (auto c : s._switch.cases)
     {
       indent(out, 2);
@@ -176,14 +176,14 @@ std::ostream & operator<< (std::ostream & out, const Stmt & s)
     break;
   case StmtType::For:
     out << "for (" <<
-      s._for.varName << " = " << *s._for.initValue << "; " <<
+      s._for.init << "; " <<
       *s._for.condition << "; " <<
       *s._for.action <<
       ")\n" << s._for.body; break;
   case StmtType::While:
     out << "while (" << s._while.condition << ")\n" << s._while.body; break;
   case StmtType::Assign:
-    out << s._assign.name << " = " << s._assign.expr << ";"; break;
+    out << s._assign.lexpr << " = " << s._assign.rexpr << ";"; break;
   case StmtType::Return:
     out << "return " << s._return.expr << ";"; break;
   case StmtType::Expr:
@@ -196,7 +196,7 @@ std::ostream & operator<< (std::ostream & out, const Stmt & s)
 
 void tocFunction (std::ostream & out, const Function & f, bool stub)
 {
-  out << f.returnType << " " << f.name << " (" << f.parameters << ")";
+  out << f.returnType << " " << namespacePrefix() << f.name << " (" << vectorStr(f.parameters, ", ") << ")";
 
   if (stub)
   {
@@ -209,19 +209,27 @@ void tocFunction (std::ostream & out, const Function & f, bool stub)
 }
 void tocStruct (std::ostream & out, const Struct & s, bool stub)
 {
-  out << "struct " << s.name;
+  out << "struct " << namespacePrefix() << s.name;
   if (stub)
   {
     out << ";\n";
     for (auto m : s.methods)
     {
-      m.parameters.insert(m.parameters.begin(),
+      Function f = m;
+
+      f.parameters.insert(f.parameters.begin(),
       {"this",
-      {s.name,
-      {{TypeModifierType::Pointer, false, -1}}}});
-      out << m.returnType << " " <<
-        s.name << "_" << m.name <<
-        " (" << m.parameters << ");\n";
+        {
+          namespaces,
+          s.name,
+          {
+            {TypeModifierType::Pointer, false, -1}
+          }
+        }
+      });
+      out << f.returnType << " " <<
+        namespacePrefix() << s.name << "_" << f.name <<
+        " (" << vectorStr(f.parameters, ", ") << ");\n";
     }
     return;
   }
@@ -239,15 +247,29 @@ void tocStruct (std::ostream & out, const Struct & s, bool stub)
   
   for (auto m : s.methods)
   {
-    m.parameters.insert(m.parameters.begin(),
-    {"this",
-    {s.name,
-    {{TypeModifierType::Pointer, false, -1}}}});  
-    out << m.returnType << " " << s.name << "_" << m.name << " (" << m.parameters << ")\n" << m.body;
+    Function f = m;
+    f.parameters.insert(f.parameters.begin(),
+      {"this",
+        {
+          namespaces,
+          s.name,
+          {
+            {TypeModifierType::Pointer, false, -1}
+          }
+        }
+      });
+    out << f.returnType << " " <<
+    namespacePrefix() << s.name << "_" << f.name <<
+    " (" << vectorStr(f.parameters, ", ") << ")\n" << f.body;
   }
 }
 void tocProgram (std::ostream & out, const Program & p)
 {
+  globalPrg = p;
+  for (auto n : p.namespaces)
+  {
+    tocNamespace(out, n, true);
+  }
   for (auto s : p.structs)
   {
     tocStruct(out, s, true);
@@ -257,10 +279,14 @@ void tocProgram (std::ostream & out, const Program & p)
     tocFunction(out, f, true);
   }
 
-  for (auto v : p.variables)
+  for (auto v : p.ctx->variables)
   {
     out << v << ";\n";
   }
+  for (auto n : p.namespaces)
+  {
+    tocNamespace(out, n, false);
+  }
   for (auto s : p.structs)
   {
     tocStruct(out, s, false);
@@ -270,3 +296,29 @@ void tocProgram (std::ostream & out, const Program & p)
     tocFunction(out, f, false);
   }
 }
+
+
+void tocNamespace  (std::ostream & out, const Namespace & n, bool stub)
+{
+  namespaces.push_back(n.name);
+  if (!stub)
+  {
+    for (auto v : n.ctx->variables)
+    {
+      out << v << ";\n";
+    }
+  }
+  for (auto n : n.namespaces)
+  {
+    tocNamespace(out, n, stub);
+  }
+  for (auto s : n.structs)
+  {
+    tocStruct(out, s, stub);
+  }
+  for (auto f : n.functions)
+  {
+    tocFunction(out, f, stub);
+  }
+  namespaces.pop_back();
+}
\ No newline at end of file