GF

GF, the Grammatical Framework, as a library

Command line interface

main :: IO ()

Run the GF main program, taking arguments from the command line. (It calls setConsoleEncoding and getOptions, then mainOpts.) Run gf --help for usage info.

getOptions :: IO (Options, [FilePath])

Get and parse GF command line arguments. Fix relative paths. Calls getArgs and parseOptions.

mainOpts :: Options -> [FilePath] -> IO ()

Run the GF main program with the given options and files. Depending on the options it invokes mainGFC, mainGFI, mainRunGFI, mainServerGFI, or it just prints version/usage info.

mainGFI :: Options -> [FilePath] -> IO ()

Run the interactive GF Shell

mainRunGFI :: Options -> [FilePath] -> IO ()

Run the GF Shell in quiet mode (gf -run).

mainServerGFI :: Options -> Int -> [FilePath] -> IO Server

Run the GF Server (gf -server). The Int argument is the port number for the HTTP service.

mainGFC :: Options -> [FilePath] -> IO ()

Compile the given GF grammar files. The result is a number of .gfo files and, depending on the options, a .pgf file. (gf -batch, gf -make)

linkGrammars :: Options -> (UTCTime, [(ModuleName, Grammar)]) -> IO ()

Create a .pgf file (and possibly files in other formats, if specified in the Options) from the output of parallelBatchCompile. If a .pgf file by the same name already exists and it is newer than the source grammar files (as indicated by the UTCTime argument), it is not recreated. Calls writePGF and writeOutputs.

writePGF :: Options -> PGF -> IOE ()

Write the result of compiling a grammar (e.g. with compileToPGF or link) to a .pgf file. A split PGF file is output if the -split-pgf option is used.

writeOutputs :: Options -> PGF -> IOE ()

Export the PGF to the OutputFormats specified in the Options. Calls exportPGF.

Compiling GF grammars

compileToPGF :: Options -> [FilePath] -> IOE PGF

Compiles a number of source files and builds a PGF structure for them. This is a composition of link and batchCompile.

link :: Options -> (ModuleName, Grammar) -> IOE PGF

Link a grammar into a PGF that can be used to linearize and parse with the PGF run-time system.

batchCompile :: Options -> [FilePath] -> IOE (UTCTime, (ModuleName, Grammar))

Compile the given grammar files and everything they depend on. Compiled modules are stored in .gfo files (unless the -tags option is used, in which case tags files are produced instead). Existing .gfo files are reused if they are up-to-date (unless the option -src aka -force-recomp is used).

srcAbsName :: Grammar -> ModuleName -> ModuleName

Returns the name of the abstract syntax corresponding to the named concrete syntax

parallelBatchCompile :: (Output m, ErrorMonad m, MonadIO m) => t -> Options -> [FilePath] -> m (UTCTime, [(ModuleName, Grammar)])

Compile the given grammar files and everything they depend on, like batchCompile. This function compiles modules in parallel. It keeps modules compiled in present and alltenses mode apart, storing the .gfo files in separate subdirectories to avoid creating the broken PGF files that can result from mixing different modes in the same concrete syntax.

The first argument is supposed to be the number of jobs to run in parallel, but this has not been implemented yet. Instead you have to use the GHC run-time flag +RTS -N -RTS to enable parallelism.

exportPGF

Arguments

:: Options

-> OutputFormat

-> PGF

-> [(FilePath, String)]

List of recommended file names and contents.

Export a PGF to the given OutputFormat. For many output formats, additional Options can be used to control the output.

Compiling a single module

type OneOutput = (Maybe FullPath, CompiledModule)

type CompiledModule = Module

compileOne :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Compile a given source file (or just load a .gfo file), given a Grammar containing everything it depends on. Calls reuseGFO or useTheSource.

reuseGFO :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Read a compiled GF module. Also undo common subexp optimization, to enable normal computations.

useTheSource :: (Output m, ErrorMonad m, MonadIO m) => Options -> Grammar -> FullPath -> m OneOutput

