BNFC.CF

Documentation

type List1 = NonEmpty

type CF = CFG RFun

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

type 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

data Rul function

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

Functor Rul

Defined in BNFC.CF

Methods

fmap :: (a -> b) -> Rul a -> Rul b

(<$) :: a -> Rul b -> Rul a

IsFun a => IsFun (Rul a)

Defined in BNFC.CF

Methods

funName :: Rul a -> String

isNilFun :: Rul a -> Bool

isOneFun :: Rul a -> Bool

isConsFun :: Rul a -> Bool

isConcatFun :: Rul a -> Bool

isCoercion :: Rul a -> Bool

Pretty function => Pretty (Rul function)

Defined in BNFC.CF

Methods

pretty :: Rul function -> Doc

prettyPrec :: Int -> Rul function -> Doc

Eq function => Eq (Rul function)

Defined in BNFC.CF

Methods

(==) :: Rul function -> Rul function -> Bool

(/=) :: Rul function -> Rul function -> Bool

data InternalRule

Constructors

Internal

internal rule (only for AST & printer)

Parsable

ordinary rule (also for parser)

Instances

Eq InternalRule

Defined in BNFC.CF

Methods

(==) :: InternalRule -> InternalRule -> Bool

(/=) :: InternalRule -> InternalRule -> Bool

type SentForm = [Either Cat String]

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

data CFG function

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

Functor CFG

Defined in BNFC.CF

Methods

fmap :: (a -> b) -> CFG a -> CFG b

(<$) :: a -> CFG b -> CFG a

type Signature = Map String (WithPosition Type)

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

type Base = Base' String

Type of a non-terminal.

data Base' a

Constructors

BaseT a

