ModuleBNFC-2.9.5Haskell2010

BNFC.CF

32 types
1 class
89 values

PackageBNFC-2.9.5
Exports122
LanguageHaskell2010
LicenceBSD-3-Clause
SourceCF.hs

typetype List1 = NonEmpty

typetype CF = CFG RFun

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

typetype Rule = Rul RFun

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

  function_name . Main_Cat ::= sequence

datadata Rul function

Polymorphic rule type.

Constructors

Rule
- 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?

Instances5Functor, Eq, Pretty, IsFun, FixTokenCats

Functor RulDefined in BNFC-2.9.5 · BNFC.CF
Eq function => Eq (Rul function)Defined in BNFC-2.9.5 · BNFC.CF
Pretty function => Pretty (Rul function)Defined in BNFC-2.9.5 · BNFC.CF
IsFun a => IsFun (Rul a)Defined in BNFC-2.9.5 · BNFC.CF
FixTokenCats (Rul f)Defined in BNFC-2.9.5 · BNFC.GetCF

datadata InternalRule

Constructors

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

Instances1Eq

Eq InternalRuleDefined in BNFC-2.9.5 · BNFC.CF

typetype SentForm = [Either Cat String]

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

datadata CFG function

Type of context-free grammars (GFG).

Constructors

CFG
- 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.

Instances2Functor, FixTokenCats

Functor CFGDefined in BNFC-2.9.5 · BNFC.CF
FixTokenCats (CFG f)Defined in BNFC-2.9.5 · BNFC.GetCF

typetype Signature = Map String (WithPosition Type)

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

typetype Base = Base' String

Type of a non-terminal.

datadata Base' a

Constructors