Compile GF module from source. It both returns the result and stores it in a .gfo file (or a tags file, if running with the -tags option)

Abstract syntax, parsing, pretty printing and serialisation

getSourceModule :: (Output m, ErrorMonad m, MonadIO m) => Options -> FilePath -> m (ModuleName, ModuleInfo)

Read a source file and parse it (after applying preprocessors specified in the options)

getCFRules :: Options -> FilePath -> IOE [CFRule]

getEBNFRules :: Options -> FilePath -> IOE [ERule]

Grammar modules

data Grammar

A grammar is a self-contained collection of grammar modules

Instances

Pretty Grammar

Binary Grammar

data ModuleName

Module names

Instances

Eq ModuleName

Ord ModuleName

Show ModuleName

Pretty ModuleName

Binary ModuleName

type Module = (ModuleName, ModuleInfo)

Modules

data ModuleInfo

Constructors

ModInfo

Fields

mtype :: ModuleType

mstatus :: ModuleStatus

mflags :: Options

mextend :: [(ModuleName, MInclude)]

mwith :: Maybe (ModuleName, MInclude, [(ModuleName, ModuleName)])

mopens :: [OpenSpec]

mexdeps :: [ModuleName]

msrc :: FilePath

mseqs :: Maybe (Array SeqId Sequence)

jments :: Map Ident Info

Instances

HasSourcePath ModuleInfo

Binary ModuleInfo

type SourceGrammar = Grammar

type SourceModInfo = ModuleInfo

type SourceModule = Module

data ModuleType

encoding the type of the module

Constructors

MTAbstract

MTResource

MTConcrete ModuleName

MTInterface

MTInstance (ModuleName, MInclude)

Instances

Eq ModuleType

Show ModuleType

Binary ModuleType

emptyGrammar :: Grammar

mGrammar :: [Module] -> Grammar

modules :: Grammar -> [Module]

prependModule :: Grammar -> Module -> Grammar

moduleMap :: Grammar -> Map ModuleName ModuleInfo

data MInclude

Constructors

MIAll

MIOnly [Ident]

MIExcept [Ident]

Instances

Eq MInclude

Show MInclude

Binary MInclude

data OpenSpec

Constructors

OSimple ModuleName

OQualif ModuleName ModuleName

Instances

Eq OpenSpec

Show OpenSpec

Binary OpenSpec

extends :: ModuleInfo -> [ModuleName]

isInherited :: MInclude -> Ident -> Bool

inheritAll :: ModuleName -> (ModuleName, MInclude)

openedModule :: OpenSpec -> ModuleName

allDepsModule :: Grammar -> ModuleInfo -> [OpenSpec]

all dependencies

partOfGrammar :: Grammar -> Module -> Grammar

select just those modules that a given one depends on, including itself

depPathModule :: ModuleInfo -> [OpenSpec]

initial dependency list

allExtends :: Grammar -> ModuleName -> [Module]

all modules that a module extends, directly or indirectly, with restricts

allExtendsPlus :: Grammar -> ModuleName -> [ModuleName]

the same as allExtends plus that an instance extends its interface

lookupModule :: ErrorMonad m => Grammar -> ModuleName -> m ModuleInfo

isModAbs :: ModuleInfo -> Bool

isModRes :: ModuleInfo -> Bool

isModCnc :: ModuleInfo -> Bool

sameMType :: ModuleType -> ModuleType -> Bool

isCompilableModule :: ModuleInfo -> Bool

don't generate code for interfaces and for incomplete modules

isCompleteModule :: ModuleInfo -> Bool

interface and "incomplete M" are not complete

allAbstracts :: Grammar -> [ModuleName]

all abstract modules sorted from least to most dependent

greatestAbstract :: Grammar -> Maybe ModuleName

the last abstract in dependency order (head of list)

allResources :: Grammar -> [ModuleName]

all resource modules

greatestResource :: Grammar -> Maybe ModuleName

the greatest resource in dependency order

allConcretes :: Grammar -> ModuleName -> [ModuleName]

all concretes for a given abstract

allConcreteModules :: Grammar -> [ModuleName]

