The GF Software System

The GF software system implements the GF programming language. Its components are

• the compiler, translating .gf source files to .gfo object files, to .pgf run-time grammars, and to various other formats
• the run-time system, performing parsing, generation, translation and other functions with .pgf grammars
• the command interpreter, also known as the GF shell, executing user commands by calling the compiler and the run-time system

This page describes the commands of the GF shell, as well as the use of the compiler in batch mode.

• The GF shell
  • GF shell commands
    • !
    • ?
    • ai = abstract_info
    • aw = align_words
    • ca = clitic_analyse
    • cc = compute_concrete
    • dc = define_command
    • dg = dependency_graph
    • dt = define_tree
    • e = empty
    • eb = example_based
    • gr = generate_random
    • gt = generate_trees
    • h = help
    • i = import
    • l = linearize
    • ma = morpho_analyse
    • mq = morpho_quiz
    • p = parse
    • pg = print_grammar
    • ph = print_history
    • ps = put_string
    • pt = put_tree
    • q = quit
    • r = reload
    • rf = read_file
    • rt = rank_trees
    • sd = show_dependencies
    • se = set_encoding
    • so = show_operations
    • sp = system_pipe
    • ss = show_source
    • t = tokenize
    • tq = translation_quiz
    • ut = unicode_table
    • vd = visualize_dependency
    • vp = visualize_parse
    • vt = visualize_tree
    • wf = write_file
• The GF batch compiler

The GF shell

The GF shell is invoked by the command gf, which takes arguments and options according to the following syntax:

    gf (OPTION | FLAG)* FILE*

The shell maintains a state, to which belong

• a multilingual PGF grammar
• optionally, a set of compiled GF modules (retaining oper definitions)
• a history of previous commands
• a set of string, tree, and command macros

Unless file arguments are provided to the gf command, the shell starts in an empty state, with no grammars and no history.

In the shell, a set of commands is available. Some of these commands may change the grammars in the state. The general syntax of commands is given by the following BNF grammar:

    COMMAND_LINE ::= COMMAND_PIPE
    COMMAND_LINE ::= COMMAND_PIPE ";" COMMAND_LINE
    COMMAND_PIPE ::= COMMAND
    COMMAND_PIPE ::= COMMAND "|" COMMAND_PIPE
    COMMAND      ::= COMMAND_ID (OPTION | FLAG)* ARGUMENT?
    OPTION       ::= "-"OPTION_ID
    FLAG         ::= "-"OPTION_ID "=" VALUE
    ARGUMENT     ::= QUOTED_STRING | TREE
    VALUE        ::= IDENT | QUOTED_STRING

A command pipe is a sequence of commands interpreted in such a way that the output of each command is send as input to the next. The option -tr causes GF to show a trace, i.e. the intermediate result of the command to which it is attached.

A command line is a sequence of pipes separated by ;. These pipes are executed one by one, in the order of appearance.

GF shell commands

The full set of GF shell commands is listed below with explanations. This list can also be obtained in the GF shell by the command help -full.

!

!: system command: escape to system shell.

• Syntax: ! SYSTEMCOMMAND

• Examples:

?

?: system pipe: send value from previous command to a system command.

• Syntax: ? SYSTEMCOMMAND

• Examples:

ai = abstract_info

ai = abstract_info: Provides an information about a function, an expression or a category from the abstract syntax.

The command has one argument which is either function, expression or a category defined in the abstract syntax of the current grammar. If the argument is a function then ?its type is printed out. If it is a category then the category definition is printed. If a whole expression is given it prints the expression with refined metavariables and the type of the expression.

• Syntax: ai IDENTIFIER or ai EXPR

aw = align_words

aw = align_words: show word alignments between languages graphically.

Prints a set of strings in the .dot format (the graphviz format). The graph can be saved in a file by the wf command as usual. If the -view flag is defined, the graph is saved in a temporary file which is processed by graphviz and displayed by the program indicated by the flag. The target format is postscript, unless overridden by the flag -format.

• Options:

• Flags:

• Examples:

ca = clitic_analyse

ca = clitic_analyse: print the analyses of all words into stems and clitics.

Analyses all words into all possible combinations of stem + clitics. The analysis is returned in the format stem &+ clitic1 &+ clitic2 ... which is hence the inverse of 'pt -bind'. The list of clitics is give by the flag '-clitics'. The list of stems is given as the list of words of the language given by the '-lang' flag.

• Options:

• Flags:

• Examples:

