{-# LANGUAGE Safe #-}
{-# LANGUAGE OverloadedLists #-}
{-# OPTIONS_GHC -Wno-partial-fields #-}
-- TODO: In next major, don't expose the constructors of the descriptions,
-- we want them built up by record copy for forwards compatible evolution
-- We can move this into an internal module to accommodate that if we want
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)