ListT (Base' a)

Instances

Functor Base'

Defined in BNFC.CF

Methods

fmap :: (a -> b) -> Base' a -> Base' b

(<$) :: a -> Base' b -> Base' a

Show Base

Defined in BNFC.CF

Methods

showsPrec :: Int -> Base -> ShowS

show :: Base -> String

showList :: [Base] -> ShowS

Eq a => Eq (Base' a)

Defined in BNFC.CF

Methods

(==) :: Base' a -> Base' a -> Bool

(/=) :: Base' a -> Base' a -> Bool

Ord a => Ord (Base' a)

Defined in BNFC.CF

Methods

compare :: Base' a -> Base' a -> Ordering

(<) :: Base' a -> Base' a -> Bool

(<=) :: Base' a -> Base' a -> Bool

(>) :: Base' a -> Base' a -> Bool

(>=) :: Base' a -> Base' a -> Bool

max :: Base' a -> Base' a -> Base' a

min :: Base' a -> Base' a -> Base' a

data Type

Type of a rule label.

Constructors

FunT [Base] Base

Instances

Show Type

Defined in BNFC.CF

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

Eq Type

Defined in BNFC.CF

Methods

(==) :: Type -> Type -> Bool

(/=) :: Type -> Type -> Bool

Ord Type

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

dummyBase :: Base

Placeholder for a type.

dummyType :: Type

Placeholder for a function type.

data 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

Instances

(IsFun f, Pretty f) => Pretty (Exp' f)

Defined in BNFC.CF

Methods

pretty :: Exp' f -> Doc

prettyPrec :: Int -> Exp' f -> Doc

Eq f => Eq (Exp' f)

Defined in BNFC.CF

Methods

(==) :: Exp' f -> Exp' f -> Bool

(/=) :: Exp' f -> Exp' f -> Bool

type Exp = Exp' String

data 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

data Define

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

Function arguments with type.

isFunDef :: Pragma -> Either Pragma Define

For use with partitionEithers.

definitions :: CFG f -> [Define]

All define pragmas of the grammar.

type LayoutKeyWords = [(KeyWord, Delimiters)]

data Delimiters

List delimiters.

Constructors

Delimiters

Fields

• listSep :: Symbol

  List separator.

• listOpen :: Symbol

  List opening delimiter.

• listClose :: Symbol

  List closing delimiter.

Instances

Show Delimiters

Defined in BNFC.CF

Methods

showsPrec :: Int -> Delimiters -> ShowS

show :: Delimiters -> String

showList :: [Delimiters] -> ShowS

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

User-defined regular expression tokens

tokenNames :: CFG f -> [String]

The names of all user-defined tokens.

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

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

hasLayout :: CF -> Bool

type Literal = String

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

type Symbol = String

type KeyWord = String

data Position

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

Show Position

Defined in BNFC.CF

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

Eq Position

Defined in BNFC.CF

Methods

(==) :: Position -> Position -> Bool

(/=) :: Position -> Position -> Bool

Ord Position

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

prettyPosition :: Position -> String

data WithPosition a

Constructors

WithPosition

Fields

• wpPosition :: Position
• wpThing :: a

Instances

Foldable WithPosition

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

IsString RFun

Defined in BNFC.CF

Methods

fromString :: String -> RFun

Traversable WithPosition

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)

Functor WithPosition

Defined in BNFC.CF

Methods

fmap :: (a -> b) -> WithPosition a -> WithPosition b

(<$) :: a -> WithPosition b -> WithPosition a

IsFun a => IsFun (WithPosition a)

Defined in BNFC.CF

Methods

funName :: WithPosition a -> String

isNilFun :: WithPosition a -> Bool

isOneFun :: WithPosition a -> Bool

isConsFun :: WithPosition a -> Bool

isConcatFun :: WithPosition a -> Bool

isCoercion :: WithPosition a -> Bool

Pretty a => Pretty (WithPosition a)

Defined in BNFC.CF

Methods

pretty :: WithPosition a -> Doc

prettyPrec :: Int -> WithPosition a -> Doc

Show a => Show (WithPosition a)

Defined in BNFC.CF

Methods

showsPrec :: Int -> WithPosition a -> ShowS

show :: WithPosition a -> String

showList :: [WithPosition a] -> ShowS

Eq a => Eq (WithPosition a)

Ignore position in equality and ordering.

Defined in BNFC.CF

Methods

(==) :: WithPosition a -> WithPosition a -> Bool

(/=) :: WithPosition a -> WithPosition a -> Bool

Ord a => Ord (WithPosition a)

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

noPosition :: a -> WithPosition a

type RString = WithPosition String

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

blendInPosition :: RString -> String

Prefix string with pretty-printed position information.

type RCat = WithPosition Cat

valCat :: Rul fun -> Cat

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

npIdentifier :: String -> Identifier

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

Instances

Pretty Cat

Defined in BNFC.CF

Methods

pretty :: Cat -> Doc

prettyPrec :: Int -> Cat -> Doc

Show Cat

This instance is for the Hspec test suite.

Defined in BNFC.CF

Methods

showsPrec :: Int -> Cat -> ShowS

show :: Cat -> String

showList :: [Cat] -> ShowS

Eq Cat

Defined in BNFC.CF

Methods

(==) :: Cat -> Cat -> Bool

(/=) :: Cat -> Cat -> Bool

Ord Cat

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

type TokenCat = String

type BaseCat = String

type NonTerminal = Cat

catToStr :: Cat -> String

Render category symbols as strings

strToCat :: 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.

catString :: TokenCat

catInteger :: TokenCat

catDouble :: TokenCat

catChar :: TokenCat

catIdent :: TokenCat

baseTokenCatNames :: [TokenCat]

Token categories corresponding to base types.

specialCatsP :: [TokenCat]

isDataCat :: Cat -> Bool

Does the category correspond to a data type?

isDataOrListCat :: Cat -> Bool

sameCat :: 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.

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

normCat :: Cat -> Cat

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

normCatOfList :: Cat -> Cat

identCat :: 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)

identType :: Base -> String

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

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

isList :: Cat -> Bool

baseCat :: Cat -> Either BaseCat TokenCat

Get the underlying category identifier.

isTokenCat :: Cat -> Bool

maybeTokenCat :: Cat -> Maybe TokenCat

catOfList :: Cat -> Cat

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

type Fun = String

Fun is the function name of a rule.

type RFun = RString

class IsFun a where

Minimal complete definition

funName

Methods

funName :: a -> String

isNilFun

Arguments

:: a

-> Bool

Is this the constructor for empty lists?

isOneFun

Arguments

:: a

-> Bool

Is this the constructor for singleton lists?

isConsFun

Arguments

:: a

-> Bool

Is this the list constructor?

isConcatFun

Arguments

:: a

-> Bool

Is this list concatenation?

isCoercion :: a -> Bool

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

Instances

IsFun String

Defined in BNFC.CF

Methods

funName :: String -> String

isNilFun :: String -> Bool

isOneFun :: String -> Bool

isConsFun :: String -> Bool

isConcatFun :: String -> Bool

isCoercion :: String -> Bool

IsFun a => IsFun (Rul a)

Defined in BNFC.CF

Methods

funName :: Rul a -> String

isNilFun :: Rul a -> Bool

isOneFun :: Rul a -> Bool

isConsFun :: Rul a -> Bool

isConcatFun :: Rul a -> Bool

isCoercion :: Rul a -> Bool

IsFun a => IsFun (WithPosition a)

Defined in BNFC.CF

Methods

funName :: WithPosition a -> String

isNilFun :: WithPosition a -> Bool

isOneFun :: WithPosition a -> Bool

isConsFun :: WithPosition a -> Bool

isConcatFun :: WithPosition a -> Bool

isCoercion :: WithPosition a -> Bool

IsFun a => IsFun (k, a)

Defined in BNFC.CF

Methods

funName :: (k, a) -> String

isNilFun :: (k, a) -> Bool

isOneFun :: (k, a) -> Bool

isConsFun :: (k, a) -> Bool

isConcatFun :: (k, a) -> Bool

isCoercion :: (k, 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])])