all concrete modules for any abstract

abstractOfConcrete :: ErrorMonad m => Grammar -> ModuleName -> m ModuleName

we store the module type with the identifier

data ModuleStatus

Constructors

MSComplete

MSIncomplete

Instances

Eq ModuleStatus

Ord ModuleStatus

Show ModuleStatus

Binary ModuleStatus

Judgements

data Info

the constructors are judgements in

• abstract syntax (ABS)
• resource (RES)
• concrete syntax (CNC)

and indirection to module (INDIR)

Constructors

AbsCat (Maybe (L Context))

(ABS) context of a category

AbsFun (Maybe (L Type)) (Maybe Int) (Maybe [L Equation]) (Maybe Bool)

(ABS) type, arrity and definition of a function

ResParam (Maybe (L [Param])) (Maybe [Term])

(RES) the second parameter is list of all possible values

ResValue (L Type)

(RES) to mark parameter constructors for lookup

ResOper (Maybe (L Type)) (Maybe (L Term))

(RES)

ResOverload [ModuleName] [(L Type, L Term)]

(RES) idents: modules inherited

CncCat (Maybe (L Type)) (Maybe (L Term)) (Maybe (L Term)) (Maybe (L Term)) (Maybe PMCFG)

(CNC) lindef ini'zed,

CncFun (Maybe (Ident, Context, Type)) (Maybe (L Term)) (Maybe (L Term)) (Maybe PMCFG)

(CNC) type info added at TC

AnyInd Bool ModuleName

(INDIR) the Bool says if canonical

Instances

Show Info

Binary Info

Terms

data Term

Constructors

Vr Ident

variable

Cn Ident

constant

Con Ident

constructor

Sort Ident

basic type

EInt Int

integer literal

EFloat Double

floating point literal

K String

string literal or token: "foo"

Empty

the empty string []

App Term Term

application: f a

Abs BindType Ident Term

abstraction: x -> b

Meta !MetaId

metavariable: ?i (only parsable: ? = ?0)

ImplArg Term

placeholder for implicit argument {t}

Prod BindType Ident Term Term

function type: (x : A) -> B, A -> B, ({x} : A) -> B

Typed Term Term

type-annotated term

below this, the constructors are only for concrete syntax

Example Term String

example-based term: @in M.C "foo"

RecType [Labelling]

record type: { p : A ; ...}

R [Assign]

record: { p = a ; ...}

P Term Label

projection: r.p

ExtR Term Term

extension: R ** {x : A} (both types and terms)

Table Term Term

table type: P => A

T TInfo [Case]

table: table {p => c ; ...}

V Type [Term]

table given as course of values: table T [c1 ; ... ; cn]

S Term Term

selection: t ! p

Let LocalDef Term

local definition: let {t : T = a} in b

Q QIdent

qualified constant from a package

QC QIdent

qualified constructor from a package

C Term Term

concatenation: s ++ t

Glue Term Term

agglutination: s + t

EPatt Patt

pattern (in macro definition): # p

EPattType Term

pattern type: pattern T

ELincat Ident Term

boxed linearization type of Ident

ELin Ident Term

boxed linearization of type Ident

AdHocOverload [Term]

ad hoc overloading generated in Rename

FV [Term]

alternatives in free variation: variants { s ; ... }

Alts Term [(Term, Term)]

alternatives by prefix: pre {t ; s/c ; ...}

Strs [Term]

conditioning prefix strings: strs {s ; ...}

Error String

error values returned by Predef.error

Instances

Eq Term

Ord Term

Show Term

Pretty Term

Binary Term

type Type = Term

type Cat = QIdent

type Fun = QIdent

type QIdent = (ModuleName, Ident)

data BindType

Constructors

Explicit

Implicit

Instances

Eq BindType

Ord BindType

Show BindType

Binary BindType

data Patt

Patterns

Constructors

PC Ident [Patt]

constructor pattern: C p1 ... pn C

PP QIdent [Patt]

package constructor pattern: P.C p1 ... pn P.C

PV Ident

variable pattern: x

