{-# LANGUAGE Safe #-}
{-# LANGUAGE OverloadedLists #-}
{-# OPTIONS_GHC -Wno-partial-fields #-}
module Text.Gigaparsec.Token.Descriptions (module Text.Gigaparsec.Token.Descriptions) where

import Data.Char (isSpace)
import Data.Set (Set)
import Data.Map (Map)
import Data.List.NonEmpty (NonEmpty)

type LexicalDesc :: *
data LexicalDesc = LexicalDesc { LexicalDesc -> NameDesc
nameDesc :: {-# UNPACK #-} !NameDesc
                               , LexicalDesc -> SymbolDesc
symbolDesc :: {-# UNPACK #-} !SymbolDesc
                               , LexicalDesc -> NumericDesc
numericDesc :: {-# UNPACK #-} !NumericDesc
                               , LexicalDesc -> TextDesc
textDesc :: {-# UNPACK #-} !TextDesc
                               , LexicalDesc -> SpaceDesc
spaceDesc :: {-# UNPACK #-} !SpaceDesc
                               }

plain :: LexicalDesc
plain :: LexicalDesc
plain = LexicalDesc { nameDesc :: NameDesc
nameDesc = NameDesc
plainName
                    , symbolDesc :: SymbolDesc
symbolDesc = SymbolDesc
plainSymbol
                    , numericDesc :: NumericDesc
numericDesc = NumericDesc
plainNumeric
                    , textDesc :: TextDesc
textDesc = TextDesc
plainText
                    , spaceDesc :: SpaceDesc
spaceDesc = SpaceDesc
plainSpace
                    }

type NameDesc :: *
data NameDesc = NameDesc { NameDesc -> CharPredicate
identifierStart :: !CharPredicate
                         , NameDesc -> CharPredicate
identifierLetter :: !CharPredicate
                         , NameDesc -> CharPredicate
operatorStart :: !CharPredicate
                         , NameDesc -> CharPredicate
operatorLetter :: !CharPredicate
                         }

plainName :: NameDesc
plainName :: NameDesc
plainName = NameDesc { identifierStart :: CharPredicate
identifierStart = CharPredicate
forall a. Maybe a
Nothing
                     , identifierLetter :: CharPredicate
identifierLetter = CharPredicate
forall a. Maybe a
Nothing
                     , operatorStart :: CharPredicate
operatorStart = CharPredicate
forall a. Maybe a
Nothing
                     , operatorLetter :: CharPredicate
operatorLetter = CharPredicate
forall a. Maybe a
Nothing
                     }

type SymbolDesc :: *
data SymbolDesc = SymbolDesc { SymbolDesc -> Set String
hardKeywords :: !(Set String)
                             , SymbolDesc -> Set String
hardOperators :: !(Set String)
                             , SymbolDesc -> Bool
caseSensitive :: !Bool
                             }

plainSymbol :: SymbolDesc
plainSymbol :: SymbolDesc
plainSymbol = SymbolDesc { hardKeywords :: Set String
hardKeywords = []
                         , hardOperators :: Set String
hardOperators = []
                         , caseSensitive :: Bool
caseSensitive = Bool
True
                         }

type NumericDesc :: *
data NumericDesc = NumericDesc { NumericDesc -> BreakCharDesc
literalBreakChar :: !BreakCharDesc
                               , NumericDesc -> Bool
leadingDotAllowed :: !Bool
                               , NumericDesc -> Bool
trailingDotAllowed :: !Bool
                               , NumericDesc -> Bool
leadingZerosAllowed :: !Bool
                               , NumericDesc -> PlusSignPresence
positiveSign :: !PlusSignPresence
                               -- generic number
                               , NumericDesc -> Bool
integerNumbersCanBeHexadecimal :: !Bool
                               , NumericDesc -> Bool
integerNumbersCanBeOctal :: !Bool
                               , NumericDesc -> Bool
integerNumbersCanBeBinary :: !Bool
                               , NumericDesc -> Bool
realNumbersCanBeHexadecimal :: !Bool
                               , NumericDesc -> Bool
realNumbersCanBeOctal :: !Bool
                               , NumericDesc -> Bool
realNumbersCanBeBinary :: !Bool
                               -- special literals
                               , NumericDesc -> Set Char
hexadecimalLeads :: !(Set Char)
                               , NumericDesc -> Set Char
octalLeads :: !(Set Char)
                               , NumericDesc -> Set Char
binaryLeads :: !(Set Char)
                               -- exponents
                               , NumericDesc -> ExponentDesc
decimalExponentDesc :: !ExponentDesc
                               , NumericDesc -> ExponentDesc
hexadecimalExponentDesc :: !ExponentDesc
                               , NumericDesc -> ExponentDesc
octalExponentDesc :: !ExponentDesc
                               , NumericDesc -> ExponentDesc
binaryExponentDesc :: !ExponentDesc
                               }

plainNumeric :: NumericDesc
plainNumeric :: NumericDesc
plainNumeric = NumericDesc { literalBreakChar :: BreakCharDesc
literalBreakChar = BreakCharDesc
NoBreakChar
                           , leadingDotAllowed :: Bool
leadingDotAllowed = Bool
False
                           , trailingDotAllowed :: Bool
trailingDotAllowed = Bool
False
                           , leadingZerosAllowed :: Bool
leadingZerosAllowed = Bool
True
                           , positiveSign :: PlusSignPresence
positiveSign = PlusSignPresence
PlusOptional
                           -- generic number
                           , integerNumbersCanBeHexadecimal :: Bool
integerNumbersCanBeHexadecimal = Bool
True
                           , integerNumbersCanBeOctal :: Bool
integerNumbersCanBeOctal = Bool
True
                           , integerNumbersCanBeBinary :: Bool
integerNumbersCanBeBinary = Bool
False
                           , realNumbersCanBeHexadecimal :: Bool
realNumbersCanBeHexadecimal = Bool
False
                           , realNumbersCanBeOctal :: Bool
realNumbersCanBeOctal = Bool
False
                           , realNumbersCanBeBinary :: Bool
realNumbersCanBeBinary = Bool
False
                           -- special literals
                           , hexadecimalLeads :: Set Char
hexadecimalLeads = [Char
Item (Set Char)
'x', Char
Item (Set Char)
'X']
                           , octalLeads :: Set Char
octalLeads = [Char
Item (Set Char)
'o', Char
Item (Set Char)
'O']
                           , binaryLeads :: Set Char
binaryLeads = [Char
Item (Set Char)
'b', Char
Item (Set Char)
'B']
                           -- exponents
                           , decimalExponentDesc :: ExponentDesc
decimalExponentDesc = ExponentsSupported { compulsory :: Bool
compulsory = Bool
False
                                                                      , chars :: Set Char
chars = [Char
Item (Set Char)
'e', Char
Item (Set Char)
'E']
                                                                      , base :: Int
base = Int
10
                                                                      , expSign :: PlusSignPresence
expSign = PlusSignPresence
PlusOptional
                                                                      , expLeadingZerosAllowd :: Bool
expLeadingZerosAllowd = Bool
True
                                                                      }
                           , hexadecimalExponentDesc :: ExponentDesc
hexadecimalExponentDesc = ExponentsSupported { compulsory :: Bool
compulsory = Bool
True
                                                                          , chars :: Set Char
chars = [Char
Item (Set Char)
'p', Char
Item (Set Char)
'P']
                                                                          , base :: Int
base = Int
2
                                                                          , expSign :: PlusSignPresence
expSign = PlusSignPresence
PlusOptional
                                                                          , expLeadingZerosAllowd :: Bool
expLeadingZerosAllowd = Bool
True
                                                                          }
                           , octalExponentDesc :: ExponentDesc
octalExponentDesc = ExponentsSupported { compulsory :: Bool
compulsory = Bool
True
                                                                    , chars :: Set Char
chars = [Char
Item (Set Char)
'e', Char
Item (Set Char)
'E', Char
Item (Set Char)
'p', Char
Item (Set Char)
'P']
                                                                    , base :: Int
base = Int
2
                                                                    , expSign :: PlusSignPresence
expSign = PlusSignPresence
PlusOptional
                                                                    , expLeadingZerosAllowd :: Bool
expLeadingZerosAllowd = Bool
True
                                                                    }
                           , binaryExponentDesc :: ExponentDesc
binaryExponentDesc = ExponentsSupported { compulsory :: Bool
compulsory = Bool
True
                                                                     , chars :: Set Char
chars = [Char
Item (Set Char)
'e', Char
Item (Set Char)
'E', Char
Item (Set Char)
'p', Char
Item (Set Char)
'P']
                                                                     , base :: Int
base = Int
2
                                                                     , expSign :: PlusSignPresence
expSign = PlusSignPresence
PlusOptional
                                                                     , expLeadingZerosAllowd :: Bool
expLeadingZerosAllowd = Bool
True
                                                                     }
                           }

type ExponentDesc :: *
data ExponentDesc = NoExponents
                  | ExponentsSupported { ExponentDesc -> Bool
compulsory :: !Bool
                                       , ExponentDesc -> Set Char
chars :: !(Set Char)
                                       , ExponentDesc -> Int
base :: !Int
                                       , ExponentDesc -> PlusSignPresence
expSign :: !PlusSignPresence
                                       , ExponentDesc -> Bool
expLeadingZerosAllowd :: !Bool
                                       }

type BreakCharDesc :: *
data BreakCharDesc = NoBreakChar
                   | BreakCharSupported { BreakCharDesc -> Char
breakChar :: !Char
                                        , BreakCharDesc -> Bool
allowedAfterNonDecimalPrefix :: !Bool
                                        }

type PlusSignPresence :: *
data PlusSignPresence = PlusRequired | PlusOptional | PlusIllegal

type TextDesc :: *
data TextDesc = TextDesc { TextDesc -> EscapeDesc
escapeSequences :: {-# UNPACK #-} !EscapeDesc
                         , TextDesc -> Char
characterLiteralEnd :: !Char
                         , TextDesc -> Set (String, String)
stringEnds :: !(Set (String, String))
                         , TextDesc -> Set (String, String)
multiStringEnds :: !(Set (String, String))
                         , TextDesc -> CharPredicate
graphicCharacter :: !CharPredicate
                         }

plainText :: TextDesc
plainText :: TextDesc
plainText = TextDesc { escapeSequences :: EscapeDesc
escapeSequences = EscapeDesc
plainEscape
                     , characterLiteralEnd :: Char
characterLiteralEnd = Char
'\''
                     , stringEnds :: Set (String, String)
stringEnds = [(String
"\"", String
"\"")]
                     , multiStringEnds :: Set (String, String)
multiStringEnds = []
                     , graphicCharacter :: CharPredicate
graphicCharacter = (Char -> Bool) -> CharPredicate
forall a. a -> Maybe a
Just (Char -> Char -> Bool
forall a. Ord a => a -> a -> Bool
>= Char
' ')
                     }

type EscapeDesc :: *
data EscapeDesc = EscapeDesc { EscapeDesc -> Char
escBegin :: !Char
                             , EscapeDesc -> Set Char
literals :: !(Set Char)
                             , EscapeDesc -> Map String Char
mapping :: !(Map String Char)
                             , EscapeDesc -> NumericEscape
decimalEscape :: !NumericEscape
                             , EscapeDesc -> NumericEscape
hexadecimalEscape :: !NumericEscape
                             , EscapeDesc -> NumericEscape
octalEscape :: !NumericEscape
                             , EscapeDesc -> NumericEscape
binaryEscape :: !NumericEscape
                             , EscapeDesc -> Maybe Char
emptyEscape :: !(Maybe Char)
                             , EscapeDesc -> Bool
gapsSupported :: !Bool
                             }

plainEscape :: EscapeDesc
plainEscape :: EscapeDesc
plainEscape = EscapeDesc { escBegin :: Char
escBegin = Char
'\\'
                         , literals :: Set Char
literals = [Char
Item (Set Char)
'\\']
                         , mapping :: Map String Char
mapping = []
                         , decimalEscape :: NumericEscape
decimalEscape = NumericEscape
NumericIllegal
                         , hexadecimalEscape :: NumericEscape
hexadecimalEscape = NumericEscape
NumericIllegal
                         , octalEscape :: NumericEscape
octalEscape = NumericEscape
NumericIllegal
                         , binaryEscape :: NumericEscape
binaryEscape = NumericEscape
NumericIllegal
                         , emptyEscape :: Maybe Char
emptyEscape = Maybe Char
forall a. Maybe a
Nothing
                         , gapsSupported :: Bool
gapsSupported = Bool
False
                         }

-- TODO: haskellEscape

type NumericEscape :: *
data NumericEscape = NumericIllegal
                   | NumericSupported { NumericEscape -> Maybe Char
prefix :: !(Maybe Char)
                                      , NumericEscape -> NumberOfDigits
numDigits :: !NumberOfDigits
                                      , NumericEscape -> Char
maxValue :: !Char
                                      }

type NumberOfDigits :: *
data NumberOfDigits = Unbounded | Exactly !(NonEmpty Word) | AtMost !Word

type SpaceDesc :: *
data SpaceDesc = SpaceDesc { SpaceDesc -> String
lineCommentStart :: !String
                           , SpaceDesc -> Bool
lineCommentAllowsEOF :: !Bool
                           , SpaceDesc -> String
multiLineCommentStart :: !String
                           , SpaceDesc -> String
multiLineCommentEnd :: !String
                           , SpaceDesc -> Bool
multiLineNestedComments :: !Bool
                           , SpaceDesc -> CharPredicate
space :: !CharPredicate
                           , SpaceDesc -> Bool
whitespaceIsContextDependent :: !Bool
                           }

plainSpace :: SpaceDesc
plainSpace :: SpaceDesc
plainSpace = SpaceDesc { lineCommentStart :: String
lineCommentStart = String
""
                       , lineCommentAllowsEOF :: Bool
lineCommentAllowsEOF = Bool
True
                       , multiLineCommentStart :: String
multiLineCommentStart = String
""
                       , multiLineCommentEnd :: String
multiLineCommentEnd = String
""
                       , multiLineNestedComments :: Bool
multiLineNestedComments = Bool
False
                       , space :: CharPredicate
space = (Char -> Bool) -> CharPredicate
forall a. a -> Maybe a
Just Char -> Bool
isSpace
                       , whitespaceIsContextDependent :: Bool
whitespaceIsContextDependent = Bool
False
                       }

type CharPredicate :: *
type CharPredicate = Maybe (Char -> Bool)