BaseT a
ListT (Base' a)

Instances4Functor, Show, Eq, Ord

Functor Base'Defined in BNFC-2.9.5 · BNFC.CF
Show BaseDefined in BNFC-2.9.5 · BNFC.CF
Eq a => Eq (Base' a)Defined in BNFC-2.9.5 · BNFC.CF
Ord a => Ord (Base' a)Defined in BNFC-2.9.5 · BNFC.CF

datadata Type

Type of a rule label.

Constructors

FunT [Base] Base

Instances3Eq, Ord, Show

Eq TypeDefined in BNFC-2.9.5 · BNFC.CF
Ord TypeDefined in BNFC-2.9.5 · BNFC.CF
Show TypeDefined in BNFC-2.9.5 · BNFC.CF

valuedummyBase :: Base

Placeholder for a type.

valuedummyType :: Type

Placeholder for a function type.

datadata Exp' f

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

Instances2Eq, Pretty

Eq f => Eq (Exp' f)Defined in BNFC-2.9.5 · BNFC.CF
(IsFun f, Pretty f) => Pretty (Exp' f)Defined in BNFC-2.9.5 · BNFC.CF

typetype Exp = Exp' String

datadata Pragma

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

Instances1FixTokenCats

FixTokenCats PragmaDefined in BNFC-2.9.5 · BNFC.GetCF

datadata Define

Constructors

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

typetype Telescope = [(String, Base)]

Function arguments with type.

valueisFunDef :: Pragma -> Either Pragma Define

For use with partitionEithers.

valuedefinitions :: CFG f -> [Define]

All define pragmas of the grammar.

typetype LayoutKeyWords = [(KeyWord, Delimiters)]

datadata Delimiters

List delimiters.

Constructors

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

Instances1Show

Show DelimitersDefined in BNFC-2.9.5 · BNFC.CF

valuetokenPragmas :: CFG f -> [(TokenCat, Reg)]

User-defined regular expression tokens

valuetokenNames :: CFG f -> [String]

The names of all user-defined tokens.

valuelayoutPragmas :: CF -> (Maybe Symbol, LayoutKeyWords, [KeyWord])

valuehasLayout_ :: (Maybe Symbol, LayoutKeyWords, [KeyWord]) -> Bool

valuehasLayout :: CF -> Bool

typetype Literal = String

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

typetype Symbol = String

typetype KeyWord = String

datadata Position

Source positions.

Constructors

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

Instances4Eq, Ord, Show, MonadReader

Eq PositionDefined in BNFC-2.9.5 · BNFC.CF
Ord PositionDefined in BNFC-2.9.5 · BNFC.CF
Show PositionDefined in BNFC-2.9.5 · BNFC.CF
MonadReader Position ErrDefined in BNFC-2.9.5 · BNFC.TypeChecker

valueprettyPosition :: Position -> String

datadata WithPosition a

Constructors

WithPosition
- wpPosition :: Position
- wpThing :: a

Instances10Functor, IsString, Foldable, Traversable, Eq, Ord, …

Functor WithPositionDefined in BNFC-2.9.5 · BNFC.CF
IsString RFunDefined in BNFC-2.9.5 · BNFC.CF
Foldable WithPositionDefined in BNFC-2.9.5 · BNFC.CF
Traversable WithPositionDefined in BNFC-2.9.5 · BNFC.CF
Eq a => Eq (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
Ignore position in equality and ordering.
Ord a => Ord (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
Show a => Show (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
Pretty a => Pretty (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
IsFun a => IsFun (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
FixTokenCats a => FixTokenCats (WithPosition a)Defined in BNFC-2.9.5 · BNFC.GetCF

valuenoPosition :: a -> WithPosition a

typetype RString = WithPosition String

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

valueblendInPosition :: RString -> String

Prefix string with pretty-printed position information.

typetype RCat = WithPosition Cat

valuevalCat :: Rul fun -> Cat

valuenpRule :: Fun -> Cat -> SentForm -> InternalRule -> Rule

valuenpIdentifier :: String -> Identifier

datadata Cat

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.

Instances6Eq, Ord, Show, Pretty, FixTokenCats

Eq CatDefined in BNFC-2.9.5 · BNFC.CF
Ord CatDefined in BNFC-2.9.5 · BNFC.CF
Show CatDefined in BNFC-2.9.5 · BNFC.CF
This instance is for the Hspec test suite.
Pretty CatDefined in BNFC-2.9.5 · BNFC.CF
FixTokenCats CatDefined in BNFC-2.9.5 · BNFC.GetCF
Change the constructor of categories with the given names from Cat to TokenCat >>> fixTokenCats [A] (Cat A) == TokenCat A True >>> fixTokenCats [A] (ListCat (Cat A)) == ListCat (TokenCat A) True >>> fixTokenCats [A] (Cat B) == Cat B True
FixTokenCats (Either Cat String)Defined in BNFC-2.9.5 · BNFC.GetCF

typetype TokenCat = String

typetype BaseCat = String

typetype NonTerminal = Cat

valuecatToStr :: Cat -> String

Render category symbols as strings

valuestrToCat :: String -> Cat

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.

valuecatString :: TokenCat

valuecatInteger :: TokenCat

valuecatDouble :: TokenCat

valuecatChar :: TokenCat

valuecatIdent :: TokenCat

valuebaseTokenCatNames :: [TokenCat]

Token categories corresponding to base types.

valuespecialCatsP :: [TokenCat]

valueisDataCat :: Cat -> Bool

Does the category correspond to a data type?

valueisDataOrListCat :: Cat -> Bool

valuesameCat :: Cat -> Cat -> Bool

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.

Example1 expression

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

valuenormCat :: Cat -> Cat

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

valuenormCatOfList :: Cat -> Cat

valueidentCat :: Cat -> String

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)

valueidentType :: Base -> String

valuecatOfType :: [TokenCat] -> Base -> Cat

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

valueisList :: Cat -> Bool

valuebaseCat :: Cat -> Either BaseCat TokenCat

Get the underlying category identifier.

valueisTokenCat :: Cat -> Bool

valuemaybeTokenCat :: Cat -> Maybe TokenCat

valuecatOfList :: Cat -> Cat

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

typetype Fun = String

Fun is the function name of a rule.

typetype RFun = RString

classclass IsFun a where

Methods

funName :: a -> String
isNilFun :: a -> Bool
isOneFun :: a -> Bool
isConsFun :: a -> Bool
isConcatFun :: a -> Bool
isCoercion :: a -> Bool
Is this function just a coercion? (I.e. the identity)

Instances4IsFun

IsFun StringDefined in BNFC-2.9.5 · BNFC.CF
IsFun a => IsFun (Rul a)Defined in BNFC-2.9.5 · BNFC.CF
IsFun a => IsFun (WithPosition a)Defined in BNFC-2.9.5 · BNFC.CF
IsFun a => IsFun (k, a)Defined in BNFC-2.9.5 · BNFC.CF

valuefunNameSatisfies :: IsFun a => (String -> Bool) -> a -> Bool

valueisDefinedRule :: IsFun a => a -> Bool

valueisProperLabel :: IsFun a => a -> Bool

valueisNilCons :: IsFun a => a -> Bool

typetype Data = (Cat, [(String, [Cat])])

The abstract syntax of a grammar.

valuefirstEntry :: CF -> Cat

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

valueallNames :: CF -> [RString]

Constructors and categories.

valuefilterNonUnique :: Ord a => [a] -> [a]

Get all elements with more than one occurrence.

valuecommentPragmas :: [Pragma] -> [Pragma]

Extract the comment pragmas.

valuelookupRule :: Eq f => f -> [Rul f] -> Maybe (Cat, SentForm)

valuerulesForCat :: CF -> Cat -> [Rule]

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

valueremoveWhiteSpaceSeparators :: Rul f -> Rul f

valuemapRhs :: (SentForm -> SentForm) -> Rul f -> Rul f

Modify the rhsRule part of a Rule.

valuerulesForNormalizedCat :: CF -> Cat -> [Rule]

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

valuerulesForCat' :: CF -> Cat -> [Rule]

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

valueallCats :: (InternalRule -> Bool) -> CFG f -> [Cat]

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

valuereallyAllCats :: CFG f -> [Cat]

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

valueallParserCats :: CFG f -> [Cat]

valueallCatsIdNorm :: CF -> [RString]

Gets all normalized identified Categories

valueallCatsNorm :: CF -> [Cat]

Get all normalized Cat

valueallParserCatsNorm :: CFG f -> [Cat]

Get all normalized Cat

valueisUsedCat :: CFG f -> Cat -> Bool

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

valueruleGroups :: CF -> [(Cat, [Rule])]

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

valueruleGroupsInternals :: CF -> [(Cat, [Rule])]

Group all categories with their rules including internal rules.

valueliterals :: CFG f -> [TokenCat]

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

valuereservedWords :: CFG f -> [String]

Get the keywords of a grammar.

valuecfTokens :: CFG f -> [(String, Int)]

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

valuecomments :: CF -> ([(String, String)], [String])

Comments can be defined by the comment pragma

valuenumberOfBlockCommentForms :: CF -> Int

Number of block comment forms defined in the grammar file.

valuehasIdent :: CFG f -> Bool

Whether the grammar uses the predefined Ident type.

valuespecialCats :: CF -> [TokenCat]

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

abstract syntax trees: data type definitions

22 declarations

valuegetAbstractSyntax :: CF -> [Data]

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

valuecf2data' :: (Cat -> Bool) -> CF -> [Data]

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.

valuecf2data :: CF -> [Data]

valuecf2dataLists :: CF -> [Data]

valuespecialData :: CF -> [Data]

valuesigLookup :: IsFun a => a -> CF -> Maybe (WithPosition Type)

Get the type of a rule label.

valueisParsable :: Rul f -> Bool

Checks if the rule is parsable.

valuehasNilRule :: [Rule] -> Maybe Rule

valuehasSingletonRule :: [Rule] -> Maybe Rule

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

valuesortRulesByPrecedence :: [Rule] -> [(Integer, Rule)]

Sort rules by descending precedence.

valueisEmptyListCat :: CF -> Cat -> Bool

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

valueisNonterm :: Either Cat String -> Bool

valuerevSepListRule :: Rul f -> Rul f

valuefindAllReversibleCats :: CF -> [Cat]

valueisEmptyNilRule :: IsFun a => Rul a -> Bool

valueprecCat :: Cat -> Integer

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

valueprecRule :: Rul f -> Integer

valuehasIdentLikeTokens :: CFG g -> Bool

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

valuehasTextualTokens :: CFG g -> Bool

Defines or uses the grammar token types or Ident?

valuehasPositionTokens :: CFG g -> Bool

Is there a position token declaration in the grammar?

valueisPositionCat :: CFG f -> TokenCat -> Bool

Does the category have a position stored in AST?

valueallEntryPoints :: CFG f -> List1 Cat

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).