PW

wild card pattern: _

PR [(Label, Patt)]

record pattern: {r = p ; ...} -- only concrete

PString String

string literal pattern: "foo" -- only abstract

PInt Int

integer literal pattern: 12 -- only abstract

PFloat Double

float literal pattern: 1.2 -- only abstract

PT Type Patt

type-annotated pattern

PAs Ident Patt

as-pattern: x@p

PImplArg Patt

placeholder for pattern for implicit argument {p}

PTilde Term

inaccessible pattern

PNeg Patt

negated pattern: -p

PAlt Patt Patt

disjunctive pattern: p1 | p2

PSeq Patt Patt

sequence of token parts: p + q

PMSeq MPatt MPatt

sequence of token parts: p + q

PRep Patt

repetition of token part: p*

PChar

string of length one: ?

PChars [Char]

character list: ["aeiou"]

PMacro Ident

PM QIdent

Instances

Eq Patt

Ord Patt

Show Patt

Pretty Patt

Binary Patt

data TInfo

to guide computation and type checking of tables

Constructors

TRaw

received from parser; can be anything

TTyped Type

type annontated, but can be anything

TComp Type

expanded

TWild Type

just one wild card pattern, no need to expand

Instances

Eq TInfo

Ord TInfo

Show TInfo

Binary TInfo

data Label

record label

Constructors

LIdent RawIdent

LVar Int

Instances

Eq Label

Ord Label

Show Label

Pretty Label

Binary Label

type MetaId = Int

type Hypo = (BindType, Ident, Term)

type Context = [Hypo]

type Equation = ([Patt], Term)

type Labelling = (Label, Type)

type Assign = (Label, (Maybe Type, Term))

type Case = (Patt, Term)

type LocalDef = (Ident, (Maybe Type, Term))

type Param = (Ident, Context)

type Altern = (Term, [(Term, Term)])

type Substitution = [(Ident, Term)]

varLabel :: Int -> Label

tupleLabel :: Int -> Label

linLabel :: Int -> Label

theLinLabel :: Label

ident2label :: Ident -> Label

label2ident :: Label -> Ident

Source locations

data Location

Constructors

NoLoc

Local Int Int

External FilePath Location

Instances

Eq Location

Ord Location

Show Location

Binary Location

data L a

Attaching location information

Constructors

L Location a

Instances

Functor L

Show a => Show (L a)

Binary a => Binary (L a)

unLoc :: L a -> a

noLoc :: a -> L a

ppLocation :: FilePath -> Location -> Doc

ppL :: (Pretty a2, Pretty a1) => L a2 -> a1 -> Doc

PMCFG

data PMCFG

Constructors

PMCFG [Production] (Array FunId (UArray LIndex SeqId))

Instances

Eq PMCFG

Show PMCFG

Binary PMCFG

data Production

Constructors

Production !FId !FunId [[FId]]

Instances

Eq Production

Ord Production

Show Production

Binary Production

type FId = Int

type FunId = Int

type SeqId = Int

type LIndex = Int

type Sequence = Array DotPos Symbol

Functions for constructing and analysing source code terms.

typeForm :: Type -> (Context, Cat, [Term])

typeFormCnc :: Type -> (Context, Type)

valCat :: Type -> Cat

valType :: Type -> Type

valTypeCnc :: Type -> Type

typeSkeleton :: Type -> ([(Int, Cat)], Cat)

catSkeleton :: Type -> ([Cat], Cat)

funsToAndFrom :: Type -> (Cat, [(Cat, [Int])])

isRecursiveType :: Type -> Bool

isHigherOrderType :: Type -> Bool

contextOfType :: Monad m => Type -> m Context

termForm :: Monad m => Term -> m ([(BindType, Ident)], Term, [Term])

termFormCnc :: Term -> ([(BindType, Ident)], Term)

appForm :: Term -> (Term, [Term])

mkProdSimple :: Context -> Term -> Term

mkProd :: Context -> Term -> [Term] -> Term

mkTerm :: ([(BindType, Ident)], Term, [Term]) -> Term