cc = compute_concrete

cc = compute_concrete: computes concrete syntax term using a source grammar.

Compute TERM by concrete syntax definitions. Uses the topmost module (the last one imported) to resolve constant names. N.B.1 You need the flag -retain when importing the grammar, if you want the definitions to be retained after compilation. N.B.2 The resulting term is not a tree in the sense of abstract syntax and hence not a valid input to a Tree-expecting command. This command must be a line of its own, and thus cannot be a part of a pipe.

• Syntax: cc (-all | -table | -unqual)? TERM
• Options:

dc = define_command

dc = define_command: define a command macro.

Defines IDENT as macro for COMMANDLINE, until IDENT gets redefined. A call of the command has the form %IDENT. The command may take an argument, which in COMMANDLINE is marked as ?0. Both strings and trees can be arguments. Currently at most one argument is possible. This command must be a line of its own, and thus cannot be a part of a pipe.

• Syntax: dc IDENT COMMANDLINE

dg = dependency_graph

dg = dependency_graph: print module dependency graph.

Prints the dependency graph of source modules. Requires that import has been done with the -retain flag. The graph is written in the file _gfdepgraph.dot which can be further processed by Graphviz (the system command 'dot'). By default, all modules are shown, but the -only flag restricts them by a comma-separated list of patterns, where 'name*' matches modules whose name has prefix 'name', and other patterns match modules with exactly the same name. The graphical conventions are: solid box = abstract, solid ellipse = concrete, dashed ellipse = other solid arrow empty head = of, solid arrow = **, dashed arrow = open dotted arrow = other dependency

• Syntax: dg (-only=MODULES)?

• Flags:

• Examples:

dt = define_tree

dt = define_tree: define a tree or string macro.

Defines IDENT as macro for TREE or STRING, until IDENT gets redefined. The defining value can also come from a command, preceded by "<". If the command gives many values, the first one is selected. A use of the macro has the form %IDENT. Currently this use cannot be a subtree of another tree. This command must be a line of its own and thus cannot be a part of a pipe.

• Syntax: dt IDENT (TREE | STRING | "<" COMMANDLINE)

• Examples:

e = empty

e = empty: empty the environment.

eb = example_based

eb = example_based: converts .gfe files to .gf files by parsing examples to trees.

Reads FILE.gfe and writes FILE.gf. Each expression of form '%ex CAT QUOTEDSTRING' in FILE.gfe is replaced by a syntax tree. This tree is the first one returned by the parser; a biased ranking can be used to regulate the order. If there are more than one parses the rest are shown in comments, with probabilities if the order is biased. The probabilities flag and configuration file is similar to the commands gr and rt. Notice that the command doesn't change the environment, but the resulting .gf file must be imported separately.

• Syntax: eb (-probs=FILE | -lang=LANG)* -file=FILE.gfe
• Options:

• Flags:

gr = generate_random

gr = generate_random: generate random trees in the current abstract syntax.

Generates a list of random trees, by default one tree. If a tree argument is given, the command completes the Tree with values to all metavariables in the tree. The generation can be biased by probabilities, given in a file in the -probs flag.

• Syntax: gr [-cat=CAT] [-number=INT]

• Flags:

• Examples:

gt = generate_trees

gt = generate_trees: generates a list of trees, by default exhaustive.

Generates all trees of a given category, with increasing depth. By default, the depth is 4, but this can be changed by a flag. If a Tree argument is given, the command completes the Tree with values to all metavariables in the tree.

• Flags:

• Examples:

h = help

h = help: get description of a command, or a the full list of commands.

Displays information concerning the COMMAND. Without argument, shows the synopsis of all commands.

• Syntax: h (-full)? COMMAND?
• Options:

i = import

i = import: import a grammar from source code or compiled .pgf file.

Reads a grammar from File and compiles it into a GF runtime grammar. If its abstract is different from current state, old modules are discarded. If its abstract is the same and a concrete with the same name is already in the state it is overwritten - but only if compilation succeeds. The grammar parser depends on the file name suffix: .cf context-free (labelled BNF) source .ebnf extended BNF source .gfm multi-module GF source .gf normal GF source .gfo compiled GF source .pgf precompiled grammar in Portable Grammar Format

• Options:

• Flags:

l = linearize

l = linearize: convert an abstract syntax expression to string.

