{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE PolymorphicComponents #-}
{-# LANGUAGE Safe #-}

-----------------------------------------------------------------------------
-- |
-- Module      :  Text.Parsec.Token
-- 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 local universal quantification: PolymorphicComponents)
--
-- A helper module to parse lexical elements (tokens). See 'makeTokenParser'
-- for a description of how to use it.
--
-----------------------------------------------------------------------------

{-# OPTIONS_GHC -fno-warn-name-shadowing #-}

module Text.Parsec.Token
    ( LanguageDef
    , GenLanguageDef (..)
    , TokenParser
    , GenTokenParser (..)
    , makeTokenParser
    ) where

import Data.Char ( isAlpha, toLower, toUpper, isSpace, digitToInt )
#if MIN_VERSION_base(4,7,0)
import Data.Typeable ( Typeable )
#endif
import Data.List ( nub, sort )
import Control.Monad.Identity
import Text.Parsec.Prim
import Text.Parsec.Char
import Text.Parsec.Combinator

-----------------------------------------------------------
-- Language Definition
-----------------------------------------------------------

type LanguageDef st = GenLanguageDef String st Identity

-- | The @GenLanguageDef@ type is a record that contains all parameterizable
-- features of the "Text.Parsec.Token" module. The module "Text.Parsec.Language"
-- contains some default definitions.

data GenLanguageDef s u m
    = LanguageDef {

    -- | Describes the start of a block comment. Use the empty string if the
    -- language doesn't support block comments. For example \"\/*\".

    forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentStart   :: String,

    -- | Describes the end of a block comment. Use the empty string if the
    -- language doesn't support block comments. For example \"*\/\".

    forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentEnd     :: String,

    -- | Describes the start of a line comment. Use the empty string if the
    -- language doesn't support line comments. For example \"\/\/\".

    forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentLine    :: String,

    -- | Set to 'True' if the language supports nested block comments.

    forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
nestedComments :: Bool,

    -- | This parser should accept any start characters of identifiers. For
    -- example @letter \<|> char \'_\'@.

    forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identStart     :: ParsecT s u m Char,

    -- | This parser should accept any legal tail characters of identifiers.
    -- For example @alphaNum \<|> char \'_\'@.

    forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identLetter    :: ParsecT s u m Char,

    -- | This parser should accept any start characters of operators. For
    -- example @oneOf \":!#$%&*+.\/\<=>?\@\\\\^|-~\"@

    forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opStart        :: ParsecT s u m Char,

    -- | This parser should accept any legal tail characters of operators.
    -- Note that this parser should even be defined if the language doesn't
    -- support user-defined operators, or otherwise the 'reservedOp'
    -- parser won't work correctly.

    forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opLetter       :: ParsecT s u m Char,

    -- | The list of reserved identifiers.

    forall s u (m :: * -> *). GenLanguageDef s u m -> [String]
reservedNames  :: [String],

    -- | The list of reserved operators.

    forall s u (m :: * -> *). GenLanguageDef s u m -> [String]
reservedOpNames:: [String],

    -- | Set to 'True' if the language is case sensitive.

    forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
caseSensitive  :: Bool

    }
#if MIN_VERSION_base(4,7,0)
    deriving ( Typeable )
#endif

-----------------------------------------------------------
-- A first class module: TokenParser
-----------------------------------------------------------

type TokenParser st = GenTokenParser String st Identity

-- | The type of the record that holds lexical parsers that work on
-- @s@ streams with state @u@ over a monad @m@.

data GenTokenParser s u m
    = TokenParser {

        -- | This lexeme parser parses a legal identifier. Returns the identifier
        -- string. This parser will fail on identifiers that are reserved
        -- words. Legal identifier (start) characters and reserved words are
        -- defined in the 'LanguageDef' that is passed to
        -- 'makeTokenParser'. An @identifier@ is treated as
        -- a single token using 'try'.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
identifier       :: ParsecT s u m String,

        -- | The lexeme parser @reserved name@ parses @symbol
        -- name@, but it also checks that the @name@ is not a prefix of a
        -- valid identifier. A @reserved@ word is treated as a single token
        -- using 'try'.

        forall s u (m :: * -> *).
GenTokenParser s u m -> String -> ParsecT s u m ()
reserved         :: String -> ParsecT s u m (),

        -- | This lexeme parser parses a legal operator. Returns the name of the
        -- operator. This parser will fail on any operators that are reserved
        -- operators. Legal operator (start) characters and reserved operators
        -- are defined in the 'LanguageDef' that is passed to
        -- 'makeTokenParser'. An @operator@ is treated as a
        -- single token using 'try'.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
operator         :: ParsecT s u m String,

        -- |The lexeme parser @reservedOp name@ parses @symbol
        -- name@, but it also checks that the @name@ is not a prefix of a
        -- valid operator. A @reservedOp@ is treated as a single token using
        -- 'try'.

        forall s u (m :: * -> *).
GenTokenParser s u m -> String -> ParsecT s u m ()
reservedOp       :: String -> ParsecT s u m (),


        -- | This lexeme parser parses a single literal character. Returns the
        -- literal character value. This parsers deals correctly with escape
        -- sequences. The literal character is parsed according to the grammar
        -- rules defined in the Haskell report (which matches most programming
        -- languages quite closely).

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Char
charLiteral      :: ParsecT s u m Char,

        -- | This lexeme parser parses a literal string. Returns the literal
        -- string value. This parsers deals correctly with escape sequences and
        -- gaps. The literal string is parsed according to the grammar rules
        -- defined in the Haskell report (which matches most programming
        -- languages quite closely).

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
stringLiteral    :: ParsecT s u m String,

        -- | This lexeme parser parses a natural number (a positive whole
        -- number). Returns the value of the number. The number can be
        -- specified in 'decimal', 'hexadecimal' or
        -- 'octal'. The number is parsed according to the grammar
        -- rules in the Haskell report.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
natural          :: ParsecT s u m Integer,

        -- | This lexeme parser parses an integer (a whole number). This parser
        -- is like 'natural' except that it can be prefixed with
        -- sign (i.e. \'-\' or \'+\'). Returns the value of the number. The
        -- number can be specified in 'decimal', 'hexadecimal'
        -- or 'octal'. The number is parsed according
        -- to the grammar rules in the Haskell report.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
integer          :: ParsecT s u m Integer,

        -- | This lexeme parser parses a floating point value. Returns the value
        -- of the number. The number is parsed according to the grammar rules
        -- defined in the Haskell report.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Double
float            :: ParsecT s u m Double,

        -- | This lexeme parser parses either 'natural' or a 'float'.
        -- Returns the value of the number. This parsers deals with
        -- any overlap in the grammar rules for naturals and floats. The number
        -- is parsed according to the grammar rules defined in the Haskell report.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m (Either Integer Double)
naturalOrFloat   :: ParsecT s u m (Either Integer Double),

        -- | Parses a non-negative whole number in the decimal system. Returns the
        -- value of the number.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
decimal          :: ParsecT s u m Integer,

        -- | Parses a non-negative whole number in the hexadecimal system. The
        -- number should be prefixed with \"x\" or \"X\". Returns the value of the
        -- number.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
hexadecimal      :: ParsecT s u m Integer,

        -- | Parses a non-negative whole number in the octal system. The number
        -- should be prefixed with \"o\" or \"O\". Returns the value of the
        -- number.

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m Integer
octal            :: ParsecT s u m Integer,

        -- | Lexeme parser @symbol s@ parses 'string' @s@ and skips
        -- trailing white space.

        forall s u (m :: * -> *).
GenTokenParser s u m -> String -> ParsecT s u m String
symbol           :: String -> ParsecT s u m String,

        -- | @lexeme p@ first applies parser @p@ and then the 'whiteSpace'
        -- parser, returning the value of @p@. Every lexical
        -- token (lexeme) is defined using @lexeme@, this way every parse
        -- starts at a point without white space. Parsers that use @lexeme@ are
        -- called /lexeme/ parsers in this document.
        --
        -- The only point where the 'whiteSpace' parser should be
        -- called explicitly is the start of the main parser in order to skip
        -- any leading white space.
        --
        -- >    mainParser  = do{ whiteSpace
        -- >                     ; ds <- many (lexeme digit)
        -- >                     ; eof
        -- >                     ; return (sum ds)
        -- >                     }

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
lexeme           :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | Parses any white space. White space consists of /zero/ or more
        -- occurrences of a 'space', a line comment or a block (multi
        -- line) comment. Block comments may be nested. How comments are
        -- started and ended is defined in the 'LanguageDef'
        -- that is passed to 'makeTokenParser'.

        forall s u (m :: * -> *). GenTokenParser s u m -> ParsecT s u m ()
whiteSpace       :: ParsecT s u m (),

        -- | Lexeme parser @parens p@ parses @p@ enclosed in parenthesis,
        -- returning the value of @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
parens           :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | Lexeme parser @braces p@ parses @p@ enclosed in braces (\'{\' and
        -- \'}\'), returning the value of @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
braces           :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | Lexeme parser @angles p@ parses @p@ enclosed in angle brackets (\'\<\'
        -- and \'>\'), returning the value of @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
angles           :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | Lexeme parser @brackets p@ parses @p@ enclosed in brackets (\'[\'
        -- and \']\'), returning the value of @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
brackets         :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | DEPRECATED: Use 'brackets'.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m a
squares          :: forall a. ParsecT s u m a -> ParsecT s u m a,

        -- | Lexeme parser |semi| parses the character \';\' and skips any
        -- trailing white space. Returns the string \";\".

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
semi             :: ParsecT s u m String,

        -- | Lexeme parser @comma@ parses the character \',\' and skips any
        -- trailing white space. Returns the string \",\".

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
comma            :: ParsecT s u m String,

        -- | Lexeme parser @colon@ parses the character \':\' and skips any
        -- trailing white space. Returns the string \":\".

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
colon            :: ParsecT s u m String,

        -- | Lexeme parser @dot@ parses the character \'.\' and skips any
        -- trailing white space. Returns the string \".\".

        forall s u (m :: * -> *).
GenTokenParser s u m -> ParsecT s u m String
dot              :: ParsecT s u m String,

        -- | Lexeme parser @semiSep p@ parses /zero/ or more occurrences of @p@
        -- separated by 'semi'. Returns a list of values returned by
        -- @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
semiSep          :: forall a . ParsecT s u m a -> ParsecT s u m [a],

        -- | Lexeme parser @semiSep1 p@ parses /one/ or more occurrences of @p@
        -- separated by 'semi'. Returns a list of values returned by @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
semiSep1         :: forall a . ParsecT s u m a -> ParsecT s u m [a],

        -- | Lexeme parser @commaSep p@ parses /zero/ or more occurrences of
        -- @p@ separated by 'comma'. Returns a list of values returned
        -- by @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
commaSep         :: forall a . ParsecT s u m a -> ParsecT s u m [a],

        -- | Lexeme parser @commaSep1 p@ parses /one/ or more occurrences of
        -- @p@ separated by 'comma'. Returns a list of values returned
        -- by @p@.

        forall s u (m :: * -> *).
GenTokenParser s u m
-> forall a. ParsecT s u m a -> ParsecT s u m [a]
commaSep1        :: forall a . ParsecT s u m a -> ParsecT s u m [a]
    }
#if MIN_VERSION_base(4,7,0)
    deriving ( Typeable )
#endif

-----------------------------------------------------------
-- Given a LanguageDef, create a token parser.
-----------------------------------------------------------

-- | The expression @makeTokenParser language@ creates a 'GenTokenParser'
-- record that contains lexical parsers that are
-- defined using the definitions in the @language@ record.
--
-- The use of this function is quite stylized - one imports the
-- appropiate language definition and selects the lexical parsers that
-- are needed from the resulting 'GenTokenParser'.
--
-- >  module Main where
-- >
-- >  import Text.Parsec
-- >  import qualified Text.Parsec.Token as P
-- >  import Text.Parsec.Language (haskellDef)
-- >
-- >  -- The parser
-- >  ...
-- >
-- >  expr  =   parens expr
-- >        <|> identifier
-- >        <|> ...
-- >
-- >
-- >  -- The lexer
-- >  lexer       = P.makeTokenParser haskellDef
-- >
-- >  parens      = P.parens lexer
-- >  braces      = P.braces lexer
-- >  identifier  = P.identifier lexer
-- >  reserved    = P.reserved lexer
-- >  ...

makeTokenParser :: (Stream s m Char)
                => GenLanguageDef s u m -> GenTokenParser s u m
{-# INLINABLE makeTokenParser #-}
makeTokenParser :: forall s (m :: * -> *) u.
Stream s m Char =>
GenLanguageDef s u m -> GenTokenParser s u m
makeTokenParser GenLanguageDef s u m
languageDef
    = TokenParser :: forall s u (m :: * -> *).
ParsecT s u m String
-> (String -> ParsecT s u m ())
-> ParsecT s u m String
-> (String -> ParsecT s u m ())
-> ParsecT s u m Char
-> ParsecT s u m String
-> ParsecT s u m Integer
-> ParsecT s u m Integer
-> ParsecT s u m Double
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m Integer
-> ParsecT s u m Integer
-> ParsecT s u m Integer
-> (String -> ParsecT s u m String)
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> ParsecT s u m ()
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> (forall a. ParsecT s u m a -> ParsecT s u m a)
-> ParsecT s u m String
-> ParsecT s u m String
-> ParsecT s u m String
-> ParsecT s u m String
-> (forall a. ParsecT s u m a -> ParsecT s u m [a])
-> (forall a. ParsecT s u m a -> ParsecT s u m [a])
-> (forall a. ParsecT s u m a -> ParsecT s u m [a])
-> (forall a. ParsecT s u m a -> ParsecT s u m [a])
-> GenTokenParser s u m
TokenParser{ identifier :: ParsecT s u m String
identifier = ParsecT s u m String
identifier
                 , reserved :: String -> ParsecT s u m ()
reserved = String -> ParsecT s u m ()
reserved
                 , operator :: ParsecT s u m String
operator = ParsecT s u m String
operator
                 , reservedOp :: String -> ParsecT s u m ()
reservedOp = String -> ParsecT s u m ()
reservedOp

                 , charLiteral :: ParsecT s u m Char
charLiteral = ParsecT s u m Char
forall {u}. ParsecT s u m Char
charLiteral
                 , stringLiteral :: ParsecT s u m String
stringLiteral = ParsecT s u m String
forall {u}. ParsecT s u m String
stringLiteral
                 , natural :: ParsecT s u m Integer
natural = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
natural
                 , integer :: ParsecT s u m Integer
integer = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
integer
                 , float :: ParsecT s u m Double
float = ParsecT s u m Double
forall {u}. ParsecT s u m Double
float
                 , naturalOrFloat :: ParsecT s u m (Either Integer Double)
naturalOrFloat = ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
naturalOrFloat
                 , decimal :: ParsecT s u m Integer
decimal = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal
                 , hexadecimal :: ParsecT s u m Integer
hexadecimal = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
hexadecimal
                 , octal :: ParsecT s u m Integer
octal = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
octal

                 , symbol :: String -> ParsecT s u m String
symbol = String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol
                 , lexeme :: forall a. ParsecT s u m a -> ParsecT s u m a
lexeme = forall a. ParsecT s u m a -> ParsecT s u m a
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme
                 , whiteSpace :: ParsecT s u m ()
whiteSpace = ParsecT s u m ()
forall {u}. ParsecT s u m ()
whiteSpace

                 , parens :: forall a. ParsecT s u m a -> ParsecT s u m a
parens = forall a. ParsecT s u m a -> ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
parens
                 , braces :: forall a. ParsecT s u m a -> ParsecT s u m a
braces = forall a. ParsecT s u m a -> ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
braces
                 , angles :: forall a. ParsecT s u m a -> ParsecT s u m a
angles = forall a. ParsecT s u m a -> ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
angles
                 , brackets :: forall a. ParsecT s u m a -> ParsecT s u m a
brackets = forall a. ParsecT s u m a -> ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
brackets
                 , squares :: forall a. ParsecT s u m a -> ParsecT s u m a
squares = forall a. ParsecT s u m a -> ParsecT s u m a
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m a
brackets
                 , semi :: ParsecT s u m String
semi = ParsecT s u m String
forall {u}. ParsecT s u m String
semi
                 , comma :: ParsecT s u m String
comma = ParsecT s u m String
forall {u}. ParsecT s u m String
comma
                 , colon :: ParsecT s u m String
colon = ParsecT s u m String
forall {u}. ParsecT s u m String
colon
                 , dot :: ParsecT s u m String
dot = ParsecT s u m String
forall {u}. ParsecT s u m String
dot
                 , semiSep :: forall a. ParsecT s u m a -> ParsecT s u m [a]
semiSep = forall a. ParsecT s u m a -> ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
semiSep
                 , semiSep1 :: forall a. ParsecT s u m a -> ParsecT s u m [a]
semiSep1 = forall a. ParsecT s u m a -> ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
semiSep1
                 , commaSep :: forall a. ParsecT s u m a -> ParsecT s u m [a]
commaSep = forall a. ParsecT s u m a -> ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
commaSep
                 , commaSep1 :: forall a. ParsecT s u m a -> ParsecT s u m [a]
commaSep1 = forall a. ParsecT s u m a -> ParsecT s u m [a]
forall {t} {u} {a}.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
commaSep1
                 }
    where

    -----------------------------------------------------------
    -- Bracketing
    -----------------------------------------------------------
    parens :: ParsecT s u m a -> ParsecT s u m a
parens ParsecT s u m a
p        = ParsecT s u m String
-> ParsecT s u m String -> ParsecT s u m a -> ParsecT s u m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"(") (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
")") ParsecT s u m a
p
    braces :: ParsecT s u m a -> ParsecT s u m a
braces ParsecT s u m a
p        = ParsecT s u m String
-> ParsecT s u m String -> ParsecT s u m a -> ParsecT s u m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"{") (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"}") ParsecT s u m a
p
    angles :: ParsecT s u m a -> ParsecT s u m a
angles ParsecT s u m a
p        = ParsecT s u m String
-> ParsecT s u m String -> ParsecT s u m a -> ParsecT s u m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"<") (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
">") ParsecT s u m a
p
    brackets :: ParsecT s u m a -> ParsecT s u m a
brackets ParsecT s u m a
p      = ParsecT s u m String
-> ParsecT s u m String -> ParsecT s u m a -> ParsecT s u m a
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"[") (String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"]") ParsecT s u m a
p

    semi :: ParsecT s u m String
semi            = String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
";"
    comma :: ParsecT s u m String
comma           = String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
","
    dot :: ParsecT s u m String
dot             = String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
"."
    colon :: ParsecT s u m String
colon           = String -> ParsecT s u m String
forall {u}. String -> ParsecT s u m String
symbol String
":"

    commaSep :: ParsecT s u m a -> ParsecT s u m [a]
commaSep ParsecT s u m a
p      = ParsecT s u m a -> ParsecT s u m String -> ParsecT s u m [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT s u m a
p ParsecT s u m String
forall {u}. ParsecT s u m String
comma
    semiSep :: ParsecT s u m a -> ParsecT s u m [a]
semiSep ParsecT s u m a
p       = ParsecT s u m a -> ParsecT s u m String -> ParsecT s u m [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy ParsecT s u m a
p ParsecT s u m String
forall {u}. ParsecT s u m String
semi

    commaSep1 :: ParsecT s u m a -> ParsecT s u m [a]
commaSep1 ParsecT s u m a
p     = ParsecT s u m a -> ParsecT s u m String -> ParsecT s u m [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1 ParsecT s u m a
p ParsecT s u m String
forall {u}. ParsecT s u m String
comma
    semiSep1 :: ParsecT s u m a -> ParsecT s u m [a]
semiSep1 ParsecT s u m a
p      = ParsecT s u m a -> ParsecT s u m String -> ParsecT s u m [a]
forall s (m :: * -> *) t u a sep.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
sepBy1 ParsecT s u m a
p ParsecT s u m String
forall {u}. ParsecT s u m String
semi


    -----------------------------------------------------------
    -- Chars & Strings
    -----------------------------------------------------------
    charLiteral :: ParsecT s u m Char
charLiteral     = ParsecT s u m Char -> ParsecT s u m Char
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m Char
-> ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\'')
                                      (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\'' ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"end of character")
                                      ParsecT s u m Char
forall {u}. ParsecT s u m Char
characterChar )
                    ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"character"

    characterChar :: ParsecT s u m Char
characterChar   = ParsecT s u m Char
forall {u}. ParsecT s u m Char
charLetter ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Char
forall {u}. ParsecT s u m Char
charEscape
                    ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"literal character"

    charEscape :: ParsecT s u m Char
charEscape      = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\\'; ParsecT s u m Char
forall {u}. ParsecT s u m Char
escapeCode }
    charLetter :: ParsecT s u m Char
charLetter      = (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (\Char
c -> (Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\'') Bool -> Bool -> Bool
&& (Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\\') Bool -> Bool -> Bool
&& (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
> Char
'\026'))



    stringLiteral :: ParsecT s u m String
stringLiteral   = ParsecT s u m String -> ParsecT s u m String
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (
                      do{ [Maybe Char]
str <- ParsecT s u m Char
-> ParsecT s u m Char
-> ParsecT s u m [Maybe Char]
-> ParsecT s u m [Maybe Char]
forall s (m :: * -> *) t u open close a.
Stream s m t =>
ParsecT s u m open
-> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
between (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'"')
                                         (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'"' ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"end of string")
                                         (ParsecT s u m (Maybe Char) -> ParsecT s u m [Maybe Char]
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many ParsecT s u m (Maybe Char)
forall {u}. ParsecT s u m (Maybe Char)
stringChar)
                        ; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return ((Maybe Char -> String -> String)
-> String -> [Maybe Char] -> String
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr ((String -> String)
-> (Char -> String -> String) -> Maybe Char -> String -> String
forall b a. b -> (a -> b) -> Maybe a -> b
maybe String -> String
forall a. a -> a
id (:)) String
"" [Maybe Char]
str)
                        }
                      ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"literal string")

    stringChar :: ParsecT s u m (Maybe Char)
stringChar      =   do{ Char
c <- ParsecT s u m Char
forall {u}. ParsecT s u m Char
stringLetter; Maybe Char -> ParsecT s u m (Maybe Char)
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> Maybe Char
forall a. a -> Maybe a
Just Char
c) }
                    ParsecT s u m (Maybe Char)
-> ParsecT s u m (Maybe Char) -> ParsecT s u m (Maybe Char)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m (Maybe Char)
forall {u}. ParsecT s u m (Maybe Char)
stringEscape
                    ParsecT s u m (Maybe Char) -> String -> ParsecT s u m (Maybe Char)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"string character"

    stringLetter :: ParsecT s u m Char
stringLetter    = (Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (\Char
c -> (Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'"') Bool -> Bool -> Bool
&& (Char
c Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\\') Bool -> Bool -> Bool
&& (Char
c Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
> Char
'\026'))

    stringEscape :: ParsecT s u m (Maybe Char)
stringEscape    = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\\'
                        ;     do{ Char
_ <- ParsecT s u m Char
forall {u}. ParsecT s u m Char
escapeGap  ; Maybe Char -> ParsecT s u m (Maybe Char)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Char
forall a. Maybe a
Nothing }
                          ParsecT s u m (Maybe Char)
-> ParsecT s u m (Maybe Char) -> ParsecT s u m (Maybe Char)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
_ <- ParsecT s u m Char
forall {u}. ParsecT s u m Char
escapeEmpty; Maybe Char -> ParsecT s u m (Maybe Char)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Char
forall a. Maybe a
Nothing }
                          ParsecT s u m (Maybe Char)
-> ParsecT s u m (Maybe Char) -> ParsecT s u m (Maybe Char)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
esc <- ParsecT s u m Char
forall {u}. ParsecT s u m Char
escapeCode; Maybe Char -> ParsecT s u m (Maybe Char)
forall (m :: * -> *) a. Monad m => a -> m a
return (Char -> Maybe Char
forall a. a -> Maybe a
Just Char
esc) }
                        }

    escapeEmpty :: ParsecT s u m Char
escapeEmpty     = Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'&'
    escapeGap :: ParsecT s u m Char
escapeGap       = do{ String
_ <- ParsecT s u m Char -> ParsecT s u m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
space
                        ; Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'\\' ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"end of string gap"
                        }



    -- escape codes
    escapeCode :: ParsecT s u m Char
escapeCode      = ParsecT s u m Char
forall {u}. ParsecT s u m Char
charEsc ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Char
forall {u}. ParsecT s u m Char
charNum ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Char
forall {u}. ParsecT s u m Char
charAscii ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Char
forall {u}. ParsecT s u m Char
charControl
                    ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"escape code"

    charControl :: ParsecT s u m Char
charControl     = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'^'
                        ; Char
code <- ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
upper
                        ; Char -> ParsecT s u m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Char
forall a. Enum a => Int -> a
toEnum (Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
code Int -> Int -> Int
forall a. Num a => a -> a -> a
- Char -> Int
forall a. Enum a => a -> Int
fromEnum Char
'A' Int -> Int -> Int
forall a. Num a => a -> a -> a
+ Int
1))
                        }

    charNum :: ParsecT s u m Char
charNum         = do{ Integer
code <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal
                                  ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'o'; Integer -> ParsecT s u m Char -> ParsecT s u m Integer
forall {s} {m :: * -> *} {t} {u}.
Stream s m t =>
Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
8 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit }
                                  ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'x'; Integer -> ParsecT s u m Char -> ParsecT s u m Integer
forall {s} {m :: * -> *} {t} {u}.
Stream s m t =>
Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
16 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
hexDigit }
                        ; if Integer