mkApp :: Term -> [Term] -> Term

mkAbs :: [(BindType, Ident)] -> Term -> Term

appCons :: Ident -> [Term] -> Term

mkLet :: [LocalDef] -> Term -> Term

mkLetUntyped :: Context -> Term -> Term

isVariable :: Term -> Bool

uType :: Type

Assignment

assign :: Label -> Term -> Assign

assignT :: Label -> Type -> Term -> Assign

unzipR :: [Assign] -> ([Label], [Term])

mkAssign :: [(Label, Term)] -> [Assign]

projectRec :: Label -> [Assign] -> Term

zipAssign :: [Label] -> [Term] -> [Assign]

mapAssignM :: Monad m => (Term -> m c) -> [Assign] -> m [(Label, (Maybe c, c))]

Records

mkRecordN :: Int -> (Int -> Label) -> [Term] -> Term

mkRecord :: (Int -> Label) -> [Term] -> Term

mkRecTypeN :: Int -> (Int -> Label) -> [Type] -> Type

mkRecType :: (Int -> Label) -> [Type] -> Type

record2subst :: Term -> Err Substitution

Types

typeType :: Type

typeStrs :: Type

typeTok :: Type

typeStr :: Type

typePType :: Type

typeString :: Type

typeInt :: Type

typeFloat :: Type

typeInts :: Int -> Type

typePBool :: Type

typeError :: Type

isTypeInts :: Type -> Maybe Int

Terms

isPredefConstant :: Term -> Bool

checkPredefError :: Monad m => Term -> m Term

cnPredef :: Ident -> Term

mkSelects :: Term -> [Term] -> Term

mkTable :: [Term] -> Term -> Term

mkCTable :: [(BindType, Ident)] -> Term -> Term

mkHypo :: Term -> Hypo

eqStrIdent :: Ident -> Ident -> Bool

tuple2record :: [Term] -> [Assign]

tuple2recordType :: [Term] -> [Labelling]

tuple2recordPatt :: [Patt] -> [(Label, Patt)]

mkCases :: Ident -> Term -> Term

mkWildCases :: Term -> Term

mkFunType :: [Type] -> Type -> Type

plusRecType :: ErrorMonad m => Term -> Term -> m Term

plusRecord :: ErrorMonad m => Term -> Term -> m Term

defLinType :: Type

default linearization type

mkFreshVar :: [Ident] -> Ident

refreshing variables

mkFreshVarX :: [Ident] -> Ident -> Ident

trying to preserve a given symbol

maxVarIndex :: [Ident] -> Int

mkFreshVars :: Int -> [Ident] -> [Ident]

freshAsTerm :: String -> Term

quick hack for refining with var in editor

string2term :: String -> Term

create a terminal for concrete syntax

int2term :: Int -> Term

float2term :: Double -> Term

ident2terminal :: Ident -> Term

create a terminal from identifier

symbolOfIdent :: Ident -> String

symid :: Ident -> String

justIdentOf :: Term -> Maybe Ident

linTypeStr :: Type

linAsStr :: String -> Term

Term and pattern conversion

term2patt :: Term -> Err Patt

patt2term :: Patt -> Term

Almost compositional

composSafeOp :: (Term -> Term) -> Term -> Term

to define compositional term functions

composOp :: Monad m => (Term -> m Term) -> Term -> m Term

to define compositional term functions

composSafePattOp :: (Patt -> Patt) -> Patt -> Patt

composPattOp :: Monad m => (Patt -> m Patt) -> Patt -> m Patt

collectOp :: Monoid m => (Term -> m) -> Term -> m

mconcatMap :: Monoid c => (a -> c) -> [a] -> c

collectPattOp :: (Patt -> [a]) -> Patt -> [a]

Misc

redirectTerm :: ModuleName -> Term -> Term

allCaseValues :: Term -> [([Patt], Term)]

to gather ultimate cases in a table; preserves pattern list

strsFromTerm :: Term -> Err [Str]

to get a string from a term that represents a sequence of terminals

stringFromTerm :: Term -> String

