ASSOCIATIVITY, DO WE EVER PARSE IT??????!!!!111!one!111eleven

[cc1516.git] / src / parse.icl

diff --git a/src/parse.icl b/src/parse.icl
index 620e39a..800d3ed 100644 (file)
--- a/src/parse.icl
+++ b/src/parse.icl
@@ -22,7 +22,11 @@ parser (Right r) = case runParser parseProgram r of
        (Left e, _) = Left $ toString e
 
 parseProgram :: Parser Token AST
-parseProgram = parseVarDecl >>= \t.pure $ AST [t] []
+parseProgram = some parseVarDecl 
+       >>= \vd->pure $ AST vd []
+
+parseFunDecl :: Parser Token FunDecl
+parseFunDecl = empty
 
 parseVarDecl :: Parser Token VarDecl
 parseVarDecl = 
@@ -46,44 +50,60 @@ parseType =
 
 parseExpr :: Parser Token Expr
 parseExpr = 
-       (satTok BraceOpenToken *> parseExpr <* satTok BraceCloseToken) <|>
-       (satTok BraceOpenToken *> parseExpr <* satTok CommaToken 
-               >>= \e1->parseExpr <* satTok BraceCloseToken 
-               >>= \e2->pure $ TupleExpr e1 e2) <|>
-       trans1 EmptyListToken EmptyListExpr <|>
-       trans2 TrueToken (const $ BoolExpr True) <|>
-       trans2 FalseToken (const $ BoolExpr True) <|>
-       trans2 (NumberToken zero) (\(NumberToken i)->IntExpr i) <|>
-       trans2 (CharToken zero) (\(CharToken c)->CharExpr c) <|>
-       (parseOp1 >>= \o->parseExpr >>= \e.pure $ Op1Expr o e) <|>
-       (parseIdent <* satTok BraceOpenToken 
-               >>= \i->parseActArgs <* satTok BraceCloseToken
-               >>= \es->pure $ FunExpr i es) <|>
-       (parseIdent >>= \i. parseFieldSelector >>= \f.pure $ VarExpr i f)
-       //TODO Parse Binary operators
+       parseOpRight (trans1 ColonToken BiCons) $
+       parseOpRight (trans1 PipesToken BiOr) $
+       parseOpRight (trans1 AmpersandsToken BiAnd) $
+       parseOpRight (trans1 EqualsToken BiEquals <|>
+                       trans1 LesserToken BiLesser <|>
+                       trans1 BiggerToken BiGreater <|>
+                       trans1 LesserEqToken BiLesserEq <|>
+                       trans1 GreaterEqToken BiGreaterEq <|>
+                       trans1 NotEqualToken BiUnEqual) $
+       parseOpLeft (trans1 PlusToken BiPlus <|>
+                       trans1 DashToken BiMinus) $
+       parseOpLeft (trans1 StarToken BiTimes <|>
+                       trans1 SlashToken BiDivide <|>
+                       trans1 PercentToken BiMod) $
+               parseBasicExpr
+       where
+               parseOpRight :: (Parser Token Op2) (Parser Token Expr) -> Parser Token Expr
+               parseOpRight ops prev = prev >>= \e1->optional (
+                               ops >>= \op->parseOpRight ops prev >>= \e->pure (op, e)
+                       ) >>= \moe->pure $ maybe e1 (\(op,e2)->Op2Expr e1 op e2) moe
+
+               parseOpLeft :: (Parser Token Op2) (Parser Token Expr) -> Parser Token Expr
+               parseOpLeft ops prev = prev >>= \e1->many (
+                               ops >>= \op->prev >>= \e->pure (op, e)
+                       ) >>= \moe->foldM (\e->(\(op,e2)->pure $ Op2Expr e op e2)) e1 moe
+
+               parseBasicExpr :: Parser Token Expr
+               parseBasicExpr = 
+                       (satTok BraceOpenToken *> parseExpr <* satTok BraceCloseToken) <|>
+                       (satTok BraceOpenToken *> parseExpr <* satTok CommaToken 
+                               >>= \e1->parseExpr <* satTok BraceCloseToken 
+                               >>= \e2->pure $ TupleExpr e1 e2) <|>
+                       trans1 EmptyListToken EmptyListExpr <|>
+                       trans2 TrueToken (const $ BoolExpr True) <|>
+                       trans2 FalseToken (const $ BoolExpr False) <|>
+                       trans2 (NumberToken zero) (\(NumberToken i)->IntExpr i) <|>
+                       trans2 (CharToken zero) (\(CharToken c)->CharExpr c) <|>
+                       (parseOp1 >>= \o->parseExpr >>= \e.pure $ Op1Expr o e) <|>
+                       (parseIdent <* satTok BraceOpenToken 
+                               >>= \i->parseActArgs <* satTok BraceCloseToken
+                               >>= \es->pure $ FunExpr i es) <|>
+                       (parseIdent >>= \i. parseFieldSelector >>= \f.pure $ VarExpr i f)
 
 parseActArgs :: Parser Token [Expr]
 parseActArgs = 
-       //One argument
-       (some (parseExpr <* satTok CommaToken) >>= \es->parseExpr >>= \e.pure [e:es]) <|>
-       //Two or more arguments
+       (some (parseExpr <* satTok CommaToken) >>= \es->parseExpr 
+               >>= \e.pure [e:es]) <|>
        (parseExpr >>= \e->pure [e]) <|>
-       //Zero arguments, dit moet nog mooier kunnen
        empty
 
 parseOp1 :: Parser Token Op1
 parseOp1 = trans1 DashToken UnMinus <|> 
        trans1 ExclamationToken UnNegation
 
-parseOp2 :: Parser Token Op2
-parseOp2 = trans1 StarToken BiTimes <|> trans1 SlashToken BiDivide <|>
-       trans1 PercentToken BiMod <|> trans1 EqualsToken BiEquals <|>
-       trans1 LesserToken BiLesser <|> trans1 BiggerToken BiGreater <|>
-       trans1 LesserEqToken BiLesserEq <|> trans1 PlusToken BiPlus <|>
-       trans1 GreaterEqToken BiGreaterEq <|> trans1 DashToken BiMinus <|>
-       trans1 NotEqualToken BiUnEqual <|> trans1 AmpersandsToken BiAnd <|>
-       trans1 PipesToken BiOr <|> trans1 ColonToken BiCons
-
 parseFieldSelector :: Parser Token (Maybe FieldSelector)
 parseFieldSelector = optional (satTok DotToken *> (
        (parseIdent >>= (\i.if (i == "hd") (pure FieldHd) empty)) <|>