code Integer -> Integer -> Bool
forall a. Ord a => a -> a -> Bool
> Integer
0x10FFFF
                          then String -> ParsecT s u m Char
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"invalid escape sequence"
                          else Char -> ParsecT s u m Char
forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> Char
forall a. Enum a => Int -> a
toEnum (Integer -> Int
forall a. Num a => Integer -> a
fromInteger Integer
code))
                        }

    charEsc :: ParsecT s u m Char
charEsc         = [ParsecT s u m Char] -> ParsecT s u m Char
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice (((Char, Char) -> ParsecT s u m Char)
-> [(Char, Char)] -> [ParsecT s u m Char]
forall a b. (a -> b) -> [a] -> [b]
map (Char, Char) -> ParsecT s u m Char
forall {s} {m :: * -> *} {b} {u}.
Stream s m Char =>
(Char, b) -> ParsecT s u m b
parseEsc [(Char, Char)]
escMap)
                    where
                      parseEsc :: (Char, b) -> ParsecT s u m b
parseEsc (Char
c,b
code)     = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
c; b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
code }

    charAscii :: ParsecT s u m Char
charAscii       = [ParsecT s u m Char] -> ParsecT s u m Char
forall s (m :: * -> *) t u a.
Stream s m t =>
[ParsecT s u m a] -> ParsecT s u m a
choice (((String, Char) -> ParsecT s u m Char)
-> [(String, Char)] -> [ParsecT s u m Char]
forall a b. (a -> b) -> [a] -> [b]
map (String, Char) -> ParsecT s u m Char
forall {s} {m :: * -> *} {a} {u}.
Stream s m Char =>
(String, a) -> ParsecT s u m a
parseAscii [(String, Char)]
asciiMap)
                    where
                      parseAscii :: (String, a) -> ParsecT s u m a