The abstract syntax of a grammar.

firstEntry :: CF -> Cat

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

allNames :: CF -> [RString]

Constructors and categories.

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

Get all elements with more than one occurrence.

commentPragmas :: [Pragma] -> [Pragma]

Extract the comment pragmas.

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

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

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

removeWhiteSpaceSeparators :: Rul f -> Rul f

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

Modify the rhsRule part of a Rule.

rulesForNormalizedCat :: 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

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

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

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

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

reallyAllCats :: CFG f -> [Cat]

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

allParserCats :: CFG f -> [Cat]

allCatsIdNorm :: CF -> [RString]

Gets all normalized identified Categories

allCatsNorm :: CF -> [Cat]

Get all normalized Cat

allParserCatsNorm :: CFG f -> [Cat]

Get all normalized Cat

isUsedCat :: CFG f -> Cat -> Bool

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

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

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

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

Group all categories with their rules including internal rules.

literals :: CFG f -> [TokenCat]

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

reservedWords :: CFG f -> [String]

Get the keywords of a grammar.

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

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

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

Comments can be defined by the comment pragma

numberOfBlockCommentForms :: CF -> Int

Number of block comment forms defined in the grammar file.

hasIdent :: CFG f -> Bool

Whether the grammar uses the predefined Ident type.

specialCats :: CF -> [TokenCat]

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

abstract syntax trees: data type definitions

getAbstractSyntax :: 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

cf2data' :: (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.

cf2data :: CF -> [Data]

cf2dataLists :: CF -> [Data]

specialData :: CF -> [Data]

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

Get the type of a rule label.

isParsable :: Rul f -> Bool

Checks if the rule is parsable.

hasNilRule :: [Rule] -> Maybe Rule

hasSingletonRule :: [Rule] -> Maybe Rule

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

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

Sort rules by descending precedence.

isEmptyListCat :: CF -> Cat -> Bool

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

isNonterm :: Either Cat String -> Bool

revSepListRule :: Rul f -> Rul f

findAllReversibleCats :: CF -> [Cat]

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

precCat :: Cat -> Integer

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

precRule :: Rul f -> Integer

hasIdentLikeTokens :: CFG g -> Bool

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

hasTextualTokens :: CFG g -> Bool

Defines or uses the grammar token types or Ident?

hasPositionTokens :: CFG g -> Bool

Is there a position token declaration in the grammar?

isPositionCat :: CFG f -> TokenCat -> Bool

Does the category have a position stored in AST?

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