1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
|
<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML//EN">
<html><head><title></title></head>
<body bgcolor="#ffffff" text="#000000">
<center>
<img src="../gf-logo.gif">
<h1>Grammatical Framework Tutorial</h1>
<p>
<b>3rd Edition, for GF version 2.2 or later</b>
</p><p>
<a href="http://www.cs.chalmers.se/~aarne</a>">Aarne Ranta</a>
</p>
<p>
<tt>aarne@cs.chalmers.se</tt>
</p></center>
<!-- NEW -->
<h2>GF = Grammatical Framework</h2>
The term GF is used for different things:
<ul>
<li> a <b>program</b> used for working with grammars
<li> a <b>programming language</b> in which grammars can be written
<li> a <b>theory</b> about the concepts of grammars and languages
</ul>
<p>
This tutorial is about the GF program and the GF programming language.
It will guide you
<ul>
<li> to use the GF program
<li> to write GF grammars
<li> to write programs in which GF grammars are used as components
</ul>
<!-- NEW -->
<h2>The GF program</h2>
The program is open-source free software, which you can download from the
GF Homepage:<br>
<a href="http://www.cs.chalmers.se/%7Eaarne/GF">
<tt>http://www.cs.chalmers.se/~aarne/GF</tt></a>
<p>
There you can download
<ul>
<li> ready-made binaries for Linux, Solaris, Macintosh, and Windows
<li> source code and documentation
<li> grammar libraries and examples
</ul>
If you want to compile GF from source, you need Haskell and Java
compilers. But normally you don't have to compile, and you don't
need to know Haskell or Java to use GF.
<p>
To start the GF program, assuming you have installed it, just type
<pre>
gf
</pre>
in the shell. You will see GF's welcome message and the prompt <tt>></tt>.
<!-- NEW -->
<h2>My first grammar</h2>
Now you are ready to try out your first grammar.
We start with one that is not written in GF language, but
in the EBNF notation (Extended Backus Naur Form), which GF can also
understand. Type (or copy) the following lines in a file named
<tt>stoneage.ebnf</tt>:
<pre>
S ::= NP VP ;
VP ::= V | TV NP | "is" A ;
NP ::= ("this" | "that" | "the" | "a") CN ;
CN ::= A CN ;
CN ::= "bird" | "boy" | "man" | "louse" | "snake" | "worm" ;
A ::= "big" | "green" | "rotten" | "thick" | "warm" ;
V ::= "laughs" | "sleeps" | "swims" ;
TV ::= "eats" | "kills" | "washes" ;
</pre>
<!-- NEW -->
<h2>Importing grammars and parsing strings</h2>
The first GF command when using a grammar is to <b>import</b> it.
The command has a long name, <tt>import</tt>, and a short name, <tt>i</tt>.
<pre>
import stoneage.gf
</pre>
The GF program now <b>compiles</b> your grammar into an internal
representation, and shows a new prompt when it is ready.
<p>
You can use GF for <b>parsing</b>:
<pre>
> parse "the boy eats a snake"
Mks_0 (Mks_6 Mks_10) (Mks_2 Mks_23 (Mks_7 Mks_13))
> parse "the snake eats a boy"
Mks_0 (Mks_6 Mks_13) (Mks_2 Mks_23 (Mks_7 Mks_10))
</pre>
The <tt>parse</tt> (= <tt>p</tt>) command takes a <b>string</b>
(in double quotes) and returns an <b>abstract syntax tree</b> - the thing
with <tt>Mks</tt>s and parentheses. We will see soon how to make sense
of the abstract syntax trees - now you should just notice that the tree
is different for the two strings.
<p>
Strings that return a tree when parsed do so in virtue of the grammar
you imported. Try parsing something else, and you fail
<pre>
> p "hello world"
No success in cf parsing
no tree found
<pre>
<!-- NEW -->
<h2>Generating trees and strings</h2>
You can also use GF for <b>linearizing</b>
(<tt>linearize = l</tt>). This is the inverse of
parsing, taking trees into strings:
<pre>
> linearize Mks_0 (Mks_6 Mks_13) (Mks_2 Mks_23 (Mks_7 Mks_10))
the snake eats a boy
</pre>
What is the use of this? Typically not that you type in a tree at
the GF prompt. The utility of linearization comes from the fact that
you can obtain a tree from somewhere else. One way to do so is
<b>random generation</b> (<tt>generate_random = gr</tt>):
<pre>
> generate_random
Mks_0 (Mks_4 Mks_11) (Mks_3 Mks_15)
</pre>
Now you can copy the tree and paste it to the <tt>linearize command</tt>.
Or, more efficiently, feed random generation into parsing by using
a <b>pipe</b>.
<pre>
> gr | l
this man is big
</pre>
<!-- NEW -->
<h2>Some random-generated sentences</h2>
Random generation can be quite amusing. So you may want to
generate ten strings with one and the same command:
<pre>
> gr -number=10 | l
a snake laughs
that man laughs
the man swims
this man is warm
a louse is rotten
that worm washes a man
a boy swims
a snake laughs
a man washes this man
this louse kills the boy
</pre>
<!-- NEW -->
<h2>Systematic generation</h2>
To generate <i>all</i> sentence that a grammar
can generate, use the command <tt>generate_trees = gt</tt>.
<pre>
this boy laughs
this boy sleeps
this boy swims
this boy is big
...
a bird is rotten
a bird is thick
a bird is warm
</pre>
You get quite a few trees but not all of them: only up to a given
<b>depth</b> of trees. To see how you can get more, use the
<tt>help = h</tt> command,
<pre>
h gr
</pre>
<b>Quiz</b>. If the command <tt>gt</tt> generated all
trees in your grammar, it would never terminate. Why?
<!-- NEW -->
<h2>More on pipes; tracing</h2>
A pipe of GF commands can have any length, but the "output type"
(either string or tree) of one command must always match the "input type"
of the next command.
<p>
The intermediate results in a pipe can be observed by putting the
<b>tracing</b> flag <tt>-tr</tt> to each command whose output you
want to see:
<pre>
> gr -tr | l -tr | p
Mks_0 (Mks_6 Mks_13) (Mks_1 Mks_20)
the snake laughs
Mks_0 (Mks_6 Mks_13) (Mks_1 Mks_20)
</pre>
This facility is good for test purposes: for instance, you
may want to see if a grammar is <b>ambiguous</b>, i.e.
contains strings that can be parsed in more than one way.
<!-- NEW -->
<h2>Writing and reading files</h2>
To save the outputs of GF commands into a file, you can
pipe it to the <tt>write_file = wf</tt> command,
<pre>
> gr -number=10 | l | write_file exx.tmp
</pre>
You can read the file back to GF with the
<tt>read_file = rf</tt> command,
<pre>
> read_file exx.tmp | l -tr | p -lines
</pre>
Notice the flag <tt>-lines</tt> given to the parsing
command. This flag tells GF to parse each line of
the file separately. Without the flag, the grammar could
not recognize the string in the file, because it is not
a sentence but a sequence of ten sentences.
<!-- NEW -->
<h2>Labelled context-free grammars</h2>
<h3>Rules and labels</h3>
The syntax trees returned by GF's parser in the previous examples
are not so nice to look at. The identifiers of form <tt>Mks</tt>
are <b>labels</b> of the EBNF rules. To see which label corresponds to
which rule, you can use the <tt>print_grammar = pg</tt> command
with the <tt>printer</tt> flag set to <tt>cf</tt> (which means context-free):
<pre>
> print_grammar -printer=cf
Mks_10. CN ::= "boy" ;
Mks_11. CN ::= "man" ;
Mks_12. CN ::= "louse" ;
Mks_13. CN ::= "snake" ;
Mks_14. CN ::= "worm" ;
Mks_8. CN ::= A CN ;
Mks_9. CN ::= "bird" ;
Mks_4. NP ::= "this" CN ;
Mks_18. A ::= "thick" ;
</pre>
A syntax tree such as
<pre>
Mks_4 (Mks_8 Mks_18 Mks_14)
this thick worm
</pre>
encodes the sequence of grammar rules used for building the
expression. If you look at this tree, you will notice that <tt>Mks_4</tt>
is the label of the rule prefixing <tt>this</tt> to a common noun,
<tt>Mks_18</tt> is the label of the adjective <tt>thick</tt>,
and so on.
</body>
</html>
|