parseAscii (String
asc,a
code) = ParsecT s u m a -> ParsecT s u m a
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (do{ String
_ <- String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
asc; a -> ParsecT s u m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
code })


    -- escape code tables
    escMap :: [(Char, Char)]
escMap          = String -> String -> [(Char, Char)]
forall a b. [a] -> [b] -> [(a, b)]
zip (String
"abfnrtv\\\"\'") (String
"\a\b\f\n\r\t\v\\\"\'")
    asciiMap :: [(String, Char)]
asciiMap        = [String] -> String -> [(String, Char)]
forall a b. [a] -> [b] -> [(a, b)]
zip ([String]
ascii3codes [String] -> [String] -> [String]
forall a. [a] -> [a] -> [a]
++ [String]
ascii2codes) (String
ascii3 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
ascii2)

    ascii2codes :: [String]
ascii2codes     = [String
"BS",String
"HT",String
"LF",String
"VT",String
"FF",String
"CR",String
"SO",String
"SI",String
"EM",
                       String
"FS",String
"GS",String
"RS",String
"US",String
"SP"]
    ascii3codes :: [String]
ascii3codes     = [String
"NUL",String
"SOH",String
"STX",String
"ETX",String
"EOT",String
"ENQ",String
"ACK",String
"BEL",
                       String
"DLE",String
"DC1",String
"DC2",String
"DC3",String
"DC4",String
"NAK",String
"SYN",String
"ETB",
                       String
"CAN",String
"SUB",String
"ESC",String
"DEL"]

    ascii2 :: String
