{-# LANGUAGE Safe #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Text.Parsec.Language
-- Copyright   :  (c) Daan Leijen 1999-2001, (c) Paolo Martini 2007
-- License     :  BSD-style (see the LICENSE file)
--
-- Maintainer  :  derek.a.elkins@gmail.com
-- Stability   :  provisional
-- Portability :  non-portable (uses non-portable module Text.Parsec.Token)
--
-- A helper module that defines some language definitions that can be used
-- to instantiate a token parser (see "Text.Parsec.Token").
--
-----------------------------------------------------------------------------

module Text.Parsec.Language
    ( haskellDef, haskell
    , mondrianDef, mondrian
    , emptyDef
    , haskellStyle
    , javaStyle
    , LanguageDef
    , GenLanguageDef
    ) where

import Text.Parsec
import Text.Parsec.Token

-----------------------------------------------------------
-- Styles: haskellStyle, javaStyle
-----------------------------------------------------------

-- | This is a minimal token definition for Haskell style languages. It
-- defines the style of comments, valid identifiers and case
-- sensitivity. It does not define any reserved words or operators.

haskellStyle :: LanguageDef st
haskellStyle :: LanguageDef st
haskellStyle = LanguageDef Any
forall st. LanguageDef st
emptyDef
                { commentStart :: String
commentStart   = "{-"
                , commentEnd :: String
commentEnd     = "-}"
                , commentLine :: String
commentLine    = "--"
                , nestedComments :: Bool
nestedComments = Bool
True
                , identStart :: ParsecT String st Identity Char
identStart     = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
                , identLetter :: ParsecT String st Identity Char
identLetter    = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum ParsecT String st Identity Char
-> ParsecT String st Identity Char
-> ParsecT String st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf "_'"
                , opStart :: ParsecT String st Identity Char
opStart        = LanguageDef st -> ParsecT String st Identity Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opLetter LanguageDef st
forall st. LanguageDef st
haskellStyle
                , opLetter :: ParsecT String st Identity Char
opLetter       = String -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf ":!#$%&*+./<=>?@\\^|-~"
                , reservedOpNames :: [String]
reservedOpNames= []
                , reservedNames :: [String]
reservedNames  = []
                , caseSensitive :: Bool
caseSensitive  = Bool
True
                }

-- | This is a minimal token definition for Java style languages. It
-- defines the style of comments, valid identifiers and case
-- sensitivity. It does not define any reserved words or operators.

javaStyle  :: LanguageDef st
javaStyle :: LanguageDef st
javaStyle   = LanguageDef st
forall st. LanguageDef st
emptyDef
                { commentStart :: String
commentStart   = "/*"
                , commentEnd :: String
commentEnd     = "*/"
                , commentLine :: String
commentLine    = "//"
                , nestedComments :: Bool
nestedComments = Bool
True
                , identStart :: ParsecT String st Identity Char
identStart     = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter
                , identLetter :: ParsecT String st Identity Char
identLetter    = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum ParsecT String st Identity Char
-> ParsecT String st Identity Char
-> ParsecT String st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf "_'"
                , reservedNames :: [String]
reservedNames  = []
                , reservedOpNames :: [String]
reservedOpNames= []
                , caseSensitive :: Bool
caseSensitive  = Bool
False
                }

-----------------------------------------------------------
-- minimal language definition
--------------------------------------------------------

-- | This is the most minimal token definition. It is recommended to use
-- this definition as the basis for other definitions. @emptyDef@ has
-- no reserved names or operators, is case sensitive and doesn't accept
-- comments, identifiers or operators.

emptyDef   :: LanguageDef st
emptyDef :: LanguageDef st
emptyDef    = LanguageDef :: forall s u (m :: * -> *).
String
-> String
-> String
-> Bool
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m Char
-> [String]
-> [String]
-> Bool
-> GenLanguageDef s u m
LanguageDef
               { commentStart :: String
commentStart   = ""
               , commentEnd :: String
commentEnd     = ""
               , commentLine :: String
commentLine    = ""
               , nestedComments :: Bool
nestedComments = Bool
True
               , identStart :: ParsecT String st Identity Char
identStart     = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
letter ParsecT String st Identity Char
-> ParsecT String st Identity Char
-> ParsecT String st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Char -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '_'
               , identLetter :: ParsecT String st Identity Char
identLetter    = ParsecT String st Identity Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
alphaNum ParsecT String st Identity Char
-> ParsecT String st Identity Char
-> ParsecT String st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf "_'"
               , opStart :: ParsecT String st Identity Char
opStart        = LanguageDef st -> ParsecT String st Identity Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opLetter LanguageDef st
forall st. LanguageDef st
emptyDef
               , opLetter :: ParsecT String st Identity Char
opLetter       = String -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf ":!#$%&*+./<=>?@\\^|-~"
               , reservedOpNames :: [String]
reservedOpNames= []
               , reservedNames :: [String]
reservedNames  = []
               , caseSensitive :: Bool
caseSensitive  = Bool
True
               }



-----------------------------------------------------------
-- Haskell
-----------------------------------------------------------

-- | A lexer for the haskell language.

haskell :: TokenParser st
haskell :: TokenParser st
haskell      = GenLanguageDef String st Identity -> TokenParser st
forall s (m :: * -> *) u.
Stream s m Char =>
GenLanguageDef s u m -> GenTokenParser s u m
makeTokenParser GenLanguageDef String st Identity
forall st. LanguageDef st
haskellDef

-- | The language definition for the Haskell language.

haskellDef  :: LanguageDef st
haskellDef :: LanguageDef st
haskellDef   = LanguageDef st
forall st. LanguageDef st
haskell98Def
                { identLetter :: ParsecT String st Identity Char
identLetter    = LanguageDef st -> ParsecT String st Identity Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identLetter LanguageDef st
forall st. LanguageDef st
haskell98Def ParsecT String st Identity Char
-> ParsecT String st Identity Char
-> ParsecT String st Identity Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Char -> ParsecT String st Identity Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char '#'
                , reservedNames :: [String]
reservedNames  = LanguageDef Any -> [String]
forall s u (m :: * -> *). GenLanguageDef s u m -> [String]
reservedNames LanguageDef Any
forall st. LanguageDef st
haskell98Def [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++
                                   ["foreign","import","export","primitive"
                                   ,"_ccall_","_casm_"
                                   ,"forall"
                                   ]
                }

-- | The language definition for the language Haskell98.

haskell98Def :: LanguageDef st
haskell98Def :: LanguageDef st
haskell98Def = LanguageDef st
forall st. LanguageDef st
haskellStyle
                { reservedOpNames :: [String]
reservedOpNames= ["::","..","=","\\","|","<-","->","@","~","=>"]
                , reservedNames :: [String]
reservedNames  = ["let","in","case","of","if","then","else",
                                    "data","type",
                                    "class","default","deriving","do","import",
                                    "infix","infixl","infixr","instance","module",
                                    "newtype","where",
                                    "primitive"
                                    -- "as","qualified","hiding"
                                   ]
                }


-----------------------------------------------------------
-- Mondrian
-----------------------------------------------------------

-- | A lexer for the mondrian language.

mondrian :: TokenParser st
mondrian :: TokenParser st
mondrian    = GenLanguageDef String st Identity -> TokenParser st
forall s (m :: * -> *) u.
Stream s m Char =>
GenLanguageDef s u m -> GenTokenParser s u m
makeTokenParser GenLanguageDef String st Identity
forall st. LanguageDef st
mondrianDef

-- | The language definition for the language Mondrian.

mondrianDef :: LanguageDef st
mondrianDef :: LanguageDef st
mondrianDef = LanguageDef st
forall st. LanguageDef st
javaStyle
                { reservedNames :: [String]
reservedNames = [ "case", "class", "default", "extends"
                                  , "import", "in", "let", "new", "of", "package"
                                  ]
                , caseSensitive :: Bool
caseSensitive  = Bool
True
                }