to print an Str-denoting term as a string; if the term is of wrong type, the error msg

getTableType :: TInfo -> Err Type

changeTableType :: Monad m => (Type -> m Type) -> TInfo -> m TInfo

wordsInTerm :: Term -> [String]

to find the word items in a term

noExist :: Term

defaultLinType :: Type

sortRec :: [(Label, a)] -> [(Label, a)]

Dependencies

allDependencies :: (ModuleName -> Bool) -> BinTree Ident Info -> [(Ident, [Ident])]

dependency check, detecting circularities and returning topo-sorted list

topoSortJments :: ErrorMonad m => SourceModule -> m [(Ident, Info)]

topoSortJments2 :: ErrorMonad m => SourceModule -> m [[(Ident, Info)]]

Pretty printing

data TermPrintQual

Constructors

Unqualified

Qualified

Internal

Instances

Eq TermPrintQual

ppModule :: TermPrintQual -> SourceModule -> Doc

ppJudgement :: Pretty a1 => TermPrintQual -> (a1, Info) -> Doc

ppParams :: Pretty a => TermPrintQual -> [(a, [(t, Ident, Term)])] -> Doc

ppTerm :: (Ord a, Num a) => TermPrintQual -> a -> Term -> Doc

ppPatt :: (Ord a, Num a) => TermPrintQual -> a -> Patt -> Doc

ppValue :: TermPrintQual -> Int -> Val -> Doc

ppConstrs :: Constraints -> [Doc]

ppQIdent :: TermPrintQual -> QIdent -> Doc

ppMeta :: MetaId -> Doc

getAbs :: Term -> ([(BindType, Ident)], Term)

Identifiers

newtype ModuleName

Module names

Constructors

MN Ident

Instances

Eq ModuleName

Ord ModuleName

Show ModuleName

Pretty ModuleName

Binary ModuleName

moduleNameS :: String -> ModuleName

data Ident

the constructors labelled INTERNAL are internal representation never returned by the parser

Instances

Eq Ident

Ord Ident

Read Ident

Show Ident

Pretty Ident

Binary Ident

ident2utf8 :: Ident -> ByteString

This function should be used with care, since the returned ByteString is UTF-8-encoded.

showIdent :: Ident -> String

prefixIdent :: String -> Ident -> Ident

Normal identifiers (returned by the parser)

identS :: String -> Ident

identC :: RawIdent -> Ident

identW :: Ident

Special identifiers for internal use

identV :: RawIdent -> Int -> Ident

identA :: RawIdent -> Int -> Ident

identAV :: RawIdent -> Int -> Int -> Ident

argIdent :: Int -> Ident -> Int -> Ident

to mark argument variables

isArgIdent :: Ident -> Bool

getArgIndex :: Ident -> Maybe Int

varStr :: Ident

used in lin defaults

varX :: Int -> Ident

refreshing variables

isWildIdent :: Ident -> Bool

varIndex :: Ident -> Int

Raw identifiers

data RawIdent

Identifiers are stored as UTF-8-encoded bytestrings. (It is also possible to use regular Haskell Strings, with somewhat reduced performance and increased memory use.)

Instances

Eq RawIdent

Ord RawIdent

Read RawIdent

Show RawIdent

Binary RawIdent

rawIdentS :: String -> RawIdent

rawIdentC :: ByteString -> RawIdent

ident2raw :: Ident -> RawIdent

prefixRawIdent :: RawIdent -> RawIdent -> RawIdent

isPrefixOf :: RawIdent -> RawIdent -> Bool

showRawIdent :: RawIdent -> String

Binary serialisation

data VersionTagged a

Constructors

Tagged

Fields

unV :: a

WrongVersion

Instances

Functor VersionTagged

Binary a => Binary (VersionTagged a)

decodeModuleHeader :: MonadIO io => FilePath -> io (VersionTagged Module)

Read just the module header, the returned Module will have an empty body

decodeModule :: MonadIO io => FilePath -> io SourceModule

encodeModule :: MonadIO io => FilePath -> SourceModule -> io ()