{-# LANGUAGE NoMonomorphismRestriction #-}
module Data.String.Ubc.Parse.Language
( languageDef
, Data.String.Ubc.Parse.Language.identifier         
, Data.String.Ubc.Parse.Language.reserved           
, Data.String.Ubc.Parse.Language.operator           
, Data.String.Ubc.Parse.Language.reservedOperator   
, Data.String.Ubc.Parse.Language.characterLiteral   
, Data.String.Ubc.Parse.Language.stringLiteral      
, Data.String.Ubc.Parse.Language.natural            
, Data.String.Ubc.Parse.Language.integer            
, Data.String.Ubc.Parse.Language.float              
, Data.String.Ubc.Parse.Language.naturalOrFloat     
, Data.String.Ubc.Parse.Language.decimal            
, Data.String.Ubc.Parse.Language.hexadecimal        
, Data.String.Ubc.Parse.Language.octal              
, Data.String.Ubc.Parse.Language.symbol             
, Data.String.Ubc.Parse.Language.lexeme             
, Data.String.Ubc.Parse.Language.whiteSpace         
, Data.String.Ubc.Parse.Language.parens             
, Data.String.Ubc.Parse.Language.braces             
, Data.String.Ubc.Parse.Language.angles             
, Data.String.Ubc.Parse.Language.brackets           
, Data.String.Ubc.Parse.Language.semicolon          
, Data.String.Ubc.Parse.Language.comma              
, Data.String.Ubc.Parse.Language.colon              
, Data.String.Ubc.Parse.Language.dot                
, Data.String.Ubc.Parse.Language.semicolonSeparated 
, Data.String.Ubc.Parse.Language.semicolonSeparated1
, Data.String.Ubc.Parse.Language.commaSeparated     
, Data.String.Ubc.Parse.Language.commaSeparated1    
)
where

import Text.Parsec
import Text.Parsec.Token

languageDef :: Monad m => GenLanguageDef String u m
languageDef = LanguageDef {
          commentStart = "/*"
        , commentEnd = "*/"
        , commentLine = "//"
        , nestedComments = True
        , identStart = letter <|> char '_'
        , identLetter = alphaNum <|> char '_'
        , opStart = oneOf "+-*/"
        , opLetter = oneOf "+-*/"
        , reservedNames = [ "struct", "u32", "i32", "f32" ]
        , reservedOpNames = [ "+", "-", "*", "/" ]
        , caseSensitive = True
        }

tokenParser :: Monad m => GenTokenParser String u m
tokenParser = makeTokenParser languageDef

identifier              :: Monad m => ParsecT String u m String
reserved                :: Monad m => String -> ParsecT String u m ()
operator                :: Monad m => ParsecT String u m String
reservedOperator        :: Monad m => String -> ParsecT String u m ()
characterLiteral        :: Monad m => ParsecT String u m Char
stringLiteral           :: Monad m => ParsecT String u m String
natural                 :: Monad m => ParsecT String u m Integer
integer                 :: Monad m => ParsecT String u m Integer
float                   :: Monad m => ParsecT String u m Double
naturalOrFloat          :: Monad m => ParsecT String u m (Either Integer Double)
decimal                 :: Monad m => ParsecT String u m Integer
hexadecimal             :: Monad m => ParsecT String u m Integer
octal                   :: Monad m => ParsecT String u m Integer
symbol                  :: Monad m => String -> ParsecT String u m String
lexeme                  :: Monad m => ParsecT String u m a -> ParsecT String u m a
whiteSpace              :: Monad m => ParsecT String u m ()
parens                  :: Monad m => ParsecT String u m a -> ParsecT String u m a
braces                  :: Monad m => ParsecT String u m a -> ParsecT String u m a
angles                  :: Monad m => ParsecT String u m a -> ParsecT String u m a
brackets                :: Monad m => ParsecT String u m a -> ParsecT String u m a
semicolon               :: Monad m => ParsecT String u m String
comma                   :: Monad m => ParsecT String u m String
colon                   :: Monad m => ParsecT String u m String
dot                     :: Monad m => ParsecT String u m String
semicolonSeparated      :: Monad m => ParsecT String u m a -> ParsecT String u m [a]
semicolonSeparated1     :: Monad m => ParsecT String u m a -> ParsecT String u m [a]
commaSeparated          :: Monad m => ParsecT String u m a -> ParsecT String u m [a]
commaSeparated1         :: Monad m => ParsecT String u m a -> ParsecT String u m [a]
TokenParser{
          identifier            = identifier
        , reserved              = reserved
        , operator              = operator
        , reservedOp            = reservedOperator
        , charLiteral           = characterLiteral
        , stringLiteral         = stringLiteral
        , natural               = natural -- decimal, hexadecimal or octal
        , integer               = integer -- decimal, hexadecimal or octal
        , float                 = float
        , naturalOrFloat        = naturalOrFloat
        , decimal               = decimal
        , hexadecimal           = hexadecimal
        , octal                 = octal
        , symbol                = symbol
        , lexeme                = lexeme
        , whiteSpace            = whiteSpace
        , parens                = parens
        , braces                = braces
        , angles                = angles
        , brackets              = brackets
        , semi                  = semicolon
        , comma                 = comma
        , colon                 = colon
        , dot                   = dot
        , semiSep               = semicolonSeparated
        , semiSep1              = semicolonSeparated1
        , commaSep              = commaSeparated
        , commaSep1             = commaSeparated1
        } = tokenParser