ascii2          = [Char
'\BS',Char
'\HT',Char
'\LF',Char
'\VT',Char
'\FF',Char
'\CR',Char
'\SO',Char
'\SI',
                       Char
'\EM',Char
'\FS',Char
'\GS',Char
'\RS',Char
'\US',Char
'\SP']
    ascii3 :: String
ascii3          = [Char
'\NUL',Char
'\SOH',Char
'\STX',Char
'\ETX',Char
'\EOT',Char
'\ENQ',Char
'\ACK',
                       Char
'\BEL',Char
'\DLE',Char
'\DC1',Char
'\DC2',Char
'\DC3',Char
'\DC4',Char
'\NAK',
                       Char
'\SYN',Char
'\ETB',Char
'\CAN',Char
'\SUB',Char
'\ESC',Char
'\DEL']


    -----------------------------------------------------------
    -- Numbers
    -----------------------------------------------------------
    naturalOrFloat :: ParsecT s u m (Either Integer Double)
naturalOrFloat  = ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
natFloat) ParsecT s u m (Either Integer Double)
-> String -> ParsecT s u m (Either Integer Double)
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"number"

    float :: ParsecT s u m Double
float           = ParsecT s u m Double -> ParsecT s u m Double
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme ParsecT s u m Double
forall {u}. ParsecT s u m Double
floating   ParsecT s u m Double -> String -> ParsecT s u m Double
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"float"
    integer :: ParsecT s u m Integer
