update bindingssterkte

diff --git a/src/grammar.txt b/src/grammar.txt
index ca25bb0..697cca2 100644 (file)
--- a/src/grammar.txt
+++ b/src/grammar.txt
@@ -1,14 +1,25 @@
-<Expr>    ::= <id> ['hd'|'tl'|'fst'|'snd] <Expr`>
-                 | <Op1> <Expr> <Expr`>
-                 | <int> <Expr`>
-                 | <char> <Expr`>
-                 | 'False' <Expr`>
-                 | 'True' <Expr`>
-                 | '(' <Expr> ')' <Expr`>
-                 | <id> '(' [<ActArgs>] ')' <Expr`>
-                 | '[]' <Expr> <Expr`>
-                 | '(' <Expr> ',' <Expr> ')' <Expr`>
-<Expr`>   ::= <Op2> <Expr> <Expr`> | e
+<Expr>    ::= <ExprWithoutOp> <ExprMaybeOp>
+
+
+<ExprMaybeOp> ::= '+' <Expr>
+
+<ModExpr>      ::= <PlusMinExpr> ['%' <ModExpr>]
+
+<PlusMinExpr>  ::= <TimesDivExpr> [('+' | '-') <PlusMinExpr>]
+
+<TimesDivExpr> ::= <BasicExpr> ['*' | '/' | '%'] <TimesDivExpr>]
+
+<BasicExpr>    ::= <id> ['hd'|'tl'|'fst'|'snd]
+                      | <Op1> <Expr>
+                      | <int>
+                      | <char>
+                      | 'False'
+                      | 'True'
+                      | '(' <Expr> ')'
+                      | <id> '(' [<ActArgs>] ')'
+                      | '[]' <Expr>
+                      | '(' <Expr> ',' <Expr> ')'
+
 <Op2>     ::= '+' | '-' | '*' | '/' | '%' | '==' | '<' | '>' | '<=' | '>='
           |    '!=' | '&&' | '||' | ':'
 

diff --git a/src/parse.icl b/src/parse.icl
index 620e39a..355ed6a 100644 (file)
--- a/src/parse.icl
+++ b/src/parse.icl
@@ -45,45 +45,101 @@ parseType =
        empty
 
 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
+parseExpr = parseOps (trans1 ColonToken BiCons) parseBinOrExpr 
+       where
+               //Dit generaliseert het onderstaande, ik moet het nog even in elkaar
+               //sleutelen. Dan werkt bindingssterkte, associativiteit moet nog
+               // Wat je hier boven ziet wordt dan een cascade van operators met op
+               // het einde de parseBasicExpr. In volgorde van bindingssterkte, de
+               // zwaktste eerst...
+               parseOps :: (Parser Token Op2) (Parser Token Expr) -> Parser Token Expr
+               parseOps ops prev = prev >>= \e1->optional (
+                               ops >>= \op->parseOps ops prev >>= \e->pure (op, e)
+                       ) >>= \moe-> pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+
+               parseBinOrExpr :: Parser Token Expr
+               parseBinOrExpr =
+                       parseBinAndExpr >>= \e1-> optional (
+                               trans1 PipesToken BiOr
+                               >>= \op->parseBinOrExpr >>= \e->pure (op, e))
+                       >>= \moe->pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+
+               parseBinAndExpr :: Parser Token Expr
+               parseBinAndExpr =
+                       parseCompareExpr >>= \e1-> optional (
+                               trans1 AmpersandsToken BiAnd
+                               >>= \op->parseBinAndExpr >>= \e->pure (op, e))
+                       >>= \moe->pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+       
+               parseCompareExpr :: Parser Token Expr
+               parseCompareExpr =
+                       parsePlusMinusExpr >>= \e1-> optional (
+                               (       trans1 EqualsToken BiEquals <|>
+                                       trans1 LesserToken BiLesser <|>
+                                       trans1 BiggerToken BiGreater <|>
+                                       trans1 LesserEqToken BiLesserEq <|>
+                                       trans1 GreaterEqToken BiGreaterEq <|>
+                                       trans1 NotEqualToken BiUnEqual
+                               ) >>= \op->parseCompareExpr >>= \e->pure (op, e))
+                       >>= \moe->pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+
+               parsePlusMinusExpr :: Parser Token Expr
+               parsePlusMinusExpr =
+                       parseTimesDivExpr >>= \e1-> optional (
+                               (       trans1 PlusToken BiPlus <|>
+                                       trans1 DashToken BiMinus
+                               ) >>= \op->parsePlusMinusExpr >>= \e->pure (op, e))
+                       >>= \moe->pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+
+               parseTimesDivExpr :: Parser Token Expr
+               parseTimesDivExpr =
+                       parseBasicExpr >>= \e1->optional (
+                               (       trans1 StarToken BiTimes <|>
+                                       trans1 SlashToken BiDivide <|>
+                                       trans1 PercentToken BiMod 
+                               ) >>= \op->parseTimesDivExpr >>= \e->pure (op, e))
+                       >>= \moe-> pure case moe of
+                               Nothing = e1
+                               (Just (op, e2)) = Op2Expr e1 op e2
+
+               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 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)
 
 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)) <|>