Added Grammar Description and Parser functions

Author: vijayphoenix

src/AST.hs

@@ -33,7 +33,7 @@ module AST (
 -- Call : Name ( [Args] ) 
 
 -- Op : + | - | * | / 
--- Args : Name[, Args]
+-- Args : Expr[, Args]
 
 -- LiteralStmt : StrLiteral  | IntLiteral 
 -- IntLiteral  : integer
@@ -42,6 +42,17 @@ module AST (
 -- Name : ident
 -- ArgList : Type Name[, ArgList]
 
+data Module 
+    = Command Expr 
+    | Method  Func 
+
+data Func 
+    = Func {
+        fname :: Name ,
+        argList:: ArgList,
+        retType:: Type ,
+        body   :: [Expr]
+    }
 
 data Expr
     = DeclarationStmt   Declaration
@@ -58,13 +69,13 @@ data Op
     deriving (Show)
 
 data Type 
-    = Int 
-    | String 
+    = IntC 
+    | StringC 
     deriving (Show)
 
 data Literal 
     = StrLiteral String
-    | IntLiteral Int
+    | IntLiteral Integer
     deriving (Show)
 
 
@@ -77,7 +88,8 @@ type Args = [Expr]
 data Declaration
     = ExternDecl {
         efName :: Name ,
-        efArgsList :: ArgList
+        efArgsList :: ArgList,
+        retT :: Type
     }
     | VarDecl { 
         vType :: Type, 
@@ -93,7 +105,7 @@ data FuncCall
     }
     | BinOpCall {
         op     :: Op ,
-        lhs    :: Expr ,
+        lhs    :: Expr,
         rhs    :: Expr
     }
     deriving (Show)
@@ -127,16 +139,16 @@ argsPrint = show
 showExpr :: Expr -> String
 showExpr = show
 
-externDeclPrint (ExternDecl f a) = "extern " ++ f ++ " -> " ++ (argListPrint a)
+externDeclPrint (ExternDecl f a _) = "extern " ++ f ++ " -> " ++ (argListPrint a)
 varDeclPrint (VarDecl t l) = (show t) ++ " " ++ (vListPrint l)
 
 
 callPrint (Call c a) = "call " ++ (show c) ++ " -> " ++ (argsPrint a)
 binOpCallPrint (BinOpCall op l r) = (show op) ++ " -> " ++ (showExpr l) ++ " " ++ (showExpr r)
 
 -- Tests
-externDecl  = ExternDecl "sin" [(Int, "arg1")]
-varDecl     = VarDecl String ["arg1", "arg2"]
+externDecl  = ExternDecl "sin" [(IntC, "arg1")]
+varDecl     = VarDecl StringC ["arg1", "arg2"]
 literal     = StrLiteral "adf"
 literalStmt = LiteralStmt literal
 call        = Call "func" [literalStmt]

src/Language.hs

@@ -29,6 +29,6 @@ haskullstyle = emptyDef {
 -- | The language definition for the Haskull language.
 haskulldef = haskullstyle { 
     reservedOpNames   = ["+", "/", "-", "*", ";"], 
-    reservedNames     = ["int", "char", "def", "extern"]
+    reservedNames     = ["int", "char", "def", "extern", "string"]
 }
 

src/Parser.hs

@@ -2,5 +2,154 @@ module Parser where
 
 import Lexer 
 import Text.Parsec.String (Parser)
+import Text.Parsec.Combinator
+import Text.Parsec.Char
+import Text.Parsec
+import AST 
 
-import AST
+-- literalParser :: Type -> Parser Literal 
+-- literalParser IntC = do 
+--     val <- integer
+--     return (IntLiteral val)
+-- literalParser StringC = do 
+--     val <- stringLiteral
+--     return (StrLiteral val)
+
+-- strP = literalParser StringC
+
+-- topParser :: Parser Module
+-- topParser = commandParser <|> funcParser
+
+-- commandParser :: Parser Module 
+-- commandParser = do 
+--     spaces
+--     exp <- exprParser
+--     char ';'
+--     spaces
+--     return $ Command exp
+
+exprParser :: Parser Expr
+exprParser = literalStmtParser
+        -- <|> funcCallParser
+        -- <|> literalParser 
+        -- <|> parens exprParser
+
+-- declStmtParser :: Parser Expr 
+-- declStmtParser = do
+--     decl <- declParser
+--     return $ DeclarationStmt decl
+
+-- declParser :: Parser Declaration
+-- declParser = externDeclParser <|> varDeclParser
+
+-- externDeclParser :: Parser Declaration
+-- externDeclParser = do
+--     spaces
+--     string "extern"
+--     name <- nameParser
+--     argList <- argListParser
+--     ret <- typeParser
+--     spaces
+--     return $ ExternDecl name argList ret 
+
+-- varDeclParser :: Parser Declaration
+-- varDeclParser = do 
+--     spaces
+--     type <- typeParser
+--     nameList <- vListParser
+--     spaces
+--     return $ VarDecl type nameList
+
+
+-- | Parsing type related stuffs. ----
+-- NSS
+typeParser :: Parser Type 
+typeParser = intTParser <|> stringTParser
+
+-- NSS
+intTParser = do 
+    reserved "int"
+    spaces
+    return IntC
+
+-- NSS
+stringTParser = do
+    reserved "string"
+    spaces
+    return StringC
+-------------------------------------
+
+-- | Variable Names and identifier -----
+-- NSS
+nameParser :: Parser Name 
+nameParser = ident
+----------------------------------------
+
+-- | VList: Name[, VList] -----------------
+-- NSS
+vListParser :: Parser VList 
+vListParser = nameParser `sepBy1` (spaces >> (char ',') >> spaces)
+-------------------------------------------
+
+-- ArgList : Type Name[, ArgList] ----------
+-- NSS
+argListParer :: Parser ArgList
+argListParer = unit `sepBy1` (spaces >> (char ',') >> spaces)
+    where unit = do
+                tp    <- typeParser
+                name  <- nameParser
+                return (tp, name)
+---------------------------------------------
+
+-- | Args : Expr[, Args]
+-- NSS
+argsParser :: Parser Args 
+argsParser = exprParser `sepBy1` (spaces >> (char ',') >> spaces)
+-----------------------------------------------
+
+-- delim :: Parser ()
+-- delim p = (spaces >> (char p) >> spaces)
+
+---------------------------------------------------
+-- | LiteralStmt : StrLiteral  | IntLiteral 
+-- NSS
+literalStmtParser :: Parser Expr 
+literalStmtParser = do
+    res <- literalParser
+    return $ LiteralStmt res
+-- NSS
+literalParser :: Parser Literal 
+literalParser = strLiteralP <|> intLiteralP
+-- NSS
+strLiteralP :: Parser Literal 
+strLiteralP = do 
+    res <- stringLiteral
+    return (StrLiteral res)
+-- NSS
+intLiteralP :: Parser Literal 
+intLiteralP = do
+    res <- integer
+    return (IntLiteral res)
+-----------------------------------------------------
+
+-- funcCallParser :: Parser 
+
+mainTest = do
+    str <- getLine
+    if str == "quit"
+    then 
+        return ()
+    else do
+        print (parse argListParer "sdf" str)
+        mainTest
+
+
+
+-- --------------Done
+-- Type
+-- Literal 
+-- Name 
+-- VList 
+-- ArgList
+-- Args
+-- LiteralStmt