Safe Haskell	None
Language	Haskell2010

BNFC.CF

Contents

abstract syntax trees: data type definitions

Synopsis

type List1 = NonEmpty
type CF = CFG RFun
type Rule = Rul RFun
data Rul function = Rule {
- funRule :: function
- valRCat :: RCat
- rhsRule :: SentForm
- internal :: InternalRule
}
data InternalRule
- = Internal
- | Parsable
type SentForm = [Either Cat String]
data CFG function = CFG {
- cfgPragmas :: [Pragma]
- cfgUsedCats :: Set Cat
- cfgLiterals :: [Literal]
- cfgSymbols :: [Symbol]
- cfgKeywords :: [KeyWord]
- cfgReversibleCats :: [Cat]
- cfgRules :: [Rul function]
- cfgSignature :: Signature
}
type Signature = Map String (WithPosition Type)
data Base
- = BaseT String
- | ListT Base
data Type = FunT [Base] Base
dummyBase :: Base
dummyType :: Type
data Exp' f
- = App f Type [Exp' f]
- | Var String
- | LitInt Integer
- | LitDouble Double
- | LitChar Char
- | LitString String
type Exp = Exp' String
data Pragma
- = CommentS String
- | CommentM (String, String)
- | TokenReg RString Bool Reg
- | EntryPoints [RCat]
- | Layout LayoutKeyWords
- | LayoutStop [KeyWord]
- | LayoutTop Symbol
- | FunDef Define
data Define = Define {
- defName :: RFun
- defArgs :: Telescope
- defBody :: Exp
- defType :: Base
}
type Telescope = [(String, Base)]
isFunDef :: Pragma -> Either Pragma Define
definitions :: CFG f -> [Define]
type LayoutKeyWords = [(KeyWord, Delimiters)]
data Delimiters = Delimiters {
- listSep :: Symbol
- listOpen :: Symbol
- listClose :: Symbol
}
tokenPragmas :: CFG f -> [(TokenCat, Reg)]
tokenNames :: CFG f -> [String]
layoutPragmas :: CF -> (Maybe Symbol, LayoutKeyWords, [KeyWord])
hasLayout_ :: (Maybe Symbol, LayoutKeyWords, [KeyWord]) -> Bool
hasLayout :: CF -> Bool
type Literal = String
type Symbol = String
type KeyWord = String
data Position
- = NoPosition
- | Position {
  - posFile :: FilePath
  - posLine :: Int
  - posColumn :: Int
  }
prettyPosition :: Position -> String
data WithPosition a = WithPosition {
- wpPosition :: Position
- wpThing :: a
}
noPosition :: a -> WithPosition a
type RString = WithPosition String
blendInPosition :: RString -> String
type RCat = WithPosition Cat
valCat :: Rul fun -> Cat
npRule :: Fun -> Cat -> SentForm -> InternalRule -> Rule
npIdentifier :: String -> Identifier
data Cat
- = Cat String
- | TokenCat TokenCat
- | ListCat Cat
- | CoercCat String Integer
type TokenCat = String
type BaseCat = String
type NonTerminal = Cat
catToStr :: Cat -> String
strToCat :: String -> Cat
catString :: TokenCat
catInteger :: TokenCat
catDouble :: TokenCat
catChar :: TokenCat
catIdent :: TokenCat
baseTokenCatNames :: [TokenCat]
specialCatsP :: [TokenCat]
isDataCat :: Cat -> Bool
isDataOrListCat :: Cat -> Bool
sameCat :: Cat -> Cat -> Bool
normCat :: Cat -> Cat
normCatOfList :: Cat -> Cat
identCat :: Cat -> String
identType :: Base -> String
catOfType :: [TokenCat] -> Base -> Cat
isList :: Cat -> Bool
baseCat :: Cat -> Either BaseCat TokenCat
isTokenCat :: Cat -> Bool
maybeTokenCat :: Cat -> Maybe TokenCat
catOfList :: Cat -> Cat
type Fun = String
type RFun = RString
class IsFun a where
- funName :: a -> String
- isNilFun :: a -> Bool
- isOneFun :: a -> Bool
- isConsFun :: a -> Bool
- isConcatFun :: a -> Bool
- isCoercion :: a -> Bool
funNameSatisfies :: IsFun a => (String -> Bool) -> a -> Bool
isDefinedRule :: IsFun a => a -> Bool
isProperLabel :: IsFun a => a -> Bool
isNilCons :: IsFun a => a -> Bool
type Data = (Cat, [(String, [Cat])])
firstEntry :: CF -> Cat
allNames :: CF -> [RString]
filterNonUnique :: Ord a => [a] -> [a]
commentPragmas :: [Pragma] -> [Pragma]
lookupRule :: Eq f => f -> [Rul f] -> Maybe (Cat, SentForm)
rulesForCat :: CF -> Cat -> [Rule]
removeWhiteSpaceSeparators :: Rul f -> Rul f
mapRhs :: (SentForm -> SentForm) -> Rul f -> Rul f
rulesForNormalizedCat :: CF -> Cat -> [Rule]
rulesForCat' :: CF -> Cat -> [Rule]
allCats :: (InternalRule -> Bool) -> CFG f -> [Cat]
reallyAllCats :: CFG f -> [Cat]
allParserCats :: CFG f -> [Cat]
allCatsIdNorm :: CF -> [RString]
allCatsNorm :: CF -> [Cat]
allParserCatsNorm :: CFG f -> [Cat]
isUsedCat :: CFG f -> Cat -> Bool
ruleGroups :: CF -> [(Cat, [Rule])]
ruleGroupsInternals :: CF -> [(Cat, [Rule])]
literals :: CFG f -> [TokenCat]
reservedWords :: CFG f -> [String]
cfTokens :: CFG f -> [(String, Int)]
comments :: CF -> ([(String, String)], [String])
numberOfBlockCommentForms :: CF -> Int
hasIdent :: CFG f -> Bool
specialCats :: CF -> [TokenCat]
getAbstractSyntax :: CF -> [Data]
cf2data' :: (Cat -> Bool) -> CF -> [Data]
cf2data :: CF -> [Data]
cf2dataLists :: CF -> [Data]
specialData :: CF -> [Data]
sigLookup :: IsFun a => a -> CF -> Maybe (WithPosition Type)
isParsable :: Rul f -> Bool
hasNilRule :: [Rule] -> Maybe Rule
hasSingletonRule :: [Rule] -> Maybe Rule
sortRulesByPrecedence :: [Rule] -> [(Integer, Rule)]
isEmptyListCat :: CF -> Cat -> Bool
isNonterm :: Either Cat String -> Bool
revSepListRule :: Rul f -> Rul f
findAllReversibleCats :: CF -> [Cat]
isEmptyNilRule :: IsFun a => Rul a -> Bool
precCat :: Cat -> Integer
precRule :: Rul f -> Integer
hasIdentLikeTokens :: CFG g -> Bool
hasTextualTokens :: CFG g -> Bool
hasPositionTokens :: CFG g -> Bool
isPositionCat :: CFG f -> TokenCat -> Bool
allEntryPoints :: CFG f -> List1 Cat

Documentation

type List1 = NonEmpty Source #

type CF = CFG RFun Source #

A context free grammar consists of a set of rules and some extended information (e.g. pragmas, literals, symbols, keywords).

type Rule = Rul RFun Source #

A rule consists of a function name, a main category and a sequence of terminals and non-terminals.

  function_name . Main_Cat ::= sequence

data Rul function Source #

Polymorphic rule type.

Constructors

Rule

Fields

funRule :: function
The function (semantic action) of a rule. In order to be able to generate data types this must be a constructor (or an identity function).
valRCat :: RCat
The value category, i.e., the defined non-terminal.
rhsRule :: SentForm
The sentential form, i.e., the list of (non)terminals in the right-hand-side of a rule.
internal :: InternalRule
Is this an "internal" rule only for the AST and printing, not for parsing?

Instances

Instances details

Functor Rul Source #
Instance details Defined in BNFC.CF Methods fmap :: (a -> b) -> Rul a -> Rul b # (<$) :: a -> Rul b -> Rul a #
Eq function => Eq (Rul function) Source #
Instance details Defined in BNFC.CF Methods (==) :: Rul function -> Rul function -> Bool # (/=) :: Rul function -> Rul function -> Bool #
Pretty function => Pretty (Rul function) Source #
Instance details Defined in BNFC.CF Methods pretty :: Rul function -> Doc Source # prettyPrec :: Int -> Rul function -> Doc Source #
IsFun a => IsFun (Rul a) Source #
Instance details Defined in BNFC.CF Methods funName :: Rul a -> String Source # isNilFun :: Rul a -> Bool Source # isOneFun :: Rul a -> Bool Source # isConsFun :: Rul a -> Bool Source # isConcatFun :: Rul a -> Bool Source # isCoercion :: Rul a -> Bool Source #

data InternalRule Source #

Constructors

Internal	`internal` rule (only for AST & printer)
Parsable	ordinary rule (also for parser)

Instances

Instances details

Eq InternalRule Source #
Instance details Defined in BNFC.CF Methods (==) :: InternalRule -> InternalRule -> Bool # (/=) :: InternalRule -> InternalRule -> Bool #

type SentForm = [Either Cat String] Source #

A sentential form is a sequence of non-terminals or terminals.

data CFG function Source #

Type of context-free grammars (GFG).

Constructors

CFG

Fields

cfgPragmas :: [Pragma]
cfgUsedCats :: Set Cat
Categories used by the parser.
cfgLiterals :: [Literal]
Char, String, Ident, Integer, Double. Strings are quoted strings, and Idents are unquoted.
cfgSymbols :: [Symbol]
Symbols in the grammar, e.g. “*”, “->”.
cfgKeywords :: [KeyWord]
Reserved words, e.g. if, while.
cfgReversibleCats :: [Cat]
Categories that can be made left-recursive.
cfgRules :: [Rul function]
cfgSignature :: Signature
Types of rule labels, computed from cfgRules.

Instances

Instances details

Functor CFG Source #
Instance details Defined in BNFC.CF Methods fmap :: (a -> b) -> CFG a -> CFG b # (<$) :: a -> CFG b -> CFG a #

type Signature = Map String (WithPosition Type) Source #

Types of the rule labels, together with the position of the rule label.

data Base Source #

Type of a non-terminal.

Constructors

BaseT String
ListT Base

Instances

Instances details

Eq Base Source #
Instance details Defined in BNFC.CF Methods (==) :: Base -> Base -> Bool # (/=) :: Base -> Base -> Bool #
Ord Base Source #
Instance details Defined in BNFC.CF Methods compare :: Base -> Base -> Ordering # (<) :: Base -> Base -> Bool # (<=) :: Base -> Base -> Bool # (>) :: Base -> Base -> Bool # (>=) :: Base -> Base -> Bool # max :: Base -> Base -> Base # min :: Base -> Base -> Base #
Show Base Source #
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> Base -> ShowS # show :: Base -> String # showList :: [Base] -> ShowS #

data Type Source #

Type of a rule label.

Constructors

FunT [Base] Base

Instances

Instances details

Eq Type Source #
Instance details Defined in BNFC.CF Methods (==) :: Type -> Type -> Bool # (/=) :: Type -> Type -> Bool #
Ord Type Source #
Instance details Defined in BNFC.CF Methods compare :: Type -> Type -> Ordering # (<) :: Type -> Type -> Bool # (<=) :: Type -> Type -> Bool # (>) :: Type -> Type -> Bool # (>=) :: Type -> Type -> Bool # max :: Type -> Type -> Type # min :: Type -> Type -> Type #
Show Type Source #
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> Type -> ShowS # show :: Type -> String # showList :: [Type] -> ShowS #

dummyBase :: Base Source #

Placeholder for a type.

dummyType :: Type Source #

Placeholder for a function type.

data Exp' f Source #

Expressions for function definitions.

Constructors

App f Type [Exp' f]	(Possibly defined) label applied to expressions. The function `Type` is inferred by the type checker.
Var String	Function parameter.
LitInt Integer
LitDouble Double
LitChar Char
LitString String

Instances

Instances details

Eq f => Eq (Exp' f) Source #
Instance details Defined in BNFC.CF Methods (==) :: Exp' f -> Exp' f -> Bool # (/=) :: Exp' f -> Exp' f -> Bool #
(IsFun f, Pretty f) => Pretty (Exp' f) Source #
Instance details Defined in BNFC.CF Methods pretty :: Exp' f -> Doc Source # prettyPrec :: Int -> Exp' f -> Doc Source #

type Exp = Exp' String Source #

data Pragma Source #

Pragmas.

Constructors

CommentS String	for single line comments
CommentM (String, String)	for multiple-line comments.
TokenReg RString Bool Reg	for tokens
EntryPoints [RCat]
Layout LayoutKeyWords
LayoutStop [KeyWord]
LayoutTop Symbol	Separator for top-level layout.
FunDef Define

data Define Source #

Constructors

Define
Fields defName :: RFun defArgs :: Telescope Argument types inferred by the type checker. defBody :: Exp defType :: Base Type of the body, inferred by the type checker.

type Telescope = [(String, Base)] Source #

Function arguments with type.

isFunDef :: Pragma -> Either Pragma Define Source #

For use with partitionEithers.

definitions :: CFG f -> [Define] Source #

All define pragmas of the grammar.

type LayoutKeyWords = [(KeyWord, Delimiters)] Source #

data Delimiters Source #

List delimiters.

Constructors

Delimiters
Fields listSep :: Symbol List separator. listOpen :: Symbol List opening delimiter. listClose :: Symbol List closing delimiter.

Instances

Instances details

Show Delimiters Source #
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> Delimiters -> ShowS # show :: Delimiters -> String # showList :: [Delimiters] -> ShowS #

tokenPragmas :: CFG f -> [(TokenCat, Reg)] Source #

User-defined regular expression tokens

tokenNames :: CFG f -> [String] Source #

The names of all user-defined tokens.

layoutPragmas :: CF -> (Maybe Symbol, LayoutKeyWords, [KeyWord]) Source #

hasLayout_ :: (Maybe Symbol, LayoutKeyWords, [KeyWord]) -> Bool Source #

hasLayout :: CF -> Bool Source #

type Literal = String Source #

Literal: builtin-token types Char, String, Ident, Integer, Double.

type Symbol = String Source #

type KeyWord = String Source #

data Position Source #

Source positions.

Constructors

NoPosition
Position
Fields posFile :: FilePath Name of the grammar file. posLine :: Int Line in the grammar file. posColumn :: Int Column in the grammar file.

Instances

Instances details

Eq Position Source #
Instance details Defined in BNFC.CF Methods (==) :: Position -> Position -> Bool # (/=) :: Position -> Position -> Bool #
Ord Position Source #
Instance details Defined in BNFC.CF Methods compare :: Position -> Position -> Ordering # (<) :: Position -> Position -> Bool # (<=) :: Position -> Position -> Bool # (>) :: Position -> Position -> Bool # (>=) :: Position -> Position -> Bool # max :: Position -> Position -> Position # min :: Position -> Position -> Position #
Show Position Source #
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> Position -> ShowS # show :: Position -> String # showList :: [Position] -> ShowS #

prettyPosition :: Position -> String Source #

data WithPosition a Source #

Constructors

WithPosition
Fields wpPosition :: Position wpThing :: a

Instances

Instances details

Functor WithPosition Source #
Instance details Defined in BNFC.CF Methods fmap :: (a -> b) -> WithPosition a -> WithPosition b # (<$) :: a -> WithPosition b -> WithPosition a #
IsString RFun Source #
Instance details Defined in BNFC.CF Methods fromString :: String -> RFun #
Foldable WithPosition Source #
Instance details Defined in BNFC.CF Methods fold :: Monoid m => WithPosition m -> m # foldMap :: Monoid m => (a -> m) -> WithPosition a -> m # foldMap' :: Monoid m => (a -> m) -> WithPosition a -> m # foldr :: (a -> b -> b) -> b -> WithPosition a -> b # foldr' :: (a -> b -> b) -> b -> WithPosition a -> b # foldl :: (b -> a -> b) -> b -> WithPosition a -> b # foldl' :: (b -> a -> b) -> b -> WithPosition a -> b # foldr1 :: (a -> a -> a) -> WithPosition a -> a # foldl1 :: (a -> a -> a) -> WithPosition a -> a # toList :: WithPosition a -> [a] # null :: WithPosition a -> Bool # length :: WithPosition a -> Int # elem :: Eq a => a -> WithPosition a -> Bool # maximum :: Ord a => WithPosition a -> a # minimum :: Ord a => WithPosition a -> a # sum :: Num a => WithPosition a -> a # product :: Num a => WithPosition a -> a #
Traversable WithPosition Source #
Instance details Defined in BNFC.CF Methods traverse :: Applicative f => (a -> f b) -> WithPosition a -> f (WithPosition b) # sequenceA :: Applicative f => WithPosition (f a) -> f (WithPosition a) # mapM :: Monad m => (a -> m b) -> WithPosition a -> m (WithPosition b) # sequence :: Monad m => WithPosition (m a) -> m (WithPosition a) #
Eq a => Eq (WithPosition a) Source #	Ignore position in equality and ordering.
Instance details Defined in BNFC.CF Methods (==) :: WithPosition a -> WithPosition a -> Bool # (/=) :: WithPosition a -> WithPosition a -> Bool #
Ord a => Ord (WithPosition a) Source #
Instance details Defined in BNFC.CF Methods compare :: WithPosition a -> WithPosition a -> Ordering # (<) :: WithPosition a -> WithPosition a -> Bool # (<=) :: WithPosition a -> WithPosition a -> Bool # (>) :: WithPosition a -> WithPosition a -> Bool # (>=) :: WithPosition a -> WithPosition a -> Bool # max :: WithPosition a -> WithPosition a -> WithPosition a # min :: WithPosition a -> WithPosition a -> WithPosition a #
Show a => Show (WithPosition a) Source #
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> WithPosition a -> ShowS # show :: WithPosition a -> String # showList :: [WithPosition a] -> ShowS #
Pretty a => Pretty (WithPosition a) Source #
Instance details Defined in BNFC.CF Methods pretty :: WithPosition a -> Doc Source # prettyPrec :: Int -> WithPosition a -> Doc Source #
IsFun a => IsFun (WithPosition a) Source #
Instance details Defined in BNFC.CF Methods funName :: WithPosition a -> String Source # isNilFun :: WithPosition a -> Bool Source # isOneFun :: WithPosition a -> Bool Source # isConsFun :: WithPosition a -> Bool Source # isConcatFun :: WithPosition a -> Bool Source # isCoercion :: WithPosition a -> Bool Source #

noPosition :: a -> WithPosition a Source #

type RString = WithPosition String Source #

A "ranged string" (terminology from Agda code base).

blendInPosition :: RString -> String Source #

Prefix string with pretty-printed position information.

type RCat = WithPosition Cat Source #

valCat :: Rul fun -> Cat Source #

npRule :: Fun -> Cat -> SentForm -> InternalRule -> Rule Source #

npIdentifier :: String -> Identifier Source #

data Cat Source #

Categories are the non-terminals of the grammar.

Constructors

Cat String	Ordinary non-terminal.
TokenCat TokenCat	Token types (like `Ident`, `Integer`, ..., user-defined).
ListCat Cat	List non-terminals, e.g., `[Ident]`, `[Exp]`, `[Exp1]`.
CoercCat String Integer	E.g. `Exp1`, `Exp2`.

Instances

Instances details

Eq Cat Source #
Instance details Defined in BNFC.CF Methods (==) :: Cat -> Cat -> Bool # (/=) :: Cat -> Cat -> Bool #
Ord Cat Source #
Instance details Defined in BNFC.CF Methods compare :: Cat -> Cat -> Ordering # (<) :: Cat -> Cat -> Bool # (<=) :: Cat -> Cat -> Bool # (>) :: Cat -> Cat -> Bool # (>=) :: Cat -> Cat -> Bool # max :: Cat -> Cat -> Cat # min :: Cat -> Cat -> Cat #
Show Cat Source #	This instance is for the Hspec test suite.
Instance details Defined in BNFC.CF Methods showsPrec :: Int -> Cat -> ShowS # show :: Cat -> String # showList :: [Cat] -> ShowS #
Pretty Cat Source #
Instance details Defined in BNFC.CF Methods pretty :: Cat -> Doc Source # prettyPrec :: Int -> Cat -> Doc Source #

type TokenCat = String Source #

type BaseCat = String Source #

type NonTerminal = Cat Source #

catToStr :: Cat -> String Source #

Render category symbols as strings

strToCat :: String -> Cat Source #

Reads a string into a category. This should only need to handle the case of simple categories (with or without coercion) since list categories are parsed in the grammar already. To be on the safe side here, we still call the parser function that parses categries.

catString :: TokenCat Source #

catInteger :: TokenCat Source #

catDouble :: TokenCat Source #

catChar :: TokenCat Source #

catIdent :: TokenCat Source #

baseTokenCatNames :: [TokenCat] Source #

Token categories corresponding to base types.

specialCatsP :: [TokenCat] Source #

isDataCat :: Cat -> Bool Source #

Does the category correspond to a data type?

isDataOrListCat :: Cat -> Bool Source #

sameCat :: Cat -> Cat -> Bool Source #

Categories C1, C2,... (one digit at the end) are variants of C. This function returns true if two category are variants of the same abstract category. E.g.

>>> sameCat (Cat "Abc") (CoercCat "Abc" 44)
True

normCat :: Cat -> Cat Source #

Removes precedence information. C1 => C, [C2] => [C]

normCatOfList :: Cat -> Cat Source #

identCat :: Cat -> String Source #

When given a list Cat, i.e. '[C]', it removes the square brackets, and adds the prefix List, i.e. ListC. (for Happy and Latex)

identType :: Base -> String Source #

catOfType :: [TokenCat] -> Base -> Cat Source #

Reconstruct (non-coercion) category from a type, given a list of what should be the token categories.

isList :: Cat -> Bool Source #

baseCat :: Cat -> Either BaseCat TokenCat Source #

Get the underlying category identifier.

isTokenCat :: Cat -> Bool Source #

maybeTokenCat :: Cat -> Maybe TokenCat Source #

catOfList :: Cat -> Cat Source #

Unwraps the list constructor from the category name. E.g. [C1] => C1.

type Fun = String Source #

Fun is the function name of a rule.

type RFun = RString Source #

class IsFun a where Source #

Minimal complete definition

funName

Methods

funName :: a -> String Source #

isNilFun Source #

Arguments

:: a
-> Bool	Is this the constructor for empty lists?

isOneFun Source #

Arguments

:: a
-> Bool	Is this the constructor for singleton lists?

isConsFun Source #

Arguments

:: a
-> Bool	Is this the list constructor?

isConcatFun Source #

Arguments

:: a
-> Bool	Is this list concatenation?

isCoercion :: a -> Bool Source #

Is this function just a coercion? (I.e. the identity)

Instances

Instances details

IsFun String Source #
Instance details Defined in BNFC.CF Methods funName :: String -> String Source # isNilFun :: String -> Bool Source # isOneFun :: String -> Bool Source # isConsFun :: String -> Bool Source # isConcatFun :: String -> Bool Source # isCoercion :: String -> Bool Source #
IsFun a => IsFun (WithPosition a) Source #
Instance details Defined in BNFC.CF Methods funName :: WithPosition a -> String Source # isNilFun :: WithPosition a -> Bool Source # isOneFun :: WithPosition a -> Bool Source # isConsFun :: WithPosition a -> Bool Source # isConcatFun :: WithPosition a -> Bool Source # isCoercion :: WithPosition a -> Bool Source #
IsFun a => IsFun (Rul a) Source #
Instance details Defined in BNFC.CF Methods funName :: Rul a -> String Source # isNilFun :: Rul a -> Bool Source # isOneFun :: Rul a -> Bool Source # isConsFun :: Rul a -> Bool Source # isConcatFun :: Rul a -> Bool Source # isCoercion :: Rul a -> Bool Source #
IsFun a => IsFun (k, a) Source #
Instance details Defined in BNFC.CF Methods funName :: (k, a) -> String Source # isNilFun :: (k, a) -> Bool Source # isOneFun :: (k, a) -> Bool Source # isConsFun :: (k, a) -> Bool Source # isConcatFun :: (k, a) -> Bool Source # isCoercion :: (k, a) -> Bool Source #

funNameSatisfies :: IsFun a => (String -> Bool) -> a -> Bool Source #

isDefinedRule :: IsFun a => a -> Bool Source #

isProperLabel :: IsFun a => a -> Bool Source #

isNilCons :: IsFun a => a -> Bool Source #

type Data = (Cat, [(String, [Cat])]) Source #

The abstract syntax of a grammar.

firstEntry :: CF -> Cat Source #

firstEntry returns the first of the entrypoints, or (if none), the first parsable Category appearing in the grammar.

allNames :: CF -> [RString] Source #

Constructors and categories.

filterNonUnique :: Ord a => [a] -> [a] Source #

Get all elements with more than one occurrence.

commentPragmas :: [Pragma] -> [Pragma] Source #

Extract the comment pragmas.

lookupRule :: Eq f => f -> [Rul f] -> Maybe (Cat, SentForm) Source #

rulesForCat :: CF -> Cat -> [Rule] Source #

Returns all parseable rules that construct the given Cat. Whitespace separators have been removed.

removeWhiteSpaceSeparators :: Rul f -> Rul f Source #

mapRhs :: (SentForm -> SentForm) -> Rul f -> Rul f Source #

Modify the rhsRule part of a Rule.

rulesForNormalizedCat :: CF -> Cat -> [Rule] Source #

Like rulesForCat but for normalized value categories. I.e., `rulesForCat (Cat Exp)` will return rules for category Exp but also Exp1, Exp2... in case of coercion

rulesForCat' :: CF -> Cat -> [Rule] Source #

As rulesForCat, but this version doesn't exclude internal rules.

allCats :: (InternalRule -> Bool) -> CFG f -> [Cat] Source #

Get all categories of a grammar matching the filter. (No Cat w/o production returned; no duplicates.)

reallyAllCats :: CFG f -> [Cat] Source #

Get all categories of a grammar. (No Cat w/o production returned; no duplicates.)

allParserCats :: CFG f -> [Cat] Source #

allCatsIdNorm :: CF -> [RString] Source #

Gets all normalized identified Categories

allCatsNorm :: CF -> [Cat] Source #

Get all normalized Cat

allParserCatsNorm :: CFG f -> [Cat] Source #

Get all normalized Cat

isUsedCat :: CFG f -> Cat -> Bool Source #

Is the category is used on an rhs? Includes internal rules.

ruleGroups :: CF -> [(Cat, [Rule])] Source #

Group all parsable categories with their rules. Deletes whitespace separators, as they will not become part of the parsing rules.

ruleGroupsInternals :: CF -> [(Cat, [Rule])] Source #

Group all categories with their rules including internal rules.

literals :: CFG f -> [TokenCat] Source #

Get all literals of a grammar. (e.g. String, Double)

reservedWords :: CFG f -> [String] Source #

Get the keywords of a grammar.

cfTokens :: CFG f -> [(String, Int)] Source #

Canonical, numbered list of symbols and reserved words. (These do not end up in the AST.)

comments :: CF -> ([(String, String)], [String]) Source #

Comments can be defined by the comment pragma

numberOfBlockCommentForms :: CF -> Int Source #

Number of block comment forms defined in the grammar file.

hasIdent :: CFG f -> Bool Source #

Whether the grammar uses the predefined Ident type.

specialCats :: CF -> [TokenCat] Source #

Categories corresponding to tokens. These end up in the AST. (unlike tokens returned by cfTokens)

abstract syntax trees: data type definitions

getAbstractSyntax :: CF -> [Data] Source #

Return the abstract syntax of the grammar. All categories are normalized, so a rule like: EAdd . Exp2 ::= Exp2 "+" Exp3 ; Will give the following signature: EAdd : Exp -> Exp -> Exp

cf2data' :: (Cat -> Bool) -> CF -> [Data] Source #

All the functions below implement the idea of getting the abstract syntax of the grammar with some variation but they seem to do a poor job at handling corner cases involving coercions. Use getAbstractSyntax instead if possible.

cf2data :: CF -> [Data] Source #

cf2dataLists :: CF -> [Data] Source #

specialData :: CF -> [Data] Source #

sigLookup :: IsFun a => a -> CF -> Maybe (WithPosition Type) Source #

Get the type of a rule label.

isParsable :: Rul f -> Bool Source #

Checks if the rule is parsable.

hasNilRule :: [Rule] -> Maybe Rule Source #

hasSingletonRule :: [Rule] -> Maybe Rule Source #

Gets the singleton rule out of the rules for a list.

sortRulesByPrecedence :: [Rule] -> [(Integer, Rule)] Source #

Sort rules by descending precedence.

isEmptyListCat :: CF -> Cat -> Bool Source #

Is the given category a list category parsing also empty lists?

isNonterm :: Either Cat String -> Bool Source #

revSepListRule :: Rul f -> Rul f Source #

findAllReversibleCats :: CF -> [Cat] Source #

isEmptyNilRule :: IsFun a => Rul a -> Bool Source #

precCat :: Cat -> Integer Source #

Returns the precedence of a category symbol. E.g. >>> precCat (CoercCat Abc 4) 4

precRule :: Rul f -> Integer Source #

hasIdentLikeTokens :: CFG g -> Bool Source #

Defines or uses the grammar token types like Ident? Excludes position tokens.

hasTextualTokens :: CFG g -> Bool Source #

Defines or uses the grammar token types or Ident?

hasPositionTokens :: CFG g -> Bool Source #

Is there a position token declaration in the grammar?

isPositionCat :: CFG f -> TokenCat -> Bool Source #

Does the category have a position stored in AST?

allEntryPoints :: CFG f -> List1 Cat Source #

Categories that are entry points to the parser.

These are either the declared entrypoints (in the original order), or, if no entrypoints were declared explicitly, all parsable categories (in the order of declaration in the grammar file).