integer         = ParsecT s u m Integer -> ParsecT s u m Integer
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
int        ParsecT s u m Integer -> String -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"integer"
    natural :: ParsecT s u m Integer
natural         = ParsecT s u m Integer -> ParsecT s u m Integer
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
nat        ParsecT s u m Integer -> String -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"natural"


    -- floats
    floating :: ParsecT s u m Double
floating        = do{ Integer
n <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal
                        ; Integer -> ParsecT s u m Double
forall {a} {a} {u}. (Read a, Show a) => a -> ParsecT s u m a
fractExponent Integer
n
                        }


    natFloat :: ParsecT s u m (Either Integer Double)
natFloat        = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'0'
                        ; ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
zeroNumFloat
                        }
                      ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
decimalFloat

    zeroNumFloat :: ParsecT s u m (Either Integer Double)
zeroNumFloat    =  do{ Integer
n <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
hexadecimal ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
octal
                         ; Either Integer Double -> ParsecT s u m (Either Integer Double)
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Either Integer Double
forall a b. a -> Either a b
Left Integer
n)
                         }
                    ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m (Either Integer Double)
forall {u}. ParsecT s u m (Either Integer Double)
decimalFloat
                    ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Integer -> ParsecT s u m (Either Integer Double)
forall {b} {a} {u} {a}.
(Read b, Show a) =>
a -> ParsecT s u m (Either a b)
fractFloat (Integer
0 :: Integer)
                    ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Either Integer Double -> ParsecT s u m (Either Integer Double)
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Either Integer Double
forall a b. a -> Either a b
Left Integer
0)

    decimalFloat :: ParsecT s u m (Either Integer Double)
