+
Resource grammar HOWTO Author: Aarne Ranta <aarne (at) cs.chalmers.se> -Last update: Thu Dec 8 14:52:30 2005 +Last update: Wed Jan 4 11:29:41 2006
- 20051208 + 20060104
The purpose of this document is to tell how to implement the GF @@ -89,7 +89,7 @@ leaves out certain complicated but not always necessary things: tenses and most part of the lexicon.
-
+
The module structure is rather flat: almost every module is a direct @@ -213,48 +213,64 @@ different languages. Unless you are writing an instance of a parametrized implementation (Romance or Scandinavian), which will be covered later, the most simple way is to follow roughly the following procedure. Assume you -are building a grammar for the Dutch language. Here are the first steps. +are building a grammar for the German language. Here are the first steps, +which we actually followed ourselves when building the German implementation +of resource v. 1.0.
GF/lib/resource/english, named
- dutch.
- ```
- cd GF/lib/resource/
- mkdir dutch
- cd dutch
- ```
+ german.
++ cd GF/lib/resource/ + mkdir german + cd german +-
Dut.
+Ger and Deu are given, and we pick Ger.
-*Eng.gf files from english dutch,
+*Eng.gf files from english german,
and rename them:
- ```
- cp ../english/*Eng.gf .
- rename 's/Eng/Dut/' *Eng.gf
- ```
++ cp ../english/*Eng.gf . + rename 's/Eng/Ger/' *Eng.gf +-
Eng module references to Dut references
+Eng module references to Ger references
in all files:
- ``` sed -i 's/Eng/Dut/g' *Dut.gf
++ sed -i 's/English/German/g' *Ger.gf + sed -i 's/Eng/Ger/g' *Ger.gf ++ The first line prevents changing the word
English, which appears
+ here and there in comments, to Gerlish.
Eng - verify this by
- ``` grep Dut *.gf
++ grep Ger *.gf +But you will have to make lots of manual changes in all files anyway!
+ sed -i 's/^/--/' *Ger.gf +This will give you a set of templates out of which the grammar will grow as you uncomment and modify the files rule by rule. -
TestDut.gf, uncomment all lines except the list
+TestGer.gf, uncomment all lines except the list
of inherited modules. Now you can open the grammar in GF:
- ``` gf TestDut.gf
++ gf TestGer.gf +
+ pg -printer=missing +tells you what exactly is missing.
NounDut, and uncomment one
- linearization rule (for instance, IndefSg, which is
+NounGer, and uncomment one
+ linearization rule (for instance, DefSg, which is
not too complicated).
-CN, NP, N) and the
- variations they have. Encode this in the lincats of CatDut.
- You may have to define some new parameter types in ResDut.
+ variations they have. Encode this in the lincats of CatGer.
+ You may have to define some new parameter types in ResGer.
LexDut. Again, it can be helpful to define some simple-minded
- morphological paradigms in ResDut, in particular worst-case
+ in LexGer. Again, it can be helpful to define some simple-minded
+ morphological paradigms in ResGer, in particular worst-case
constructors corresponding to e.g.
ResEng.mkNoun.
+ i -retain ResGer + cc mkNoun "Brief" "Briefe" Masc +-
NounDut and LexDut in TestDut,
- and compile TestDut in GF. Then test by parsing, linearization,
+NounGer and LexGer in TestGer,
+ and compile TestGer in GF. Then test by parsing, linearization,
and random generation. In particular, linearization to a table should
be used so that you see all forms produced:
- ```
- gr -cat=NP -number=20 -tr | l -table
- ```
++ gr -cat=NP -number=20 -tr | l -table +
ResDut: parameter types and auxiliary operations
-MorphoDut: complete inflection engine; not needed for Test.
+ResGer: parameter types and auxiliary operations
+MorphoGer: complete inflection engine; not needed for Test.
@@ -342,13 +359,13 @@ package.
When the implementation of Test is complete, it is time to
work out the lexicon files. The underlying machinery is provided in
-MorphoDut, which is, in effect, your linguistic theory of
-Dutch morphology. It can contain very sophisticated and complicated
+MorphoGer, which is, in effect, your linguistic theory of
+German morphology. It can contain very sophisticated and complicated
definitions, which are not necessarily suitable for actually building a
lexicon. For this purpose, you should write the module
ParadigmsDut: morphological paradigms for the lexicographer.
+ParadigmsGer: morphological paradigms for the lexicographer.
@@ -364,15 +381,15 @@ the functions
mkN, for worst-case construction of N. Its type signature
has the form
- ```
- mkN : Str -> ... -> Str -> P -> ... -> Q -> N
- ```
++ mkN : Str -> ... -> Str -> P -> ... -> Q -> N +with as many string and parameter arguments as can ever be needed to construct an
N.
regN, for the most common cases, with just one string argument:
- ```
- regN : Str -> N
- ```
++ regN : Str -> N +
V2, we provide
mkV2, which takes a V and all necessary arguments, such
as case and preposition:
- ```
- mkV2 : V -> Case -> Str -> V2 ;
- ```
++ mkV2 : V -> Case -> Str -> V2 ; +
+ dirV2 : V -> V2 ; + -- dirV2 v = mkV2 v accusative [] +
@@ -403,33 +420,33 @@ The golden rule for the design of paradigms is that
The discipline of data abstraction moreover requires that the user of the resource
is not given access to parameter constructors, but only to constants that denote
them. This gives the resource grammarian the freedom to change the underlying
-data representation if needed. It means that the ParadigmsDut module has
+data representation if needed. It means that the ParadigmsGer module has
to define constants for those parameter types and constructors that
the application grammarian may need to use, e.g.
oper
Case : Type ;
- nominative, accusative, genitive : Case ;
+ nominative, accusative, genitive, dative : Case ;
These constants are defined in terms of parameter types and constructors
-in ResDut and MorphoDut, which modules are are not
+in ResGer and MorphoGer, which modules are are not
accessible to the application grammarian.
-An important difference between MorphoDut and
-ParadigmsDut is that the former uses "raw" record types
+An important difference between MorphoGer and
+ParadigmsGer is that the former uses "raw" record types
as lincats, whereas the latter used category symbols defined in
-CatDut. When these category symbols are used to denote
-record types in a resource modules, such as ParadigmsDut,
+CatGer. When these category symbols are used to denote
+record types in a resource modules, such as ParadigmsGer,
a lock field is added to the record, so that categories
with the same implementation are not confused with each other.
(This is inspired by the newtype discipline in Haskell.)
For instance, the lincats of adverbs and conjunctions may be the same
-in CatDut:
+in CatGer:
lincat Adv = {s : Str} ;
@@ -467,21 +484,21 @@ in her hidden definitions of constants in Paradigms. For instance,
Lexicon construction
-The lexicon belonging to LangDut consists of two modules:
+The lexicon belonging to LangGer consists of two modules:
StructuralDut, structural words, built by directly using
- MorphoDut.
-BasicDut, content words, built by using ParadigmsDut.
+StructuralGer, structural words, built by directly using
+ MorphoGer.
+BasicGer, content words, built by using ParadigmsGer.
-The reason why MorphoDut has to be used in StructuralDut
-is that ParadigmsDut does not contain constructors for closed
+The reason why MorphoGer has to be used in StructuralGer
+is that ParadigmsGer does not contain constructors for closed
word classes such as pronouns and determiners. The reason why we
-recommend ParadigmsDut for building BasicDut is that
+recommend ParadigmsGer for building BasicGer is that
the coverage of the paradigms gets thereby tested and that the
-use of the paradigms in BasicDut gives a good set of examples for
+use of the paradigms in BasicGer gives a good set of examples for
those who want to build new lexica.
mkV etc).
You can often find resources such as lists of irregular verbs on the internet. For instance, the -Dutch for Travelers +Irregular German Verbs page gives a list of verbs in the traditional tabular format, which begins as follows:
- begrijpen begrijp begreep begrepen to understand - bijten bijt beet gebeten to bite - binden bind bond gebonden to tie - breken breek brak gebroken to break + backen (du bäckst, er bäckt) backte [buk] gebacken + befehlen (du befiehlst, er befiehlt; befiehl!) befahl (beföhle; befähle) befohlen + beginnen begann (begönne; begänne) begonnen + beißen biß gebissen
All you have to do is to write a suitable verb paradigm
- irregV : Str -> Str -> Str -> Str -> V ; + irregV : (x1,_,_,_,_,x6 : Str) -> V ;
and a Perl or Python or Haskell script that transforms the table to
- begrijpen_V = irregV "begrijpen" "begrijp" "begreep" "begrepen" ; - bijten_V = irregV "bijten" "bijt" "beet" "gebeten" ; - binden_V = irregV "binden" "bind" "bond" "gebonden" ; + backen_V = irregV "backen" "bäckt" "back" "backte" "backte" "gebacken" ; + befehlen_V = irregV "befehlen" "befiehlt" "befiehl" "befahl" "beföhle" "befohlen" ;-
-(You may want to use the English translation for some purpose, as well.) -
+When using ready-made word lists, you should think about coyright issues. Ideally, all resource grammar material should @@ -563,7 +577,7 @@ extension modules. This chapter will deal with this issue.
Above we have looked at how a resource implementation is built by
-the copy and paste method (from English to Dutch), that is, formally
+the copy and paste method (from English to German), that is, formally
speaking, from scratch. A more elegant solution available for
families of languages such as Romance and Scandinavian is to
use parametrized modules. The advantages are
diff --git a/lib/resource-1.0/doc/Resource-HOWTO.txt b/lib/resource-1.0/doc/Resource-HOWTO.txt
index 3910beabe..93af780da 100644
--- a/lib/resource-1.0/doc/Resource-HOWTO.txt
+++ b/lib/resource-1.0/doc/Resource-HOWTO.txt
@@ -5,7 +5,7 @@ Last update: %%date(%c)
% NOTE: this is a txt2tags file.
% Create an html file from this file using:
-% txt2tags Resource-HOWTO.txt
+% txt2tags --toc -thtml Resource-HOWTO.txt
%!target:html
@@ -175,88 +175,112 @@ different languages.
Unless you are writing an instance of a parametrized implementation
(Romance or Scandinavian), which will be covered later, the most
simple way is to follow roughly the following procedure. Assume you
-are building a grammar for the Dutch language. Here are the first steps.
+are building a grammar for the German language. Here are the first steps,
+which we actually followed ourselves when building the German implementation
+of resource v. 1.0.
+ Create a sister directory for ``GF/lib/resource/english``, named
- ``dutch``.
- ```
+ ``german``.
+```
cd GF/lib/resource/
- mkdir dutch
- cd dutch
- ```
+ mkdir german
+ cd german
+```
-+ Check out the [ISO 639 3-letter language code http://www.w3.org/WAI/ER/IG/ert/iso639.htm]
- for Dutch: it is ``Dut``.
++ Check out the [ISO 639 3-letter language code
+ http://www.w3.org/WAI/ER/IG/ert/iso639.htm]
+ for German: both ``Ger`` and ``Deu`` are given, and we pick ``Ger``.
-+ Copy the ``*Eng.gf`` files from ``english`` ``dutch``,
++ Copy the ``*Eng.gf`` files from ``english`` ``german``,
and rename them:
- ```
+```
cp ../english/*Eng.gf .
- rename 's/Eng/Dut/' *Eng.gf
- ```
+ rename 's/Eng/Ger/' *Eng.gf
+```
-+ Change the ``Eng`` module references to ``Dut`` references
++ Change the ``Eng`` module references to ``Ger`` references
in all files:
- ``` sed -i 's/Eng/Dut/g' *Dut.gf
+```
+ sed -i 's/English/German/g' *Ger.gf
+ sed -i 's/Eng/Ger/g' *Ger.gf
+```
+ The first line prevents changing the word ``English``, which appears
+ here and there in comments, to ``Gerlish``.
+ This may of course change unwanted occurrences of the
string ``Eng`` - verify this by
- ``` grep Dut *.gf
+```
+ grep Ger *.gf
+```
But you will have to make lots of manual changes in all files anyway!
+ Comment out the contents of these files:
- ``` sed -i 's/^/--/' *Dut.gf
+```
+ sed -i 's/^/--/' *Ger.gf
+```
This will give you a set of templates out of which the grammar
will grow as you uncomment and modify the files rule by rule.
-+ In the file ``TestDut.gf``, uncomment all lines except the list
- of inherited modules. Now you can open the grammar in GF:
- ``` gf TestDut.gf
++ In all ``.gf`` files, uncomment the module headers and brackets,
+ leaving the module bodies commented. Unfortunately, there is no
+ simple way to do this automatically (or to avoid commenting these
+ lines in the previous step) - but you uncommenting the first
+ and the last lines will actually do the job for many of the files.
-+ Now you will at all following steps have a valid, but incomplete
++ Now you can open the grammar ``TestGer`` in GF:
+```
+ gf TestGer.gf
+```
+ You will get lots of warnings on missing rules, but the grammar will compile.
+
++ At all following steps you will now have a valid, but incomplete
GF grammar. The GF command
- ``` pg -printer=missing
+```
+ pg -printer=missing
+```
tells you what exactly is missing.
+
===The develop-test cycle===
The real work starts now. The order in which the ``Phrase`` modules
were introduced above is a natural order to proceed, even though not the
only one. So you will find yourself iterating the following steps:
-+ Select a phrase category module, e.g. ``NounDut``, and uncomment one
- linearization rule (for instance, ``IndefSg``, which is
++ Select a phrase category module, e.g. ``NounGer``, and uncomment one
+ linearization rule (for instance, ``DefSg``, which is
not too complicated).
-+ Write down some Dutch examples of this rule, in this case translations
- of "a dog", "a house", "a big house", etc.
++ Write down some German examples of this rule, for instance translations
+ of "the dog", "the house", "the big house", etc. Write these in all their
+ different forms (two numbers and four cases).
+ Think about the categories involved (``CN, NP, N``) and the
- variations they have. Encode this in the lincats of ``CatDut``.
- You may have to define some new parameter types in ``ResDut``.
+ variations they have. Encode this in the lincats of ``CatGer``.
+ You may have to define some new parameter types in ``ResGer``.
+ To be able to test the construction,
define some words you need to instantiate it
- in ``LexDut``. Again, it can be helpful to define some simple-minded
- morphological paradigms in ``ResDut``, in particular worst-case
+ in ``LexGer``. Again, it can be helpful to define some simple-minded
+ morphological paradigms in ``ResGer``, in particular worst-case
constructors corresponding to e.g.
``ResEng.mkNoun``.
+ Doing this, you may want to test the resource independently. Do this by
- ```
- i -retain ResDut
- cc mkNoun "ei" "eieren" Neutr
- ```
+```
+ i -retain ResGer
+ cc mkNoun "Brief" "Briefe" Masc
+```
-+ Uncomment ``NounDut`` and ``LexDut`` in ``TestDut``,
- and compile ``TestDut`` in GF. Then test by parsing, linearization,
++ Uncomment ``NounGer`` and ``LexGer`` in ``TestGer``,
+ and compile ``TestGer`` in GF. Then test by parsing, linearization,
and random generation. In particular, linearization to a table should
be used so that you see all forms produced:
- ```
+```
gr -cat=NP -number=20 -tr | l -table
- ```
+```
+ Spare some tree-linearization pairs for later regression testing.
You can do this way (!!to be completed)
@@ -278,8 +302,8 @@ very soon, keep you motivated, and reveal errors.
These modules will be written by you.
-- ``ResDut``: parameter types and auxiliary operations
-- ``MorphoDut``: complete inflection engine; not needed for ``Test``.
+- ``ResGer``: parameter types and auxiliary operations
+- ``MorphoGer``: complete inflection engine; not needed for ``Test``.
These modules are language-independent and provided by the existing resource
@@ -300,12 +324,12 @@ package.
When the implementation of ``Test`` is complete, it is time to
work out the lexicon files. The underlying machinery is provided in
-``MorphoDut``, which is, in effect, your linguistic theory of
-Dutch morphology. It can contain very sophisticated and complicated
+``MorphoGer``, which is, in effect, your linguistic theory of
+German morphology. It can contain very sophisticated and complicated
definitions, which are not necessarily suitable for actually building a
lexicon. For this purpose, you should write the module
-- ``ParadigmsDut``: morphological paradigms for the lexicographer.
+- ``ParadigmsGer``: morphological paradigms for the lexicographer.
This module provides high-level ways to define the linearization of
@@ -320,15 +344,15 @@ the functions
- ``mkN``, for worst-case construction of ``N``. Its type signature
has the form
- ```
+```
mkN : Str -> ... -> Str -> P -> ... -> Q -> N
- ```
+```
with as many string and parameter arguments as can ever be needed to
construct an ``N``.
- ``regN``, for the most common cases, with just one string argument:
- ```
+```
regN : Str -> N
- ```
+```
- A language-dependent (small) set of functions to handle mild irregularities
and common exceptions.
@@ -336,15 +360,15 @@ For the complement-taking variants, such as ``V2``, we provide
- ``mkV2``, which takes a ``V`` and all necessary arguments, such
as case and preposition:
- ```
+```
mkV2 : V -> Case -> Str -> V2 ;
- ```
+```
- A language-dependent (small) set of functions to handle common special cases,
such as direct transitive verbs:
- ```
+```
dirV2 : V -> V2 ;
-- dirV2 v = mkV2 v accusative []
- ```
+```
The golden rule for the design of paradigms is that
@@ -356,31 +380,31 @@ The golden rule for the design of paradigms is that
The discipline of data abstraction moreover requires that the user of the resource
is not given access to parameter constructors, but only to constants that denote
them. This gives the resource grammarian the freedom to change the underlying
-data representation if needed. It means that the ``ParadigmsDut`` module has
+data representation if needed. It means that the ``ParadigmsGer`` module has
to define constants for those parameter types and constructors that
the application grammarian may need to use, e.g.
```
oper
Case : Type ;
- nominative, accusative, genitive : Case ;
+ nominative, accusative, genitive, dative : Case ;
```
These constants are defined in terms of parameter types and constructors
-in ``ResDut`` and ``MorphoDut``, which modules are are not
+in ``ResGer`` and ``MorphoGer``, which modules are are not
accessible to the application grammarian.
===Lock fields===
-An important difference between ``MorphoDut`` and
-``ParadigmsDut`` is that the former uses "raw" record types
+An important difference between ``MorphoGer`` and
+``ParadigmsGer`` is that the former uses "raw" record types
as lincats, whereas the latter used category symbols defined in
-``CatDut``. When these category symbols are used to denote
-record types in a resource modules, such as ``ParadigmsDut``,
+``CatGer``. When these category symbols are used to denote
+record types in a resource modules, such as ``ParadigmsGer``,
a **lock field** is added to the record, so that categories
with the same implementation are not confused with each other.
(This is inspired by the ``newtype`` discipline in Haskell.)
For instance, the lincats of adverbs and conjunctions may be the same
-in ``CatDut``:
+in ``CatGer``:
```
lincat Adv = {s : Str} ;
lincat Conj = {s : Str} ;
@@ -415,19 +439,19 @@ in her hidden definitions of constants in ``Paradigms``. For instance,
===Lexicon construction===
-The lexicon belonging to ``LangDut`` consists of two modules:
+The lexicon belonging to ``LangGer`` consists of two modules:
-- ``StructuralDut``, structural words, built by directly using
- ``MorphoDut``.
-- ``BasicDut``, content words, built by using ``ParadigmsDut``.
+- ``StructuralGer``, structural words, built by directly using
+ ``MorphoGer``.
+- ``BasicGer``, content words, built by using ``ParadigmsGer``.
-The reason why ``MorphoDut`` has to be used in ``StructuralDut``
-is that ``ParadigmsDut`` does not contain constructors for closed
+The reason why ``MorphoGer`` has to be used in ``StructuralGer``
+is that ``ParadigmsGer`` does not contain constructors for closed
word classes such as pronouns and determiners. The reason why we
-recommend ``ParadigmsDut`` for building ``BasicDut`` is that
+recommend ``ParadigmsGer`` for building ``BasicGer`` is that
the coverage of the paradigms gets thereby tested and that the
-use of the paradigms in ``BasicDut`` gives a good set of examples for
+use of the paradigms in ``BasicGer`` gives a good set of examples for
those who want to build new lexica.
@@ -459,29 +483,25 @@ worst-case paradigms (``mkV`` etc).
You can often find resources such as lists of
irregular verbs on the internet. For instance, the
-[Dutch for Travelers http://www.dutchtrav.com/gram/irrverbs.html]
+[Irregular German Verbs http://www.iee.et.tu-dresden.de/~wernerr/grammar/verben_dt.html]
page gives a list of verbs in the
traditional tabular format, which begins as follows:
```
- begrijpen begrijp begreep begrepen to understand
- bijten bijt beet gebeten to bite
- binden bind bond gebonden to tie
- breken breek brak gebroken to break
+ backen (du bäckst, er bäckt) backte [buk] gebacken
+ befehlen (du befiehlst, er befiehlt; befiehl!) befahl (beföhle; befähle) befohlen
+ beginnen begann (begönne; begänne) begonnen
+ beißen biß gebissen
```
All you have to do is to write a suitable verb paradigm
```
- irregV : Str -> Str -> Str -> Str -> V ;
+ irregV : (x1,_,_,_,_,x6 : Str) -> V ;
```
and a Perl or Python or Haskell script that transforms
the table to
```
- begrijpen_V = irregV "begrijpen" "begrijp" "begreep" "begrepen" ;
- bijten_V = irregV "bijten" "bijt" "beet" "gebeten" ;
- binden_V = irregV "binden" "bind" "bond" "gebonden" ;
+ backen_V = irregV "backen" "bäckt" "back" "backte" "backte" "gebacken" ;
+ befehlen_V = irregV "befehlen" "befiehlt" "befiehl" "befahl" "beföhle" "befohlen" ;
```
-(You may want to use the English translation for some purpose, as well.)
-
-
When using ready-made word lists, you should think about
coyright issues. Ideally, all resource grammar material should
@@ -510,7 +530,7 @@ extension modules. This chapter will deal with this issue.
==Writing an instance of parametrized resource grammar implementation==
Above we have looked at how a resource implementation is built by
-the copy and paste method (from English to Dutch), that is, formally
+the copy and paste method (from English to German), that is, formally
speaking, from scratch. A more elegant solution available for
families of languages such as Romance and Scandinavian is to
use parametrized modules. The advantages are
diff --git a/lib/resource-1.0/german/AdjectiveGer.gf b/lib/resource-1.0/german/AdjectiveGer.gf
new file mode 100644
index 000000000..6e4f60a32
--- /dev/null
+++ b/lib/resource-1.0/german/AdjectiveGer.gf
@@ -0,0 +1,42 @@
+concrete AdjectiveGer of Adjective = CatGer ** open ResGer, Prelude in {
+--
+-- lin
+--
+-- PositA a = {
+-- s = \\_ => a.s ! AAdj Posit ;
+-- isPre = True
+-- } ;
+-- ComparA a np = {
+-- s = \\_ => a.s ! AAdj Compar ++ "than" ++ np.s ! Nom ;
+-- isPre = False
+-- } ;
+--
+---- $SuperlA$ belongs to determiner syntax in $Noun$.
+--
+-- ComplA2 a np = {
+-- s = \\_ => a.s ! AAdj Posit ++ a.c2 ++ np.s ! Acc ;
+-- isPre = False
+-- } ;
+--
+-- ReflA2 a = {
+-- s = \\ag => a.s ! AAdj Posit ++ a.c2 ++ reflPron ! ag ;
+-- isPre = False
+-- } ;
+--
+-- SentAP ap s = {
+-- s = \\a => ap.s ! a ++ conjThat ++ s.s ;
+-- isPre = False
+-- } ;
+-- QuestAP ap qs = {
+-- s = \\a => ap.s ! a ++ qs.s ! QIndir ;
+-- isPre = False
+-- } ;
+--
+-- AdAP ada ap = {
+-- s = \\a => ada.s ++ ap.s ! a ;
+-- isPre = ap.isPre
+-- } ;
+--
+-- UseA2 a = a ;
+--
+}
diff --git a/lib/resource-1.0/german/AdverbGer.gf b/lib/resource-1.0/german/AdverbGer.gf
new file mode 100644
index 000000000..00d06bb4f
--- /dev/null
+++ b/lib/resource-1.0/german/AdverbGer.gf
@@ -0,0 +1,21 @@
+concrete AdverbGer of Adverb = CatGer ** open ResGer, Prelude in {
+--
+-- lin
+-- PositAdvAdj a = {s = a.s ! AAdv} ;
+-- ComparAdvAdj cadv a np = {
+-- s = cadv.s ++ a.s ! AAdv ++ "than" ++ np.s ! Nom
+-- } ;
+-- ComparAdvAdjS cadv a s = {
+-- s = cadv.s ++ a.s ! AAdv ++ "than" ++ s.s
+-- } ;
+--
+-- PrepNP prep np = {s = prep.s ++ np.s ! Acc} ;
+--
+-- AdAdv = cc2 ;
+--
+-- SubjS = cc2 ;
+-- AdvSC s = s ; --- this rule give stack overflow in ordinary parsing
+--
+-- AdnCAdv cadv = {s = cadv.s ++ "than"} ;
+--
+}
diff --git a/lib/resource-1.0/german/BasicGer.gf b/lib/resource-1.0/german/BasicGer.gf
new file mode 100644
index 000000000..e5966d1ac
--- /dev/null
+++ b/lib/resource-1.0/german/BasicGer.gf
@@ -0,0 +1,225 @@
+----# -path=.:prelude
+--
+--concrete BasicGer of Basic = CatGer ** open ParadigmsGer in {
+--
+--flags
+-- startcat=Phr ; lexer=textlit ; unlexer=text ;
+-- optimize=all ;
+--
+--lin
+-- airplane_N = regN "airplane" ;
+-- answer_V2S = mkV2S (regV "answer") "to" ;
+-- apartment_N = regN "apartment" ;
+-- apple_N = regN "apple" ;
+-- art_N = regN "art" ;
+-- ask_V2Q = mkV2Q (regV "ask") [] ;
+-- baby_N = regN "baby" ;
+-- bad_A = regADeg "bad" ;
+-- bank_N = regN "bank" ;
+-- beautiful_A = regADeg "beautiful" ;
+-- become_VA = mkVA (irregV "become" "became" "become") ;
+-- beer_N = regN "beer" ;
+-- beg_V2V = mkV2V (regDuplV "beg") [] "to" ;
+-- big_A = regADeg "big" ;
+-- bike_N = regN "bike" ;
+-- bird_N = regN "bird" ;
+-- black_A = regADeg "black" ;
+-- blue_A = regADeg "blue" ;
+-- boat_N = regN "boat" ;
+-- book_N = regN "book" ;
+-- boot_N = regN "boot" ;
+-- boss_N = regN "boss" ;
+-- boy_N = regN "boy" ;
+-- bread_N = regN "bread" ;
+-- break_V2 = dirV2 (irregV "break" "broke" "broken") ;
+-- broad_A = regADeg "broad" ;
+-- brother_N2 = regN2 "brother" ;
+-- brown_A = regADeg "brown" ;
+-- butter_N = regN "butter" ;
+-- buy_V2 = dirV2 (irregV "buy" "bought" "bought") ;
+-- camera_N = regN "camera" ;
+-- cap_N = regN "cap" ;
+-- car_N = regN "car" ;
+-- carpet_N = regN "carpet" ;
+-- cat_N = regN "cat" ;
+-- ceiling_N = regN "ceiling" ;
+-- chair_N = regN "chair" ;
+-- cheese_N = regN "cheese" ;
+-- child_N = mk2N "child" "children" ;
+-- church_N = regN "church" ;
+-- city_N = regN "city" ;
+-- clean_A = regADeg "clean" ;
+-- clever_A = regADeg "clever" ;
+-- close_V2 = dirV2 (regV "close") ;
+-- coat_N = regN "coat" ;
+-- cold_A = regADeg "cold" ;
+-- come_V = (irregV "come" "came" "come") ;
+-- computer_N = regN "computer" ;
+-- country_N = regN "country" ;
+-- cousin_N = regN "cousin" ;
+-- cow_N = regN "cow" ;
+-- die_V = (regV "die") ;
+-- dirty_A = regADeg "dirty" ;
+-- distance_N3 = mkN3 (regN "distance") "from" "to" ;
+-- doctor_N = regN "doctor" ;
+-- dog_N = regN "dog" ;
+-- door_N = regN "door" ;
+-- drink_V2 = dirV2 (irregV "drink" "drank" "drunk") ;
+-- easy_A2V = mkA2V (regA "easy") "for" ;
+-- eat_V2 = dirV2 (irregV "eat" "ate" "eaten") ;
+-- empty_A = regADeg "empty" ;
+-- enemy_N = regN "enemy" ;
+-- factory_N = regN "factory" ;
+-- father_N2 = regN2 "father" ;
+-- fear_VS = mkVS (regV "fear") ;
+-- find_V2 = dirV2 (irregV "find" "found" "found") ;
+-- fish_N = mk2N "fish" "fish" ;
+-- floor_N = regN "floor" ;
+-- forget_V2 = dirV2 (irregV "forget" "forgot" "forgotten") ;
+-- fridge_N = regN "fridge" ;
+-- friend_N = regN "friend" ;
+-- fruit_N = regN "fruit" ;
+-- fun_AV = mkAV (regA "fun") ;
+-- garden_N = regN "garden" ;
+-- girl_N = regN "girl" ;
+-- glove_N = regN "glove" ;
+-- gold_N = regN "gold" ;
+-- good_A = mkADeg "good" "well" "better" "best" ;
+-- go_V = (mkV "go" "goes" "went" "gone" "going") ;
+-- green_A = regADeg "green" ;
+-- harbour_N = regN "harbour" ;
+-- hate_V2 = dirV2 (regV "hate") ;
+-- hat_N = regN "hat" ;
+-- have_V2 = dirV2 (mkV "have" "has" "had" "had" "having") ;
+-- hear_V2 = dirV2 (irregV "hear" "heard" "heard") ;
+-- hill_N = regN "hill" ;
+-- hope_VS = mkVS (regV "hope") ;
+-- horse_N = regN "horse" ;
+-- hot_A = regADeg "hot" ;
+-- house_N = regN "house" ;
+-- important_A = compoundADeg (regA "important") ;
+-- industry_N = regN "industry" ;
+-- iron_N = regN "iron" ;
+-- king_N = regN "king" ;
+-- know_V2 = dirV2 (irregV "know" "knew" "known") ;
+-- lake_N = regN "lake" ;
+-- lamp_N = regN "lamp" ;
+-- learn_V2 = dirV2 (regV "learn") ;
+-- leather_N = regN "leather" ;
+-- leave_V2 = dirV2 (irregV "leave" "left" "left") ;
+-- like_V2 = dirV2 (regV "like") ;
+-- listen_V2 = dirV2 (regV "listen") ;
+-- live_V = (regV "live") ;
+-- long_A = regADeg "long" ;
+-- lose_V2 = dirV2 (irregV "lose" "lost" "lost") ;
+-- love_N = regN "love" ;
+-- love_V2 = dirV2 (regV "love") ;
+-- man_N = mk2N "man" "men" ;
+-- married_A2 = mkA2 (regA "married") "to" ;
+-- meat_N = regN "meat" ;
+-- milk_N = regN "milk" ;
+-- moon_N = regN "moon" ;
+-- mother_N2 = regN2 "mother" ;
+-- mountain_N = regN "mountain" ;
+-- music_N = regN "music" ;
+-- narrow_A = regADeg "narrow" ;
+-- new_A = regADeg "new" ;
+-- newspaper_N = regN "newspaper" ;
+-- oil_N = regN "oil" ;
+-- old_A = regADeg "old" ;
+-- open_V2 = dirV2 (regV "open") ;
+-- paint_V2A = mkV2A (regV "paint") [] ;
+-- paper_N = regN "paper" ;
+-- peace_N = regN "peace" ;
+-- pen_N = regN "pen" ;
+-- planet_N = regN "planet" ;
+-- plastic_N = regN "plastic" ;
+-- play_V2 = dirV2 (regV "play") ;
+-- policeman_N = regN "policeman" ;
+-- priest_N = regN "priest" ;
+-- probable_AS = mkAS (regA "probable") ;
+-- queen_N = regN "queen" ;
+-- radio_N = regN "radio" ;
+-- rain_V0 = mkV0 (regV "rain") ;
+-- read_V2 = dirV2 (irregV "read" "read" "read") ;
+-- red_A = regADeg "red" ;
+-- religion_N = regN "religion" ;
+-- restaurant_N = regN "restaurant" ;
+-- river_N = regN "river" ;
+-- rock_N = regN "rock" ;
+-- roof_N = regN "roof" ;
+-- rubber_N = regN "rubber" ;
+-- run_V = (irregDuplV "run" "ran" "run") ;
+-- say_VS = mkVS (irregV "say" "said" "said") ;
+-- school_N = regN "school" ;
+-- science_N = regN "science" ;
+-- sea_N = regN "sea" ;
+-- seek_V2 = dirV2 (irregV "seek" "sought" "sought") ;
+-- see_V2 = dirV2 (irregV "see" "saw" "seen") ;
+-- sell_V3 = dirV3 (irregV "sell" "sold" "sold") "to" ;
+-- send_V3 = dirV3 (irregV "send" "sent" "sent") "to" ;
+-- sheep_N = mk2N "sheep" "sheep" ;
+-- ship_N = regN "ship" ;
+-- shirt_N = regN "shirt" ;
+-- shoe_N = regN "shoe" ;
+-- shop_N = regN "shop" ;
+-- short_A = regADeg "short" ;
+-- silver_N = regN "silver" ;
+-- sister_N = regN "sister" ;
+-- sleep_V = (irregV "sleep" "slept" "slept") ;
+-- small_A = regADeg "small" ;
+-- snake_N = regN "snake" ;
+-- sock_N = regN "sock" ;
+-- speak_V2 = dirV2 (irregV "speak" "spoke" "spoken") ;
+-- star_N = regN "star" ;
+-- steel_N = regN "steel" ;
+-- stone_N = regN "stone" ;
+-- stove_N = regN "stove" ;
+-- student_N = regN "student" ;
+-- stupid_A = regADeg "stupid" ;
+-- sun_N = regN "sun" ;
+-- switch8off_V2 = dirV2 (partV (regV "switch") "off") ;
+-- switch8on_V2 = dirV2 (partV (regV "switch") "on") ;
+-- table_N = regN "table" ;
+-- talk_V3 = mkV3 (regV "talk") "to" "about" ;
+-- teacher_N = regN "teacher" ;
+-- teach_V2 = dirV2 (irregV "teach" "taught" "taught") ;
+-- television_N = regN "television" ;
+-- thick_A = regADeg "thick" ;
+-- thin_A = regADeg "thin" ;
+-- train_N = regN "train" ;
+-- travel_V = (regDuplV "travel") ;
+-- tree_N = regN "tree" ;
+-- ---- trousers_N = regN "trousers" ;
+-- ugly_A = regADeg "ugly" ;
+-- understand_V2 = dirV2 (irregV "understand" "understood" "understood") ;
+-- university_N = regN "university" ;
+-- village_N = regN "village" ;
+-- wait_V2 = mkV2 (regV "wait") "for" ;
+-- walk_V = (regV "walk") ;
+-- warm_A = regADeg "warm" ;
+-- war_N = regN "war" ;
+-- watch_V2 = dirV2 (regV "watch") ;
+-- water_N = regN "water" ;
+-- white_A = regADeg "white" ;
+-- window_N = regN "window" ;
+-- wine_N = regN "wine" ;
+-- win_V2 = dirV2 (irregV "win" "won" "won") ;
+-- woman_N = mk2N "woman" "women" ;
+-- wonder_VQ = mkVQ (regV "wonder") ;
+-- wood_N = regN "wood" ;
+-- write_V2 = dirV2 (irregV "write" "wrote" "written") ;
+-- yellow_A = regADeg "yellow" ;
+-- young_A = regADeg "young" ;
+--
+-- do_V2 = dirV2 (mkV "do" "does" "did" "done" "doing") ;
+-- now_Adv = mkAdv "now" ;
+-- already_Adv = mkAdv "already" ;
+-- song_N = regN "song" ;
+-- add_V3 = dirV3 (regV "add") "to" ;
+-- number_N = regN "number" ;
+-- put_V2 = mkV2 (irregDuplV "put" "put" "put") [] ;
+-- stop_V = regDuplV "stop" ;
+-- jump_V = regV "jump" ;
+--
+--} ;
diff --git a/lib/resource-1.0/german/CatGer.gf b/lib/resource-1.0/german/CatGer.gf
new file mode 100644
index 000000000..01fb351e7
--- /dev/null
+++ b/lib/resource-1.0/german/CatGer.gf
@@ -0,0 +1,61 @@
+concrete CatGer of Cat = open ResGer, Prelude, (R = ParamX) in {
+
+ lincat
+-- Text, Phr, Utt = {s : Str} ;
+--
+-- Imp = {s : Polarity => Number => Str} ;
+--
+-- S = {s : Str} ;
+-- QS = {s : QForm => Str} ;
+-- RS = {s : Agr => Str} ;
+--
+-- Cl = {s : Tense => Anteriority => Polarity => Order => Str} ;
+-- Slash = {s : Tense => Anteriority => Polarity => Order => Str} ** {c2 : Str} ;
+--
+-- QCl = {s : Tense => Anteriority => Polarity => QForm => Str} ;
+-- RCl = {s : Tense => Anteriority => Polarity => Agr => Str} ;
+--
+-- VP = {
+-- s : Tense => Anteriority => Polarity => Order => Agr => {fin, inf : Str} ;
+-- s2 : Agr => Str
+-- } ;
+--
+-- V, VS, VQ, VA = Verb ; -- = {s : VForm => Str} ;
+-- V2, VV, V2A = Verb ** {c2 : Str} ;
+-- V3 = Verb ** {c2, c3 : Str} ;
+--
+-- AP = {s : Agr => Str ; isPre : Bool} ;
+-- Comp = {s : Agr => Str} ;
+--
+-- SC = {s : Str} ;
+--
+-- A = {s : AForm => Str} ;
+-- A2 = {s : AForm => Str ; c2 : Str} ;
+--
+-- Adv, AdV, AdA, AdS, AdN = {s : Str} ;
+-- Prep = {s : Str} ;
+--
+-- Det, Quant = {s : Str ; n : Number} ;
+-- Predet, Num, Ord = {s : Str} ;
+--
+ CN = {s : Adjf => Number => Case => Str ; g : Gender} ;
+ N = {s : Number => Case => Str ; g : Gender} ;
+-- PN = {s : Case => Str} ;
+-- Pron, NP = {s : Case => Str ; a : Agr} ;
+-- N2 = {s : Number => Case => Str} ** {c2 : Str} ;
+-- N3 = {s : Number => Case => Str} ** {c2,c3 : Str} ;
+--
+-- IP = {s : Case => Str ; n : Number} ;
+-- IDet = {s : Str ; n : Number} ;
+-- IAdv = {s : Str} ;
+--
+-- RP = {s : Case => Str ; a : RAgr} ;
+--
+-- Numeral = {s : CardOrd => Str ; n : Number} ;
+--
+-- CAdv = {s : Str} ;
+--
+-- Conj = {s : Str ; n : Number} ;
+-- DConj = {s1,s2 : Str ; n : Number} ;
+--
+}
diff --git a/lib/resource-1.0/german/ConjunctionGer.gf b/lib/resource-1.0/german/ConjunctionGer.gf
new file mode 100644
index 000000000..37a978ea4
--- /dev/null
+++ b/lib/resource-1.0/german/ConjunctionGer.gf
@@ -0,0 +1,45 @@
+concrete ConjunctionGer of Conjunction =
+ CatGer ** open ResGer, Coordination, Prelude in {
+--
+-- flags optimize=all_subs ;
+--
+-- lin
+--
+-- ConjS = conjunctSS ;
+-- DConjS = conjunctDistrSS ;
+--
+-- ConjAdv = conjunctSS ;
+-- DConjAdv = conjunctDistrSS ;
+--
+-- ConjNP conj ss = conjunctTable Case conj ss ** {
+-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+-- } ;
+-- DConjNP conj ss = conjunctDistrTable Case conj ss ** {
+-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+-- } ;
+--
+-- ConjAP conj ss = conjunctTable Agr conj ss ** {
+-- isPre = ss.isPre
+-- } ;
+-- DConjAP conj ss = conjunctDistrTable Agr conj ss ** {
+-- isPre = ss.isPre
+-- } ;
+--
+---- These fun's are generated from the list cat's.
+--
+-- BaseS = twoSS ;
+-- ConsS = consrSS comma ;
+-- BaseAdv = twoSS ;
+-- ConsAdv = consrSS comma ;
+-- BaseNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ;
+-- ConsNP xs x = consrTable Case comma xs x ** {a = conjAgr xs.a x.a} ;
+-- BaseAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ;
+-- ConsAP xs x = consrTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ;
+--
+-- lincat
+-- [S] = {s1,s2 : Str} ;
+-- [Adv] = {s1,s2 : Str} ;
+-- [NP] = {s1,s2 : Case => Str ; a : Agr} ;
+-- [AP] = {s1,s2 : Agr => Str ; isPre : Bool} ;
+--
+}
diff --git a/lib/resource-1.0/german/ExtGer.gf b/lib/resource-1.0/german/ExtGer.gf
new file mode 100644
index 000000000..b87b483e6
--- /dev/null
+++ b/lib/resource-1.0/german/ExtGer.gf
@@ -0,0 +1,26 @@
+--concrete ExtGer of ExtGerAbs = CatGer ** open ResGer in {
+--
+-- lincat
+--
+-- Aux = {s : Polarity => Str} ;
+--
+-- lin
+--
+-- PredAux np aux vp = mkClause (np.s ! Nom) np.a {
+-- s = \\t,ant,b,ord,agr =>
+-- let
+-- fin = aux.s ! b ;
+-- vf : Str -> Str -> {fin, inf : Str} = \x,y ->
+-- {fin = x ; inf = y} ;
+-- in
+-- case ant of {
+-- Simul => vf fin [] ;
+-- Anter => vf fin "have"
+-- } ;
+-- s2 = \\agr => infVP vp agr
+-- } ;
+--
+-- can_Aux = {s = \\p => posneg p "can"} ; ---- cannt
+-- must_Aux = {s = \\p => posneg p "must"} ;
+--
+--}
diff --git a/lib/resource-1.0/german/IrregGer.gf b/lib/resource-1.0/german/IrregGer.gf
new file mode 100644
index 000000000..93bcb927f
--- /dev/null
+++ b/lib/resource-1.0/german/IrregGer.gf
@@ -0,0 +1,181 @@
+----# -path=.:prelude:../abstract:../common
+--
+--concrete IrregGer of IrregGerAbs = CatGer ** open ParadigmsGer in {
+--
+--flags optimize=values ;
+--
+-- lin
+-- awake_V = irregV "awake" "awoke" "awoken" ;
+-- bear_V = irregV "bear" "bore" "born" ;
+-- beat_V = irregV "beat" "beat" "beat" ;
+-- become_V = irregV "become" "became" "become" ;
+-- begin_V = irregV "begin" "began" "begun" ;
+-- bend_V = irregV "bend" "bent" "bent" ;
+-- beset_V = irregV "beset" "beset" "beset" ;
+-- bet_V = irregDuplV "bet" "bet" "bet" ;
+-- bid_V = irregDuplV "bid" (variants {"bid" ; "bade"}) (variants {"bid" ; "bidden"}) ;
+-- bind_V = irregV "bind" "bound" "bound" ;
+-- bite_V = irregV "bite" "bit" "bitten" ;
+-- bleed_V = irregV "bleed" "bled" "bled" ;
+-- blow_V = irregV "blow" "blew" "blown" ;
+-- break_V = irregV "break" "broke" "broken" ;
+-- breed_V = irregV "breed" "bred" "bred" ;
+-- bring_V = irregV "bring" "brought" "brought" ;
+-- broadcast_V = irregV "broadcast" "broadcast" "broadcast" ;
+-- build_V = irregV "build" "built" "built" ;
+-- burn_V = irregV "burn" (variants {"burned" ; "burnt"}) (variants {"burned" ; "burnt"}) ;
+-- burst_V = irregV "burst" "burst" "burst" ;
+-- buy_V = irregV "buy" "bought" "bought" ;
+-- cast_V = irregV "cast" "cast" "cast" ;
+-- catch_V = irregV "catch" "caught" "caught" ;
+-- choose_V = irregV "choose" "chose" "chosen" ;
+-- cling_V = irregV "cling" "clung" "clung" ;
+-- come_V = irregV "come" "came" "come" ;
+-- cost_V = irregV "cost" "cost" "cost" ;
+-- creep_V = irregV "creep" "crept" "crept" ;
+-- cut_V = irregDuplV "cut" "cut" "cut" ;
+-- deal_V = irregV "deal" "dealt" "dealt" ;
+-- dig_V = irregDuplV "dig" "dug" "dug" ;
+-- dive_V = irregV "dive" (variants {"dived" ; "dove"}) "dived" ;
+-- do_V = mkV "do" "does" "did" "done" "doing" ;
+-- draw_V = irregV "draw" "drew" "drawn" ;
+-- dream_V = irregV "dream" (variants {"dreamed" ; "dreamt"}) (variants {"dreamed" ; "dreamt"}) ;
+-- drive_V = irregV "drive" "drove" "driven" ;
+-- drink_V = irregV "drink" "drank" "drunk" ;
+-- eat_V = irregV "eat" "ate" "eaten" ;
+-- fall_V = irregV "fall" "fell" "fallen" ;
+-- feed_V = irregV "feed" "fed" "fed" ;
+-- feel_V = irregV "feel" "felt" "felt" ;
+-- fight_V = irregV "fight" "fought" "fought" ;
+-- find_V = irregV "find" "found" "found" ;
+-- fit_V = irregDuplV "fit" "fit" "fit" ;
+-- flee_V = irregV "flee" "fled" "fled" ;
+-- fling_V = irregV "fling" "flung" "flung" ;
+-- fly_V = irregV "fly" "flew" "flown" ;
+-- forbid_V = irregDuplV "forbid" "forbade" "forbidden" ;
+-- forget_V = irregDuplV "forget" "forgot" "forgotten" ;
+-- forgive_V = irregV "forgive" "forgave" "forgiven" ;
+-- forsake_V = irregV "forsake" "forsook" "forsaken" ;
+-- freeze_V = irregV "freeze" "froze" "frozen" ;
+-- get_V = irregDuplV "get" "got" "gotten" ;
+-- give_V = irregV "give" "gave" "given" ;
+-- go_V = irregV "go" "went" "gone" ;
+-- grind_V = irregV "grind" "ground" "ground" ;
+-- grow_V = irregV "grow" "grew" "grown" ;
+-- hang_V = irregV "hang" "hung" "hung" ;
+-- have_V = mkV "have" "has" "had" "had" "having" ;
+-- hear_V = irregV "hear" "heard" "heard" ;
+-- hide_V = irregV "hide" "hid" "hidden" ;
+-- hit_V = irregDuplV "hit" "hit" "hit" ;
+-- hold_V = irregV "hold" "held" "held" ;
+-- hurt_V = irregV "hurt" "hurt" "hurt" ;
+-- keep_V = irregV "keep" "kept" "kept" ;
+-- kneel_V = irregV "kneel" "knelt" "knelt" ;
+-- knit_V = irregDuplV "knit" "knit" "knit" ;
+-- know_V = irregV "know" "knew" "know" ;
+-- lay_V = irregV "lay" "laid" "laid" ;
+-- lead_V = irregV "lead" "led" "led" ;
+-- leap_V = irregV "leap" (variants {"leaped" ; "lept"}) (variants {"leaped" ; "lept"}) ;
+-- learn_V = irregV "learn" (variants {"learned" ; "learnt"}) (variants {"learned" ; "learnt"}) ;
+-- leave_V = irregV "leave" "left" "left" ;
+-- lend_V = irregV "lend" "lent" "lent" ;
+-- let_V = irregDuplV "let" "let" "let" ;
+-- lie_V = irregV "lie" "lay" "lain" ;
+-- light_V = irregV "light" (variants {"lighted" ; "lit"}) "lighted" ;
+-- lose_V = irregV "lose" "lost" "lost" ;
+-- make_V = irregV "make" "made" "made" ;
+-- mean_V = irregV "mean" "meant" "meant" ;
+-- meet_V = irregV "meet" "met" "met" ;
+-- misspell_V = irregV "misspell" (variants {"misspelled" ; "misspelt"}) (variants {"misspelled" ; "misspelt"}) ;
+-- mistake_V = irregV "mistake" "mistook" "mistaken" ;
+-- mow_V = irregV "mow" "mowed" (variants {"mowed" ; "mown"}) ;
+-- overcome_V = irregV "overcome" "overcame" "overcome" ;
+-- overdo_V = mkV "overdo" "overdoes" "overdid" "overdone" "overdoing" ;
+-- overtake_V = irregV "overtake" "overtook" "overtaken" ;
+-- overthrow_V = irregV "overthrow" "overthrew" "overthrown" ;
+-- pay_V = irregV "pay" "paid" "paid" ;
+-- plead_V = irregV "plead" "pled" "pled" ;
+-- prove_V = irregV "prove" "proved" (variants {"proved" ; "proven"}) ;
+-- put_V = irregDuplV "put" "put" "put" ;
+-- quit_V = irregDuplV "quit" "quit" "quit" ;
+-- read_V = irregV "read" "read" "read" ;
+-- rid_V = irregDuplV "rid" "rid" "rid" ;
+-- ride_V = irregV "ride" "rode" "ridden" ;
+-- ring_V = irregV "ring" "rang" "rung" ;
+-- rise_V = irregV "rise" "rose" "risen" ;
+-- run_V = irregDuplV "run" "ran" "run" ;
+-- saw_V = irregV "saw" "sawed" (variants {"sawed" ; "sawn"}) ;
+-- say_V = irregV "say" "said" "said" ;
+-- see_V = irregV "see" "saw" "seen" ;
+-- seek_V = irregV "seek" "sought" "sought" ;
+-- sell_V = irregV "sell" "sold" "sold" ;
+-- send_V = irregV "send" "sent" "sent" ;
+-- set_V = irregDuplV "set" "set" "set" ;
+-- sew_V = irregV "sew" "sewed" (variants {"sewed" ; "sewn"}) ;
+-- shake_V = irregV "shake" "shook" "shaken" ;
+-- shave_V = irregV "shave" "shaved" (variants {"shaved" ; "shaven"}) ;
+-- shear_V = irregV "shear" "shore" "shorn" ;
+-- shed_V = irregDuplV "shed" "shed" "shed" ;
+-- shine_V = irregV "shine" "shone" "shone" ;
+-- shoe_V = irregV "shoe" "shoed" (variants {"shoed" ; "shod"}) ;
+-- shoot_V = irregV "shoot" "shot" "shot" ;
+-- show_V = irregV "show" "showed" (variants {"showed" ; "shown"}) ;
+-- shrink_V = irregV "shrink" "shrank" "shrunk" ;
+-- shut_V = irregDuplV "shut" "shut" "shut" ;
+-- sing_V = irregV "sing" "sang" "sung" ;
+-- sink_V = irregV "sink" "sank" "sunk" ;
+-- sit_V = irregDuplV "sit" "sat" "sat" ;
+-- sleep_V = irregV "sleep" "slept" "slept" ;
+-- slay_V = irregV "slay" "slew" "slain" ;
+-- slide_V = irregV "slide" "slid" "slid" ;
+-- sling_V = irregV "sling" "slung" "slung" ;
+-- slit_V = irregDuplV "slit" "slit" "slit" ;
+-- smite_V = irregV "smite" "smote" "smitten" ;
+-- sow_V = irregV "sow" "sowed" (variants {"sowed" ; "sown"}) ;
+-- speak_V = irregV "speak" "spoke" "spoken" ;
+-- speed_V = irregV "speed" "sped" "sped" ;
+-- spend_V = irregV "spend" "spent" "spent" ;
+-- spill_V = irregV "spill" (variants {"spilled" ; "spilt"}) (variants {"spilled" ; "spilt"}) ;
+-- spin_V = irregDuplV "spin" "spun" "spun" ;
+-- spit_V = irregDuplV "spit" (variants {"spit" ; "spat"}) "spit" ;
+-- split_V = irregDuplV "split" "split" "split" ;
+-- spread_V = irregV "spread" "spread" "spread" ;
+-- spring_V = irregV "spring" (variants {"sprang" ; "sprung"}) "sprung" ;
+-- stand_V = irregV "stand" "stood" "stood" ;
+-- steal_V = irregV "steal" "stole" "stolen" ;
+-- stick_V = irregV "stick" "stuck" "stuck" ;
+-- sting_V = irregV "sting" "stung" "stung" ;
+-- stink_V = irregV "stink" "stank" "stunk" ;
+-- stride_V = irregV "stride" "strod" "stridden" ;
+-- strike_V = irregV "strike" "struck" "struck" ;
+-- string_V = irregV "string" "strung" "strung" ;
+-- strive_V = irregV "strive" "strove" "striven" ;
+-- swear_V = irregV "swear" "swore" "sworn" ;
+-- sweep_V = irregV "sweep" "swept" "swept" ;
+-- swell_V = irregV "swell" "swelled" (variants {"swelled" ; "swollen"}) ;
+-- swim_V = irregDuplV "swim" "swam" "swum" ;
+-- swing_V = irregV "swing" "swung" "swung" ;
+-- take_V = irregV "take" "took" "taken" ;
+-- teach_V = irregV "teach" "taught" "taught" ;
+-- tear_V = irregV "tear" "tore" "torn" ;
+-- tell_V = irregV "tell" "told" "told" ;
+-- think_V = irregV "think" "thought" "thought" ;
+-- thrive_V = irregV "thrive" (variants {"thrived" ; "throve"}) "thrived" ;
+-- throw_V = irregV "throw" "threw" "thrown" ;
+-- thrust_V = irregV "thrust" "thrust" "thrust" ;
+-- tread_V = irregV "tread" "trod" "trodden" ;
+-- understand_V = irregV "understand" "understood" "understood" ;
+-- uphold_V = irregV "uphold" "upheld" "upheld" ;
+-- upset_V = irregDuplV "upset" "upset" "upset" ;
+-- wake_V = irregV "wake" "woke" "woken" ;
+-- wear_V = irregV "wear" "wore" "worn" ;
+-- weave_V = irregV "weave" (variants {"weaved" ; "wove"}) (variants {"weaved" ; "woven"}) ;
+-- wed_V = irregDuplV "wed" "wed" "wed" ;
+-- weep_V = irregV "weep" "wept" "wept" ;
+-- wind_V = irregV "wind" "wound" "wound" ;
+-- win_V = irregDuplV "win" "won" "won" ;
+-- withhold_V = irregV "withhold" "withheld" "withheld" ;
+-- withstand_V = irregV "withstand" "withstood" "withstood" ;
+-- wring_V = irregV "wring" "wrung" "wrung" ;
+-- write_V = irregV "write" "wrote" "written" ;
+--}
diff --git a/lib/resource-1.0/german/LangGer.gf b/lib/resource-1.0/german/LangGer.gf
new file mode 100644
index 000000000..2519d9f72
--- /dev/null
+++ b/lib/resource-1.0/german/LangGer.gf
@@ -0,0 +1,21 @@
+----# -path=.:../abstract:../common:prelude
+--
+--concrete LangGer of Lang =
+-- NounGer,
+-- VerbGer,
+-- AdjectiveGer,
+-- AdverbGer,
+-- NumeralGer,
+-- SentenceGer,
+-- QuestionGer,
+-- RelativeGer,
+-- ConjunctionGer,
+-- PhraseGer,
+-- TensedGer,
+-- StructuralGer,
+-- BasicGer
+-- ** {
+--
+--flags startcat = Phr ;
+--
+--} ;
diff --git a/lib/resource-1.0/german/LexGer.gf b/lib/resource-1.0/german/LexGer.gf
new file mode 100644
index 000000000..c4841ddf1
--- /dev/null
+++ b/lib/resource-1.0/german/LexGer.gf
@@ -0,0 +1,60 @@
+concrete LexGer of Lex = CatGer ** open ResGer, Prelude in {
+--
+-- lin
+-- walk_V = regV "walk" ;
+-- help_V2 = regV "help" ** {c2 = []} ;
+-- show_V3 = regV "show" ** {c2 = [] ; c3 = "to"} ;
+-- want_VV = regV "want" ** {c2 = "to"} ;
+-- claim_VS = regV "claim" ;
+-- ask_VQ = regV "ask" ;
+--
+-- dog_N = regN "dog" ;
+-- son_N2 = regN "son" ** {c2 = "of"} ;
+-- way_N3 = regN "way" ** {c2 = "from" ; c3 = "to"} ;
+--
+-- warm_A = regA "warm" ;
+-- close_A2 = regA "close" ** {c2 = "to"} ;
+--
+-- here_Adv = {s = "here"} ;
+-- very_AdA = {s = "very"} ;
+-- always_AdV = {s = "always"} ;
+--
+-- only_Predet = {s = "only"} ;
+-- all_Predet = {s = "only"} ;
+-- this_Quant = {s = "this" ; n = Sg} ;
+-- these_Quant = {s = "these" ; n = Pl} ;
+--
+-- i_Pron = mkNP "I" "me" "my" Sg P1 ;
+-- he_Pron = mkNP "he" "him" "his" Sg P3 ;
+-- we_Pron = mkNP "we" "us" "our" Pl P1 ;
+--
+-- whoSg_IP = mkIP "who" "whom" "whose" Sg ;
+-- whoPl_IP = mkIP "who" "whom" "whose" Pl ;
+--
+-- when_IAdv = {s = "when"} ;
+-- where_IAdv = {s = "where"} ;
+-- why_IAdv = {s = "why"} ;
+--
+-- whichSg_IDet = {s = "which" ; n = Sg} ;
+-- whichPl_IDet = {s = "which" ; n = Pl} ;
+--
+-- one_Numeral = {s = table {NCard => "one" ; NOrd => "first"} ; n = Sg} ;
+-- forty_Numeral = {s = table {NCard => "forty" ; NOrd => "fortieth"} ; n = Pl} ;
+--
+-- in_Prep = {s = "in"} ;
+-- of_Prep = {s = "of"} ;
+--
+-- and_Conj = {s = "and" ; n = Pl} ;
+-- either7or_DConj = {s1 = "either" ; s2 = "or" ; n = Sg} ;
+--
+-- if_Subj = ss "if" ;
+-- because_Subj = ss "because" ;
+--
+-- but_PConj = {s = "but"} ;
+--
+-- please_Voc = {s = "," ++ "please"} ;
+--
+-- more_CAdv = ss "more" ;
+-- less_CAdv = ss "less" ;
+--
+}
diff --git a/lib/resource-1.0/german/ListConjunctionGer.gf b/lib/resource-1.0/german/ListConjunctionGer.gf
new file mode 100644
index 000000000..88cd8817e
--- /dev/null
+++ b/lib/resource-1.0/german/ListConjunctionGer.gf
@@ -0,0 +1,43 @@
+--concrete ListConjunctionGer of Conjunction =
+-- CatGer ** open ResGer, Coordination, Prelude in {
+--
+-- lin
+--
+-- ConjS conj ss = {s = conjunctX conj ss} ;
+-- DConjS conj ss = {s = conjunctDistrX conj ss} ;
+--
+-- ConjAdv conj ss = {s = conjunctX conj ss} ;
+-- DConjAdv conj ss = {s = conjunctDistrX conj ss} ;
+--
+-- ConjNP conj ss = conjunctTable Case conj ss ** {
+-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+-- } ;
+-- DConjNP conj ss = conjunctDistrTable Case conj ss ** {
+-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p}
+-- } ;
+--
+-- ConjAP conj ss = conjunctTable Agr conj ss ** {
+-- isPre = ss.isPre
+-- } ;
+-- DConjAP conj ss = conjunctDistrTable Agr conj ss ** {
+-- isPre = ss.isPre
+-- } ;
+--
+---- These fun's are generated from the list cat's.
+--
+-- BaseS = twoSS ;
+-- ConsS = consrSS comma ;
+-- BaseAdv = twoSS ;
+-- ConsAdv = consrSS comma ;
+-- BaseNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ;
+-- ConsNP xs x = consrTable Case comma xs x ** {a = conjAgr xs.a x.a} ;
+-- BaseAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ;
+-- ConsAP xs x = consrTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ;
+--
+-- lincat
+-- [S] = {s1,s2 : Str} ;
+-- [Adv] = {s1,s2 : Str} ;
+-- [NP] = {s1,s2 : Case => Str ; a : Agr} ;
+-- [AP] = {s1,s2 : Agr => Str ; isPre : Bool} ;
+--
+--}
diff --git a/lib/resource-1.0/german/MathGer.gf b/lib/resource-1.0/german/MathGer.gf
new file mode 100644
index 000000000..ad190a54f
--- /dev/null
+++ b/lib/resource-1.0/german/MathGer.gf
@@ -0,0 +1,26 @@
+--concrete MathGer of Math = CatGer ** open Prelude, ResGer in {
+--
+--lin
+-- SymbPN i = {s = \\c => i.s ; a = agrP3 Sg} ; --- c
+-- IntPN i = {s = \\c => i.s ; a = agrP3 Sg} ; --- c
+-- CNIntNP cn i = {
+-- s = \\c => (cn.s ! Sg ! Nom ++ i.s) ;
+-- a = agrP3 Sg
+-- } ;
+-- CNSymbNP det cn xs = {
+-- s = \\c => det.s ++ cn.s ! det.n ! c ++ xs.s ;
+-- a = agrP3 det.n
+-- } ;
+--
+--lincat
+--
+-- Symb, SymbList = SS ;
+--
+--lin
+--
+-- MkSymb s = s ;
+--
+-- BaseSymb = infixSS "and" ;
+-- ConsSymb = infixSS "," ;
+--
+--}
diff --git a/lib/resource-1.0/german/MorphoGer.gf b/lib/resource-1.0/german/MorphoGer.gf
new file mode 100644
index 000000000..00290e6cc
--- /dev/null
+++ b/lib/resource-1.0/german/MorphoGer.gf
@@ -0,0 +1,198 @@
+----# -path=.:../../prelude
+--
+----1 A Simple German Resource Morphology
+----
+---- Aarne Ranta 2002 -- 2005
+----
+---- This resource morphology contains definitions needed in the resource
+---- syntax. To build a lexicon, it is better to use $ParadigmsGer$, which
+---- gives a higher-level access to this module.
+--
+--resource MorphoGer = ResGer ** open Prelude, (Predef=Predef) in {
+--
+-- flags optimize=all ;
+--
+----2 Phonology
+----
+---- To regulate the use of endings for both nouns, adjectives, and verbs:
+--
+--oper
+-- y2ie : Str -> Str -> Str = \fly,s ->
+-- let y = last (init fly) in
+-- case y of {
+-- "a" => fly + s ;
+-- "e" => fly + s ;
+-- "o" => fly + s ;
+-- "u" => fly + s ;
+-- _ => init fly + "ie" + s
+-- } ;
+--
+--
+----2 Nouns
+----
+---- For conciseness and abstraction, we define a worst-case macro for
+---- noun inflection. It is used for defining special case that
+---- only need one string as argument.
+--
+--oper
+-- CommonNoun : Type = {s : Number => Case => Str} ;
+--
+-- nounGen : Str -> CommonNoun = \dog -> case last dog of {
+-- "y" => nounY "dog" ;
+-- "s" => nounS (init "dog") ;
+-- _ => nounReg "dog"
+-- } ;
+--
+---- These are auxiliaries to $nounGen$.
+--
+-- nounReg : Str -> CommonNoun = \dog ->
+-- mkNoun dog (dog + "s") (dog + "'s") (dog + "s'");
+-- nounS : Str -> CommonNoun = \kiss ->
+-- mkNoun kiss (kiss + "es") (kiss + "'s") (kiss + "es'") ;
+-- nounY : Str -> CommonNoun = \fl ->
+-- mkNoun (fl + "y") (fl + "ies") (fl + "y's") (fl + "ies'") ;
+--
+--
+----3 Proper names
+----
+---- Regular proper names are inflected with "'s" in the genitive.
+--
+-- nameReg : Str -> Gender -> {s : Case => Str} = \john,g ->
+-- {s = table {Gen => john + "'s" ; _ => john} ; g = g} ;
+--
+----2 Determiners
+--
+-- mkDeterminer : Number -> Str -> {s : Str ; n : Number} = \n,s ->
+-- {s = s ; n = n} ;
+--
+----2 Pronouns
+----
+---- Here we define personal pronouns.
+----
+---- We record the form "mine" and the gender for later use.
+--
+-- Pronoun : Type =
+-- {s : Case => Str ; a : Agr ; g : Gender} ;
+--
+-- mkPronoun : (_,_,_,_ : Str) -> Number -> Person -> Gender -> Pronoun =
+-- \I,me,my,mine,n,p,g ->
+-- {s = table {Nom => I ; Acc => me ; Gen => my} ;
+-- a = {n = n ; p = p} ;
+-- g = g
+-- } ;
+--
+-- human : Gender = Masc ; --- doesn't matter
+--
+-- pronI = mkPronoun "I" "me" "my" "mine" Sg P1 human ;
+-- pronYouSg = mkPronoun "you" "you" "your" "yours" Sg P2 human ; -- verb agr OK
+-- pronHe = mkPronoun "he" "him" "his" "his" Sg P3 Masc ;
+-- pronShe = mkPronoun "she" "her" "her" "hers" Sg P3 Fem ;
+-- pronIt = mkPronoun "it" "it" "its" "it" Sg P3 Neutr ;
+--
+-- pronWe = mkPronoun "we" "us" "our" "ours" Pl P1 human ;
+-- pronYouPl = mkPronoun "you" "you" "your" "yours" Pl P2 human ;
+-- pronThey = mkPronoun "they" "them" "their" "theirs" Pl P3 human ; ---
+--
+--
+----2 Adjectives
+----
+---- To form the adjectival and the adverbial forms, two strings are needed
+---- in the worst case. (First without degrees.)
+--
+-- Adjective = {s : AForm => Str} ;
+--
+---- However, most adjectives can be inflected using the final character.
+---- N.B. this is not correct for "shy", but $mkAdjective$ has to be used.
+--
+-- regAdjective : Str -> Adjective = \free ->
+-- let
+-- e = last free ;
+-- fre = init free ;
+-- freely = case e of {
+-- "y" => fre + "ily" ;
+-- _ => free + "ly"
+-- } ;
+-- fre = case e of {
+-- "e" => fre ;
+-- "y" => fre + "i" ;
+-- _ => free
+-- }
+-- in
+-- mkAdjective free (fre + "er") (fre + "est") freely ;
+--
+---- Many adjectives are 'inflected' by adding a comparison word.
+--
+-- adjDegrLong : Str -> Adjective = \ridiculous ->
+-- mkAdjective
+-- ridiculous
+-- ("more" ++ ridiculous)
+-- ("most" ++ ridiculous)
+-- ((regAdjective ridiculous).s ! AAdv) ;
+--
+--
+----3 Verbs
+----
+---- The worst case needs five forms. (The verb "be" is treated separately.)
+--
+-- mkVerb4 : (_,_,_,_: Str) -> Verb = \go,goes,went,gone ->
+-- let going = case last go of {
+-- "e" => init go + "ing" ;
+-- _ => go + "ing"
+-- }
+-- in
+-- mkVerb go goes went gone going ;
+--
+---- This is what we use to derive the irregular forms in almost all cases
+--
+-- mkVerbIrreg : (_,_,_ : Str) -> Verb = \bite,bit,bitten ->
+-- let bites = case last bite of {
+-- "y" => y2ie bite "s" ;
+-- "s" => init bite + "es" ;
+-- _ => bite + "s"
+-- }
+-- in mkVerb4 bite bites bit bitten ;
+--
+---- This is used to derive regular forms.
+--
+-- mkVerbReg : Str -> Verb = \soak ->
+-- let
+-- soaks = case last soak of {
+-- "y" => y2ie soak "s" ;
+-- "s" => init soak + "es" ;
+-- _ => soak + "s"
+-- } ;
+-- soaked = case last soak of {
+-- "e" => init soak + "s" ;
+-- _ => soak + "ed"
+-- }
+-- in
+-- mkVerb4 soak soaks soaked soaked ;
+--
+-- verbGen : Str -> Verb = \kill -> case last kill of {
+-- "y" => verbP3y (init kill) ;
+-- "e" => verbP3e (init kill) ;
+-- "s" => verbP3s (init kill) ;
+-- _ => regVerbP3 kill
+-- } ;
+--
+---- These are just auxiliary to $verbGen$.
+--
+-- regVerbP3 : Str -> Verb = \walk ->
+-- mkVerbIrreg walk (walk + "ed") (walk + "ed") ;
+-- verbP3s : Str -> Verb = \kiss ->
+-- mkVerb4 kiss (kiss + "es") (kiss + "ed") (kiss + "ed") ;
+-- verbP3e : Str -> Verb = \love ->
+-- mkVerb4 love (love + "s") (love + "d") (love + "d") ;
+-- verbP3y : Str -> Verb = \cr ->
+-- mkVerb4 (cr + "y") (cr + "ies") (cr + "ied") (cr + "ied") ;
+--
+----- The particle always appears right after the verb.
+--
+-- verbPart : Verb -> Str -> Verb = \v,p ->
+-- {s = \\f => v.s ! f ++ p} ;
+--
+-- verbNoPart : Verb -> Verb = \v -> verbPart v [] ;
+--
+--
+--} ;
+--
diff --git a/lib/resource-1.0/german/NounGer.gf b/lib/resource-1.0/german/NounGer.gf
new file mode 100644
index 000000000..573b3b362
--- /dev/null
+++ b/lib/resource-1.0/german/NounGer.gf
@@ -0,0 +1,50 @@
+concrete NounGer of Noun = CatGer ** open ResGer, Prelude in {
+--
+-- flags optimize=all_subs ;
+--
+-- lin
+-- DetCN det cn = {
+-- s = \\c => det.s ++ cn.s ! det.n ! c ;
+-- a = agrP3 det.n
+-- } ;
+-- UsePN pn = pn ** {a = agrP3 Sg} ;
+-- UsePron p = p ;
+--
+-- MkDet pred quant num ord = {
+-- s = pred.s ++ quant.s ++ num.s ++ ord.s ;
+-- n = quant.n
+-- } ;
+--
+-- PossPronSg p = {s = p.s ! Gen ; n = Sg} ;
+-- PossPronPl p = {s = p.s ! Gen ; n = Pl} ;
+--
+-- NoPredet, NoNum, NoOrd = {s = []} ;
+-- NumInt n = n ;
+--
+-- NumNumeral numeral = {s = numeral.s ! NCard} ;
+-- OrdNumeral numeral = {s = numeral.s ! NOrd} ;
+--
+-- AdNum adn num = {s = adn.s ++ num.s} ;
+--
+-- OrdSuperl a = {s = a.s ! AAdj Superl} ;
+--
+-- DefSg = {s = artDef ; n = Sg} ;
+-- DefPl = {s = artDef ; n = Pl} ;
+--
+-- IndefSg = {s = artIndef ; n = Sg} ;
+-- IndefPl = {s = [] ; n = Pl} ;
+--
+-- ComplN2 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c} ;
+-- ComplN3 f x = {s = \\n,c => f.s ! n ! Nom ++ f.c2 ++ x.s ! c ; c2 = f.c3} ;
+--
+-- AdjCN ap cn = {
+-- s = \\n,c => preOrPost ap.isPre (ap.s ! agrP3 n) (cn.s ! n ! c)
+-- } ;
+-- RelCN cn rs = {s = \\n,c => cn.s ! n ! c ++ rs.s ! {n = n ; p = P3}} ;
+--
+-- SentCN cn s = {s = \\n,c => cn.s ! n ! c ++ conjThat ++ s.s} ;
+-- QuestCN cn qs = {s = \\n,c => cn.s ! n ! c ++ qs.s ! QIndir} ;
+--
+-- UseN n = n ;
+--
+}
diff --git a/lib/resource-1.0/german/NumeralGer.gf b/lib/resource-1.0/german/NumeralGer.gf
new file mode 100644
index 000000000..efc028483
--- /dev/null
+++ b/lib/resource-1.0/german/NumeralGer.gf
@@ -0,0 +1,44 @@
+--concrete NumeralGer of Numeral = CatGer ** open ResGer in {
+--
+--lincat
+-- Digit = {s : DForm => CardOrd => Str} ;
+-- Sub10 = {s : DForm => CardOrd => Str ; n : Number} ;
+-- Sub100 = {s : CardOrd => Str ; n : Number} ;
+-- Sub1000 = {s : CardOrd => Str ; n : Number} ;
+-- Sub1000000 = {s : CardOrd => Str ; n : Number} ;
+--
+--lin num x = x ;
+--lin n2 = let two = mkNum "two" "twelve" "twenty" "second" in
+-- {s = \\f,c => case