lexer iets aangepaste, we parsen geen negatieve ints meer, nu zien we het gewoon...

diff --git a/src/lex.icl b/src/lex.icl
index b6e56d5..99aa37c 100644 (file)
--- a/src/lex.icl
+++ b/src/lex.icl
@@ -15,7 +15,7 @@ SingleCharTokens = fromList [
        (',', CommaToken), (':', ColonToken), (';', SColonToken),
        ('.', DotToken), ('+', PlusToken), ('*', StarToken), ('/', SlashToken),
        ('%', PercentToken), ('=', AssignmentToken), ('<', LesserToken),
-       ('>', BiggerToken), ('!', ExclamationToken)]
+       ('>', BiggerToken), ('!', ExclamationToken), ('-', DashToken)]
 
 EscapeMap :: Map Char Char
 EscapeMap = fromList [('a', toChar 7), ('b', '\b'), ('f', '\f'), ('n', '\n'),
@@ -65,10 +65,6 @@ lex ['\'':x:'\'':xs] = ret (CharToken x) xs
 lex ['\'':'\\':x:'\'':xs] = case get x EscapeMap of
        Just t = ret (CharToken t) xs
        _ = err ("Unknown escape: \\" +++ toString x)
-lex ['-':t=:[x:xs]]
-| isDigit x = let (n, r) = span isDigit t in
-       ret (NumberToken (toInt $ toString ['-':n])) r
-| otherwise = ret DashToken t 
 lex t=:[x:xs] = case get x SingleCharTokens of
        (Just tok) = ret tok xs
        Nothing

diff --git a/src/parse.icl b/src/parse.icl
index 355ed6a..75eed41 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->some parseFunDecl >>= \fd->pure $ AST vd fd
+
+parseFunDecl :: Parser Token FunDecl
+parseFunDecl = empty
 
 parseVarDecl :: Parser Token VarDecl
 parseVarDecl = 
@@ -45,13 +49,23 @@ parseType =
        empty
 
 parseExpr :: Parser Token Expr
-parseExpr = parseOps (trans1 ColonToken BiCons) parseBinOrExpr 
+parseExpr = 
+       parseOps (trans1 ColonToken BiCons) $
+       parseOps (trans1 PipesToken BiOr) $
+       parseOps (trans1 AmpersandsToken BiAnd) $
+       parseOps (trans1 EqualsToken BiEquals <|>
+                       trans1 LesserToken BiLesser <|>
+                       trans1 BiggerToken BiGreater <|>
+                       trans1 LesserEqToken BiLesserEq <|>
+                       trans1 GreaterEqToken BiGreaterEq <|>
+                       trans1 NotEqualToken BiUnEqual) $
+       parseOps (trans1 PlusToken BiPlus <|>
+                       trans1 DashToken BiMinus) $
+       parseOps (trans1 StarToken BiTimes <|>
+                       trans1 SlashToken BiDivide <|>
+                       trans1 PercentToken BiMod) $
+               parseBasicExpr
        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)
@@ -59,59 +73,6 @@ parseExpr = parseOps (trans1 ColonToken BiCons) parseBinOrExpr
                                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) <|>