decimalFloat    = do{ Integer
n <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal
                        ; Either Integer Double
-> ParsecT s u m (Either Integer Double)
-> ParsecT s u m (Either Integer Double)
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option (Integer -> Either Integer Double
forall a b. a -> Either a b
Left Integer
n)
                                 (Integer -> ParsecT s u m (Either Integer Double)
forall {b} {a} {u} {a}.
(Read b, Show a) =>
a -> ParsecT s u m (Either a b)
fractFloat Integer
n)
                        }

    fractFloat :: a -> ParsecT s u m (Either a b)
fractFloat a
n    = do{ b
f <- a -> ParsecT s u m b
forall {a} {a} {u}. (Read a, Show a) => a -> ParsecT s u m a
fractExponent a
n
                        ; Either a b -> ParsecT s u m (Either a b)
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Either a b
forall a b. b -> Either a b
Right b
f)
                        }

    fractExponent :: a -> ParsecT s u m a
fractExponent a
n = do{ String
fract <- ParsecT s u m String
forall {u}. ParsecT s u m String
fraction
                        ; String
expo  <- String -> ParsecT s u m String -> ParsecT s u m String
forall s (m :: * -> *) t a u.
Stream s m t =>
a -> ParsecT s u m a -> ParsecT s u m a
option String
"" ParsecT s u m String
forall {u}. ParsecT s u m String
exponent'
                        ; String -> ParsecT s u m a
forall {a} {s} {u} {m :: * -> *}.
Read a =>
String -> ParsecT s u m a
readDouble (a -> String
forall a. Show a => a -> String
show a
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
fract String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
expo)
                        }
                    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|>
                      do{ String
expo <- ParsecT s u m String
forall {u}. ParsecT s u m String
exponent'
                        ; String -> ParsecT s u m a
forall {a} {s} {u} {m :: * -> *}.
Read a =>
String -> ParsecT s u m a
readDouble (a -> String
forall a. Show a => a -> String
show a
n String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
expo)
                        }
                      where
                        readDouble :: String -> ParsecT s u m a
readDouble String
s =
                          case ReadS a
forall a. Read a => ReadS a
reads String
s of
                            [(a
x, String
"")] -> a -> ParsecT s u m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
x
                            [(a, String)]
_         -> ParsecT s u m a
forall s u (m :: * -> *) a. ParsecT s u m a
parserZero

    fraction :: ParsecT s u m String
fraction        = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'.'
                        ; String
digits <- ParsecT s u m Char -> ParsecT s u m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"fraction"
                        ; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return (Char
'.' Char -> String -> String
forall a. a -> [a] -> [a]
: String
digits)
                        }
                      ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"fraction"

    exponent' :: ParsecT s u m String
exponent'       = do{ Char
_ <- String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"eE"
                        ; String
sign' <- (Char -> String) -> ParsecT s u m Char -> ParsecT s u m String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (Char -> String -> String
forall a. a -> [a] -> [a]
:[]) (String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"+-") ParsecT s u m String
-> ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
""
                        ; Integer
e <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal ParsecT s u m Integer -> String -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"exponent"
                        ; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return (Char
'e' Char -> String -> String
forall a. a -> [a] -> [a]
: String
sign' String -> String -> String
forall a. [a] -> [a] -> [a]
++ Integer -> String
forall a. Show a => a -> String
show Integer
e)
                        }
                      ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"exponent"


    -- integers and naturals
    int :: ParsecT s u m Integer
int             = do{ Integer -> Integer
f <- ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme ParsecT s u m (Integer -> Integer)
forall {u}. ParsecT s u m (Integer -> Integer)
sign
                        ; Integer
n <- ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
nat
                        ; Integer -> ParsecT s u m Integer
forall (m :: * -> *) a. Monad m => a -> m a
return (Integer -> Integer
f Integer
n)
                        }

    sign :: ParsecT s u m (Integer -> Integer)
sign            =   (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'-' ParsecT s u m Char
-> ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Integer -> Integer) -> ParsecT s u m (Integer -> Integer)
forall (m :: * -> *) a. Monad m => a -> m a
return Integer -> Integer
forall a. Num a => a -> a
negate)
                    ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'+' ParsecT s u m Char
-> ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Integer -> Integer) -> ParsecT s u m (Integer -> Integer)
forall (m :: * -> *) a. Monad m => a -> m a
return Integer -> Integer
forall a. a -> a
id)
                    ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
-> ParsecT s u m (Integer -> Integer)
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> (Integer -> Integer) -> ParsecT s u m (Integer -> Integer)
forall (m :: * -> *) a. Monad m => a -> m a
return Integer -> Integer
forall a. a -> a
id

    nat :: ParsecT s u m Integer
nat             = ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
zeroNumber ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal

    zeroNumber :: ParsecT s u m Integer
zeroNumber      = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
'0'
                        ; ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
hexadecimal ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
octal ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m Integer
forall {u}. ParsecT s u m Integer
decimal ParsecT s u m Integer
-> ParsecT s u m Integer -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Integer -> ParsecT s u m Integer
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
0
                        }
                      ParsecT s u m Integer -> String -> ParsecT s u m Integer
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
""

    decimal :: ParsecT s u m Integer
decimal         = Integer -> ParsecT s u m Char -> ParsecT s u m Integer
forall {s} {m :: * -> *} {t} {u}.
Stream s m t =>
Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
10 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
digit
    hexadecimal :: ParsecT s u m Integer
hexadecimal     = do{ Char
_ <- String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"xX"; Integer -> ParsecT s u m Char -> ParsecT s u m Integer
forall {s} {m :: * -> *} {t} {u}.
Stream s m t =>
Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
16 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
hexDigit }
    octal :: ParsecT s u m Integer
octal           = do{ Char
_ <- String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
"oO"; Integer -> ParsecT s u m Char -> ParsecT s u m Integer
forall {s} {m :: * -> *} {t} {u}.
Stream s m t =>
Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
8 ParsecT s u m Char
forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
octDigit  }

    number :: Integer -> ParsecT s u m Char -> ParsecT s u m Integer
number Integer
base ParsecT s u m Char
baseDigit
        = do{ String
digits <- ParsecT s u m Char -> ParsecT s u m String
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m [a]
many1 ParsecT s u m Char
baseDigit
            ; let n :: Integer
n = (Integer -> Char -> Integer) -> Integer -> String -> Integer
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl (\Integer
x Char
d -> Integer
baseInteger -> Integer -> Integer
forall a. Num a => a -> a -> a
*Integer
x Integer -> Integer -> Integer
forall a. Num a => a -> a -> a
+ Int -> Integer
forall a. Integral a => a -> Integer
toInteger (Char -> Int
digitToInt Char
d)) Integer
0 String
digits
            ; Integer -> ParsecT s u m Integer -> ParsecT s u m Integer
seq Integer
n (Integer -> ParsecT s u m Integer
forall (m :: * -> *) a. Monad m => a -> m a
return Integer
n)
            }

    -----------------------------------------------------------
    -- Operators & reserved ops
    -----------------------------------------------------------
    reservedOp :: String -> ParsecT s u m ()