Shows the linearization of a Tree by the grammars in scope. The -lang flag can be used to restrict this to fewer languages. A sequence of string operations (see command ps) can be given as options, and works then like a pipe to the ps command, except that it only affect the strings, not e.g. the table labels. These can be given separately to each language with the unlexer flag whose results are prepended to the other lexer flags. The value of the unlexer flag is a space-separated list of comma-separated string operation sequences; see example.

• Options:

• Flags:

• Examples:

ma = morpho_analyse

ma = morpho_analyse: print the morphological analyses of all words in the string.

Prints all the analyses of space-separated words in the input string, using the morphological analyser of the actual grammar (see command pg)

• Options:

• Flags:

mq = morpho_quiz

mq = morpho_quiz: start a morphology quiz.

• Syntax: mq (-cat=CAT)? (-probs=FILE)? TREE?

• Flags:

p = parse

p = parse: parse a string to abstract syntax expression.

Shows all trees returned by parsing a string in the grammars in scope. The -lang flag can be used to restrict this to fewer languages. The default start category can be overridden by the -cat flag. See also the ps command for lexing and character encoding.

The -openclass flag is experimental and allows some robustness in the parser. For example if -openclass="A,N,V" is given, the parser will accept unknown adjectives, nouns and verbs with the resource grammar.

• Options:

• Flags:

pg = print_grammar

pg = print_grammar: print the actual grammar with the given printer.

Prints the actual grammar, with all involved languages. In some printers, this can be restricted to a subset of languages with the -lang=X,Y flag (comma-separated, no spaces). The -printer=P flag sets the format in which the grammar is printed. N.B.1 Since grammars are compiled when imported, this command generally shows a grammar that looks rather different from the source. N.B.2 Another way to produce different formats is to use 'gf -make', the batch compiler. The following values are available both for the batch compiler (flag -output-format) and the print_grammar command (flag -printer):

bnf BNF (context-free grammar) ebnf Extended BNF fa finite automaton in graphviz format gsl Nuance speech recognition format haskell Haskell (abstract syntax) js JavaScript (whole grammar) jsgf JSGF speech recognition format lambda_prolog LambdaProlog (abstract syntax) pgf_pretty human-readable pgf prolog Prolog (whole grammar) prolog_abs Prolog (abstract syntax) regexp regular expression slf SLF speech recognition format srgs_abnf SRGS speech recognition format in ABNF srgs_abnf_nonrec SRGS ABNF, recursion eliminated srgs_xml SRGS speech recognition format in XML srgs_xml_nonrec SRGS XML, recursion eliminated vxml Voice XML based on abstract syntax

• Options:

• Flags:

• Examples:

ph = print_history

ph = print_history: print command history.

Prints the commands issued during the GF session. The result is readable by the eh command. The result can be used as a script when starting GF.

• Examples:

ps = put_string

ps = put_string: return a string, possibly processed with a function.

Returns a string obtained from its argument string by applying string processing functions in the order given in the command line option list. Thus 'ps -f -g s' returns g (f s). Typical string processors are lexers and unlexers, but also character encoding conversions are possible. The unlexers preserve the division of their input to lines. To see transliteration tables, use command ut.

• Syntax: ps OPT? STRING
• Options:

• Flags:

• Examples:

pt = put_tree

pt = put_tree: return a tree, possibly processed with a function.

Returns a tree obtained from its argument tree by applying tree processing functions in the order given in the command line option list. Thus 'pt -f -g s' returns g (f s). Typical tree processors are type checking and semantic computation.

• Syntax: ps OPT? TREE
• Options:

• Flags:

• Examples:

q = quit

q = quit: exit GF interpreter.

r = reload

r = reload: repeat the latest import command.

rf = read_file

rf = read_file: read string or tree input from a file.

Reads input from file. The filename must be in double quotes. The input is interpreted as a string by default, and can hence be piped e.g. to the parse command. The option -tree interprets the input as a tree, which can be given e.g. to the linearize command. The option -lines will result in a list of strings or trees, one by line.

• Options:

• Flags:

rt = rank_trees

rt = rank_trees: show trees in an order of decreasing probability.

Order trees from the most to the least probable, using either even distribution in each category (default) or biased as specified by the file given by flag -probs=FILE, where each line has the form 'function probability', e.g. 'youPol_Pron 0.01'.

• Options:

• Flags:

• Examples:

sd = show_dependencies

sd = show_dependencies: show all constants that the given constants depend on.

Show recursively all qualified constant names, by tracing back the types and definitions of each constant encountered, but just listing every name once. This command requires a source grammar to be in scope, imported with 'import -retain'. Notice that the accuracy is better if the modules are compiled with the flag -optimize=noexpand. This command must be a line of its own, and thus cannot be a part of a pipe.

