{-# 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
, NumericDesc -> Bool
integerNumbersCanBeHexadecimal :: !Bool
, NumericDesc -> Bool
integerNumbersCanBeOctal :: !Bool
, NumericDesc -> Bool
integerNumbersCanBeBinary :: !Bool
, NumericDesc -> Bool
realNumbersCanBeHexadecimal :: !Bool
, NumericDesc -> Bool
realNumbersCanBeOctal :: !Bool
, NumericDesc -> Bool
realNumbersCanBeBinary :: !Bool
, NumericDesc -> Set Char
hexadecimalLeads :: !(Set Char)
, NumericDesc -> Set Char
octalLeads :: !(Set Char)
, NumericDesc -> Set Char
binaryLeads :: !(Set Char)
, 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
, 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
, 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']
, 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
}
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 { :: !String
, :: !Bool
, :: !String
, :: !String
, :: !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)