reservedOp String
name =
        ParsecT s u m () -> ParsecT s u m ()
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m () -> ParsecT s u m ())
-> ParsecT s u m () -> ParsecT s u m ()
forall a b. (a -> b) -> a -> b
$ ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT s u m () -> ParsecT s u m ())
-> ParsecT s u m () -> ParsecT s u m ()
forall a b. (a -> b) -> a -> b
$
        do{ String
_ <- String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
name
          ; ParsecT s u m Char -> ParsecT s u m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opLetter GenLanguageDef s u m
languageDef) ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> (String
"end of " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
name)
          }

    operator :: ParsecT s u m String
operator =
        ParsecT s u m String -> ParsecT s u m String
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m String -> ParsecT s u m String)
-> ParsecT s u m String -> ParsecT s u m String
forall a b. (a -> b) -> a -> b
$ ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT s u m String -> ParsecT s u m String)
-> ParsecT s u m String -> ParsecT s u m String
forall a b. (a -> b) -> a -> b
$
        do{ String
name <- ParsecT s u m String
oper
          ; if (String -> Bool
isReservedOp String
name)
             then String -> ParsecT s u m String
forall s (m :: * -> *) t u a.
Stream s m t =>
String -> ParsecT s u m a
unexpected (String
"reserved operator " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
name)
             else String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
name
          }

    oper :: ParsecT s u m String
oper =
        do{ Char
c <- (GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opStart GenLanguageDef s u m
languageDef)
          ; String
cs <- ParsecT s u m Char -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
opLetter GenLanguageDef s u m
languageDef)
          ; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:String
cs)
          }
        ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"operator"

    isReservedOp :: String -> Bool
isReservedOp String
name =
        [String] -> String -> Bool
forall {p}. Ord p => [p] -> p -> Bool
isReserved ([String] -> [String]
forall a. Ord a => [a] -> [a]
sort (GenLanguageDef s u m -> [String]
forall s u (m :: * -> *). GenLanguageDef s u m -> [String]
reservedOpNames GenLanguageDef s u m
languageDef)) String
name


    -----------------------------------------------------------
    -- Identifiers & Reserved words
    -----------------------------------------------------------
    reserved :: String -> ParsecT s u m ()
reserved String
name =
        ParsecT s u m () -> ParsecT s u m ()
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m () -> ParsecT s u m ())
-> ParsecT s u m () -> ParsecT s u m ()
forall a b. (a -> b) -> a -> b
$ ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT s u m () -> ParsecT s u m ())
-> ParsecT s u m () -> ParsecT s u m ()
forall a b. (a -> b) -> a -> b
$
        do{ String
_ <- String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
caseString String
name
          ; ParsecT s u m Char -> ParsecT s u m ()
forall s (m :: * -> *) t a u.
(Stream s m t, Show a) =>
ParsecT s u m a -> ParsecT s u m ()
notFollowedBy (GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identLetter GenLanguageDef s u m
languageDef) ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> (String
"end of " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
name)
          }

    caseString :: String -> ParsecT s u m String
caseString String
name
        | GenLanguageDef s u m -> Bool
forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
caseSensitive GenLanguageDef s u m
languageDef  = String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
name
        | Bool
otherwise               = do{ String -> ParsecT s u m ()
forall {s} {m :: * -> *} {u}.
Stream s m Char =>
String -> ParsecT s u m ()
walk String
name; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
name }
        where
          walk :: String -> ParsecT s u m ()
walk []     = () -> ParsecT s u m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          walk (Char
c:String
cs) = do{ Char
_ <- Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
caseChar Char
c ParsecT s u m Char -> String -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
msg; String -> ParsecT s u m ()
walk String
cs }

          caseChar :: Char -> ParsecT s u m Char
caseChar Char
c  | Char -> Bool
isAlpha Char
c  = Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char (Char -> Char
toLower Char
c) ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char (Char -> Char
toUpper Char
c)
                      | Bool
otherwise  = Char -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
Char -> ParsecT s u m Char
char Char
c

          msg :: String
msg         = String -> String
forall a. Show a => a -> String
show String
name


    identifier :: ParsecT s u m String
identifier =
        ParsecT s u m String -> ParsecT s u m String
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (ParsecT s u m String -> ParsecT s u m String)
-> ParsecT s u m String -> ParsecT s u m String
forall a b. (a -> b) -> a -> b
$ ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (ParsecT s u m String -> ParsecT s u m String)
-> ParsecT s u m String -> ParsecT s u m String
forall a b. (a -> b) -> a -> b
$
        do{ String
name <- ParsecT s u m String
ident
          ; if (String -> Bool
isReservedName String
name)
             then String -> ParsecT s u m String
forall s (m :: * -> *) t u a.
Stream s m t =>
String -> ParsecT s u m a
unexpected (String
"reserved word " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String -> String
forall a. Show a => a -> String
show String
name)
             else String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return String
name
          }


    ident :: ParsecT s u m String
ident
        = do{ Char
c <- GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identStart GenLanguageDef s u m
languageDef
            ; String
cs <- ParsecT s u m Char -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
many (GenLanguageDef s u m -> ParsecT s u m Char
forall s u (m :: * -> *).
GenLanguageDef s u m -> ParsecT s u m Char
identLetter GenLanguageDef s u m
languageDef)
            ; String -> ParsecT s u m String
forall (m :: * -> *) a. Monad m => a -> m a
return (Char
cChar -> String -> String
forall a. a -> [a] -> [a]
:String
cs)
            }
        ParsecT s u m String -> String -> ParsecT s u m String
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"identifier"

    isReservedName :: String -> Bool
isReservedName String
name
        = [String] -> String -> Bool
forall {p}. Ord p => [p] -> p -> Bool
isReserved [String]
theReservedNames String
caseName
        where
          caseName :: String
caseName      | GenLanguageDef s u m -> Bool
forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
caseSensitive GenLanguageDef s u m
languageDef  = String
name
                        | Bool
