Expressions in brackets

src/parser/parser.cpp

@@ -40,6 +40,10 @@ namespace Solstice {
                 return "Literal";
             case NodeType::Identifier:
                 return "Identifier";
+            case NodeType::Expression:
+                return "Expression";
+            case NodeType::Tuple:
+                return "Tuple";
             case NodeType::FunctionBind:
                 return "FunctionBind";
             case NodeType::Bind:
@@ -115,17 +119,19 @@ namespace Solstice {
         return input[current++];
     }
 
-    std::optional<Node> Parser::getPreviousNode(Node& parent) {
+    std::optional<Node> Parser::getPreviousNode(Node& parent, bool popBack) {
         if (parent.children.empty()) {
             return {};
         }
         Node node = parent.children[parent.children.size() - 1];
-        parent.children.pop_back();
+        if (popBack) {
+            parent.children.pop_back();
+        }
         return node;
     }
 
     Node Parser::parseExpr(TT type) {
-        auto left = getPreviousNode(output);
+        auto left = getPreviousNode(*context);
         if (!left.has_value()) {
             throw std::runtime_error("Expecting expression on left of expression");
         }
@@ -158,6 +164,57 @@ namespace Solstice {
 
     }
 
+    Node Parser::parseOpenParen() {
+        Node node{NodeType::Expression};
+
+        for (;;) {
+            auto next = peek();
+            if (!next.has_value()) {
+                throw std::runtime_error("unclosed parens");
+            }
+            if (next->type == TT::CloseParen) {
+                consume();
+                if (node.children.size() != 1) {
+                    node.type = NodeType::Tuple;
+                }
+                break;
+            }
+
+            Node elem{NodeType::Root};
+            Node* prevContext = context;
+            context = &elem;
+
+            for (;;) {
+                auto t = peek();
+                if (!t.has_value() || t->type == TT::CloseParen || t->type == TT::Comma) {
+                    break;
+                }
+                auto n = parseOneNode(Precedence::NewLine);
+                if (!n.has_value()) break;
+                elem.children.push_back(*n);
+            }
+
+            context = prevContext;
+
+            if (elem.children.empty()) {
+                throw std::runtime_error("expecting expression in parens");
+            }
+            node.children.push_back(elem.children.back());
+
+            auto sep = peek();
+            if (!sep.has_value()) {
+                throw std::runtime_error("unclosed parens");
+            }
+            if (sep->type == TT::Comma) {
+                consume();
+            } else if (sep->type != TT::CloseParen) {
+                throw std::runtime_error("expecting comma between expressions in parens");
+            }
+        }
+
+        return node;
+    }
+
     Node Parser::parseLiteral() {
         auto current = peek(-1);
         if (!current.has_value()) {
@@ -190,14 +247,15 @@ namespace Solstice {
                 return Precedence::Root;
             case NodeType::Literal:
             case NodeType::Identifier:
+            case NodeType::Lambda:
+            case NodeType::FunctionCall:
+            case NodeType::Expression:
+            case NodeType::Tuple:
                 return Precedence::Identifier;
             case NodeType::FunctionBind:
             case NodeType::Bind:
             case NodeType::Set:
                 return Precedence::Set;
-            case NodeType::Lambda:
-            case NodeType::FunctionCall:
-                return Precedence::Identifier;
             case NodeType::Add:
             case NodeType::Subtract:
                 return Precedence::Add;
@@ -214,42 +272,6 @@ namespace Solstice {
     }
 
     Precedence Parser::getTokenPrecedence(const Token& token) {
-        switch (token.type) {
-            case TT::OpenCurly: {
-                braceCount++;
-                return Precedence::Other;
-            }
-            case TT::CloseCurly: {
-                braceCount--;
-                return Precedence::Other;
-            }
-            case TT::OpenSpiky: {
-                spikyBracketCount++;
-                return Precedence::Other;
-            }
-            case TT::CloseSpiky: {
-                spikyBracketCount--;
-                return Precedence::Other;
-            }
-            case TT::OpenParen: {
-                bracketCount++;
-                return Precedence::Other;
-            }
-            case TT::CloseParen: {
-                bracketCount--;
-                return Precedence::Other;
-            }
-            default: break;
-        }
-        if (braceCount > 0) {
-            return Precedence::Other;
-        }
-        if (bracketCount > 0) {
-            return Precedence::Other;
-        }
-        if (spikyBracketCount > 0) {
-            return Precedence::Other;
-        }
         switch (token.type) {
             case TT::None:
             case TT::Kw_Type:
@@ -298,6 +320,16 @@ namespace Solstice {
             case TT::Math_Multiply:
             case TT::Math_Divide:
                 return parseExpr(next->type);
+            case TT::OpenParen:
+                return parseOpenParen();
+
+            // stuff that causes errors 
+            case TT::CloseParen:
+                throw std::runtime_error("Extra closing paren");
+            case TT::CloseSpiky:
+                throw std::runtime_error("Extra closing angle bracket");
+            case TT::CloseCurly:
+                throw std::runtime_error("Extra closing curly brace");
         }
         throw std::runtime_error("FIXME: unimplemented parsing case");
     }