module VarParser where {

import Text.ParserCombinators.Parsec;
import Text.ParserCombinators.Parsec.Expr;
import Token;
import VarType;

parseExpr = buildExpressionParser table parseFactor <?> "expression";

table = [
         [ Infix (do { reservedOp "*"; return Mult }) AssocLeft],
         [ Infix (do { reservedOp "+"; return Add }) AssocLeft]
        ];

parseFactor = parens parseExpr
              <|>
              (do { t <- naturalOrFloat;
                    return (case t of { Left i -> Const (Num (fromInteger i));
                                        Right d -> Const (Num d) }) })
              <|>
              (do { t <- identifier; return (Var t) })
              <|>
              (do { reserved "let";
--                  decls <- parseDecls; 
                    decl <- parseDecl;
                    reserved "in";
                    expr  <- parseExpr;
--                  return (Let decls expr)
                    return (Let decl expr)
                  })
;

parseDecl = do {
                i <- identifier;
                reservedOp "=";
                e <- parseExpr;
                return (i, e)
               };

parseDecls = sepBy1 parseDecl semi;

myParse :: String -> Expr;
myParse str = case
                (parse (do {whiteSpace; s<- parseExpr; eof; return s }) "" str)
              of {
                Left err -> Const (Num (1/0));
                Right x  -> x
              };
}