otherwise               = (Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower String
name


    isReserved :: [p] -> p -> Bool
isReserved [p]
names p
name
        = [p] -> Bool
scan [p]
names
        where
          scan :: [p] -> Bool
scan []       = Bool
False
          scan (p
r:[p]
rs)   = case (p -> p -> Ordering
forall a. Ord a => a -> a -> Ordering
compare p
r p
name) of
                            Ordering
LT  -> [p] -> Bool
scan [p]
rs
                            Ordering
EQ  -> Bool
True
                            Ordering
GT  -> Bool
False

    theReservedNames :: [String]
theReservedNames
        | GenLanguageDef s u m -> Bool
forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
caseSensitive GenLanguageDef s u m
languageDef  = [String] -> [String]
forall a. Ord a => [a] -> [a]
sort [String]
reserved
        | Bool
otherwise                  = [String] -> [String]
forall a. Ord a => [a] -> [a]
sort ([String] -> [String])
-> ([String] -> [String]) -> [String] -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String -> String) -> [String] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map ((Char -> Char) -> String -> String
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower) ([String] -> [String]) -> [String] -> [String]
forall a b. (a -> b) -> a -> b
$ [String]
reserved
        where
          reserved :: [String]
reserved = GenLanguageDef s u m -> [String]
forall s u (m :: * -> *). GenLanguageDef s u m -> [String]
reservedNames GenLanguageDef s u m
languageDef



    -----------------------------------------------------------
    -- White space & symbols
    -----------------------------------------------------------
    symbol :: String -> ParsecT s u m String
symbol String
name
        = ParsecT s u m String -> ParsecT s u m String
forall {u} {b}. ParsecT s u m b -> ParsecT s u m b
lexeme (String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string String
name)

    lexeme :: ParsecT s u m b -> ParsecT s u m b
lexeme ParsecT s u m b
p
        = do{ b
x <- ParsecT s u m b
p; ParsecT s u m ()
forall {u}. ParsecT s u m ()
whiteSpace; b -> ParsecT s u m b
forall (m :: * -> *) a. Monad m => a -> m a
return b
x  }


    --whiteSpace
    whiteSpace :: ParsecT s u m ()
whiteSpace
        | Bool
noLine Bool -> Bool -> Bool
&& Bool
noMulti  = ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (ParsecT s u m ()
forall {u}. ParsecT s u m ()
simpleSpace ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"")
        | Bool
noLine             = ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (ParsecT s u m ()
forall {u}. ParsecT s u m ()
simpleSpace ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m ()
forall {u}. ParsecT s u m ()
multiLineComment ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"")
        | Bool
noMulti            = ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (ParsecT s u m ()
forall {u}. ParsecT s u m ()
simpleSpace ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m ()
forall {u}. ParsecT s u m ()
oneLineComment ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"")
        | Bool
otherwise          = ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany (ParsecT s u m ()
forall {u}. ParsecT s u m ()
simpleSpace ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m ()
forall {u}. ParsecT s u m ()
oneLineComment ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> ParsecT s u m ()
forall {u}. ParsecT s u m ()
multiLineComment ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"")
        where
          noLine :: Bool
noLine  = String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentLine GenLanguageDef s u m
languageDef)
          noMulti :: Bool
noMulti = String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentStart GenLanguageDef s u m
languageDef)


    simpleSpace :: ParsecT s u m ()
simpleSpace =
        ParsecT s u m Char -> ParsecT s u m ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 ((Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy Char -> Bool
isSpace)

    oneLineComment :: ParsecT s u m ()
oneLineComment =
        do{ String
_ <- ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentLine GenLanguageDef s u m
languageDef))
          ; ParsecT s u m Char -> ParsecT s u m ()
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
skipMany ((Char -> Bool) -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
(Char -> Bool) -> ParsecT s u m Char
satisfy (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
'\n'))
          ; () -> ParsecT s u m ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()
          }

    multiLineComment :: ParsecT s u m ()
multiLineComment =
        do { String
_ <- ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentStart GenLanguageDef s u m
languageDef))
           ; ParsecT s u m ()
inComment
           }

    inComment :: ParsecT s u m ()
inComment
        | GenLanguageDef s u m -> Bool
forall s u (m :: * -> *). GenLanguageDef s u m -> Bool
nestedComments GenLanguageDef s u m
languageDef  = ParsecT s u m ()
inCommentMulti
        | Bool
otherwise                = ParsecT s u m ()
forall {u}. ParsecT s u m ()
inCommentSingle

    inCommentMulti :: ParsecT s u m ()
inCommentMulti
        =   do{ String
_ <- ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentEnd GenLanguageDef s u m
languageDef)) ; () -> ParsecT s u m ()
forall (m :: * -> *) a. Monad m => a -> m a
return () }
        ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ ParsecT s u m ()
multiLineComment                     ; ParsecT s u m ()
inCommentMulti }
        ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ ParsecT s u m Char -> ParsecT s u m ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 (String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
noneOf String
startEnd)          ; ParsecT s u m ()
inCommentMulti }
        ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
_ <- String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
startEnd                  ; ParsecT s u m ()
inCommentMulti }
        ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"end of comment"
        where
          startEnd :: String
startEnd   = String -> String
forall a. Eq a => [a] -> [a]
nub (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentEnd GenLanguageDef s u m
languageDef String -> String -> String
forall a. [a] -> [a] -> [a]
++ GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentStart GenLanguageDef s u m
languageDef)

    inCommentSingle :: ParsecT s u m ()
inCommentSingle
        =   do{ String
_ <- ParsecT s u m String -> ParsecT s u m String
forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
try (String -> ParsecT s u m String
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m String
string (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentEnd GenLanguageDef s u m
languageDef)); () -> ParsecT s u m ()
forall (m :: * -> *) a. Monad m => a -> m a
return () }
        ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ ParsecT s u m Char -> ParsecT s u m ()
forall s (m :: * -> *) t u a.
Stream s m t =>
ParsecT s u m a -> ParsecT s u m ()
skipMany1 (String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
noneOf String
startEnd)         ; ParsecT s u m ()
inCommentSingle }
        ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
<|> do{ Char
_ <- String -> ParsecT s u m Char
forall s (m :: * -> *) u.
Stream s m Char =>
String -> ParsecT s u m Char
oneOf String
startEnd                 ; ParsecT s u m ()
inCommentSingle }
        ParsecT s u m () -> String -> ParsecT s u m ()
forall s u (m :: * -> *) a.
ParsecT s u m a -> String -> ParsecT s u m a
<?> String
"end of comment"
        where
          startEnd :: String
startEnd   = String -> String
forall a. Eq a => [a] -> [a]
nub (GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentEnd GenLanguageDef s u m
languageDef String -> String -> String
forall a. [a] -> [a] -> [a]
++ GenLanguageDef s u m -> String
forall s u (m :: * -> *). GenLanguageDef s u m -> String
commentStart GenLanguageDef s u m
languageDef)