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
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
|
<!-- This comment will put IE 6, 7 and 8 in quirks mode -->
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<title>The m17n Library: Tutorial for writing the m17n database</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javaScript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css"/>
</head>
<body onload='searchBox.OnSelectItem(0);'>
<!-- Generated by Doxygen 1.6.3 -->
<script type="text/javascript"><!--
var searchBox = new SearchBox("searchBox", "search",false,'Search');
--></script>
<div class="navigation" id="top">
<div class="tabs">
<ul>
<li><a href="index.html"><span>Main Page</span></a></li>
<li class="current"><a href="pages.html"><span>Related Pages</span></a></li>
<li><a href="modules.html"><span>Modules</span></a></li>
<li><a href="annotated.html"><span>Data Structures</span></a></li>
<li><a href="files.html"><span>Files</span></a></li>
<li>
<div id="MSearchBox" class="MSearchBoxInactive">
<img id="MSearchSelect" src="search/search.png"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
alt=""/>
<input type="text" id="MSearchField" value="Search" accesskey="S"
onfocus="searchBox.OnSearchFieldFocus(true)"
onblur="searchBox.OnSearchFieldFocus(false)"
onkeyup="searchBox.OnSearchFieldChange(event)"/>
<a id="MSearchClose" href="javascript:searchBox.CloseResultsWindow()"><img id="MSearchCloseImg" border="0" src="search/close.png" alt=""/></a>
</div>
</li>
</ul>
</div>
</div>
<div class="contents">
<h1><a class="anchor" id="m17nDBTutorial">Tutorial for writing the m17n database </a></h1><p>This section contains tutorials for writing various database files of the m17n database.</p>
<ul>
<li>
<a class="el" href="m17nDBTutorial.html#mdbTutorialIM">TutorialIM</a> -- Tutorial of input method </li>
</ul>
<h2><a class="anchor" id="mdbTutorialIM">
Tutorial of input method</a></h2>
<h3><a class="anchor" id="im-struct">
Structure of an input method file</a></h3>
<p>An input method is defined in a *.mim file with this format.</p>
<div class="fragment"><pre class="fragment">
(input-method LANG NAME)
(description (_ "DESCRIPTION"))
(title "TITLE-STRING")
(map
(MAP-NAME
(KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
(KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
...)
(MAP-NAME
(KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
(KEYSEQ MAP-ACTION MAP-ACTION ...) <- rule
...)
...)
(state
(STATE-NAME
(MAP-NAME BRANCH-ACTION BRANCH-ACTION ...) <- branch
...)
(STATE-NAME
(MAP-NAME BRANCH-ACTION BRANCH-ACTION ...) <- branch
...)
...)
</pre></div><p> Lowercase letters and parentheses are literals, so they must be written as they are. Uppercase letters represent arbitrary strings.</p>
<p>KEYSEQ specifies a sequence of keys in this format: </p>
<div class="fragment"><pre class="fragment">
(SYMBOLIC-KEY SYMBOLIC-KEY ...)
</pre></div><p> where SYMBOLIC-KEY is the keysym value returned by the xev command. For instance </p>
<div class="fragment"><pre class="fragment">
(n i)
</pre></div><p> represents a key sequence of <n> and <i>. If all SYMBOLIC-KEYs are ASCII characters, you can use the short form </p>
<div class="fragment"><pre class="fragment">
"ni"
</pre></div><p> instead. Consult <a class="el" href="m17nDBFormat.html#mdbIM">Input Method</a> for Non-ASCII characters.</p>
<p>Both MAP-ACTION and BRANCH-ACTION are a sequence of actions of this format: </p>
<div class="fragment"><pre class="fragment">
(ACTION ARG ARG ...)
</pre></div><p> The most common action is <code>insert</code>, which is written as this: </p>
<div class="fragment"><pre class="fragment">
(insert "TEXT")
</pre></div><p> But as it is very frequently used, you can use the short form </p>
<div class="fragment"><pre class="fragment">
"TEXT"
</pre></div><p> If <code>"TEXT"</code> contains only one character "C", you can write it as </p>
<div class="fragment"><pre class="fragment">
(insert ?C)
</pre></div><p> or even shorter as </p>
<div class="fragment"><pre class="fragment">
?C
</pre></div><p> So the shortest notation for an action of inserting "a" is </p>
<div class="fragment"><pre class="fragment">
?a
</pre></div><h3><a class="anchor" id="im-upcase">
Simple example of capslock</a></h3>
<p>Here is a simple example of an input method that works as CapsLock.</p>
<div class="fragment"><pre class="fragment">
(input-method en capslock)
(description (_ "Upcase all lowercase letters"))
(title "a->A")
(map
(toupper ("a" "A") ("b" "B") ("c" "C") ("d" "D") ("e" "E")
("f" "F") ("g" "G") ("h" "H") ("i" "I") ("j" "J")
("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
("z" "Z")))
(state
(init (toupper)))
</pre></div><p>When this input method is activated, it is in the initial condition of the first state (in this case, the only state <code>init</code>). In the initial condition, no key is being processed and no action is suspended. When the input method receives a key event <a>, it searches branches in the current state for a rule that matches <a> and finds one in the map <code>toupper</code>. Then it executes MAP-ACTIONs (in this case, just inserting "A" in the preedit buffer). After all MAP-ACTIONs have been executed, the input method shifts to the initial condition of the current state.</p>
<p>The shift to <em>the initial condition of the first state</em> has a special meaning; it commits all characters in the preedit buffer then clears the preedit buffer.</p>
<p>As a result, "A" is given to the application program.</p>
<p>When a key event does not match with any rule in the current state, that event is unhandled and given back to the application program.</p>
<p>Turkish users may want to extend the above example for "İ" (U+0130: LATIN CAPITAL LETTER I WITH DOT ABOVE). It seems that assigning the key sequence <i> <i> for that character is convenient. So, he will add this rule in <code>toupper</code>.</p>
<div class="fragment"><pre class="fragment">
("ii" "İ")
</pre></div><p>However, we already have the following rule:</p>
<div class="fragment"><pre class="fragment">
("i" "I")
</pre></div><p>What will happen when a key event <i> is sent to the input method?</p>
<p>No problem. When the input method receives <i>, it inserts "I" in the preedit buffer. It knows that there is another rule that may match the additional key event <i>. So, after inserting "I", it suspends the normal behavior of shifting to the initial condition, and waits for another key. Thus, the user sees "I" with underline, which indicates it is not yet committed.</p>
<p>When the input method receives the next <i>, it cancels the effects done by the rule for the previous "i" (in this case, the preedit buffer is cleared), and executes MAP-ACTIONs of the rule for "ii". So, "İ" is inserted in the preedit buffer. This time, as there are no other rules that match with an additional key, it shifts to the initial condition of the current state, which leads to commit "İ".</p>
<p>Then, what will happen when the next key event is <a> instead of <i>?</p>
<p>No problem, either.</p>
<p>The input method knows that there are no rules that match the <i> <a> key sequence. So, when it receives the next <a>, it executes the suspended behavior (i.e. shifting to the initial condition), which leads to commit "I". Then the input method tries to handle <a> in the current state, which leads to commit "A".</p>
<p>So far, we have explained MAP-ACTION, but not BRANCH-ACTION. The format of BRANCH-ACTION is the same as that of MAP-ACTION. It is executed only after a matching rule has been determined and the corresponding MAP-ACTIONs have been executed. A typical use of BRANCH-ACTION is to shift to a different state.</p>
<p>To see this effect, let us modify the current input method to upcase only word-initial letters (i.e. to capitalize). For that purpose, we modify the "init" state as this:</p>
<div class="fragment"><pre class="fragment">
(init
(toupper (shift non-upcase)))
</pre></div><p>Here <code>(shift non-upcase)</code> is an action to shift to the new state <code>non-upcase</code>, which has two branches as below:</p>
<div class="fragment"><pre class="fragment">
(non-upcase
(lower)
(nil (shift init)))
</pre></div><p>The first branch is simple. We can define the new map <code>lower</code> as the following to insert lowercase letters as they are.</p>
<div class="fragment"><pre class="fragment">
(map
...
(lower ("a" "a") ("b" "b") ("c" "c") ("d" "d") ("e" "e")
("f" "f") ("g" "g") ("h" "h") ("i" "i") ("j" "j")
("k" "k") ("l" "l") ("m" "m") ("n" "n") ("o" "o")
("p" "p") ("q" "q") ("r" "r") ("s" "s") ("t" "t")
("u" "u") ("v" "v") ("w" "w") ("x" "x") ("y" "y")
("z" "z")))
</pre></div><p>The second branch has a special meaning. The map name <code>nil</code> means that it matches with any key event that does not match any rules in the other maps in the current state. In addition, it does not consume any key event. We will show the full code of the new input method before explaining how it works.</p>
<div class="fragment"><pre class="fragment">
(input-method en titlecase)
(description (_ "Titlecase letters"))
(title "abc->Abc")
(map
(toupper ("a" "A") ("b" "B") ("c" "C") ("d" "D") ("e" "E")
("f" "F") ("g" "G") ("h" "H") ("i" "I") ("j" "J")
("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
("z" "Z") ("ii" "İ"))
(lower ("a" "a") ("b" "b") ("c" "c") ("d" "d") ("e" "e")
("f" "f") ("g" "g") ("h" "h") ("i" "i") ("j" "j")
("k" "k") ("l" "l") ("m" "m") ("n" "n") ("o" "o")
("p" "p") ("q" "q") ("r" "r") ("s" "s") ("t" "t")
("u" "u") ("v" "v") ("w" "w") ("x" "x") ("y" "y")
("z" "z")))
(state
(init
(toupper (shift non-upcase)))
(non-upcase
(lower (commit))
(nil (shift init))))
</pre></div><p>Let's see what happens when the user types the key sequence <a> <b> < >. Upon <a>, "A" is inserted into the buffer and the state shifts to <code>non-upcase</code>. So, the next <b> is handled in the <code>non-upcase</code> state. As it matches a rule in the map <code>lower</code>, "b" is inserted in the preedit buffer and characters in the buffer ("Ab") are committed explicitly by the "commit" command in BRANCH-ACTION. After that, the input method is still in the <code>non-upcase</code> state. So the next < > is also handled in <code>non-upcase</code>. For this time, no rule in this state matches it. Thus the branch <code>(nil (shift init))</code> is selected and the state is shifted to <code>init</code>. Please note that < > is not yet handled because the map <code>nil</code> does not consume any key event. So, the input method tries to handle it in the <code>init</code> state. Again no rule matches it. Therefore, that event is given back to the application program, which usually inserts a space for that.</p>
<p>When you type "a quick blown fox" with this input method, you get "A
Quick Blown Fox". OK, you find a typo in "blown", which should be "brown". To correct it, you probably move the cursor after "l" and type <Backspace> and <r>. However, if the current input method is still active, a capital "R" is inserted. It is not a sophisticated behavior.</p>
<h3><a class="anchor" id="im-surrounding-text">
Example of utilizing surrounding text support</a></h3>
<p>To make the input method work well also in such a case, we must use "surrounding text support". It is a way to check characters around the inputting spot and delete them if necessary. Note that this facility is available only with Gtk+ applications and Qt applications. You cannot use it with applications that use XIM to communicate with an input method.</p>
<p>Before explaining how to utilize "surrounding text support", you must understand how to use variables, arithmetic comparisons, and conditional actions.</p>
<p>At first, any symbol (except for several preserved ones) used as ARG of an action is treated as a variable. For instance, the commands</p>
<div class="fragment"><pre class="fragment">
(set X 32) (insert X)
</pre></div><p>set the variable <code>X</code> to integer value 32, then insert a character whose Unicode character code is 32 (i.e. SPACE).</p>
<p>The second argument of the <code>set</code> action can be an expression of this form:</p>
<div class="fragment"><pre class="fragment">
(OPERATOR ARG1 [ARG2])
</pre></div><p>Both ARG1 and ARG2 can be an expression. So,</p>
<div class="fragment"><pre class="fragment">
(set X (+ (* Y 32) Z))
</pre></div><p>sets <code>X</code> to the value of <code>Y * 32 + Z</code>.</p>
<p>We have the following arithmetic/bitwise OPERATORs (require two arguments):</p>
<div class="fragment"><pre class="fragment">
+ - * / & |
</pre></div><p>these relational OPERATORs (require two arguments):</p>
<div class="fragment"><pre class="fragment">
== <= >= < >
</pre></div><p>and this logical OPERATOR (requires one argument):</p>
<div class="fragment"><pre class="fragment">
!
</pre></div><p>For surrounding text support, we have these preserved variables:</p>
<div class="fragment"><pre class="fragment">
@-0, @-N, @+N (N is a positive integer)
</pre></div><p>The values of them are predefined as below and can not be altered.</p>
<ul>
<li>
<p class="startli"><code>@-0</code></p>
<p>-1 if surrounding text is supported, -2 if not.</p>
<p class="endli"></p>
</li>
<li>
<p class="startli"><code>@-N</code></p>
<p>The Nth previous character in the preedit buffer. If there are only M (M<N) previous characters in it, the value is the (N-M)th previous character from the inputting spot.</p>
<p class="endli"></p>
</li>
<li>
<p class="startli"><code>@+N</code></p>
<p>The Nth following character in the preedit buffer. If there are only M (M<N) following characters in it, the value is the (N-M)th following character from the inputting spot.</p>
<p class="endli"></p>
</li>
</ul>
<p>So, provided that you have this context:</p>
<div class="fragment"><pre class="fragment">
ABC|def|GHI
</pre></div><p>("def" is in the preedit buffer, two "|"s indicate borders between the preedit buffer and the surrounding text) and your current position in the preedit buffer is between "d" and "e", you get these values:</p>
<div class="fragment"><pre class="fragment">
@-3 -- ?B
@-2 -- ?C
@-1 -- ?d
@+1 -- ?e
@+2 -- ?f
@+3 -- ?G
</pre></div><p>Next, you have to understand the conditional action of this form:</p>
<div class="fragment"><pre class="fragment">
(cond
(EXPR1 ACTION ACTION ...)
(EXPR2 ACTION ACTION ...)
...)
</pre></div><p>where EXPRn are expressions. When an input method executes this action, it resolves the values of EXPRn one by one from the first branch. If the value of EXPRn is resolved into nonzero, the corresponding actions are executed.</p>
<p>Now you are ready to write a new version of the input method "Titlecase".</p>
<div class="fragment"><pre class="fragment">
(input-method en titlecase2)
(description (_ "Titlecase letters"))
(title "abc->Abc")
(map
(toupper ("a" "A") ("b" "B") ("c" "C") ("d" "D") ("e" "E")
("f" "F") ("g" "G") ("h" "H") ("i" "I") ("j" "J")
("k" "K") ("l" "L") ("m" "M") ("n" "N") ("o" "O")
("p" "P") ("q" "Q") ("r" "R") ("s" "S") ("t" "T")
("u" "U") ("v" "V") ("w" "W") ("x" "X") ("y" "Y")
("z" "Z") ("ii" "İ")))
(state
(init
(toupper
;; Now we have exactly one uppercase character in the preedit
;; buffer. So, "@-2" is the character just before the inputting
;; spot.
(cond ((| (& (>= @-2 ?A) (<= @-2 ?Z))
(& (>= @-2 ?a) (<= @-2 ?z))
(= @-2 ?İ))
;; If the character before the inputting spot is A..Z,
;; a..z, or İ, remember the only character in the preedit
;; buffer in the variable X and delete it.
(set X @-1) (delete @-)
;; Then insert the lowercase version of X.
(cond ((= X ?İ) "i")
(1 (set X (+ X 32)) (insert X))))))))
</pre></div><p>The above example contains the new action <code>delete</code>. So, it is time to explain more about the preedit buffer. The preedit buffer is a temporary place to store a sequence of characters. In this buffer, the input method keeps a position called the "current position". The current position exists between two characters, at the beginning of the buffer, or at the end of the buffer. The <code>insert</code> action inserts characters before the current position. For instance, when your preedit buffer contains "ab.c" ("." indicates the current position),</p>
<div class="fragment"><pre class="fragment">
(insert "xyz")
</pre></div><p>changes the buffer to "abxyz.c".</p>
<p>There are several predefined variables that represent a specific position in the preedit buffer. They are:</p>
<ul>
<li>
<p class="startli"><code>@<, @=, @></code></p>
<p>The first, current, and last positions.</p>
<p class="endli"></p>
</li>
<li>
<p class="startli"><code>@-, @+</code></p>
<p class="endli">The previous and the next positions. </p>
</li>
</ul>
<p>The format of the <code>delete</code> action is this:</p>
<div class="fragment"><pre class="fragment">
(delete POS)
</pre></div><p>where POS is a predefined positional variable. The above action deletes the characters between POS and the current position. So, <code>(delete @-)</code> deletes one character before the current position. The other examples of <code>delete</code> include the followings:</p>
<div class="fragment"><pre class="fragment">
(delete @+) ; delete the next character
(delete @<) ; delete all the preceding characters in the buffer
(delete @>) ; delete all the following characters in the buffer
</pre></div><p>You can change the current position using the <code>move</code> action as below:</p>
<div class="fragment"><pre class="fragment">
(move @-) ; move the current position to the position before the
previous character
(move @<) ; move to the first position
</pre></div><p>Other positional variables work similarly.</p>
<p>Let's see how our new example works. Whatever a key event is, the input method is in its only state, <code>init</code>. Since an event of a lower letter key is firstly handled by MAP-ACTIONs, every key is changed into the corresponding uppercase and put into the preedit buffer. Now this character can be accessed with <code>@-1</code>.</p>
<p>How can we tell whether the new character should be a lowercase or an uppercase? We can do so by checking the character before it, i.e. <code>@-2</code>. BRANCH-ACTIONs in the <code>init</code> state do the job.</p>
<p>It first checks if the character <code>@-2</code> is between A to Z, between a to z, or İ by the conditional below.</p>
<div class="fragment"><pre class="fragment">
(cond ((| (& (>= @-2 ?A) (<= @-2 ?Z))
(& (>= @-2 ?a) (<= @-2 ?z))
(= @-2 ?İ))
</pre></div><p>If not, there is nothing to do specially. If so, our new key should be changed back into lowercase. Since the uppercase character is already in the preedit buffer, we retrieve and remember it in the variable <code>X</code> by</p>
<div class="fragment"><pre class="fragment">
(set X @-1)
</pre></div><p>and then delete that character by</p>
<div class="fragment"><pre class="fragment">
(delete @-)
</pre></div><p>Lastly we re-insert the character in its lowercase form. The problem here is that "İ" must be changed into "i", so we need another conditional. The first branch</p>
<div class="fragment"><pre class="fragment">
((= X ?İ) "i")
</pre></div><p>means that "if the character remembered in X is 'İ', 'i' is inserted".</p>
<p>The second branch</p>
<div class="fragment"><pre class="fragment">
(1 (set X (+ X 32)) (insert X))
</pre></div><p>starts with "1", which is always resolved into nonzero, so this branch is a catchall. Actions in this branch increase <code>X</code> by 32, then insert <code>X</code>. In other words, they change A...Z into a...z respectively and insert the resulting lowercase character into the preedit buffer. As the input method reaches the end of the BRANCH-ACTIONs, the character is committed.</p>
<p>This new input method always checks the character before the current position, so "A Quick Blown Fox" will be successfully fixed to "A
Quick Brown Fox" by the key sequence <BackSpace> <r>. </p>
</div>
<!--- window showing the filter options -->
<div id="MSearchSelectWindow"
onmouseover="return searchBox.OnSearchSelectShow()"
onmouseout="return searchBox.OnSearchSelectHide()"
onkeydown="return searchBox.OnSearchSelectKey(event)">
<a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(0)"><span class="SelectionMark"> </span>All</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(1)"><span class="SelectionMark"> </span>Data Structures</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(2)"><span class="SelectionMark"> </span>Files</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(3)"><span class="SelectionMark"> </span>Functions</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(4)"><span class="SelectionMark"> </span>Variables</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(5)"><span class="SelectionMark"> </span>Typedefs</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(6)"><span class="SelectionMark"> </span>Enumerations</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(7)"><span class="SelectionMark"> </span>Enumerator</a><a class="SelectItem" href="javascript:void(0)" onclick="searchBox.OnSelectItem(8)"><span class="SelectionMark"> </span>Defines</a></div>
<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="" frameborder="0"
name="MSearchResults" id="MSearchResults">
</iframe>
</div>
<hr>
<ADDRESS>
<a href="http://www.m17n.org/m17n-lib-en/index.html" target="mulewindow"><img src="parrot.png" align=bottom alt="m17n-lib Home" border=0></a>
</ADDRESS>
</body>
</HTML>
<!-- Copyright information
Copyright (C) 2001 Information-technology Promotion Agency (IPA)
Copyright (C) 2001-2011
National Institute of Advanced Industrial Science and Technology (AIST)
This file is part of the m17n library documentation.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.2 or
any later version published by the Free Software Foundation; with no
Invariant Section, no Front-Cover Texts,
and no Back-Cover Texts. A copy of the license is included in the
appendix entitled "GNU Free Documentation License".
-->
|
