BNFC.CF

Documentation

type CF = CFG RFun

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

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

Show function => Show (CFG function)

Defined in BNFC.CF

Methods

showsPrec :: Int -> CFG function -> ShowS

show :: CFG function -> String

showList :: [CFG function] -> ShowS

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

Eq function => Eq (Rul function)

Defined in BNFC.CF

Methods

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

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

Show function => Show (Rul function)

Defined in BNFC.CF

Methods

showsPrec :: Int -> Rul function -> ShowS

show :: Rul function -> String

showList :: [Rul function] -> ShowS

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

valCat :: Rul fun -> Cat

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

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

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 [String]

LayoutStop [String]

LayoutTop

FunDef RFun [String] Exp

Instances

Show Pragma

Defined in BNFC.CF

Methods

showsPrec :: Int -> Pragma -> ShowS

show :: Pragma -> String

showList :: [Pragma] -> ShowS

data Exp

Expressions for function definitions.

Constructors

App String [Exp]

(Possibly defined) label applied to expressions.

Var String

Function parameter.

LitInt Integer

LitDouble Double

LitChar Char

LitString String

Instances

Eq Exp

Defined in BNFC.CF

Methods

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

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

Show Exp

Defined in BNFC.CF

Methods

showsPrec :: Int -> Exp -> ShowS

show :: Exp -> String

showList :: [Exp] -> ShowS

data Base

Type of a non-terminal.

Constructors

BaseT String

ListT Base

Instances

Eq Base

Defined in BNFC.CF

Methods

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

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

Ord Base

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

Defined in BNFC.CF

Methods

showsPrec :: Int -> Base -> ShowS

show :: Base -> String

showList :: [Base] -> ShowS

data Type

Type of a rule label.

Constructors

FunT [Base] Base

Instances

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

Show Type

Defined in BNFC.CF

Methods

showsPrec :: Int -> Type -> ShowS

show :: Type -> String

showList :: [Type] -> ShowS

type Signature = Map String (WithPosition Type)

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

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

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

Show Position

Defined in BNFC.CF

Methods

showsPrec :: Int -> Position -> ShowS

show :: Position -> String

showList :: [Position] -> ShowS

noPosition :: a -> WithPosition a

prettyPosition :: Position -> String

npIdentifier :: String -> Identifier

data WithPosition a

Constructors

WithPosition

Fields

• wpPosition :: Position
• wpThing :: a

Instances

Functor WithPosition

Defined in BNFC.CF

Methods

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

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

IsString RFun

Defined in BNFC.CF

Methods

fromString :: String -> RFun

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

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)

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

Show a => Show (WithPosition a)

Defined in BNFC.CF

Methods

showsPrec :: Int -> WithPosition a -> ShowS

show :: WithPosition a -> String

showList :: [WithPosition a] -> ShowS

IsFun a => IsFun (WithPosition a)

Defined in BNFC.CF

Methods

funName :: WithPosition a -> String

blendInPosition :: RString -> String

Prefix string with pretty-printed position information.

type RString = WithPosition String

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

type RCat = WithPosition Cat

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

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

Show Cat

Defined in BNFC.CF

Methods

showsPrec :: Int -> Cat -> ShowS

show :: Cat -> String

showList :: [Cat] -> ShowS

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.

catToStr :: Cat -> String

Render category symbols as strings

type BaseCat = String

type TokenCat = String

catString :: TokenCat

catInteger :: TokenCat

catDouble :: TokenCat

catChar :: TokenCat

catIdent :: TokenCat

type NonTerminal = Cat

type SentForm = [Either Cat String]

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

type Fun = String

Fun is the function name of a rule.

type RFun = RString

class IsFun a where

Methods

funName :: a -> String

Instances

IsFun String

Defined in BNFC.CF

Methods

funName :: String -> String

IsFun a => IsFun (WithPosition a)

Defined in BNFC.CF

Methods

funName :: WithPosition a -> String

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

The abstract syntax of a grammar.

cf2data :: CF -> [Data]

cf2dataLists :: CF -> [Data]

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

firstEntry :: CF -> Cat

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

baseTokenCatNames :: [TokenCat]

Token categories corresponding to base types.

specialCats :: CF -> [TokenCat]

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

specialCatsP :: [TokenCat]

specialData :: CF -> [Data]

isCoercion :: IsFun a => a -> Bool

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

isDefinedRule :: IsFun a => a -> Bool

isProperLabel :: IsFun a => a -> Bool

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

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

allParserCats :: CFG f -> [Cat]

allParserCatsNorm :: CFG f -> [Cat]

Get all normalized Cat

reallyAllCats :: CFG f -> [Cat]

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

allCatsNorm :: CF -> [Cat]

Get all normalized Cat

allCatsIdNorm :: CF -> [RString]

Gets all normalized identified Categories

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

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

literals :: CFG f -> [TokenCat]

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

findAllReversibleCats :: CF -> [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)

isParsable :: Rul f -> Bool

Checks if the rule is parsable.

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

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

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

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.

allNames :: CF -> [RString]

Constructors and categories.

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

Get all elements with more than one occurrence.

isList :: Cat -> Bool

isTokenCat :: Cat -> Bool

maybeTokenCat :: Cat -> Maybe TokenCat

baseCat :: Cat -> Either BaseCat TokenCat

Get the underlying category identifier.

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

isNilFun :: IsFun a => a -> Bool

isOneFun :: IsFun a => a -> Bool

hasOneFunc :: [Rule] -> Bool

Checks if the list has a non-empty rule.

getCons :: [Rule] -> String

Gets the separator for a list.

getSeparatorByPrecedence :: [Rule] -> [(Integer, String)]

Helper function that gets the list separator by precedence level

isConsFun :: IsFun a => a -> Bool

isNilCons :: IsFun a => a -> Bool

isEmptyListCat :: CF -> Cat -> Bool

revSepListRule :: Rul f -> Rul f

normCat :: Cat -> Cat

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

isDataCat :: Cat -> Bool

Does the category correspond to a data type?

isDataOrListCat :: Cat -> Bool

normCatOfList :: Cat -> Cat

catOfList :: Cat -> Cat

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

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.

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

User-defined regular expression tokens

tokenNames :: CFG f -> [String]

The names of all user-defined tokens.

precCat :: Cat -> Integer

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

precRule :: Rul f -> Integer

isUsedCat :: CFG f -> Cat -> Bool

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

isPositionCat :: CFG f -> TokenCat -> Bool

Does the category have a position stored in AST?

hasPositionTokens :: CFG g -> Bool

Is there a position token declaration in the grammar?

hasIdent :: CFG f -> Bool

Whether the grammar uses the predefined Ident type.

hasIdentLikeTokens :: CFG g -> Bool

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

hasLayout :: CF -> Bool

layoutPragmas :: CF -> (Bool, [String], [String])

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

Get the type of a rule label.