• Syntax: sd QUALIFIED_CONSTANT+
• Options:

• Examples:

se = set_encoding

se = set_encoding: set the encoding used in current terminal.

• Syntax: se ID

• Examples:

so = show_operations

so = show_operations: show all operations in scope, possibly restricted to a value type.

Show the names and type signatures of all operations available in the current resource. This command requires a source grammar to be in scope, imported with 'import -retain'. The operations include the parameter constructors that are in scope. The optional TYPE filters according to the value type. The grep STRINGs filter according to other substrings of the type signatures. This command must be a line of its own, and thus cannot be a part of a pipe.

• Syntax: so (-grep=STRING)* TYPE?
• Options:

• Flags:

sp = system_pipe

sp = system_pipe: send argument to a system command.

• Syntax: sp -command="SYSTEMCOMMAND", alt. ? SYSTEMCOMMAND

• Flags:

• Examples:

ss = show_source

ss = show_source: show the source code of modules in scope, possibly just headers.

Show compiled source code, i.e. as it is included in GF object files. This command requires a source grammar to be in scope, imported with 'import -retain'. The optional MODULE arguments cause just these modules to be shown. The -size and -detailedsize options show code size as the number of constructor nodes. This command must be a line of its own, and thus cannot be a part of a pipe.

• Syntax: ss (-strip)? (-save)? MODULE*
• Options:

• Examples:

t = tokenize

t = tokenize: Tokenize string using the vocabulary.

• Flags:

tq = translation_quiz

tq = translation_quiz: start a translation quiz.

• Syntax: tq -from=LANG -to=LANG (-cat=CAT)? (-probs=FILE)? TREE?

• Flags:

• Examples:

ut = unicode_table

ut = unicode_table: show a transliteration table for a unicode character set.

• Options:

vd = visualize_dependency

vd = visualize_dependency: show word dependency tree graphically.

Prints a dependency tree in the .dot format (the graphviz format, default) or the MaltParser/CoNLL format (flag -output=malt for training, malt_input) for unanalysed input. By default, the last argument is the head of every abstract syntax function; moreover, the head depends on the head of the function above. The graph can be saved in a file by the wf command as usual. If the -view flag is defined, the graph is saved in a temporary file which is processed by graphviz and displayed by the program indicated by the flag. The target format is png, unless overridden by the flag -format.

• Options:

• Flags:

• Examples:

vp = visualize_parse

vp = visualize_parse: show parse tree graphically.

Prints a parse tree the .dot format (the graphviz format). The graph can be saved in a file by the wf command as usual. If the -view flag is defined, the graph is saved in a temporary file which is processed by graphviz and displayed by the program indicated by the flag. The target format is png, unless overridden by the flag -format.

• Flags:

• Examples:

vt = visualize_tree

vt = visualize_tree: show a set of trees graphically.

Prints a set of trees in the .dot format (the graphviz format). The graph can be saved in a file by the wf command as usual. If the -view flag is defined, the graph is saved in a temporary file which is processed by graphviz and displayed by the program indicated by the flag. The target format is postscript, unless overridden by the flag -format. With option -mk, use for showing library style function names of form 'mkC'.

• Options:

• Flags:

• Examples:

wf = write_file

wf = write_file: send string or tree to a file.

• Options:

• Flags:

The GF batch compiler

With the option -batch, GF can be invoked in batch mode, i.e. without opening the shell, to compile files from .gf to .gfo. The -s option ("silent") eliminates all messages except errors.

    $ gf -batch -s LangIta.gf

With the option -make, and as a set of top-level grammar files (with the same abstract syntax) as arguments, GF produces a .pgf file. The flag -optimize-pgf minimizes the size of the .pgf file, and is recommended for grammars to be shipped.

    $ gf -make -optimize-pgf LangIta.gf LangEng.gf LangGer.gf

The flag -output-format changes the output format from .pgf to some other format. For instance

    $ gf -make -output-format=js LangEng.pgf LangGer.pgf

Notice that the arguments can be .pgf files, which in this case are merged and written into a JavaScript grammar file.

More options and instructions are obtained with

    $ gf -help

To run GF from a script, redirection of standard input can be used:

    $ gf <script.gfs

The file script.gfs should then contain a sequence of GF commands, one per line. Unrecognized command lines are skipped without terminating GF.