diff --git a/lib/src/dutch/AdjectiveDut.gf b/lib/src/dutch/AdjectiveDut.gf new file mode 100644 index 000000000..52100ad4b --- /dev/null +++ b/lib/src/dutch/AdjectiveDut.gf @@ -0,0 +1,59 @@ +concrete AdjectiveDut of Adjective = CatDut ** open ResDut, Prelude in +{ + + + flags optimize=all_subs ; + + lin + + PositA a = { + s = a.s ! Posit ; + isPre = True + } ; +-- ComparA a np = { +-- s = \\af => a.s ! Compar ! af ++ conjThan ++ np.s ! Nom ; +-- isPre = True +-- } ; +-- CAdvAP ad ap np = { +-- s = \\af => ad.s ++ ap.s ! af ++ ad.p ++ np.s ! Nom ; +-- isPre = False +-- } ; +-- UseComparA a = { +-- s = \\af => a.s ! Compar ! af ; +-- isPre = True +-- } ; +-- AdjOrd a = { +-- s = a.s ; +-- isPre = True +-- } ; +-- +---- $SuperlA$ belongs to determiner syntax in $Noun$. +-- +-- ComplA2 a np = { +-- s = \\af => a.s ! Posit ! af ++ appPrep a.c2 np.s ; +-- isPre = True +-- } ; +-- +-- ReflA2 a = { +-- s = \\af => a.s ! Posit ! APred ++ appPrep a.c2 (reflPron ! agrP3 Sg) ; --- agr +-- isPre = True +-- } ; +-- +-- SentAP ap sc = { +-- s = \\a => ap.s ! a ++ sc.s ; +-- isPre = False +-- } ; +-- +-- AdAP ada ap = { +-- s = \\a => ada.s ++ ap.s ! a ; +-- isPre = ap.isPre +-- } ; +-- +-- UseA2 a = { +-- s = a.s ! Posit ; +-- isPre = True +-- } ; +-- +--} + +} diff --git a/lib/src/dutch/AdverbDut.gf b/lib/src/dutch/AdverbDut.gf new file mode 100644 index 000000000..837c1f37c --- /dev/null +++ b/lib/src/dutch/AdverbDut.gf @@ -0,0 +1,27 @@ +concrete AdverbDut of Adverb = CatDut ** open ResDut, Prelude in +{ +--{ +-- +-- lin +-- PositAdvAdj a = {s = a.s ! Posit ! APred} ; +-- +-- ComparAdvAdj cadv a np = { +-- s = cadv.s ++ a.s ! Posit ! APred ++ cadv.p ++ np.s ! Nom +-- } ; +-- ComparAdvAdjS cadv a s = { +-- s = cadv.s ++ a.s ! Posit ! APred ++ cadv.p ++ s.s ! Sub +-- } ; +-- +-- PrepNP prep np = {s = appPrep prep np.s} ; +-- +-- AdAdv = cc2 ; +-- +-- SubjS subj s = {s = subj.s ++ s.s ! Sub} ; +-- +-- AdnCAdv cadv = {s = cadv.s ++ conjThan} ; +-- +--} +-- +-----b AdvSC s = s ; + +} diff --git a/lib/src/dutch/AllDut.gf b/lib/src/dutch/AllDut.gf new file mode 100644 index 000000000..5397513f8 --- /dev/null +++ b/lib/src/dutch/AllDut.gf @@ -0,0 +1,11 @@ +--# -path=.:../abstract:../common:prelude + +concrete AllDut of AllDutAbs = + LangDut, + IrregDut, + ExtraDut + ** +{ +--{} ; + +} diff --git a/lib/src/dutch/AllDutAbs.gf b/lib/src/dutch/AllDutAbs.gf new file mode 100644 index 000000000..4ddd642c7 --- /dev/null +++ b/lib/src/dutch/AllDutAbs.gf @@ -0,0 +1,11 @@ +--# -path=.:../abstract:../common:prelude + +abstract AllDutAbs = + Lang, + IrregDutAbs, + ExtraDutAbs + ** +{ +--{} ; + +} diff --git a/lib/src/dutch/CatDut.gf b/lib/src/dutch/CatDut.gf new file mode 100644 index 000000000..bc6a7678f --- /dev/null +++ b/lib/src/dutch/CatDut.gf @@ -0,0 +1,106 @@ +concrete CatDut of Cat = + CommonX ** + open ResDut, Prelude in +{ + flags optimize=all_subs ; + + lincat +-- +---- Tensed/Untensed +-- + S = {s : Order => Str} ; + QS = {s : QForm => Str} ; +-- RS = {s : GenNum => Str ; c : Case} ; +-- SSlash = {s : Order => Str} ** {c2 : Preposition} ; +-- +---- Sentence +-- + Cl = Clause ; -- {s : Tense => Anteriority => Polarity => Order => Str} ; +-- ClSlash = { +-- s : Mood => ResDut.Tense => Anteriority => Polarity => Order => Str ; +-- c2 : Preposition +-- } ; +-- Imp = {s : Polarity => ImpForm => Str} ; +-- +---- Question +-- + QCl = {s : ResDut.Tense => Anteriority => Polarity => QForm => Str} ; +-- IP = {s : Case => Str ; n : Number} ; +-- IComp = {s : Agr => Str} ; +-- IDet = {s : Gender => Case => Str ; n : Number} ; +-- IQuant = {s : Number => Gender => Case => Str} ; +-- +---- Relative +-- +-- RCl = {s : Mood => ResDut.Tense => Anteriority => Polarity => GenNum => Str ; c : Case} ; +-- RP = {s : GenNum => Case => Str ; a : RAgr} ; +-- +---- Verb +-- + VP = ResDut.VP ; + VPSlash = ResDut.VP ** {c2 : Preposition} ; + Comp = {s : Agr => Str} ; + +-- Adjective + + AP = {s : AForm => Str ; isPre : Bool} ; + +-- Noun + + CN = Noun ; + NP = {s : NPCase => Str ; a : Agr} ; + Pron = Pronoun ; + +-- Det = {s,sp : Gender => Case => Str ; n : Number ; a : Adjf} ; +-- Quant = { +-- s : Bool => Number => Gender => Case => Str ; +-- sp : Number => Gender => Case => Str ; +-- a : Adjf +-- } ; +-- Predet = {s : Number => Gender => Case => Str ; c : PredetCase} ; +-- Num = {s : Gender => Case => Str ; n : Number ; isNum : Bool} ; +-- Card = {s : Gender => Case => Str ; n : Number} ; +-- Ord = {s : AForm => Str} ; +-- +---- Numeral +-- +-- Numeral = {s : CardOrd => Str ; n : Number } ; +-- Digits = {s : CardOrd => Str ; n : Number } ; +-- +---- Structural +-- +-- Conj = {s1,s2 : Str ; n : Number} ; +-- Subj = {s : Str} ; +-- Prep = {s : Str ; c : Case} ; +-- +---- Open lexical classes, e.g. Lexicon +-- + V, VS, VQ, VA = ResDut.Verb ** {aux : VAux} ; -- = {s : VForm => Str} ; +-- VV = Verb ** {isAux : Bool} ; + V2, V2A, V2S, V2Q = VVerb ** {c2 : Preposition} ; +-- V2V = Verb ** {c2 : Preposition ; isAux : Bool} ; +-- V3 = Verb ** {c2, c3 : Preposition} ; +-- + A = Adjective ; +-- A2 = {s : Degree => AForm => Str ; c2 : Preposition} ; +-- + N = Noun ; +-- N2 = {s : Number => Case => Str ; g : Gender} ** {c2 : Preposition} ; +-- N3 = {s : Number => Case => Str ; g : Gender} ** {c2,c3 : Preposition} ; +-- PN = {s : Case => Str} ; +-- +---- tense with possibility to choose conjunctive forms +-- +-- Temp = {s : Str ; t : ResDut.Tense ; a : Anteriority ; m : Mood} ; +-- Tense = {s : Str ; t : ResDut.Tense ; m : Mood} ; +-- +-- lin +-- TTAnt t a = {s = t.s ++ a.s ; t = t.t ; a = a.a ; m = t.m} ; +-- +-- TPres = {s = [] ; t = Pres ; m = MIndic} ; +-- TPast = {s = [] ; t = Past ; m = MIndic} ; --# notpresent +-- TFut = {s = [] ; t = Fut ; m = MIndic} ; --# notpresent +-- TCond = {s = [] ; t = Cond ; m = MIndic} ; --# notpresent +--} + +} diff --git a/lib/src/dutch/ConjunctionDut.gf b/lib/src/dutch/ConjunctionDut.gf new file mode 100644 index 000000000..c64995543 --- /dev/null +++ b/lib/src/dutch/ConjunctionDut.gf @@ -0,0 +1,49 @@ +concrete ConjunctionDut of Conjunction = + CatDut ** open ResDut, Coordination, Prelude in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- ConjS conj ss = conjunctDistrTable Order conj ss ; +-- +-- ConjAdv conj ss = conjunctDistrSS conj ss ; +-- +-- ConjNP conj ss = conjunctDistrTable Case conj ss ** { +-- a = {g = Fem ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} +-- } ; +-- +-- ConjAP conj ss = conjunctDistrTable AForm conj ss ** { +-- isPre = ss.isPre +-- } ; +-- +-- ConjRS conj ss = conjunctDistrTable GenNum conj ss ** { +-- c = ss.c +-- } ; +-- +-- +---- These fun's are generated from the list cat's. +-- +-- BaseS = twoTable Order ; +-- ConsS = consrTable Order 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 AForm x y ** {isPre = andB x.isPre y.isPre} ; +-- ConsAP xs x = consrTable AForm comma xs x ** {isPre = andB xs.isPre x.isPre} ; +-- BaseRS x y = twoTable GenNum x y ** {c = y.c} ; +-- ConsRS xs x = consrTable GenNum comma xs x ** {c = xs.c} ; +-- +-- lincat +-- [S] = {s1,s2 : Order => Str} ; +-- [Adv] = {s1,s2 : Str} ; +-- [NP] = {s1,s2 : Case => Str ; a : Agr} ; +-- [AP] = {s1,s2 : AForm => Str ; isPre : Bool} ; +-- [RS] = {s1,s2 : GenNum => Str ; c : Case} ; +-- +--} + +} diff --git a/lib/src/dutch/ExtDut.gf b/lib/src/dutch/ExtDut.gf new file mode 100644 index 000000000..bf5932556 --- /dev/null +++ b/lib/src/dutch/ExtDut.gf @@ -0,0 +1,30 @@ +--concrete ExtDut of ExtDutAbs = CatDut ** open ResDut 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/src/dutch/ExtraDut.gf b/lib/src/dutch/ExtraDut.gf new file mode 100644 index 000000000..ea63fd221 --- /dev/null +++ b/lib/src/dutch/ExtraDut.gf @@ -0,0 +1,38 @@ +concrete ExtraDut of ExtraDutAbs = CatDut ** + open ResDut, Coordination, Prelude, IrregDut in +{ +--{ +-- +-- lincat +-- VPI = {s : Bool => Str} ; +-- [VPI] = {s1,s2 : Bool => Str} ; +-- lin +-- BaseVPI = twoTable Bool ; +-- ConsVPI = consrTable Bool comma ; +-- +-- MkVPI vp = {s = \\b => useInfVP b vp} ; +-- ConjVPI = conjunctDistrTable Bool ; +-- +-- ComplVPIVV v vpi = +-- insertInf (vpi.s ! v.isAux) ( +-- predVGen v.isAux v) ; ---- +--{- +-- insertExtrapos vpi.p3 ( +-- insertInf vpi.p2 ( +-- insertObj vpi.p1 ( +-- predVGen v.isAux v))) ; +---} +-- +-- PPzuAdv cn = {s = case cn.g of { +-- Masc | Neutr => "zum" ; +-- Fem => "zur" +-- } ++ cn.s ! adjfCase Weak Dat ! Sg ! Dat +-- } ; +-- +-- TImpfSubj = {s = [] ; t = Past ; m = MConjunct} ; --# notpresent +-- +-- moegen_VV = auxVV mögen_V ; +-- +--} + +} diff --git a/lib/src/dutch/ExtraGerDut.gf b/lib/src/dutch/ExtraGerDut.gf new file mode 100644 index 000000000..5c34bc890 --- /dev/null +++ b/lib/src/dutch/ExtraGerDut.gf @@ -0,0 +1,15 @@ +abstract ExtraDutAbs = Extra [ + VPI,ListVPI,BaseVPI,ConsVPI,MkVPI,ComplVPIVV,ConjVPI, + VV,VP,Conj] ** +{ +--{ +-- +-- fun +-- PPzuAdv : CN -> Adv ; -- zum Lied, zur Flasche +-- TImpfSubj : Tense ; -- ich möchte... --# notpresent +-- +-- moegen_VV : VV ; -- ich mag/möchte singen +-- +--} + +} diff --git a/lib/src/dutch/GrammarDut.gf b/lib/src/dutch/GrammarDut.gf new file mode 100644 index 000000000..c03598c53 --- /dev/null +++ b/lib/src/dutch/GrammarDut.gf @@ -0,0 +1,16 @@ +--# -path=.:../abstract:../common:prelude + +concrete GrammarDut of Grammar = + NounDut, + VerbDut, + AdjectiveDut, + AdverbDut, + NumeralDut, + SentenceDut, + QuestionDut, + RelativeDut, + ConjunctionDut, + PhraseDut, + TextX, + IdiomDut, + StructuralDut ; diff --git a/lib/src/dutch/IdiomDut.gf b/lib/src/dutch/IdiomDut.gf new file mode 100644 index 000000000..386dfa7c1 --- /dev/null +++ b/lib/src/dutch/IdiomDut.gf @@ -0,0 +1,50 @@ +concrete IdiomDut of Idiom = CatDut ** + open MorphoDut, ParadigmsDut, Prelude in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- ImpersCl vp = mkClause "es" (agrP3 Sg) vp ; +-- GenericCl vp = mkClause "man" (agrP3 Sg) vp ; +-- +-- CleftNP np rs = mkClause "es" (agrP3 Sg) +-- (insertExtrapos (rs.s ! gennum np.a.g np.a.n) ---- +-- (insertObj (\\_ => np.s ! rs.c) (predV MorphoDut.sein_V))) ; +-- +-- CleftAdv ad s = mkClause "es" (agrP3 Sg) +-- (insertExtrapos (conjThat ++ s.s ! Sub) +-- (insertObj (\\_ => ad.s) (predV MorphoDut.sein_V))) ; +-- +-- +-- ExistNP np = +-- mkClause "es" (agrP3 Sg) +-- (insertObj (\\_ => appPrep geben.c2 np.s) +-- (predV geben)) ; +-- +-- ExistIP ip = { +-- s = \\m,t,a,p => +-- let +-- cls = +-- (mkClause "es" (agrP3 Sg) (predV geben)).s ! m ! t ! a ! p ; +-- who = ip.s ! Acc +-- in table { +-- QDir => who ++ cls ! Inv ; +-- QIndir => who ++ cls ! Sub +-- } +-- } ; +-- +-- ProgrVP = insertAdv "eben" ; ---- +-- +-- ImpPl1 vp = {s = +-- (mkClause "wir" {g = Fem ; n = Pl ; p = P1} vp).s ! +-- MConjunct ! Pres ! Simul ! Pos ! Inv +-- } ; +-- +-- oper +-- geben = dirV2 (mk6V "geben" "gibt" "gib" "gab" "gäbe" "gegeben") ; +--} +-- + +} diff --git a/lib/src/dutch/IrregDut.gf b/lib/src/dutch/IrregDut.gf new file mode 100644 index 000000000..bd663009d --- /dev/null +++ b/lib/src/dutch/IrregDut.gf @@ -0,0 +1,232 @@ +--# -path=.:prelude:../abstract:../common + +-- adapted from verb list in +-- http://www.iee.et.tu-dresden.de/~wernerr/grammar/verben_dt.html + +concrete IrregDut of IrregDutAbs = CatDut ** open + ParadigmsDut, + (M = MorphoDut) +in +{ +--{ +-- +-- flags optimize=values ; +-- +-- lin backen_V = irregV "backen" "bäckt" (variants {"backt" ; "buk"}) (variants {"backt" ; "buke"}) "gebacken" ; +-- lin befehlen_V = irregV "befehlen" "befiehlt" "befahl" "beföhle" "befähle)" ; +-- lin beginnen_V = irregV "beginnen" "beginnt" "begann" "begönne" "begänne)" ; +-- lin beißen_V = irregV "beißen" "beißt" "biß" "biße" "gebissen" ; +-- lin bergen_V = irregV "bergen" "birgt" "barg" "bärge" "geborgen" ; +-- lin bersten_V = irregV "bersten" "birst" "barst" "bärste" "geborsten" ; +-- lin bewegen_V = irregV "bewegen" "bewegt" "bewog" "bewöge" "bewogen" ; +-- lin biegen_V = irregV "biegen" "biegt" "bog" "böge" "gebogen" ; +-- lin bieten_V = irregV "bieten" "bietet" "bot" "böte" "geboten" ; +-- lin binden_V = irregV "binden" "bindt" "band" "bände" "gebunden" ; +-- lin bitten_V = irregV "bitten" "bittet" "bat" "bäte" "gebeten" ; +-- lin blasen_V = irregV "blasen" "bläst" "blies" "bliese" "geblasen" ; +-- lin bleiben_V = irregV "bleiben" "bleibt" "blieb" "bliebe" "geblieben" ; +-- lin braten_V = irregV "braten" "brät" "briet" "briete" "gebraten" ; +-- lin brechen_V = irregV "brechen" "bricht" "brach" "bräche" "gebrochen" ; +-- lin brennen_V = irregV "brennen" "brennt" "brannte" "brennte" "gebrannt" ; +-- lin bringen_V = irregV "bringen" "bringt" "brachte" "brachte" "gebracht" ; +-- lin denken_V = irregV "denken" "denkt" "dachte" "dachte" "gedacht" ; +-- lin dingen_V = irregV "dingen" "dingt" "dingte" "dang" "gedungen" ; +-- lin dreschen_V = irregV "dreschen" "drischt" "drosch" "drösche" "gedroschen" ; +-- lin dringen_V = irregV "dringen" "dringt" "drang" "dränge" "gedrungen" ; +-- lin dürfen_V = M.mkV +-- "dürfen" "darf" "darfst" "darf" "dürft" "dürf" +-- "durfte" "durftest" "durften" "durftet" +-- "dürfte" "gedurft" [] +-- M.VHaben ** {lock_V = <>} ; +-- lin empfehlen_V = irregV "empfehlen" "empfiehlt" "empfahl" +-- (variants {"empföhle" ; "empfähle"}) "empfohlen" ; +-- lin erlöschen_V = irregV "erlöschen" "erlischt" "erlosch" "erlösche" "erloschen" ; +-- lin erkennen_V = irregV "erkennen" "erkennt" "erkannte" "erkannte" "erkannt" ; +-- lin erschrecken_V = irregV "erschrecken" "erschrickt" "erschrak" "erschräke" "erschrocken" ; +-- lin essen_V = irregV "essen" "ißt" "aß" "äße" "gegessen" ; +-- lin fahren_V = irregV "fahren" "fährt" "fuhr" "führe" "gefahren" ; +-- lin fallen_V = irregV "fallen" "fällt" "fiel" "fiele" "gefallen" ; +-- lin fangen_V = irregV "fangen" "fängt" "fing" "finge" "gefangen" ; +-- lin fechten_V = irregV "fechten" "fechtet" "focht" "föchte" "gefochten" ; +-- lin finden_V = irregV "finden" "findt" "fand" "fände" "gefunden" ; +-- lin flechten_V = irregV "flechten" "flicht" "flocht" "flöchte" "geflochten" ; +-- lin fliegen_V = irregV "fliegen" "fliegt" "flog" "flöge" "geflogen" ; +-- lin fliehen_V = irregV "fliehen" "flieht" "floh" "flöhe" "geflohen" ; +-- lin fließen_V = irregV "fließen" "fließt" "floß" "flösse" "geflossen" ; +-- lin fressen_V = irregV "fressen" "frißt" "fraß" "fräße" "gefressen" ; +-- lin frieren_V = irregV "frieren" "friert" "fror" "fröre" "gefroren" ; +-- lin gären_V = irregV "gären" "gärt" (variants {"gor" ; "gärte"}) "göre" "gegoren" ; +-- lin gebären_V = irregV "gebären" "gebiert" "gebar" "gebäre" "geboren" ; +-- lin geben_V = irregV "geben" "gibt" "gab" "gäbe" "gegeben" ; +-- lin gedeihen_V = irregV "gedeihen" "gedeiht" "gedieh" "gediehe" "gediehen" ; +-- lin gehen_V = irregV "gehen" "geht" "ging" "ginge" "gegangen" ; +-- lin gelingen_V = irregV "gelingen" "gelingt" "gelang" "gelange" "gelungen" ; +-- lin gelten_V = irregV "gelten" "gilt" "galt" (variants {"galte" ; "golte"}) "gegolten" ; +-- lin genesen_V = irregV "genesen" "genest" "genas" "genäse" "genesen" ; +-- lin genießen_V = irregV "genießen" "genießt" "genoß" "genösse" "genossen" ; +-- lin geschehen_V = irregV "geschehen" "geschieht" "geschah" "geschehen" "geschähe" ; +-- lin gewinnen_V = irregV "gewinnen" "gewinnt" "gewann" (variants {"gewönne" ; "gewänne"}) "gewonnen" ; +-- lin gießen_V = irregV "gießen" "gießt" "goß" "gösse" "gegossen" ; +-- lin gleichen_V = irregV "gleichen" "gleicht" "glich" "gliche" "geglichen" ; +-- lin gleiten_V = irregV "gleiten" "gleitet" "glitt" "glitte" "geglitten" ; +-- lin glimmen_V = irregV "glimmen" "glimmt" "glomm" "glimmte" "glömme" ; +-- lin graben_V = irregV "graben" "gräbt" "grub" "grübe" "gegraben" ; +-- lin greifen_V = irregV "greifen" "greift" "griff" "griffe" "gegriffen" ; +-- lin haben_V = irregV "haben" "hat" "hatte" "hatte" "gehabt" ; +-- lin halten_V = irregV "halten" "hält" "hielt" "hielte" "gehalten" ; +-- lin hängen_V = irregV "hängen" "hängt" "hing" "hinge" "gehangen" ; +-- lin hauen_V = irregV "hauen" "haut" (variants {"haute" ; "hieb"}) (variants {"haute" ; "hiebe"}) "gehauen" ; +-- lin heben_V = irregV "heben" "hebt" "hob" "höbe" "gehoben" ; +-- lin heißen_V = irregV "heißen" "heißt" "hieß" "hieße" "geheißen" ; +-- lin helfen_V = irregV "helfen" "hilft" "half" "hülfe" "geholfen" ; +-- lin kennen_V = irregV "kennen" "kennt" "kannte" "kennte" "gekannt" ; +-- lin klimmen_V = irregV "klimmen" "klimmt" "klomm" "klömme" "geklommen" ; +-- lin klingen_V = irregV "klingen" "klingt" "klang" "klänge" "geklungen" ; +-- lin kneifen_V = irregV "kneifen" "kneift" "kniff" "kniffe" "gekniffen" ; +-- lin kommen_V = irregV "kommen" "kommt" "kam" "käme" "gekommen" ; +-- lin können_V = M.mkV +-- "können" "kann" "kannst" "kann" "könnt" "könn" +-- "konnte" "konntest" "konnten" "konntet" +-- "könnte" "gekonnt" [] +-- M.VHaben ** {lock_V = <>} ; +-- lin kriechen_V = irregV "kriechen" "kriecht" "kroch" "kröche" "gekrochen" ; +-- lin küren_V = irregV "küren" "kürt" "kürte" "kor" "gekürt" ; +-- lin laden_V = irregV "laden" "lädt" "lud" "lüde" "geladen" ; +-- lin lassen_V = irregV "lassen" "läßt" "ließ" "ließe" "gelassen" ; +-- lin laufen_V = irregV "laufen" "läuft" "lief" "liefe" "gelaufen" ; +-- lin leiden_V = irregV "leiden" "leidt" "litt" "litte" "gelitten" ; +-- lin leihen_V = irregV "leihen" "leiht" "lieh" "liehe" "geliehen" ; +-- lin lesen_V = irregV "lesen" "liest" "las" "läse" "gelesen" ; +-- lin liegen_V = irregV "liegen" "liegt" "lag" "läge" "gelegen" ; +-- lin lügen_V = irregV "lügen" "lügt" "log" "löge" "gelogen" ; +-- lin mahlen_V = irregV "mahlen" "mahlt" "mahlte" "mahlte" "gemahlen" ; +-- lin meiden_V = irregV "meiden" "meidt" "mied" "miede" "gemieden" ; +-- lin melken_V = irregV "melken" (variants {"melkt" ; "milkt"}) (variants {"melkte" ; "molk"}) "gemolken" "gemelkt" ; +-- lin messen_V = irregV "messen" "mißt" "maß" "mäße" "gemessen" ; +-- lin mißlingen_V = irregV "mißlingen" "mißlingt" "mißlang" "mißlungen" "mißlänge" ; +-- lin mögen_V = M.mkV +-- "mögen" "mag" "magst" "mag" "mögt" "mög" +-- "mochte" "mochtest" "mochten" "mochtet" +-- "möchte" "gemocht" [] +-- M.VHaben ** {lock_V = <>} ; +-- lin müssen_V = M.mkV +-- "müssen" "muß" "mußt" "muß" "müßt" "müß" +-- "mußte" "mußtest" "mußten" "mußtet" +-- "müßte" "gemußt" [] +-- M.VHaben ** {lock_V = <>} ; +-- lin nehmen_V = mk6V "nehmen" "nimmt" "nimm" "nahm" "nähme" "genommen" ; +-- lin nennen_V = irregV "nennen" "nennt" "nannte" "nennte" "genannt" ; +-- lin pfeifen_V = irregV "pfeifen" "pfeift" "pfiff" "pfiffe" "gepfiffen" ; +-- lin preisen_V = irregV "preisen" "preist" "pries" "priese" "gepriesen" ; +-- lin quellen_V = irregV "quellen" "quillt" "quoll" "quölle" "gequollen" ; +-- lin raten_V = irregV "raten" "rät" "riet" "riete" "geraten" ; +-- lin reiben_V = irregV "reiben" "reibt" "rieb" "riebe" "gerieben" ; +-- lin reißen_V = irregV "reißen" "reißt" "riß" "riße" "gerissen" ; +-- lin reiten_V = irregV "reiten" "reitet" "ritt" "ritte" "geritten" ; +-- lin rennen_V = irregV "rennen" "rennt" "rannte" "rennte" "gerannt" ; +-- lin riechen_V = irregV "riechen" "riecht" "roch" "röche" "gerochen" ; +-- lin ringen_V = irregV "ringen" "ringt" "rang" "ränge" "gerungen" ; +-- lin rinnen_V = irregV "rinnen" "rinnt" "rann" "ränne" "geronnen" ; +-- lin rufen_V = irregV "rufen" "ruft" "rief" "riefe" "gerufen" ; +-- lin salzen_V = irregV "salzen" "salzt" "salzte" "salzte" "gesalzen" ; +-- lin saufen_V = irregV "saufen" "säuft" "soff" "söffe" "gesoffen" ; +-- lin saugen_V = irregV "saugen" "saugt" (variants {"saugte" ; "sog"}) (variants {"saugte" ; "soge"}) (variants {"gesaugt" ; "gesogen"}) ; +-- lin schaffen_V = irregV "schaffen" "schafft" "schuf" "schüfe" "geschaffen" ; +-- lin scheiden_V = irregV "scheiden" "scheidt" "schied" "schiede" "geschieden" ; +-- lin scheinen_V = irregV "scheinen" "scheint" "schien" "schiene" "geschienen" ; +-- lin scheißen_V = irregV "scheißen" "scheißt" "schiß" "schiße" "geschissen" ; +-- lin schelten_V = irregV "schelten" "schilt" "schalt" "schölte" "gescholten" ; +-- lin scheren_V = irregV "scheren" "schert" "schor" "schöre" "geschoren" ; +-- lin schieben_V = irregV "schieben" "schiebt" "schob" "schöbe" "geschoben" ; +-- lin schießen_V = irregV "schießen" "schießt" "schoß" "schösse" "geschossen" ; +-- lin schinden_V = irregV "schinden" "schindt" "schund" "schunde" "geschunden" ; +-- lin schlafen_V = irregV "schlafen" "schläft" "schlief" "schliefe" "geschlafen" ; +-- lin schlagen_V = irregV "schlagen" "schlägt" "schlug" "schlüge" "geschlagen" ; +-- lin schleichen_V = irregV "schleichen" "schleicht" "schlich" "schliche" "geschlichen" ; +-- lin schleifen_V = irregV "schleifen" "schleift" "schliff" "schliffe" "geschliffen" ; +-- lin schleißen_V = irregV "schleißen" "schleißt" (variants {"schliß" ; "schleißte"}) (variants {"schliß" ; "schleißte"}) (variants {"geschlissen" ; "geschleißt"}) ; +-- lin schließen_V = irregV "schließen" "schließt" "schloß" "schlösse" "geschlossen" ; +-- lin schlingen_V = irregV "schlingen" "schlingt" "schlang" "schlünge" "geschlungen" ; +-- lin schmeißen_V = irregV "schmeißen" "schmeißt" "schmiß" "schmiße" "geschmissen" ; +-- lin schmelzen_V = irregV "schmelzen" "schmilzt" "schmolz" "schmölze" "geschmolzen" ; +-- lin schneiden_V = irregV "schneiden" "schneidt" "schnitt" "schnitte" "geschnitten" ; +-- lin schreiben_V = irregV "schreiben" "schreibt" "schrieb" "schriebe" "geschrieben" ; +-- lin schreien_V = irregV "schreien" "schreit" "schrie" "schrie" "geschrien" ; +-- lin schreiten_V = irregV "schreiten" "schreitet" "schritt" "schritte" "geschritten" ; +-- lin schweigen_V = irregV "schweigen" "schweigt" "schwieg" "schwiege" "geschwiegen" ; +-- lin schwellen_V = irregV "schwellen" "schwillt" "schwoll" "schwölle" "geschwollen" ; +-- lin schwimmen_V = irregV "schwimmen" "schwimmt" "schwamm" (variants {"schwömme" ; "schwämme"}) "geschwommen" ; +-- lin schwinden_V = irregV "schwinden" "schwindt" "schwand" "schwände" "geschwunden" ; +-- lin schwingen_V = irregV "schwingen" "schwingt" "schwang" "schwänge" "geschwungen" ; +-- lin schwören_V = irregV "schwören" "schwört" "schwor" "schwüre" "geschworen" ; +-- lin sehen_V = irregV "sehen" "sieht" "sah" "sähe" "gesehen" ; +-- lin sein_V = irregV "sein" "ist" "war" "wäre" "gewesen" ; +-- lin senden_V = irregV "senden" "sendt" (variants {"sandte" ; "sendete"}) (variants {"sandte" ; "sendete"}) (variants {"gesandt" ; "gesendet"}) ; +-- lin sieden_V = irregV "sieden" "siedt" (variants {"siedete" ; "sott"}) (variants {"siedete" ; "sotte"}) (variants {"gesotten" ; "gesiedet"}) ; +-- lin singen_V = irregV "singen" "singt" "sang" "sänge" "gesungen" ; +-- lin sinken_V = irregV "sinken" "sinkt" "sank" "sänke" "gesunken" ; +-- lin sinnen_V = irregV "sinnen" "sinnt" "sann" "sänne" "gesonnen" ; +-- lin sitzen_V = irregV "sitzen" "sitzt" "saß" "säße" "gesessen" ; +-- lin sollen_V = M.mkV +-- "sollen" "soll" "sollst" "soll" "sollt" "soll" +-- "sollte" "solltest" "sollten" "solltet" +-- "sollte" "gesollt" [] +-- M.VHaben ** {lock_V = <>} ; +-- +-- lin speien_V = irregV "speien" "speit" "spie" "spie" "gespien" ; +-- lin spinnen_V = irregV "spinnen" "spinnt" "spann" (variants {"spönne" ; "spänne"}) "gesponnen" ; +-- lin spleißen_V = irregV "spleißen" "spleißt" "spliß" "spliße" "gesplissen" ; +-- lin sprechen_V = irregV "sprechen" "spricht" "sprach" "spräche" "gesprochen" ; +-- lin sprießen_V = irregV "sprießen" "sprießt" "sproß" "sprösse" "gesprossen" ; +-- lin springen_V = irregV "springen" "springt" "sprang" "spränge" "gesprungen" ; +-- lin stechen_V = irregV "stechen" "sticht" "stach" "stäche" "gestochen" ; +-- lin stehen_V = irregV "stehen" "steht" "stand" (variants {"stünde" ; "stände"}) "gestanden" ; +-- lin stehlen_V = irregV "stehlen" "stiehlt" "stahl" "stähle" "gestohlen" ; +-- lin steigen_V = irregV "steigen" "steigt" "stieg" "stiege" "gestiegen" ; +-- lin sterben_V = irregV "sterben" "stirbt" "starb" "stürbe" "gestorben" ; +-- lin stieben_V = irregV "stieben" "stiebt" "stob" "stöbe" "gestoben" ; +-- lin stinken_V = irregV "stinken" "stinkt" "stank" "stänke" "gestunken" ; +-- lin stoßen_V = irregV "stoßen" "stößt" "stieß" "stieße" "gestoßen" ; +-- lin streichen_V = irregV "streichen" "streicht" "strich" "striche" "gestrichen" ; +-- lin streiten_V = irregV "streiten" "streitet" "stritt" "stritte" "gestritten" ; +-- lin tragen_V = irregV "tragen" "trägt" "trug" "trüge" "getragen" ; +-- lin treffen_V = irregV "treffen" "trifft" "traf" "träfe" "getroffen" ; +-- lin treiben_V = irregV "treiben" "treibt" "trieb" "triebe" "getrieben" ; +-- lin treten_V = irregV "treten" "tritt" "trat" "träte" "getreten" ; +-- lin trinken_V = irregV "trinken" "trinkt" "trank" "tränke" "getrunken" ; +-- lin trügen_V = irregV "trügen" "trügt" "trog" "tröge" "getrogen" ; +-- lin tun_V = irregV "tun" "tut" "tat" "täte" "getan" ; +-- lin verderben_V = irregV "verderben" "verdirbt" "verdarb" "verdarbe" "verdorben" ; +-- lin verlieren_V = irregV "verlieren" "verliert" "verlor" "verlöre" "verloren" ; +-- lin wachsen_V = irregV "wachsen" "wächst" "wuchs" "wüchse" "gewachsen" ; +-- lin wägen_V = irregV "wägen" "wägt" "wog" "woge" "gewogen" ; +-- lin waschen_V = irregV "waschen" "wäscht" "wusch" "wüsche" "gewaschen" ; +-- lin weben_V = irregV "weben" "webt" (variants {"wob" ; "webte"}) "wöbe" (variants {"gewoben" ; "gewebt"}) ; +-- lin weichen_V = irregV "weichen" "weicht" "wich" "wiche" "gewichen" ; +-- lin weisen_V = irregV "weisen" "weist" "wies" "wiese" "gewiesen" ; +-- lin wenden_V = irregV "wenden" "wendt" (variants {"wandte" ; "wendete"}) (variants {"wandte" ; "wendete"}) (variants {"gewandt" ; "gewendet"}) ; +-- lin werben_V = irregV "werben" "wirbt" "warb" "würbe" "geworben" ; +-- lin werden_V = M.mkV +-- "werden" "werde" "wirst" "wird" "werdet" "werd" +-- "wurde" "wurdest" "wurden" "wurdet" +-- "würde" "geworden" [] +-- M.VHaben ** {lock_V = <>} ; +-- lin werfen_V = irregV "werfen" "wirft" "warf" "würfe" "geworfen" ; +-- lin wiegen_V = irregV "wiegen" "wiegt" "wog" "wöge" "gewogen" ; +-- lin winden_V = irregV "winden" "windt" "wand" "wände" "gewunden" ; +-- lin wissen_V = irregV "wissen" "weiß" "wußte" "wüßte" "gewußt" ; +-- lin wollen_V = M.mkV +-- "wollen" "will" "willst" "will" "wollt" "woll" +-- "wollte" "wolltest" "wollten" "wolltet" +-- "wollte" "gewollt" [] +-- M.VHaben ** {lock_V = <>} ; +-- +-- +-- lin wringen_V = irregV "wringen" "wringt" "wrang" "wränge" "gewrungen" ; +-- lin zeihen_V = irregV "zeihen" "zeiht" "zieh" "ziehe" "geziehen" ; +-- lin ziehen_V = irregV "ziehen" "zieht" "zog" "zöge" "gezogen" ; +-- lin zwingen_V = irregV "zwingen" "zwingt" "zwang" "zwänge" "gezwungen" ; +-- +--} + +} diff --git a/lib/src/dutch/IrregDutAbs.gf b/lib/src/dutch/IrregDutAbs.gf new file mode 100644 index 000000000..c1f75704d --- /dev/null +++ b/lib/src/dutch/IrregDutAbs.gf @@ -0,0 +1,189 @@ +abstract IrregDutAbs = Cat ** +{ +--{ +-- +-- fun backen_V : V ; +-- fun befehlen_V : V ; +-- fun beginnen_V : V ; +-- fun beißen_V : V ; +-- fun bergen_V : V ; +-- fun bersten_V : V ; +-- fun bewegen_V : V ; +-- fun biegen_V : V ; +-- fun bieten_V : V ; +-- fun binden_V : V ; +-- fun bitten_V : V ; +-- fun blasen_V : V ; +-- fun bleiben_V : V ; +-- fun braten_V : V ; +-- fun brechen_V : V ; +-- fun brennen_V : V ; +-- fun bringen_V : V ; +-- fun denken_V : V ; +-- fun dingen_V : V ; +-- fun dreschen_V : V ; +-- fun dringen_V : V ; +-- fun dürfen_V : V ; +-- fun empfehlen_V : V ; +-- fun erlöschen_V : V ; +-- fun erkennen_V : V ; +-- fun erschrecken_V : V ; +-- fun essen_V : V ; +-- fun fahren_V : V ; +-- fun fallen_V : V ; +-- fun fangen_V : V ; +-- fun fechten_V : V ; +-- fun finden_V : V ; +-- fun flechten_V : V ; +-- fun fliegen_V : V ; +-- fun fliehen_V : V ; +-- fun fließen_V : V ; +-- fun fressen_V : V ; +-- fun frieren_V : V ; +-- fun gären_V : V ; +-- fun gebären_V : V ; +-- fun geben_V : V ; +-- fun gedeihen_V : V ; +-- fun gehen_V : V ; +-- fun gelingen_V : V ; +-- fun gelten_V : V ; +-- fun genesen_V : V ; +-- fun genießen_V : V ; +-- fun geschehen_V : V ; +-- fun gewinnen_V : V ; +-- fun gießen_V : V ; +-- fun gleichen_V : V ; +-- fun gleiten_V : V ; +-- fun glimmen_V : V ; +-- fun graben_V : V ; +-- fun greifen_V : V ; +-- fun haben_V : V ; +-- fun halten_V : V ; +-- fun hängen_V : V ; +-- fun hauen_V : V ; +-- fun heben_V : V ; +-- fun heißen_V : V ; +-- fun helfen_V : V ; +-- fun kennen_V : V ; +-- fun klimmen_V : V ; +-- fun klingen_V : V ; +-- fun kneifen_V : V ; +-- fun kommen_V : V ; +-- fun können_V : V ; +-- fun kriechen_V : V ; +-- fun küren_V : V ; +-- fun laden_V : V ; +-- fun lassen_V : V ; +-- fun laufen_V : V ; +-- fun leiden_V : V ; +-- fun leihen_V : V ; +-- fun lesen_V : V ; +-- fun liegen_V : V ; +-- fun lügen_V : V ; +-- fun mahlen_V : V ; +-- fun meiden_V : V ; +-- fun melken_V : V ; +-- fun messen_V : V ; +-- fun mißlingen_V : V ; +-- fun mögen_V : V ; +-- fun müssen_V : V ; +-- fun nehmen_V : V ; +-- fun nennen_V : V ; +-- fun pfeifen_V : V ; +-- fun preisen_V : V ; +-- fun quellen_V : V ; +-- fun raten_V : V ; +-- fun reiben_V : V ; +-- fun reißen_V : V ; +-- fun reiten_V : V ; +-- fun rennen_V : V ; +-- fun riechen_V : V ; +-- fun ringen_V : V ; +-- fun rinnen_V : V ; +-- fun rufen_V : V ; +-- fun salzen_V : V ; +-- fun saufen_V : V ; +-- fun saugen_V : V ; +-- fun schaffen_V : V ; +-- fun scheiden_V : V ; +-- fun scheinen_V : V ; +-- fun scheißen_V : V ; +-- fun schelten_V : V ; +-- fun scheren_V : V ; +-- fun schieben_V : V ; +-- fun schießen_V : V ; +-- fun schinden_V : V ; +-- fun schlafen_V : V ; +-- fun schlagen_V : V ; +-- fun schleichen_V : V ; +-- fun schleifen_V : V ; +-- fun schleißen_V : V ; +-- fun schließen_V : V ; +-- fun schlingen_V : V ; +-- fun schmeißen_V : V ; +-- fun schmelzen_V : V ; +-- fun schneiden_V : V ; +-- fun schreiben_V : V ; +-- fun schreien_V : V ; +-- fun schreiten_V : V ; +-- fun schweigen_V : V ; +-- fun schwellen_V : V ; +-- fun schwimmen_V : V ; +-- fun schwinden_V : V ; +-- fun schwingen_V : V ; +-- fun schwören_V : V ; +-- fun sehen_V : V ; +-- fun sein_V : V ; +-- fun senden_V : V ; +-- fun sieden_V : V ; +-- fun singen_V : V ; +-- fun sinken_V : V ; +-- fun sinnen_V : V ; +-- fun sitzen_V : V ; +-- fun sollen_V : V ; +-- fun speien_V : V ; +-- fun spinnen_V : V ; +-- fun spleißen_V : V ; +-- fun sprechen_V : V ; +-- fun sprießen_V : V ; +-- fun springen_V : V ; +-- fun stechen_V : V ; +-- fun stehen_V : V ; +-- fun stehlen_V : V ; +-- fun steigen_V : V ; +-- fun sterben_V : V ; +-- fun stieben_V : V ; +-- fun stinken_V : V ; +-- fun stoßen_V : V ; +-- fun streichen_V : V ; +-- fun streiten_V : V ; +-- fun tragen_V : V ; +-- fun treffen_V : V ; +-- fun treiben_V : V ; +-- fun treten_V : V ; +-- fun trinken_V : V ; +-- fun trügen_V : V ; +-- fun tun_V : V ; +-- fun verderben_V : V ; +-- fun verlieren_V : V ; +-- fun wachsen_V : V ; +-- fun wägen_V : V ; +-- fun waschen_V : V ; +-- fun weben_V : V ; +-- fun weichen_V : V ; +-- fun weisen_V : V ; +-- fun wenden_V : V ; +-- fun werben_V : V ; +-- fun werden_V : V ; +-- fun werfen_V : V ; +-- fun wiegen_V : V ; +-- fun winden_V : V ; +-- fun wissen_V : V ; +-- fun wollen_V : V ; +-- fun wringen_V : V ; +-- fun zeihen_V : V ; +-- fun ziehen_V : V ; +-- fun zwingen_V : V ; +--} + +} diff --git a/lib/src/dutch/LangDut.gf b/lib/src/dutch/LangDut.gf new file mode 100644 index 000000000..02d112a73 --- /dev/null +++ b/lib/src/dutch/LangDut.gf @@ -0,0 +1,5 @@ +--# -path=.:../abstract:../common:../prelude + +concrete LangDut of Lang = + GrammarDut, + LexiconDut ; diff --git a/lib/src/dutch/LexiconDut.gf b/lib/src/dutch/LexiconDut.gf new file mode 100644 index 000000000..9ef0d4ffd --- /dev/null +++ b/lib/src/dutch/LexiconDut.gf @@ -0,0 +1,368 @@ +--# -path=.:../common:../abstract:../../prelude + +-- work by Aarne Ranta, Andreas Priesnitz, and Henning Thielemann. + +concrete LexiconDut of Lexicon = CatDut ** + open Prelude, ParadigmsDut in { + +flags + optimize=all_subs ; + +lin +-- add_V3 = dirV3 (prefixV "hinzu" (regV "fügen")) zu_Prep ; +-- airplane_N = mkN "Flugzeug" ; +-- already_Adv = mkAdv "schon" ; +-- answer_V2S = mkV2S (regV "antworten") datPrep ; +-- apartment_N = mkN "Wohnung" ; +-- apple_N = reg2N "Apfel" "Äpfel" masculine ; +-- art_N = reg2N "Kunst" "Künste" feminine ; +-- ask_V2Q = mkV2Q (regV "fragen") accPrep ; +-- baby_N = reg2N "Baby" "Babies" neuter ; ---- + bad_A = mkA "boos" ; +-- bank_N = reg2N "Bank" "Banken" feminine ; +-- beautiful_A = regA "schön" ; +-- become_VA = mkVA IrregDut.werden_V ; +-- beer_N = reg2N "Bier" "Biere" neuter ; +-- beg_V2V = mkV2V (mk6V "bitten" "bittet" "bitte" "bat" "bäte" "gebeten") accPrep ; +-- big_A = mk3A "groß" "größer" "größte" ; +-- bike_N = reg2N "Fahrrad" "Fahrräder" neuter ; +-- bird_N = reg2N "Vogel" "Vögel" masculine ; +-- black_A = regA "schwarz" ; +-- blue_A = regA "blau"; +-- boat_N = reg2N "Boot" "Boote" neuter ; +-- book_N = reg2N "Buch" "Bücher" neuter ; +-- boot_N = reg2N "Stiefel" "Stiefel" masculine ; +-- boss_N = reg2N "Chef" "Chefs" masculine ; ---- +-- boy_N = reg2N "Junge" "Jungen" masculine ; +-- bread_N = reg2N "Brot" "Brote" neuter ; +-- break_V2 = dirV2 +-- (irregV "zerschlagen" "zerschlägt" "zerschlug" "zerschlüge" "zerschlagen") ; +-- broad_A = regA "breit" ; +-- brother_N2 = mkN2 (reg2N "Bruder" "Brüder" masculine) von_Prep ; +-- brown_A = regA "braun" ; +-- butter_N = reg2N "Butter" "Butter" feminine ; ---- infl +-- buy_V2 = dirV2 (regV "kaufen") ; +-- camera_N = reg2N "Kamera" "Kameras" feminine ; +-- cap_N = mkN "Mütze" ; +-- car_N = mkN "Wagen" ; +-- carpet_N = mkN "Teppich" ; +-- cat_N = mkN "Katze" ; +-- ceiling_N = reg2N "Dach" "Dächer" neuter ; +-- chair_N = reg2N "Stuhl" "Stühle" masculine ; +-- cheese_N = mkN "Käse" "Käse" masculine ; +-- child_N = reg2N "Kind" "Kinder" neuter ; +-- church_N = mkN "Kirche" ; +-- city_N = reg2N "Stadt" "Städte" feminine ; +-- clean_A = regA "rein" ; +-- clever_A = mk3A "klug" "klüger" "klügste" ; +-- close_V2 = dirV2 (irregV "schließen" "schließt" "schloß" "schlösse" "geschlossen") ; +-- coat_N = mkN "Jacke" ; +-- cold_A = regA "kalt" ; +-- come_V = seinV (mk6V "kommen" "kommt" "komm" "kam" "käme" "gekommen") ; +-- computer_N = reg2N "Rechner" "Rechner" masculine ; +-- country_N = reg2N "Land" "Länder" neuter ; +-- cousin_N = reg2N "Vetter" "Vetter" masculine ; --- Kusine +-- cow_N = reg2N "Kuh" "Kühe" feminine ; +-- die_V = seinV (irregV "sterben" "stirbt" "starb" "stürbe" "gestorben") ; +-- distance_N3 = mkN3 (mkN "Entfernung") von_Prep zu_Prep ; +-- dirty_A = regA "schmutzig" ; +-- do_V2 = dirV2 (irregV "tun" "tut" "tat" "täte" "getan") ; +-- doctor_N = reg2N "Arzt" "Ärzte" masculine ; +-- dog_N = mkN "Hund" ; +-- door_N = reg2N "Tür" "Türen" feminine ; +-- drink_V2 = dirV2 (irregV "trinken" "trinkt" "trank" "tränke" "getrunken") ; +-- easy_A2V = mkA2V (regA "leicht") (mkPrep "für" accusative) ; +-- eat_V2 = dirV2 (irregV "essen" "ißt" "aß" "äße" "gegessen") ; +-- empty_A = regA "leer" ; ---- check infl +-- enemy_N = mkN "Feind" ; +-- factory_N = mkN "Fabrik" "Fabriken" feminine ; +-- father_N2 = mkN2 (reg2N "Vater" "Väter" masculine) von_Prep ; +-- fear_VS = mkVS (regV "fürchten") ; +-- find_V2 = dirV2 (irregV "finden" "findet" "fand" "fände" "gefunden") ; +-- fish_N = mkN "Fisch" ; +-- floor_N = reg2N "Fußboden" "Fußböden" masculine ; +-- forget_V2 = dirV2 (irregV "vergessen" "vergißt" "vergaß" "vergäße" "vergessen") ; +-- fridge_N = reg2N "Kühlschrank" "Kühlschränke" masculine ; +-- friend_N = mkN "Freund" ; +-- fruit_N = reg2N "Frucht" "Früchte" feminine ; +-- fun_AV = mkAV (regA "toll") ; +-- garden_N = reg2N "Garten" "Gärten" masculine ; +-- girl_N = reg2N "Mädchen" "Mädchen" neuter ; +-- glove_N = mkN "Handschuh" ; +-- gold_N = reg2N "Gold" "Golde" neuter ; ---- infl +-- good_A = mk3A "gut" "besser" "beste" ; +-- go_V = seinV (irregV "gehen" "geht" "ging" "ginge" "gegangen") ; +-- green_A = regA "grün" ; +-- harbour_N = reg2N "Hafen" "Häfen" masculine ; +-- hate_V2 = dirV2 (regV "hassen") ; +-- hat_N = reg2N "Hut" "Hüte" masculine ; +-- hear_V2 = dirV2 (regV "hören") ; +-- hill_N = mkN "Hügel" ; +-- hope_VS = mkVS (regV "hoffen") ; +-- horse_N = reg2N "Pferd" "Pferde" neuter ; +-- hot_A = regA "heiß" ; +-- house_N = reg2N "Haus" "Häuser" neuter ; +-- important_A = regA "wichtig" ; +-- industry_N = mkN "Industrie" ; +-- iron_N = reg2N "Eisen" "Eisen" neuter ; +-- jump_V = seinV (irregV "springen" "springt" "sprang" "spränge" "gesprungen") ; +-- king_N = mkN "König" ; +-- know_V2 = dirV2 (irregV "kennen" "kennt" "kannte" "kännte" "gekannt") ; ---- infl +-- know_VS = mkVS (irregV "wissen" "weiß" "wußte" "wüßte" "gewußt") ; ---- infl +-- lake_N = reg2N "See" "Seen" masculine ; --- infl +-- lamp_N = mkN "Lampe"; +-- learn_V2 = dirV2 (regV "lernen") ; +-- leather_N = reg2N "Leder" "Leder" neuter ; +-- leave_V2 = dirV2 (irregV "verlassen" "verläßt" "verließ" "verließe" "verlassen") ; +-- like_V2 = dirV2 (irregV "mögen" "mag" "mochte" "möchte" "gemocht") ; +-- listen_V2 = prepV2 (prefixV "zu" (regV "hören")) datPrep ; ---- dat +-- live_V = regV "leben" ; +-- long_A = mk3A "lang" "länger" "längste" ; +-- lose_V2 = dirV2 (irregV "verlieren" "verliert" "verlor" "verlöre" "verloren") ; +-- love_N = mkN "Liebe" ; +-- love_V2 = dirV2 (regV "lieben") ; +-- man_N = reg2N "Mann" "Männer" masculine ; +-- married_A2 = mkA2 (regA "verheiratet") (mkPrep "mit" dative) ; +-- meat_N = reg2N "Fleisch" "Fleische" neuter ; ---- infl +-- milk_N = reg2N "Milch" "Milche" feminine ; ---- infl +-- moon_N = mkN "Mond" ; +-- mother_N2 = mkN2 (reg2N "Mutter" "Mütter" feminine) von_Prep ; +-- mountain_N = mkN "Berg" ; +-- music_N = reg2N "Musik" "Musiken" feminine ; +-- narrow_A = regA "schmal" ; +-- new_A = regA "neu" ; +-- newspaper_N = mkN "Zeitung" ; +-- now_Adv = mkAdv "jetzt" ; +-- number_N = reg2N "Zahl" "Zahlen" feminine ; +-- oil_N = reg2N "Öl" "Öle" neuter ; +-- old_A = mk3A "alt" "älter" "älteste" ; +-- open_V2 = dirV2 (regV "öffnen") ; +-- paint_V2A = mkV2A (regV "malen") accPrep ; +-- paper_N = reg2N "Papier" "Papiere" neuter ; +-- paris_PN = mkPN "Paris" "Paris" ; +-- peace_N = mk6N "Friede" "Frieden" "Frieden" "Friedens" "Frieden" "Frieden" masculine ; +-- pen_N = mkN "Bleistift" ; ---- +-- planet_N = reg2N "Planet" "Planeten" masculine ; +-- plastic_N = reg2N "Plastik" "Plastiken" feminine ; ---- +-- play_V2 = dirV2 (regV "spielen") ; +-- policeman_N = reg2N "Polizist" "Polizisten" masculine ; +-- priest_N = mkN "Priester" ; +-- probable_AS = mkAS (regA "wahrscheinlich") ; +-- put_V2 = dirV2 (regV "setzen") ; +-- queen_N = reg2N "Königin" "Königinnen" feminine ; +-- radio_N = reg2N "Radio" "Radios" neuter ; ---- +-- rain_V0 = mkV0 (regV "regnen") ; +-- read_V2 = dirV2 (irregV "lesen" "liest" "las" "läse" "gelesen") ; +-- red_A = regA "rot" ; +-- religion_N = mkN "Religion" ; +-- restaurant_N = reg2N "Restaurant" "Restaurants" neuter ; +-- river_N = reg2N "Fluß" "Flüsse" masculine ; +-- rock_N = mkN "Stein" ; +-- roof_N = reg2N "Dach" "Dächer" neuter ; +-- rubber_N = reg2N "Gummi" "Gummis" neuter ; +-- run_V = seinV (irregV "laufen" "läuft" "lief" "liefe" "gelaufen") ; +-- say_VS = mkVS (regV "sagen") ; +-- school_N = mkN "Schule"; +-- science_N = reg2N "Wissenschaft" "Wissenschaften" feminine ; +-- sea_N = reg2N "Meer" "Meere" neuter ; +-- seek_V2 = dirV2 (regV "suchen") ; + see_V2 = mkV2 (mkV "zien" "zag" "gezien") ; +-- sell_V3 = accdatV3 (no_geV (regV "verkaufen")) ; +-- send_V3 = accdatV3 (regV "schicken") ; +-- sheep_N = reg2N "Schaf" "Schafe" neuter ; +-- ship_N = reg2N "Schiff" "Schiffe" neuter ; +-- shirt_N = reg2N "Hemd" "Hemden" neuter ; ---- infl +-- shoe_N = mkN "Schuh" ; +-- shop_N = reg2N "Laden" "Läden" masculine ; +-- short_A = mk3A "kurz" "kürzer" "kürzeste" ; +-- silver_N = reg2N "Silber" "Silber" neuter ; ---- infl +-- sister_N = reg2N "Schwester" "Schwestern" feminine ; + sleep_V = mkV "slapen" "sliep" "geslapen" ; +-- small_A = regA "klein" ; +-- snake_N = mkN "Schlange" ; +-- sock_N = reg2N "Strumpf" "Strümpfe" masculine ; +-- song_N = reg2N "Lied" "Lieder" neuter ; +-- speak_V2 = dirV2 (irregV "sprechen" "spricht" "sprach" "spräche" "gesprochen") ; +-- star_N = mkN "Sterne" ; +-- steel_N = mkN "Stahl" ; +-- stone_N = mkN "Stein" ; +-- stop_V = seinV (irregV "halten" "hält" "hielt" "hielte" "gehalten") ; +-- stove_N = mkN "Herd" ; +-- student_N = reg2N "Student" "Studenten" masculine ; +-- stupid_A = mk3A "dumm" "dümmer" "dümmste" ; ---- +-- sun_N = mkN "Sonne" ; +-- switch8off_V2 = dirV2 (prefixV "aus" (regV "schalten")) ; +-- switch8on_V2 = dirV2 (prefixV "ein" (regV "schalten")) ; +-- table_N = mkN "Tisch" ; +-- talk_V3 = mkV3 (regV "reden") datPrep von_Prep ; +-- teacher_N = reg2N "Lehrer" "Lehrer" masculine ; +-- teach_V2 = dirV2 (no_geV (regV "unterrichten")) ; +-- television_N = reg2N "Fernsehen" "Fernsehen" neuter; +-- thick_A = regA "dick" ; +-- thin_A = regA "dünn" ; +-- train_N = reg2N "Zug" "Züge" masculine ; +-- travel_V = regV "reisen" ; +-- tree_N = reg2N "Baum" "Bäume" masculine ; +-- ---- trousers_N = mkN "trousers" ; ---- pl t ! +-- ugly_A = regA "häßlich" ; +-- understand_V2 = +-- dirV2 (irregV "verstehen" "versteht" "verstand" "verstände" "verstanden") ; +-- university_N = reg2N "Universität" "Universitäten" feminine ; +-- village_N = reg2N "Dorf" "Dörfer" neuter ; +-- wait_V2 = prepV2 (regV "warten") (mkPrep "auf" accusative) ; +-- walk_V = seinV (irregV "gehen" "geht" "ging" "ginge" "gegangen") ; +-- warm_A = mk3A "warm" "wärmer" "wärmste" ; +-- war_N = mkN "Krieg" ; +-- watch_V2 = prepV2 (regV "schauen") (mkPrep "an" accusative) ; +-- water_N = reg2N "Wasser" "Wasser" neuter ; +-- white_A = regA "weiß" ; +-- window_N = reg2N "Fenster" "Fenster" neuter ; +-- wine_N = mkN "Wein" ; +-- win_V2 = dirV2 (irregV "gewinnen" "gewinnt" "gewann" "gewänne" "gewonnen") ; +-- woman_N = reg2N "Frau" "Frauen" feminine ; +-- wonder_VQ = mkVQ (reflV (regV "wundern") accusative) ; +-- wood_N = reg2N "Holz" "Hölzer" neuter ; +-- write_V2 = dirV2 (irregV "schreiben" "schreibt" "schrieb" "schriebe" "geschrieben") ; +-- yellow_A = regA "gelb" ; +-- young_A = mk3A "jung" "jünger" "jüngste" ; +-- left_Ord = Mo.mkOrd (regA "link") ; +-- right_Ord = Mo.mkOrd (regA "recht") ; +-- far_Adv = mkAdv "weit" ; +-- correct_A = regA "richtig" ; +-- dry_A = regA "trocken" ; +-- dull_A = regA "stumpf" ; +-- full_A = regA "voll" ; +-- heavy_A = mkA "schwer" "schwere" "schwerer" "schwerste" ; +-- near_A = mk3A "nahe" "näher" "nächste" ; +-- rotten_A = regA "verdorben" ; +-- round_A = regA "rund" ; +-- sharp_A = mk3A "scharf" "schärfer" "schärfste" ; +-- smooth_A = regA "glatt" ; +-- straight_A = regA "gerade" ; +-- wet_A = regA "naß" ; +-- wide_A = regA "breit" ; +-- animal_N = reg2N "Tier" "Tiere" neuter ; +-- ashes_N = mkN "Asche" ; +-- back_N = reg2N "Rücken" "Rücken" masculine ; +-- bark_N = mkN "Rinde" ; +-- belly_N = reg2N "Bauch" "Bäuche" masculine ; +-- blood_N = mkN "Blut" "Blute" neuter ; +-- bone_N = reg2N "Knochen" "Knochen" masculine ; +-- breast_N = reg2N "Brust" "Brüste" feminine ; +-- cloud_N = mkN "Wolke" ; +-- day_N = mkN "Tag" ; +-- dust_N = reg2N "Staub" "Stäube" masculine ; +-- ear_N = mkN "Ohr" "Ohren" neuter ; +-- earth_N = mkN "Erde" ; +-- egg_N = mkN "Ei" "Eier" neuter ; +-- eye_N = mkN "Auge" "Augen" neuter; +-- fat_N = mkN "Fett" "Fetter" neuter ; +-- feather_N = mkN "Feder" "Federn" feminine ; +-- fingernail_N = reg2N "Fingernagel" "Fingernägel" masculine ; +-- fire_N = mkN "Feuer" "Feuer" neuter ; +-- flower_N = mkN "Blume" ; +-- fog_N = mkN "Nebel" "Nebel" masculine ; +-- foot_N = reg2N "Fuß" "Füße" masculine ; +-- forest_N = reg2N "Wald" "Wälder" masculine ; +-- grass_N = mkN "Gras" "Gräser" neuter ; +-- guts_N = mkN "Eingeweide" ; +-- hair_N = mkN "Haar" "Haare" neuter ; +-- hand_N = mkN "Hand" "Hände" feminine ; +-- head_N = mkN "Kopf" "Köpfe" masculine ; +-- heart_N = mkN "Herz" "Herzen" neuter ; +-- horn_N = mkN "Horn" "Hörner" neuter ; +-- husband_N = mkN "Ehemann" "Ehemänner" masculine ; +-- ice_N = mkN "Eis" "Eise" neuter ; +-- knee_N = mkN "Knie" "Knien" neuter ; +-- leaf_N = reg2N "Blatt" "Blätter" neuter ; +-- leg_N = mkN "Bein" "Beine" neuter ; +-- liver_N = mkN "Leber" "Lebern" feminine ; +-- louse_N = reg2N "Laus" "Läuse" feminine ; +-- mouth_N = mkN "Mund" "Münder" masculine ; +-- name_N = mkN "Name" "Namen" "Namen" "Namens" "Namen" "Namen" masculine ; +-- neck_N = mkN "Nacken" "Nacken" masculine ; +-- night_N = reg2N "Nacht" "Nächte" feminine ; +-- nose_N = mkN "Nase" ; +-- person_N = mkN "Person" "Personen" feminine ; +-- rain_N = mkN "Regen" ; +-- road_N = mkN "Straße" ; +-- root_N = mkN "Wurzel" "Wurzeln" feminine ; +-- rope_N = mkN "Seil" "Seile" neuter ; +-- salt_N = mkN "Salz" "Salze" neuter ; +-- sand_N = mkN "Sand" ; +-- seed_N = mkN "Same" ; +-- skin_N = mkN "Haut" "Häute" feminine ; +-- sky_N = mkN "Himmel" ; ---- pl +-- smoke_N = mkN "Rauch" ; +-- snow_N = mkN "Schnee" "Schneen" masculine ; ---- pl +-- stick_N = mkN "Stock" "Stöcke" masculine ; +-- tail_N = mkN "Schwanz" "Schwänze" masculine ; +-- tongue_N = mkN "Zunge" ; +-- tooth_N = mkN "Zahn" "Zähne" masculine ; +-- wife_N = mkN "Ehefrau" "Ehefrauen" feminine ; +-- wind_N = mkN "Wind" ; +-- wing_N = reg2N "Flügel" "Flügel" masculine ; +-- worm_N = mkN "Wurm" "Würmer" masculine ; +-- year_N = mkN "Jahr" "Jahre" neuter ; +-- blow_V = regV "blasen" ; +-- breathe_V = regV "atmen" ; +-- burn_V = regV "brennen" ; +-- dig_V = regV "graben" ; +-- fall_V = regV "fallen" ; +-- float_V = regV "treiben" ; +-- flow_V = regV "fließen" ; +-- fly_V = regV "fliegen" ; +-- freeze_V = regV "frieren" ; +-- give_V3 = accdatV3 (irregV "geben" "gibt" "gab" "gäbe" "gegeben") ; +-- laugh_V = regV "lachen" ; +-- lie_V = regV "lügen" ; +-- play_V = regV "spielen" ; +-- sew_V = regV "nähen" ; +-- sing_V = regV "singen" ; +-- sit_V = irregV "sitzen" "sitzt" "saß" "säße" "gesessen" ; +-- smell_V = regV "riechen" ; +-- spit_V = regV "spucken" ; +-- stand_V = regV "stehen" ; +-- swell_V = prefixV "an" (regV "schwellen") ; +-- swim_V = regV "schwimmen" ; +-- think_V = regV "denken" ; +-- turn_V = regV "drehen" ; +-- vomit_V = regV "kotzen" ; +-- +-- bite_V2 = dirV2 (irregV "beißen" "beißt" "biss" "bisse" "gebissen") ; +-- count_V2 = dirV2 (regV "zählen") ; +-- cut_V2 = dirV2 (irregV "schneiden" "schneidet" "schnitt" "schnitte" "geschnitten") ; +-- fear_V2 = dirV2 (regV "fürchten") ; +-- fight_V2 = dirV2 (regV "bekämpfen") ; +-- hit_V2 = dirV2 (irregV "schlagen" "schlägt" "schlug" "schlüge" "geschlagen") ; +-- hold_V2 = dirV2 (irregV "halten" "hält" "hielt" "hielte" "gehalten") ; +-- hunt_V2 = dirV2 (regV "jagen") ; +-- kill_V2 = dirV2 (regV "töten") ; +-- pull_V2 = dirV2 (irregV "ziehen" "zieht" "zog" "zöge" "gezogen") ; +-- push_V2 = dirV2 (irregV "schieben" "schiebt" "schub" "schübe" "geschoben") ; +-- rub_V2 = dirV2 (irregV "reiben" "reibt" "rieb" "riebe" "gerieben") ; +-- scratch_V2 = dirV2 (regV "kratzen") ; +-- split_V2 = dirV2 (prefixV "auf" (regV "teilen")) ; +-- squeeze_V2 = dirV2 (regV "pressen") ; +-- stab_V2 = dirV2 (irregV "stechen" "sticht" "stach" "stäche" "gestochen") ; +-- suck_V2 = dirV2 (regV "saugen") ; +-- throw_V2 = dirV2 (irregV "werfen" "wirft" "warf" "würfe" "geworfen") ; +-- tie_V2 = dirV2 (irregV "binden" "bindet" "band" "bände" "gebunden") ; +-- wash_V2 = dirV2 (irregV "waschen" "wäscht" "wusch" "wüsche" "gewaschen") ; +-- wipe_V2 = dirV2 (regV "wischen") ; +-- +-- grammar_N = reg2N "Grammatik" "Grammatiken" feminine ; +-- language_N = mkN "Sprache" ; +-- rule_N = reg2N "Regel" "Regeln" feminine ; +-- +-- john_PN = regPN "Johann" ; +-- question_N = mkN "Frage" ; +-- ready_A = regA "fertig" ; +-- reason_N = reg2N "Grund" "Gründe" masculine ; +-- today_Adv = mkAdv "heute" ; +-- uncertain_A = regA "unsicher" ; +-- +-- +--} ; + +} diff --git a/lib/src/dutch/MakeStructuralDut.gf b/lib/src/dutch/MakeStructuralDut.gf new file mode 100644 index 000000000..f96271aa2 --- /dev/null +++ b/lib/src/dutch/MakeStructuralDut.gf @@ -0,0 +1,17 @@ +--# -path=.:../common:../abstract + +resource MakeStructuralDut = open CatDut, ParadigmsDut, MorphoDut, Prelude in +{ +--{ +-- +--oper +-- mkConj : Str -> Str -> Number -> Conj = \x,y,n -> +-- {s1 = x ; s2 = y ; n = n ; lock_Conj = <>} ; +-- mkSubj : Str -> Subj = \x -> +-- {s = x ; lock_Subj = <>} ; +-- mkIQuant : Str -> IQuant = \s -> +-- {s = \\_,_,_ => s ; lock_IQuant = <>} ; +-- +--} + +} diff --git a/lib/src/dutch/MorphoDut.gf b/lib/src/dutch/MorphoDut.gf new file mode 100644 index 000000000..cf0becf89 --- /dev/null +++ b/lib/src/dutch/MorphoDut.gf @@ -0,0 +1,100 @@ +--# -path=.:../common:../../prelude +-- +----1 A Simple Dutman Resource Morphology +---- +---- Aarne Ranta & Harald Hammarström 2002 -- 2006 +---- +---- This resource morphology contains definitions needed in the resource +---- syntax. To build a lexicon, it is better to use $ParadigmsDut$, which +---- gives a higher-level access to this module. +-- +resource MorphoDut = ResDut ** open Prelude, (Predef=Predef) in +{ +--{ +-- +-- flags optimize=all ; +-- +--oper +-- +---- For $StructuralDut$. +-- +-- mkPrep : Str -> Case -> Preposition = \s,c -> +-- {s = s ; c = c} ; +-- +-- nameNounPhrase : {s : Case => Str} -> {s : Case => Str ; a : Agr} = \name -> +-- name ** {a = agrP3 Sg} ; +-- +-- detLikeAdj : Number -> Str -> +-- {s,sp : Gender => Case => Str ; n : Number ; a : Adjf} = \n,dies -> +-- {s,sp = appAdj (regA dies) ! n ; n = n ; a = Weak} ; +-- +-- mkOrd : {s : Degree => AForm => Str} -> {s : AForm => Str} = \a -> +-- {s = a.s ! Posit} ; +-- +---- For $ParadigmsDut$. +-- +-- genitS : Str -> Str = \hund -> case hund of { +-- _ + ("el" | "en" | "er") => hund + "s" ; +-- _ + ("s" | "ß" | "sch" | "st" | "x" | "z") => hund + "es" ; +-- _ => hund + variants {"s" ; "es"} +-- } ; +-- pluralN : Str -> Str = \hund -> case hund of { +-- _ + ("el" | "er" | "e") => hund + "n" ; +-- _ + "en" => hund ; +-- _ => hund + "en" +-- } ; +-- dativE : Str -> Str = \hund -> case hund of { +-- _ + ("el" | "en" | "er" | "e") => hund ; +-- _ => variants {hund ; hund + "e"} +-- } ; +-- +---- Duden, p. 119 +-- +-- verbT : Str -> Str = \v -> case v of { +-- _ + ("t" | "d") => v + "et" ; -- gründen, reden, betten +-- _ + ("ch" | "k" | "p" | "t" | "g" | "b" | "d" | "f" | "s") + +-- ("m" | "n") => v + "et" ; -- atmen, widmen, öffnen, rechnen +-- _ => v + "t" -- lernen, lärmen, qualmen etc +-- } ; +-- +-- verbST : Str -> Str = \v -> case v of { +-- _ + ("s" | "ss" | "ß" | "sch" | "x" | "z") => v + "t" ; +-- _ => v + "st" +-- } ; +-- +-- stemVerb : Str -> Str = \v -> case v of { +-- _ + ("rn" | "ln") => init v ; +-- _ => Predef.tk 2 v +-- } ; +-- +---- For $Numeral$. +-- +-- LinDigit = {s : DForm => CardOrd => Str} ; +-- +-- cardOrd : Str -> Str -> CardOrd => Str = \drei,dritte -> +-- table { +-- NCard _ _ => drei ; +-- NOrd a => (regA (init dritte)).s ! Posit ! a +-- } ; +-- +-- cardReg : Str -> CardOrd => Str = \zehn -> +-- cardOrd zehn (zehn + "te") ; +-- +-- mkDigit : (x1,_,_,x4 : Str) -> LinDigit = +-- \drei,dreizehn,dreissig,dritte -> +-- {s = table { +-- DUnit => cardOrd drei dritte ; +-- DTeen => cardReg dreizehn ; +-- DTen => cardOrd dreissig (dreissig + "ste") +-- } +-- } ; +-- +-- regDigit : Str -> LinDigit = \vier -> +-- mkDigit vier (vier + "zehn") (vier + "zig") (vier + "te") ; +-- +-- invNum : CardOrd = NCard Masc Nom ; +-- +--} ; +-- + +} diff --git a/lib/src/dutch/NounDut.gf b/lib/src/dutch/NounDut.gf new file mode 100644 index 000000000..fbd7f2c13 --- /dev/null +++ b/lib/src/dutch/NounDut.gf @@ -0,0 +1,183 @@ +concrete NounDut of Noun = CatDut ** open ResDut, Prelude in { + + flags optimize=all_subs ; + + lin +-- DetCN det cn = { +-- s = \\c => det.s ! cn.g ! c ++ cn.s ! adjfCase det.a c ! det.n ! c ; +-- a = agrP3 det.n ; +-- isPron = False +-- } ; +-- +-- DetNP det = { +-- s = \\c => det.sp ! Neutr ! c ; ---- genders +-- a = agrP3 det.n ; +-- isPron = False +-- } ; +-- +-- UsePN pn = pn ** {a = agrP3 Sg} ; + + UsePron pron = { + s = table {NPNom => pron.unstressed.nom ; NPAcc => pron.unstressed.acc} ; + a = pron.a + } ; + +-- PredetNP pred np = { +-- s = \\c0 => +-- let c = case pred.c of {NoCase => c0 ; PredCase k => k} in +-- pred.s ! np.a.n ! Masc ! c0 ++ np.s ! c ; ---- g +-- a = np.a +-- } ; +-- +-- PPartNP np v2 = { +-- s = \\c => np.s ! c ++ v2.s ! VPastPart APred ; --- invar part +-- a = np.a +-- } ; +-- +-- AdvNP np adv = { +-- s = \\c => np.s ! c ++ adv.s ; +-- a = np.a +-- } ; +-- +-- DetQuantOrd quant num ord = +-- let +-- n = num.n ; +-- a = quant.a +-- in { +-- s = \\g,c => quant.s ! num.isNum ! n ! g ! c ++ +-- num.s!g!c ++ ord.s ! agrAdj g (adjfCase a c) n c ; +-- sp = \\g,c => quant.sp ! n ! g ! c ++ +-- num.s!g!c ++ ord.s ! agrAdj g (adjfCase a c) n c ; +-- n = n ; +-- a = a +-- } ; +-- +-- DetQuant quant num = +-- let +-- n = num.n ; +-- a = quant.a +-- in { +-- s = \\g,c => quant.s ! num.isNum ! n ! g ! c ++ num.s!g!c ; +-- sp = \\g,c => quant.sp ! n ! g ! c ++ num.s!g!c ; +-- n = n ; +-- a = a +-- } ; +-- +-- +-- PossPron p = { +-- s = \\_,n,g,c => p.s ! NPPoss (gennum g n) c ; +-- sp = \\n,g,c => p.s ! NPPoss (gennum g n) c ; +-- a = Strong --- need separately weak for Pl ? +-- } ; +-- +-- NumCard n = n ** {isNum = True} ; +-- +-- NumPl = {s = \\g,c => []; n = Pl ; isNum = False} ; +-- NumSg = {s = \\g,c => []; n = Sg ; isNum = False} ; +-- +-- NumDigits numeral = {s = \\g,c => numeral.s ! NCard g c; n = numeral.n } ; +-- OrdDigits numeral = {s = \\af => numeral.s ! NOrd af} ; +-- +-- NumNumeral numeral = {s = \\g,c => numeral.s ! NCard g c; n = numeral.n } ; +-- OrdNumeral numeral = {s = \\af => numeral.s ! NOrd af} ; +-- +-- AdNum adn num = {s = \\g,c => adn.s ++ num.s!g!c; n = num.n } ; +-- +-- OrdSuperl a = {s = a.s ! Superl} ; +-- +-- DefArt = { +-- s = \\_,n,g,c => artDef ! gennum g n ! c ; +-- sp = \\n,g,c => artDef ! gennum g n ! c ; ---- deren, denem... +-- a = Weak +-- } ; +-- +-- IndefArt = { +-- s = table { +-- True => \\_,_,_ => [] ; +-- False => table { +-- Sg => \\g,c => "ein" + pronEnding ! GSg g ! c ; +-- Pl => \\_,_ => [] +-- } +-- } ; +-- sp = table { +-- Sg => \\g,c => "ein" + pronEnding ! GSg g ! c ; +-- Pl => \\_ => caselist "einige" "einige" "einigen" "einiger" +-- } ; +-- a = Strong +-- } ; +-- +-- MassNP cn = { +-- s = \\c => cn.s ! adjfCase Strong c ! Sg ! c ; +-- a = agrP3 Sg ; +-- isPron = False +-- } ; +-- +-- UseN, UseN2 = \n -> { +-- s = \\_ => n.s ; +-- g = n.g +-- } ; +-- +-- ComplN2 f x = { +-- s = \\_,n,c => f.s ! n ! c ++ appPrep f.c2 x.s ; +-- g = f.g +-- } ; +-- +-- ComplN3 f x = { +-- s = \\n,c => f.s ! n ! c ++ appPrep f.c2 x.s ; +-- g = f.g ; +-- c2 = f.c3 +-- } ; +-- +-- Use2N3 f = { +-- s = f.s ; +-- g = f.g ; +-- c2 = f.c2 +-- } ; +-- +-- Use3N3 f = { +-- s = f.s ; +-- g = f.g ; +-- c2 = f.c3 +-- } ; +-- +-- AdjCN ap cn = +-- let +-- g = cn.g +-- in { +-- s = \\a,n,c => +-- preOrPost ap.isPre +-- (ap.s ! agrAdj g a n c) +-- (cn.s ! a ! n ! c) ; +-- g = g +-- } ; +-- +-- RelCN cn rs = { +-- s = \\a,n,c => cn.s ! a ! n ! c ++ rs.s ! gennum cn.g n ; +-- g = cn.g +-- } ; +-- +-- RelNP np rs = { +-- s = \\c => np.s ! c ++ "," ++ rs.s ! gennum np.a.g np.a.n ; +-- a = np.a ; +-- isPron = False +-- } ; +-- +-- SentCN cn s = { +-- s = \\a,n,c => cn.s ! a ! n ! c ++ s.s ; +-- g = cn.g +-- } ; +-- +-- AdvCN cn s = { +-- s = \\a,n,c => cn.s ! a ! n ! c ++ s.s ; +-- g = cn.g +-- } ; +-- +-- ApposCN cn np = let g = cn.g in { +-- s = \\a,n,c => cn.s ! a ! n ! c ++ np.s ! c ; +-- g = g ; +-- isMod = cn.isMod +-- } ; +-- +--} + +} diff --git a/lib/src/dutch/NumeralDut.gf b/lib/src/dutch/NumeralDut.gf new file mode 100644 index 000000000..0b7891d15 --- /dev/null +++ b/lib/src/dutch/NumeralDut.gf @@ -0,0 +1,90 @@ +concrete NumeralDut of Numeral = CatDut ** open MorphoDut in +{ +--{ +-- +--flags optimize = all_subs ; +-- +--lincat +-- Digit = {s : DForm => CardOrd => Str} ; +-- Sub10 = {s : DForm => CardOrd => Str ; n : Number} ; +-- Sub100, Sub1000, Sub1000000 = +-- {s : CardOrd => Str ; n : Number} ; +-- +--lin +-- num x = x ; +-- +-- n2 = mkDigit "zwei" "zwölf" "zwanzig" "zweite" ; +-- n3 = mkDigit "drei" "dreizehn" "dreissig" "dritte" ; +-- n4 = regDigit "vier" ; +-- n5 = regDigit "fünf" ; +-- n6 = regDigit "sechs" ; +-- n7 = mkDigit "sieben" "siebzehn" "siebzig" "siebte" ; +-- n8 = mkDigit "acht" "achzehn" "achzig" "achte" ; +-- n9 = regDigit "neun" ; +-- +-- pot01 = { +-- s = \\f => table { +-- NCard g c => "ein" + pronEnding ! GSg g ! c ; +-- NOrd af => (regA "erst").s ! Posit ! af +-- } ; +-- n = Sg +-- } ; +-- pot0 d = {s = \\f,g => d.s ! f ! g ; n = Pl} ; +-- pot110 = {s = cardReg "zehn"; n = Pl} ; +-- pot111 = {s = cardReg "elf"; n = Pl} ; +-- pot1to19 d = {s = d.s ! DTeen; n = Pl} ; +-- pot0as1 n = {s = n.s ! DUnit; n = n.n } ; +-- pot1 d = {s = d.s ! DTen; n = Pl} ; +-- pot1plus d e = {s = \\g => e.s ! DUnit ! invNum ++ "und" ++ d.s ! DTen ! g; n = Pl} ; +-- pot1as2 n = n ; +-- pot2 d = +-- {s = \\g => d.s ! DUnit ! invNum ++ cardOrd "hundert" "hunderte" ! g ; n = Pl} ; +-- pot2plus d e = +-- {s = \\g => d.s ! DUnit ! invNum ++ "hundert" ++ e.s ! g ; n = Pl} ; +-- pot2as3 n = n ; +-- pot3 n = +-- {s = \\g => n.s ! invNum ++ cardOrd "tausend" "tausendte" ! g ; n = Pl} ; ---- +-- pot3plus n m = +-- {s = \\g => n.s ! invNum ++ "tausend" ++ m.s ! g ; n = Pl} ; +-- +-- +-- lincat +-- Dig = TDigit ; +-- +-- lin +-- IDig d = d ; +-- +-- IIDig d i = { +-- s = \\o => d.s ! invNum ++ i.s ! o ; +-- n = Pl +-- } ; +-- +-- ---- TODO: case endings of ordinals +-- D_0 = mkDig "0" ; +-- D_1 = mk3Dig "1" "1e" Sg ; +-- D_2 = mk2Dig "2" "2e" ; +-- D_3 = mkDig "3" ; +-- D_4 = mkDig "4" ; +-- D_5 = mkDig "5" ; +-- D_6 = mkDig "6" ; +-- D_7 = mkDig "7" ; +-- D_8 = mkDig "8" ; +-- D_9 = mkDig "9" ; +-- +-- oper +-- mk2Dig : Str -> Str -> TDigit = \c,o -> mk3Dig c o Pl ; +-- mkDig : Str -> TDigit = \c -> mk2Dig c (c + "e") ; +-- +-- mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> { +-- s = table {NCard _ _ => c ; NOrd _ => o} ; +-- n = n +-- } ; +-- +-- TDigit = { +-- n : Number ; +-- s : CardOrd => Str +-- } ; +-- +--} + +} diff --git a/lib/src/dutch/ParadigmsDut.gf b/lib/src/dutch/ParadigmsDut.gf new file mode 100644 index 000000000..7e710ffaf --- /dev/null +++ b/lib/src/dutch/ParadigmsDut.gf @@ -0,0 +1,461 @@ +--# -path=.:../common:../abstract:../../prelude + +--1 Dutch Lexical Paradigms +-- +-- Aarne Ranta 2009 +-- +-- This is an API for the user of the resource grammar +-- for adding lexical items. It gives functions for forming +-- expressions of open categories: nouns, adjectives, verbs. +-- +-- Closed categories (determiners, pronouns, conjunctions) are +-- accessed through the resource syntax API, $Structural.gf$. +-- +-- The structure of functions for each word class $C$ is the following: +-- first we give a handful of patterns that aim to cover all +-- cases, from the most regular (with just one argument) to the worst. +-- The name of this function is $mkC$. +-- +-- There is also a module [``IrregDut`` IrregDut.gf] +-- which covers irregular verbs. + + +resource ParadigmsDut = open + (Predef=Predef), + Prelude, + MorphoDut, + CatDut + in +{ +--2 Parameters + +-- To abstract over gender names, we define the following identifiers. + +oper + masculine : Gender ; + feminine : Gender ; + neuter : Gender ; + utrum : Gender ; + + masculine = Utr ; + feminine = Utr ; + neuter = Neutr ; + utrum = Utr ; + +--2 Nouns + + mkN : overload { + mkN : (muis : Str) -> N ; + mkN : (bit : Str) -> Gender -> N ; + mkN : (gat,gaten : Str) -> Gender -> N ; + } ; + mkN = overload { + mkN : (muis : Str) -> N = \a -> lin N (regNoun a) ; + mkN : (bit : Str) -> Gender -> N = \a,b -> lin N (regNounG a b) ; + mkN : (gat,gaten : Str) -> Gender -> N = \a,b,c -> lin N (mkNoun a b c) ; + } ; + +-- +-- +---- Relational nouns need a preposition. The most common is "von" with +---- the dative, and there is a special case for regular nouns. +-- +-- mkN2 : overload { +-- mkN2 : Str -> N2 ; +-- mkN2 : N -> N2 ; +-- mkN2 : N -> Prep -> N2 +-- } ; +-- +---- Use the function $mkPrep$ or see the section on prepositions below to +---- form other prepositions. +---- Some prepositions are moreover constructed in [StructuralDut StructuralDut.html]. +---- +---- Three-place relational nouns ("die Verbindung von x nach y") need two prepositions. +-- +-- mkN3 : N -> Prep -> Prep -> N3 ; +-- +-- +----3 Proper names and noun phrases +---- +---- Proper names, with an "s" genitive and other cases like the +---- nominative, are formed from a string. Final "s" ("Johannes-Johannes") is +---- taken into account. +-- +-- mkPN : overload { +-- mkPN : Str -> PN ; +-- +---- If only the genitive differs, two strings are needed. +-- +-- mkPN : (nom,gen : Str) -> PN ; +-- +---- In the worst case, all four forms are needed. +-- +-- mkPN : (nom,acc,dat,gen : Str) -> PN +-- } ; + +--2 Adjectives + + mkA : overload { + mkA : (vers : Str) -> A ; + mkA : (goed,goede,goeds,beter,best : Str) -> A ; + } ; + + mkA = overload { + mkA : (vers : Str) -> A = \a -> lin A (regAdjective a) ; + mkA : (goed,goede,goeds,beter,best : Str) -> A = \a,b,c,d,e -> lin A (mkAdjective a b c d e) ; + } ; + +---- Invariable adjective are a special case. +-- +-- invarA : Str -> A ; -- prima +-- +---- Two-place adjectives are formed by adding a preposition to an adjective. +-- +-- mkA2 : A -> Prep -> A2 ; +-- +----2 Adverbs +-- +---- Adverbs are formed from strings. +-- +-- mkAdv : Str -> Adv ; +-- +-- + +--2 Prepositions + +-- A preposition is formed from a string. + + mkPrep : Str -> Prep ; + mkPrep s = lin Prep (ss s) ; + +---- A couple of common prepositions (always with the dative). +-- +-- von_Prep : Prep ; +-- zu_Prep : Prep ; +-- +--2 Verbs + + mkV : overload { + mkV : (aaien : Str) -> V ; + mkV : (aai,aait,aaien,aaide,aaide,aaiden,geaaid : Str) -> V ; + +---- To add a movable suffix e.g. "auf(fassen)". +-- +-- mkV : Str -> V -> V + } ; + + mkV = overload { + mkV : (aaien : Str) -> V = + \s -> lin V (regVerb s ** {aux = VHebben}) ; + mkV : (breken,brak,gebroken : Str) -> V = + \a,b,c -> lin V (irregVerb a b c ** {aux = VHebben}) ; + mkV : (aai,aait,aaien,aaide,aaiden,geaaid : Str) -> V = + \a,b,c,d,f,g -> lin V (mkVerb a b c d d f g ** {aux = VHebben}) ; + } ; + + zijnV : V -> V ; + zijnV v = lin V {s = v.s ; aux = VZijn} ; + +---- Reflexive verbs can take reflexive pronouns of different cases. +-- +-- reflV : V -> Case -> V ; +-- +-- +----3 Two-place verbs + + mkV2 : overload { + mkV2 : Str -> V2 ; + mkV2 : V -> V2 ; + mkV2 : V -> Prep -> V2 ; + } ; + + mkV2 = overload { + mkV2 : Str -> V2 = \s -> lin V2 (regVerb s ** {aux = VHebben ; c2 = []}) ; + mkV2 : V -> V2 = \s -> lin V2 (s ** {c2 = []}) ; + mkV2 : V -> Prep -> V2 = \s,p -> lin V2 (s ** {c2 = p.s}) ; + } ; + + +-- +-- +----3 Three-place verbs +---- +---- Three-place (ditransitive) verbs need two prepositions, of which +---- the first one or both can be absent. +-- +-- mkV3 : V -> Prep -> Prep -> V3 ; -- sprechen, mit, über +-- dirV3 : V -> Prep -> V3 ; -- senden,(accusative),nach +-- accdatV3 : V -> V3 ; -- give,accusative,dative +-- +----3 Other complement patterns +---- +---- Verbs and adjectives can take complements such as sentences, +---- questions, verb phrases, and adjectives. +-- +-- mkV0 : V -> V0 ; +-- mkVS : V -> VS ; +-- mkV2S : V -> Prep -> V2S ; +-- mkVV : V -> VV ; +-- mkV2V : V -> Prep -> V2V ; +-- mkVA : V -> VA ; +-- mkV2A : V -> Prep -> V2A ; +-- mkVQ : V -> VQ ; +-- mkV2Q : V -> Prep -> V2Q ; +-- +-- mkAS : A -> AS ; +-- mkA2S : A -> Prep -> A2S ; +-- mkAV : A -> AV ; +-- mkA2V : A -> Prep -> A2V ; +-- +---- Notice: categories $AS, A2S, AV, A2V$ are just $A$, +---- and the second argument is given as an adverb. Likewise +---- $V0$ is just $V$. +-- +-- V0 : Type ; +-- AS, A2S, AV, A2V : Type ; +-- +-- +----. +----2 Definitions of paradigms +---- +---- The definitions should not bother the user of the API. So they are +---- hidden from the document. +-- +-- +-- +-- Gender = MorphoDut.Gender ; +-- Case = MorphoDut.Case ; +-- Number = MorphoDut.Number ; +-- masculine = Masc ; +-- feminine = Fem ; +-- neuter = Neutr ; +-- nominative = Nom ; +-- accusative = Acc ; +-- dative = Dat ; +-- genitive = Gen ; +-- singular = Sg ; +-- plural = Pl ; +-- +-- mk6N a b c d e f g = MorphoDut.mkN a b c d e f g ** {lock_N = <>} ; +-- +-- regN : Str -> N = \hund -> case hund of { +-- _ + "e" => mk6N hund hund hund hund (hund + "n") (hund + "n") Fem ; +-- _ + ("ion" | "ung") => mk6N hund hund hund hund (hund + "en") (hund + "en") Fem ; +-- _ + ("er" | "en" | "el") => mk6N hund hund hund (genitS hund) hund (pluralN hund) Masc ; +-- _ => mk6N hund hund hund (genitS hund) (hund + "e") (pluralN hund) Masc +-- } ; +-- +-- reg2N : (x1,x2 : Str) -> Gender -> N = \hund,hunde,g -> +-- let +-- hunds = genitS hund ; +-- hundE = dativE hund ; +-- hunden = pluralN hunde +-- in +-- case of { -- Duden p. 223 +-- <_,_ + ("e" | "er"), Masc | Neutr> => -- I,IV +-- mk6N hund hund hundE hunds hunde hunden g ; +-- <_ + ("el"|"er"|"en"),_ + ("el"|"er"|"en"), Masc | Neutr> => -- II +-- mk6N hund hund hund hunds hunde hunden g ; +-- <_,_ + "s", Masc | Neutr> => -- V +-- mk6N hund hund hund (hund + "s") hunde hunde g ; +-- <_,_ + "en", Masc> => -- VI +-- mk6N hund hunde hunde hunde hunde hunde g ; +-- <_,_ + ("e" | "er"), Fem> => -- VII,VIII +-- mk6N hund hund hund hund hunde hunden g ; +-- <_,_ + ("n" | "s"), Fem> => -- IX,X +-- mk6N hund hund hund hund hunde hunde g ; +-- _ => {s = (regN hund).s ; g = g ; lock_N = <>} +-- } ; +-- +-- mkN2 = overload { +-- mkN2 : Str -> N2 = \s -> vonN2 (regN s) ; +-- mkN2 : N -> N2 = vonN2 ; +-- mkN2 : N -> Prep -> N2 = mmkN2 +-- } ; +-- +-- +-- mmkN2 : N -> Prep -> N2 = \n,p -> n ** {c2 = p ; lock_N2 = <>} ; +-- vonN2 : N -> N2 = \n -> n ** {c2 = {s = "von" ; c = dative} ; lock_N2 = <>} ; +-- +-- mkN3 = \n,p,q -> n ** {c2 = p ; c3 = q ; lock_N3 = <>} ; +-- +-- mk2PN = \karolus, karoli -> +-- {s = table {Gen => karoli ; _ => karolus} ; lock_PN = <>} ; +-- regPN = \horst -> +-- mk2PN horst (ifTok Tok (Predef.dp 1 horst) "s" horst (horst + "s")) ; +-- +-- mkPN = overload { +-- mkPN : Str -> PN = regPN ; +-- mkPN : (nom,gen : Str) -> PN = mk2PN ; +-- mkPN : (nom,acc,dat,gen : Str) -> PN = \nom,acc,dat,gen -> +-- {s = table {Nom => nom ; Acc => acc ; Dat => dat ; Gen => gen} ; lock_PN = <>} +-- } ; +-- +-- mk2PN : (karolus, karoli : Str) -> PN ; -- karolus, karoli +-- regPN : (Johann : Str) -> PN ; +-- -- Johann, Johanns ; Johannes, Johannes +-- +-- +-- mk3A : (gut,besser,beste : Str) -> A = \a,b,c -> +-- let aa : Str = case a of { +-- teu + "er" => teu + "r" ; +-- mud + "e" => mud ; +-- _ => a +-- } in +-- MorphoDut.mkA a aa b (init c) ** {lock_A = <>} ; +-- mk4A : (gut,gute,besser,beste : Str) -> A = \a,aa,b,c -> +-- MorphoDut.mkA a aa b (init c) ** {lock_A = <>} ; +-- +-- regA : Str -> A = \a -> case a of { +-- teu + "er" => mk3A a (teu + "rer") (teu + "reste") ; +-- _ + "e" => mk3A a (a + "r") (a + "ste") ; +-- _ => mk3A a (a + "er") (a + "este") +-- } ; +-- +-- invarA = \s -> {s = \\_,_ => s ; lock_A = <>} ; ---- comparison +-- +-- mkA2 = \a,p -> a ** {c2 = p ; lock_A2 = <>} ; +-- +-- mkAdv s = {s = s ; lock_Adv = <>} ; +-- +-- mkPrep s c = {s = s ; c = c ; lock_Prep = <>} ; +-- accPrep = mkPrep [] accusative ; +-- datPrep = mkPrep [] dative ; +-- genPrep = mkPrep [] genitive ; +-- von_Prep = mkPrep "von" dative ; +-- zu_Prep = mkPrep "zu" dative ; +-- +-- mk6V geben gibt gib gab gaebe gegeben = +-- let +-- geb = stemVerb geben ; +-- gebe = geb + "e" ; +-- gibst = verbST (init gibt) ; +-- gebt = verbT geb ; +-- gabst = verbST gab ; +-- gaben = pluralN gab ; +-- gabt = verbT gab +-- in +-- MorphoDut.mkV +-- geben gebe gibst gibt gebt gib gab gabst gaben gabt gaebe gegeben +-- [] VHaben ** {lock_V = <>} ; +-- +-- regV fragen = +-- let +-- frag = stemVerb fragen ; +-- fragt = verbT frag ; +-- fragte = fragt + "e" ; +-- gefragt = "ge" + fragt ; +-- in +-- mk6V fragen fragt (frag + "e") fragte fragte gefragt ; +-- +-- irregV singen singt sang saenge gesungen = +-- let +-- sing = stemVerb singen ; +-- in +-- mk6V singen singt sing sang saenge gesungen ; +-- +-- prefixV p v = MorphoDut.prefixV p v ** {lock_V = v.lock_V} ; +-- +-- habenV v = +-- {s = v.s ; prefix = v.prefix ; lock_V = v.lock_V ; aux = VHaben ; vtype = v.vtype} ; +-- seinV v = +-- {s = v.s ; prefix = v.prefix ; lock_V = v.lock_V ; aux = VSein ; vtype = v.vtype} ; +-- reflV v c = +-- {s = v.s ; prefix = v.prefix ; lock_V = v.lock_V ; aux = VHaben ; vtype = VRefl c} ; +-- +-- no_geV v = let vs = v.s in { +-- s = table { +-- p@(VPastPart _) => Predef.drop 2 (vs ! p) ; +-- p => vs ! p +-- } ; +-- prefix = v.prefix ; lock_V = v.lock_V ; aux = v.aux ; vtype = v.vtype +-- } ; +-- +-- haben_V = MorphoDut.haben_V ** {lock_V = <>} ; +-- sein_V = MorphoDut.sein_V ** {lock_V = <>} ; +-- werden_V = MorphoDut.werden_V ** {lock_V = <>} ; +-- +-- prepV2 v c = v ** {c2 = c ; lock_V2 = <>} ; +-- dirV2 v = prepV2 v (mkPrep [] accusative) ; +-- datV2 v = prepV2 v (mkPrep [] dative) ; +-- +-- mkV3 v c d = v ** {c2 = c ; c3 = d ; lock_V3 = <>} ; +-- dirV3 v p = mkV3 v (mkPrep [] accusative) p ; +-- accdatV3 v = dirV3 v (mkPrep [] dative) ; +-- +-- mkVS v = v ** {lock_VS = <>} ; +-- mkVQ v = v ** {lock_VQ = <>} ; +-- mkVV v = v ** {isAux = False ; lock_VV = <>} ; +-- +-- V0 : Type = V ; +---- V2S, V2V, V2Q : Type = V2 ; +-- AS, A2S, AV : Type = A ; +-- A2V : Type = A2 ; +-- +-- mkV0 v = v ** {lock_V = <>} ; +-- mkV2S v p = prepV2 v p ** {lock_V2S = <>} ; +-- mkV2V v p = prepV2 v p ** {isAux = False ; lock_V2V = <>} ; +-- mkVA v = v ** {lock_VA = <>} ; +-- mkV2A v p = prepV2 v p ** {lock_V2A = <>} ; +-- mkV2Q v p = prepV2 v p ** {lock_V2Q = <>} ; +-- +-- mkAS v = v ** {lock_A = <>} ; +-- mkA2S v p = mkA2 v p ** {lock_A = <>} ; +-- mkAV v = v ** {lock_A = <>} ; +-- mkA2V v p = mkA2 v p ** {lock_A2 = <>} ; +-- +---- pre-overload API and overload definitions +-- +-- regN : Str -> N ; +-- reg2N : (x1,x2 : Str) -> Gender -> N ; +-- mk6N : (x1,_,_,_,_,x6 : Str) -> Gender -> N ; +-- +-- mkN = overload { +-- mkN : Str -> N = regN ; +-- mkN : (x1,x2 : Str) -> Gender -> N = reg2N ; +-- mkN : (x1,_,_,_,_,x6 : Str) -> Gender -> N = mk6N +-- }; +-- +-- +-- +-- regA : Str -> A ; +-- mk3A : (gut,besser,beste : Str) -> A ; +-- +-- mkA = overload { +-- mkA : Str -> A = regA ; +-- mkA : (gut,besser,beste : Str) -> A = mk3A ; +-- mkA : (gut,gute,besser,beste : Str) -> A = mk4A +-- }; +-- +-- +-- +-- regV : Str -> V ; +-- irregV : (x1,_,_,_,x5 : Str) -> V ; +-- mk6V : (x1,_,_,_,_,x6 : Str) -> V ; +-- +-- prefixV : Str -> V -> V ; +-- +-- mkV = overload { +-- mkV : Str -> V = regV ; +-- mkV : (x1,_,_,_,x5 : Str) -> V = irregV ; +-- mkV : (x1,_,_,_,_,x6 : Str) -> V = mk6V ; +-- mkV : Str -> V -> V = prefixV +-- }; +-- +-- +-- prepV2 : V -> Prep -> V2 ; +-- +-- dirV2 : V -> V2 ; +-- +-- datV2 : V -> V2 ; +-- +-- mkV2 = overload { +-- mkV2 : Str -> V2 = \s -> dirV2 (regV s) ; +-- mkV2 : V -> V2 = dirV2 ; +-- mkV2 : V -> Prep -> V2 = prepV2; +-- mkV2 : V -> Case -> V2 = \v,c -> prepV2 v (mkPrep [] c) +-- } ; +-- +--} + +} diff --git a/lib/src/dutch/PhraseDut.gf b/lib/src/dutch/PhraseDut.gf new file mode 100644 index 000000000..aa1900285 --- /dev/null +++ b/lib/src/dutch/PhraseDut.gf @@ -0,0 +1,30 @@ +concrete PhraseDut of Phrase = CatDut ** open Prelude, ResDut in +{ + + + flags optimize=all_subs ; + + lin + PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; + + UttS s = {s = s.s ! Main} ; + UttQS qs = {s = qs.s ! QDir} ; +-- UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg False} ; +-- UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False} ; +-- UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True} ; +-- +-- UttIP ip = {s = ip.s ! Nom} ; --- Acc also +-- UttIAdv iadv = iadv ; +-- UttNP np = {s = np.s ! Nom} ; +-- UttVP vp = {s = useInfVP True vp} ; -- without zu +-- UttAdv adv = adv ; +-- + NoPConj = {s = []} ; +-- PConjConj conj = ss (conj.s2) ; +-- + NoVoc = {s = []} ; +-- VocNP np = {s = "," ++ np.s ! Nom} ; +-- +--} + +} diff --git a/lib/src/dutch/QuestionDut.gf b/lib/src/dutch/QuestionDut.gf new file mode 100644 index 000000000..a0bde36e9 --- /dev/null +++ b/lib/src/dutch/QuestionDut.gf @@ -0,0 +1,105 @@ +concrete QuestionDut of Question = CatDut ** open ResDut in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- QuestCl cl = { +-- s = \\m,t,a,p => +-- let cls = cl.s ! m ! t ! a ! p +-- in table { +-- QDir => cls ! Inv ; +-- QIndir => "ob" ++ cls ! Sub +-- } +-- } ; +-- +-- QuestVP qp vp = { +-- s = \\m,t,a,b,q => +-- let +-- cl = (mkClause (qp.s ! Nom) (agrP3 qp.n) vp).s ! m ! t ! a ! b +-- in +-- case q of { +-- QIndir => cl ! Sub ; +-- _ => cl ! Main +-- } +-- } ; +-- +-- QuestSlash ip slash = { +-- s = \\m,t,a,p => +-- let +-- cls = slash.s ! m ! t ! a ! p ; +-- who = appPrep slash.c2 ip.s +-- in table { +-- QDir => who ++ cls ! Inv ; +-- QIndir => who ++ cls ! Sub +-- } +-- } ; +-- +-- QuestIAdv iadv cl = { +-- s = \\m,t,a,p => +-- let +-- cls = cl.s ! m ! t ! a ! p ; +-- why = iadv.s +-- in table { +-- QDir => why ++ cls ! Inv ; +-- QIndir => why ++ cls ! Sub +-- } +-- } ; +-- +-- QuestIComp icomp np = { +-- s = \\m,t,a,p => +-- let +-- vp = predV sein_V ; +-- cls = (mkClause (np.s ! Nom) np.a vp).s ! m ! t ! a ! p ; +-- why = icomp.s ! np.a +-- in table { +-- QDir => why ++ cls ! Inv ; +-- QIndir => why ++ cls ! Sub +-- } +-- } ; +-- +-- PrepIP p ip = { +-- s = appPrep p ip.s +-- } ; +-- +-- AdvIP ip adv = { +-- s = \\c => ip.s ! c ++ adv.s ; +-- n = ip.n +-- } ; +-- +-- IdetCN idet cn = +-- let +-- g = cn.g ; +-- n = idet.n +-- in { +-- s = \\c => idet.s ! g ! c ++ cn.s ! Weak ! n ! c ; +-- n = n +-- } ; +-- +-- IdetIP idet = +-- let +-- g = Neutr ; ---- +-- n = idet.n +-- in { +-- s = idet.s ! g ; +-- n = n +-- } ; +-- +-- IdetQuant idet num = +-- let +-- n = num.n +-- in { +-- s = \\g,c => idet.s ! n ! g ! c ++ num.s!g!c ; +-- n = n +-- } ; +-- +-- CompIAdv a = {s = \\_ => a.s} ; +-- +-- CompIP ip = {s = \\_ => ip.s ! Nom} ; +-- +--} +-- + +} diff --git a/lib/src/dutch/RelativeDut.gf b/lib/src/dutch/RelativeDut.gf new file mode 100644 index 000000000..b6f14c9c4 --- /dev/null +++ b/lib/src/dutch/RelativeDut.gf @@ -0,0 +1,52 @@ +concrete RelativeDut of Relative = CatDut ** open ResDut in +{ +--{ +-- +-- flags optimize=all_subs ; +-- +-- lin +-- +-- RelCl cl = { +-- s = \\m,t,a,b,_ => "derart" ++ conjThat ++ cl.s ! m ! t ! a ! b ! Sub ; +-- c = Nom +-- } ; +-- +-- RelVP rp vp = { +-- s = \\m,t,ant,b,gn => +-- let +-- agr = case rp.a of { +-- RNoAg => agrP3 (numGenNum gn) ; +-- RAg a => a ** {g = Neutr} +-- } ; +-- cl = mkClause (rp.s ! gn ! Nom) agr vp +-- in +-- cl.s ! m ! t ! ant ! b ! Sub ; +-- c = Nom +-- } ; +-- +-- RelSlash rp slash = { +-- s = \\m,t,a,p,gn => +-- appPrep slash.c2 (rp.s ! gn) ++ slash.s ! m ! t ! a ! p ! Sub ; +-- c = slash.c2.c +-- } ; +-- +-- FunRP p np rp = { +-- s = \\gn,c => np.s ! c ++ appPrep p (rp.s ! gn) ; +-- a = RAg {n = np.a.n ; p = np.a.p} +-- } ; +-- +-- IdRP = {s = relPron ; a = RNoAg} ; +-- +-- oper +-- relPron : GenNum => Case => Str = \\gn,c => +-- case of { +-- => "deren" ; +-- => "dessen" ; +-- => "denen" ; +-- => "deren" ; +-- _ => artDef ! gn ! c +-- } ; +-- +--} + +} diff --git a/lib/src/dutch/ResDut.gf b/lib/src/dutch/ResDut.gf new file mode 100644 index 000000000..15ebf4d93 --- /dev/null +++ b/lib/src/dutch/ResDut.gf @@ -0,0 +1,698 @@ +--# -path=.:../abstract:../common + +--1 Dutch auxiliary operations. +-- +-- (c) 2009 Femke Johansson and Aarne Ranta + +resource ResDut = ParamX ** open Prelude in { + + flags optimize=all ; + +--2 For $Noun$ + + param + Case = Nom | Gen ; + Gender = Utr | Neutr ; + + NForm = NF Number Case ; + + NPCase = NPNom | NPAcc ; + + oper + Noun = {s : NForm => Str ; g : Gender} ; + + mkNoun : (_,_ : Str) -> Gender -> Noun = \sg,pl,g -> { + s = table { + NF Sg _ => sg ; + NF Pl _ => pl + } ; + g = g + } ; + + regNoun : Str -> Noun = \s -> case s of { + _ + ("a" | "o" | "y" | "u" | "oe" | "é") => mkNoun s (s + "'s") Utr ; + _ + ("oir" | "ion") => mkNoun s (s + "s") Neutr ; + ? + ? + ? + _ + ("el" | "em" | "en" | "er" | "erd" | "aar" | "aard") => -- unstressed + mkNoun s (s + s) Utr ; + b + v@("aa"|"ee"|"oo"|"uu") + c@? => mkNoun s (b + shortVoc v c + "en") Utr ; + b + v@("a" |"e" |"o" |"u" ) + c@? => mkNoun s (b + v + c + c + "en") Utr ; + _ => mkNoun s (endCons s + "en") Utr + } ; + + regNounG : Str -> Gender -> Noun = \s,g -> { + s = (regNoun s).s ; + g = g + } ; + + shortVoc : Str -> Str -> Str = \v,s -> init v + endCons s ; + + endCons : Str -> Str = \s -> case s of { + _ + "rs" => s ; + b + "s" => b + "z" ; + b + "f" => b + "v" ; + _ => s + } ; + + param + AForm = APred | AAttr | AGen ; + + oper + Adjective = {s : Degree => AForm => Str} ; + + mkAdjective : (_,_,_,_,_ : Str) -> Adjective = \ap,aa,ag,ac,as -> { + s = table { + Posit => table {APred => ap ; AAttr => aa ; AGen => ag} ; + Compar => table {APred => ac ; AAttr => ac + "e" ; AGen => ac + "es"} ; ---- + Superl => table {APred => as ; AAttr => as + "e" ; AGen => as + "es"} ---- + } + } ; + regAdjective : Str -> Adjective = \s -> ---- + let + se : Str = case s of { + b + v@("aa"|"ee"|"oo"|"uu") + c@? => b + shortVoc v c + "e" ; + b + v@("a" |"e" |"o" |"u" ) + c@? => b + v + c + c + "en" ; + _ => endCons s + "e" + } ; + ser : Str = case s of { + _ + "r" => s + "der" ; + _ => se + "r" + } ; + sst : Str = case s of { + _ + "s" => s + "t" ; + _ => s + "st" + } ; + in + mkAdjective s se (s + "s") ser sst ; + + param + VForm = + VInf -- zijn + | VPresSg1 -- ben + | VPresSg2 -- bent + | VPresSg3 -- is + | VPastSg -- was + | VPastPl -- waren + | VImp2 -- wees + | VImp3 -- weest + | VImpPl -- wezen + | VPerf -- geweest + ; + + VPart = VPart_aan | VPart_af | VPart_be ; + + oper + Verb : Type = {s: VForm => Str}; + + mkVerb : (_,_,_,_,_,_,_ : Str) -> + Verb = \aai, aait, aaien, aaide, _, aaiden, geaaid -> { + s = table { + VInf | VImpPl => aaien; -- hij/zij/het/wij aaien + VPresSg1 | VImp2 => aai; -- ik aai + VPresSg2 | VPresSg3 | VImp3 => aait; -- jij aait + VPastSg => aaide; -- ik aaide + VPastPl => aaiden; -- hij/zij/het/wij aaiden + VPerf => geaaid -- ik heb geaaid + } + }; + + regVerb : Str -> Verb = \s -> smartVerb s (mkStem s) ; + + irregVerb : (breken,brak,gebroken : Str) -> Verb = \breken,brak,gebroken -> + let brek = (regVerb breken).s + in + mkVerb (brek ! VPresSg1) (brek ! VPresSg3) (brek ! VInf) brak brak (brak + "en") gebroken ; + + -- Pattern matching verbs + smartVerb : (_,_:Str) -> Verb = \verb,stem -> + let raw = Predef.tk 2 verb; + in + case raw of { + _+ ("k"|"f"|"s"|"c"|"h"|"p") => t_regVerb verb stem; + _+ "v" => v_regVerb verb; + _+ "z" => z_regVerb verb; + _+ ("t" | "tt") => t_end_regVerb verb; + _+ "d" => d_end_regVerb verb; + + _ => d_regVerb verb stem + + }; + + -- To make a stem out of a verb + -- If a stem ends in a 'v' then the 'v' changes into a 'f' + -- If a stem ends in a 'z' then the 'z' changes into an 's' + -- If a stem ends on a double consonant then one of them disappears + -- If a stem ends on a consonant but that consonant has exactly 1 vowel before it + -- then we have to double this vowel + mkStem : Str -> Str =\werken -> + let stem = Predef.tk 2 werken + in + case stem of { + -- Vowel doubling for verbs whose stem does not end on 'v' or 'z' + _+ ("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"v"|"w"|"x"|"y"|"z") + + ("a"|"e"|"i"|"o"|"u") + + ("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"w"|"x"|"y") + => Predef.tk 2 stem + (Predef.tk 1 (Predef.dp 2 stem)) + Predef.dp 2 stem; + + -- Vowel doubling for verbs whose stem end on 'v' + _+ ("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"v"|"w"|"x"|"y"|"z") + + ("a"|"e"|"i"|"o"|"u") + + "v" => Predef.tk 2 stem + (Predef.tk 1 (Predef.dp 2 stem)) + + (Predef.tk 1 (Predef.dp 2 stem)) +"f"; + + -- Vowel doubling for verbs whose stem end on 'z`' + _+ ("b"|"c"|"d"|"f"|"g"|"h"|"j"|"k"|"l"|"m"|"n"|"p"|"q"|"r"|"s"|"t"|"v"|"w"|"x"|"y"|"z") + + ("a"|"e"|"i"|"o"|"u") + + "z" => Predef.tk 2 stem + (Predef.tk 1 (Predef.dp 2 stem)) + + (Predef.tk 1 (Predef.dp 2 stem)) + "s"; + + _+ "v" => (Predef.tk 1 stem) + "f"; + _+ "z" => (Predef.tk 1 stem) + "s"; + + _+ ("bb" | "dd" | "ff" | "gg" | "kk" | "ll" | "mm" | "nn" | "pp" | + "rr" | "ss" | "tt") => Predef.tk 1 stem; + + + _ => stem + }; + + + -- To add a particle to a verb + -- addPartVerb : Str -> Verb -> Verb = \aanmoedigen -> + -- let verbpiece = Predef.drop 3 aanmoedigen; + -- part = Predef.take 3 aanmoedigen; + -- in + -- mkVerb (smartVerb verbpiece) part; + + -- For regular verbs with past tense 'd' + d_regVerb : (_,_ :Str) -> Verb = \geeuwen,geeuw -> + let stem = mkStem geeuwen + in + mkVerb stem (stem + "t") geeuwen + (stem + "de") (stem + "de") (stem + "den") + ("ge" + stem + "d"); + + -- For regular verbs with past tense 't' + t_regVerb : (_,_ :Str) -> Verb = \botsen,bots -> + let bots = mkStem botsen + in + mkVerb bots (bots + "t") botsen + (bots + "te") (bots + "te") (bots + "ten") + ("ge" + bots + "t"); + + -- For verbs that dont need an extra 't' at the end + t_end_regVerb : Str -> Verb = \achten -> + let acht = mkStem achten + in + mkVerb acht (acht) achten + (acht + "te") (acht +"te") (acht+"ten") ("ge"+acht); + + -- For verbs that dont need an extra 'd' at the end + d_end_regVerb : Str -> Verb = \aarden -> + let aard = mkStem aarden + in + mkVerb aard (aard+"t") aarden + (aard + "de") (aard +"de") (aard+"den") ("ge"+aard); + + -- For verbs that need a vowel doubled in singular + add_vowel_regVerb : Str -> Verb = \absorberen -> + let stem = mkStem absorberen + in + case stem of { + _+ ("t"|"k"|"f"|"s"|"c"|"h"|"p") => t_regVerb absorberen stem; + _ => d_regVerb absorberen stem + }; + + -- For verbs that have their stem ending with a 'z' + z_regVerb : Str -> Verb = \omhelzen -> + let stem = mkStem omhelzen + in + d_regVerb omhelzen stem; + + -- For verbs that have their stem ending with a 'v' + v_regVerb : Str -> Verb = \hoeven -> + let hoef = mkStem hoeven + in + mkVerb hoef (hoef +"t") hoeven (hoef+"de") (hoef+"de") (hoef+"den") + ("ge"+hoef+"d"); + + + + zijn_V : VVerb = { + s = table { + VInf => "zijn" ; + VPresSg1 => "ben" ; + VPresSg2 => "bent" ; + VPresSg3 => "is" ; + VPastSg => "was" ; + VPastPl => "waren" ; + VImp2 => "wees" ; + VImp3 => "weest" ; + VImpPl => "wezen" ; + VPerf => "geweest" + } ; + aux = VZijn + } ; + + hebben_V : VVerb = { + s = table { + VInf => "hebben" ; + VPresSg1 => "heb" ; + VPresSg2 => "hebt" ; + VPresSg3 => "heeft" ; + VPastSg => "had" ; + VPastPl => "hadden" ; + VImp2 => "heb" ; + VImp3 => "heeft" ; + VImpPl => "hebben" ; + VPerf => "gehad" + } ; + aux = VHebben + } ; + + zullen_V : VVerb = { + s = table { + VInf => "zullen" ; + VPresSg1 => "zal" ; + VPresSg2 => "zult" ; + VPresSg3 => "zal" ; + VPastSg => "zou" ; + VPastPl => "zouden" ; + VImp2 => "zoud" ; ---- not used + VImp3 => "zoudt" ; + VImpPl => "zouden" ; ---- + VPerf => "gezoudt" + } ; + aux = VHebben + } ; + + Pronoun : Type = { + unstressed,stressed : {nom, acc, poss : Str} ; + substposs : Str ; + a : Agr + } ; + + mkPronoun : (x1,_,_,_,_,x6,x7 : Str) -> Gender -> Number -> Person -> Pronoun = + \ik,me,mn,Ik,mij,mijn,mijne,g,n,p -> { + unstressed = {nom = ik ; acc = me ; poss = mn} ; + stressed = {nom = Ik ; acc = mij ; poss = mijn} ; + substposs = mijne ; + a = {g = g ; n = n ; p = p} + } ; + + het_Pron : Pronoun = mkPronoun "'t" "'t" "ze" "hij" "hem" "zijn" "zijne" Neutr Sg P3 ; + + + + +-- Complex $CN$s, like adjectives, have strong and weak forms. +-- +-- Adjf = Strong | Weak ; +-- +---- Gender distinctions are only made in the singular. +-- +-- GenNum = GSg Gender | GPl ; +-- +---- Agreement of $NP$ is a record. +-- + oper Agr = {g : Gender ; n : Number ; p : Person} ; +-- +---- Pronouns are the worst-case noun phrases, which have both case +---- and possessive forms. +-- +-- param NPForm = NPCase Case | NPPoss GenNum Case ; +-- +---- Predeterminers sometimes require a case ("ausser mir"), sometimes not ("nur ich"). +-- +-- param PredetCase = NoCase | PredCase Case ; +-- +----2 For $Adjective$ +-- +---- The predicative form of adjectives is not inflected further. +-- +-- param AForm = APred | AMod GenNum Case ; +-- +-- +----2 For $Verb$ +-- +-- param VForm = +-- VInf Bool -- True = with the particle "zu" +-- | VFin Bool VFormFin -- True = prefix glued to verb +-- | VImper Number -- prefix never glued +-- | VPresPart AForm -- prefix always glued +-- | VPastPart AForm ; +-- +-- param VFormFin = +-- VPresInd Number Person +-- | VPresSubj Number Person +-- | VImpfInd Number Person --# notpresent +-- | VImpfSubj Number Person --# notpresent +-- ; +-- +-- param VPForm = +-- VPFinite Mood Tense Anteriority +-- | VPImperat Bool +-- | VPInfinit Anteriority ; + + oper VVerb = Verb ** {aux : VAux} ; + param VAux = VHebben | VZijn ; + +-- param VType = VAct | VRefl Case ; +-- +---- The order of sentence is depends on whether it is used as a main +---- clause, inverted, or subordinate. + + oper + Preposition = Str ; + appPrep : Preposition -> (NPCase => Str) -> Str = \p,np -> p ++ np ! NPAcc ; ---- + + param + Order = Main | Inv | Sub ; + + oper + vForm : Tense -> Number -> Person -> Order -> VForm = \t,n,p,o -> case of { + => case o of { + Inv => VPresSg1 ; + _ => VPresSg2 + } ; + => VPresSg1 ; + => VPresSg3 ; + => VInf ; + + => VPastSg ; -- Fut and Cond affect zullen + => VPastPl + } ; + +-- +---- Main clause mood: "es sei, es wäre, es werde sein". +---- Not relevant for $Fut$. --- +-- +-- Mood = MIndic | MConjunct ; +-- +----2 For $Relative$ +-- +-- RAgr = RNoAg | RAg {n : Number ; p : Person} ; +-- +----2 For $Numeral$ +-- +-- CardOrd = NCard Gender Case | NOrd AForm ; +-- DForm = DUnit | DTeen | DTen ; +-- +----2 Transformations between parameter types +-- + oper + agrP3 : Number -> Agr = agrgP3 Neutr ; + + agrgP3 : Gender -> Number -> Agr = \g,n -> + {g = g ; n = n ; p = P3} ; + +-- gennum : Gender -> Number -> GenNum = \g,n -> +-- case n of { +-- Sg => GSg g ; +-- Pl => GPl +-- } ; +-- +---- Needed in $RelativeDut$. +-- +-- numGenNum : GenNum -> Number = \gn -> +-- case gn of { +-- GSg _ => Sg ; +-- GPl => Pl +-- } ; +-- +---- Used in $NounDut$. +-- +-- agrAdj : Gender -> Adjf -> Number -> Case -> AForm = \g,a,n,c -> +-- let +-- gn = gennum g n ; +-- e = AMod (GSg Fem) Nom ; +-- en = AMod (GSg Masc) Acc ; +-- in +-- case a of { +-- Strong => AMod gn c ; +-- _ => case of { +-- => e ; +-- => en ; +-- => e ; +-- _ => en +-- } +-- } ; +-- +---- To add a prefix (like "ein") to an already existing verb. +-- +-- prefixV : Str -> Verb -> Verb = \ein,verb -> +-- let +-- vs = verb.s ; +-- geben = vs ! VInf False ; +-- einb : Bool -> Str -> Str = \b,geb -> +-- if_then_Str b (ein + geb) geb ; +-- in +-- {s = table { +-- VInf False => ein + geben ; +-- VInf True => +-- if_then_Str (isNil ein) ("zu" ++ geben) (ein + "zu" + geben) ; +-- VFin b vf => einb b (vs ! VFin b vf) ; +-- VImper n => vs ! VImper n ; +-- VPresPart a => ein + (regA (geben + "d")).s ! Posit ! a ; +-- VPastPart a => ein + vs ! VPastPart a +-- } ; +-- prefix = ein ; +-- aux = verb.aux ; +-- vtype = verb.vtype +-- } ; +-- +-- +-- +---- Pronouns and articles +---- Here we define personal and relative pronouns. +---- All personal pronouns, except "ihr", conform to the simple +---- pattern $mkPronPers$. +-- +-- mkPronPers : (x1,_,_,_,x5 : Str) -> Gender -> Number -> Person -> +-- {s : NPForm => Str ; a : Agr} = +-- \ich,mich,mir,meiner,mein,g,n,p -> { +-- s = table { +-- NPCase c => caselist ich mich mir meiner ! c ; +-- NPPoss gn c => mein + pronEnding ! gn ! c +-- } ; +-- a = {g = g ; n = n ; p = p} +-- } ; +-- +-- pronEnding : GenNum => Case => Str = table { +-- GSg Masc => caselist "" "en" "em" "es" ; +-- GSg Fem => caselist "e" "e" "er" "er" ; +-- GSg Neut => caselist "" "" "em" "es" ; +-- GPl => caselist "e" "e" "en" "er" +-- } ; +-- +-- artDef : GenNum => Case => Str = table { +-- GSg Masc => caselist "der" "den" "dem" "des" ; +-- GSg Fem => caselist "die" "die" "der" "der" ; +-- GSg Neut => caselist "das" "das" "dem" "des" ; +-- GPl => caselist "die" "die" "den" "der" +-- } ; +-- +---- This is used when forming determiners that are like adjectives. +-- +-- appAdj : Adjective -> Number => Gender => Case => Str = \adj -> +-- let +-- ad : GenNum -> Case -> Str = \gn,c -> +-- adj.s ! Posit ! AMod gn c +-- in +-- \\n,g,c => case n of { +-- Sg => ad (GSg g) c ; +-- _ => ad GPl c +-- } ; +-- +---- This auxiliary gives the forms in each degree of adjectives. +-- +-- adjForms : (x1,x2 : Str) -> AForm => Str = \teuer,teur -> +-- table { +-- APred => teuer ; +-- AMod (GSg Masc) c => +-- caselist (teur+"er") (teur+"en") (teur+"em") (teur+"es") ! c ; +-- AMod (GSg Fem) c => +-- caselist (teur+"e") (teur+"e") (teur+"er") (teur+"er") ! c ; +-- AMod (GSg Neut) c => +-- caselist (teur+"es") (teur+"es") (teur+"em") (teur+"es") ! c ; +-- AMod GPl c => +-- caselist (teur+"e") (teur+"e") (teur+"en") (teur+"er") ! c +-- } ; +-- +---- For $Verb$. +-- +-- VPC : Type = { +-- s : Bool => Agr => VPForm => { -- True = prefix glued to verb +-- fin : Str ; -- hat +-- inf : Str -- wollen +-- } +-- } ; +-- + + oper VP : Type = { + s : VVerb ; + a1 : Polarity => Str ; -- niet + n2 : Agr => Str ; -- dich + a2 : Str ; -- heute + isAux : Bool ; -- is a double infinitive + inf : Str ; -- sagen + ext : Str -- dass sie kommt + } ; + + predV : VVerb -> VP = predVGen False ; + + + predVGen : Bool -> VVerb -> VP = \isAux, verb -> { + s = verb ; + a1 : Polarity => Str = negation ; + n2 : Agr => Str = \\_ => [] ; +-- case verb.vtype of { +-- VAct => \\_ => [] ; +-- VRefl c => \\a => reflPron ! a ! c +-- } ; + a2 : Str = [] ; + isAux = isAux ; ---- + inf,ext : Str = [] + } ; + + negation : Polarity => Str = table { + Pos => [] ; + Neg => "niet" + } ; + +-- Extending a verb phrase with new constituents. + + insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> { + s = vp.s ; + a1 = vp.a1 ; + n2 = \\a => obj ! a ++ vp.n2 ! a ; + a2 = vp.a2 ; + isAux = vp.isAux ; + inf = vp.inf ; + ext = vp.ext + } ; + +-- insertAdV : Str -> VP -> VP = \adv,vp -> { +-- s = vp.s ; +-- a1 = \\a => adv ++ vp.a1 ! a ; -- immer nicht +-- n2 = vp.n2 ; +-- a2 = vp.a2 ; +-- isAux = vp.isAux ; +-- inf = vp.inf ; +-- ext = vp.ext +-- } ; + + insertAdv : Str -> VP -> VP = \adv,vp -> { + s = vp.s ; + a1 = vp.a1 ; + n2 = vp.n2 ; + a2 = vp.a2 ++ adv ; + isAux = vp.isAux ; + inf = vp.inf ; + ext = vp.ext + } ; + +-- insertExtrapos : Str -> VP -> VP = \ext,vp -> { +-- s = vp.s ; +-- a1 = vp.a1 ; +-- n2 = vp.n2 ; +-- a2 = vp.a2 ; +-- isAux = vp.isAux ; +-- inf = vp.inf ; +-- ext = vp.ext ++ ext +-- } ; +-- +-- insertInf : Str -> VP -> VP = \inf,vp -> { +-- s = vp.s ; +-- a1 = vp.a1 ; +-- n2 = vp.n2 ; +-- a2 = vp.a2 ; +-- isAux = vp.isAux ; ---- +-- inf = inf ++ vp.inf ; +-- ext = vp.ext +-- } ; +-- +-- For $Sentence$. + + Clause : Type = { + s : Tense => Anteriority => Polarity => Order => Str + } ; + + mkClause : Str -> Agr -> VP -> Clause = \subj,agr,vp -> { + s = \\t,a,b,o => + let + ord = case o of { + Sub => True ; -- glue prefix to verb + _ => False + } ; + vform = vForm t agr.n agr.p o ; + auxv = (auxVerb vp.s.aux).s ; + vperf = vp.s.s ! VPerf ; + verb : Str * Str = case of { + => ; + => ; + <_, Anter> => ; + <_, Simul> => + } ; + fin = verb.p1 ; + neg = vp.a1 ! b ; + obj = vp.n2 ! agr ; + compl = obj ++ neg ++ vp.a2 ; + inf = vp.inf ++ verb.p2 ; + extra = vp.ext ; + inffin = + case of { --# notpresent + => fin ++ inf ; -- double inf --# notpresent + _ => --# notpresent + inf ++ fin --- or just auxiliary vp + } --# notpresent + in + case o of { + Main => subj ++ fin ++ compl ++ inf ++ extra ; + Inv => fin ++ subj ++ compl ++ inf ++ extra ; + Sub => subj ++ compl ++ inffin ++ extra + } + } ; + + auxVerb : VAux -> VVerb = \a -> case a of { + VHebben => hebben_V ; + VZijn => zijn_V + } ; + +-- infVP : Bool -> VP -> ((Agr => Str) * Str * Str) = \isAux, vp -> let vps = useVP vp in +-- < +-- \\agr => vp.n2 ! agr ++ vp.a2, +-- vp.a1 ! Pos ++ (vps.s ! (notB isAux) ! agrP3 Sg ! VPInfinit Simul).inf, +-- vp.inf ++ vp.ext +-- > ; +-- +-- useInfVP : Bool -> VP -> Str = \isAux,vp -> +-- let vpi = infVP isAux vp in +-- vpi.p1 ! agrP3 Sg ++ vpi.p3 ++ vpi.p2 ; +-- +---- The nominative case is not used as reflexive, but defined here +---- so that we can reuse this in personal pronouns. +---- The missing Sg "ihrer" shows that a dependence on gender would +---- be needed. +-- +-- reflPron : Agr => Case => Str = table { +-- {n = Sg ; p = P1} => caselist "ich" "mich" "mir" "meiner" ; +-- {n = Sg ; p = P2} => caselist "du" "dich" "dir" "deiner" ; +-- {g = Masc ; n = Sg ; p = P3} => caselist "er" "sich" "sich" "seiner" ; +-- {g = Fem ; n = Sg ; p = P3} => caselist "sie" "sich" "sich" "ihrer" ; +-- {g = Neutr ; n = Sg ; p = P3} => caselist "es" "sich" "sich" "seiner" ; +-- {n = Pl ; p = P1} => caselist "wir" "uns" "uns" "unser" ; +-- {n = Pl ; p = P2} => caselist "ihr" "euch" "euch" "euer" ; +-- {n = Pl ; p = P3} => caselist "sie" "sich" "sich" "ihrer" +-- } ; +-- +-- conjThat : Str = "daß" ; +-- +-- conjThan : Str = "als" ; +-- +---- The infinitive particle "zu" is used if and only if $vv.isAux = False$. +-- +-- infPart : Bool -> Str = \b -> if_then_Str b [] "zu" ; +-- +--} + +} diff --git a/lib/src/dutch/SentenceDut.gf b/lib/src/dutch/SentenceDut.gf new file mode 100644 index 000000000..437c58350 --- /dev/null +++ b/lib/src/dutch/SentenceDut.gf @@ -0,0 +1,69 @@ +concrete SentenceDut of Sentence = CatDut ** open ResDut, Prelude in { + + flags optimize=all_subs ; + + lin + + PredVP np vp = mkClause (np.s ! NPNom) np.a vp ; +-- +-- PredSCVP sc vp = mkClause sc.s (agrP3 Sg) vp ; +-- +-- ImpVP vp = let vps = useVP vp in { +-- s = \\pol,n => +-- let +-- ps = case n of { +-- ImpF _ True => ; -- setzen Sie sich +-- _ => +-- } ; +-- agr = {g = Fem ; n = numImp n ; p = ps.p1} ; --- g does not matter +-- verb = vps.s ! False ! agr ! VPImperat ps.p3 ; +-- inf = vp.inf ++ verb.inf ; +-- in +-- verb.fin ++ ps.p2 ++ +-- vp.n2 ! agr ++ vp.a1 ! pol ++ vp.a2 ++ inf ++ vp.ext +-- } ; +-- +-- SlashVP np vp = +-- mkClause +-- (np.s ! Nom) np.a +-- vp ** +-- {c2 = vp.c2} ; +-- +-- AdvSlash slash adv = { +-- s = \\m,t,a,b,o => slash.s ! m ! t ! a ! b ! o ++ adv.s ; +-- c2 = slash.c2 +-- } ; +-- +-- SlashPrep cl prep = cl ** {c2 = prep} ; +-- +-- SlashVS np vs slash = +-- mkClause (np.s ! Nom) np.a +-- (insertExtrapos (conjThat ++ slash.s ! Sub) (predV vs)) ** +-- {c2 = slash.c2} ; +-- +-- EmbedS s = {s = conjThat ++ s.s ! Sub} ; +-- EmbedQS qs = {s = qs.s ! QIndir} ; +-- EmbedVP vp = {s = useInfVP False vp} ; + + UseCl t p cl = { + s = \\o => t.s ++ p.s ++ cl.s ! t.t ! t.a ! p.p ! o + } ; + UseQCl t p cl = { + s = \\q => t.s ++ p.s ++ cl.s ! t.t ! t.a ! p.p ! q + } ; +-- UseRCl t p cl = { +-- s = \\r => t.s ++ p.s ++ cl.s ! t.m ! t.t ! t.a ! p.p ! r ; +-- c = cl.c +-- } ; +-- UseSlash t p cl = { +-- s = \\o => t.s ++ p.s ++ cl.s ! t.m ! t.t ! t.a ! p.p ! o ; +-- c2 = cl.c2 +-- } ; +-- +-- AdvS a s = {s = \\o => a.s ++ s.s ! Inv} ; +-- +-- RelS s r = {s = \\o => s.s ! o ++ "," ++ r.s ! gennum Neutr Sg} ; --- "welches" +-- +--} + +} diff --git a/lib/src/dutch/StructuralDut.gf b/lib/src/dutch/StructuralDut.gf new file mode 100644 index 000000000..4b6c64ab3 --- /dev/null +++ b/lib/src/dutch/StructuralDut.gf @@ -0,0 +1,156 @@ +concrete StructuralDut of Structural = CatDut ** + + open ResDut in +{ + + + flags optimize=all ; + + lin + +-- above_Prep = mkPrep "über" Dat ; +-- after_Prep = mkPrep "nach" Dat ; +-- all_Predet = {s = appAdj (regA "all") ; c = NoCase} ; +-- almost_AdA, almost_AdN = ss "fast" ; +-- although_Subj = ss "obwohl" ; +-- always_AdV = ss "immer" ; +-- and_Conj = {s1 = [] ; s2 = "und" ; n = Pl} ; +-- because_Subj = ss "weil" ; +-- before_Prep = mkPrep "vor" Dat ; +-- behind_Prep = mkPrep "hinter" Dat ; +-- between_Prep = mkPrep "zwischen" Dat ; +-- both7and_DConj = sd2 "sowohl" ["als auch"] ** {n = Pl} ; +-- but_PConj = ss "aber" ; +-- by8agent_Prep = mkPrep "durch" Acc ; +-- by8means_Prep = mkPrep "mit" Dat ; +-- can8know_VV, can_VV = auxVV +-- (mkV +-- "können" "kann" "kannst" "kann" "könnt" "könn" +-- "konnte" "konntest" "konnten" "konntet" +-- "könnte" "gekonnt" [] +-- VHaben) ; +-- during_Prep = mkPrep "während" Gen ; +-- either7or_DConj = sd2 "entweder" "oder" ** {n = Sg} ; +-- everybody_NP = nameNounPhrase {s = caselist "jeder" "jeden" "jedem" "jedes"} ; +-- every_Det = detLikeAdj Sg "jed" ; +-- everything_NP = nameNounPhrase {s = caselist "alles" "alles" "allem" "alles"} ; +-- everywhere_Adv = ss "überall" ; +-- few_Det = detLikeAdj Pl "wenig" ; +------ first_Ord = {s = (regA "erst").s ! Posit} ; +-- for_Prep = mkPrep "für" Acc ; +-- from_Prep = mkPrep "aus" Dat ; +-- he_Pron = mkPronPers "er" "ihn" "ihm" "seiner" "sein" Utr Sg P3 ; +-- here7to_Adv = ss ["hierher"] ; +-- here7from_Adv = ss ["hieraus"] ; +-- here_Adv = ss "hier" ; +-- how_IAdv = ss "wie" ; +-- how8many_IDet = detLikeAdj Pl "wieviel" ; +-- if_Subj = ss "wenn" ; +-- in8front_Prep = mkPrep "vor" Dat ; + i_Pron = mkPronoun "ik" "me" "m'n" "ik" "mij" "mijn" "mijne" Utr Sg P1 ; +-- in_Prep = mkPrep "in" Dat ; +-- it_Pron = mkPronPers "es" "es" "ihm" "seiner" "sein" Neutr Sg P3 ; +-- less_CAdv = X.mkCAdv "weniger" "als" ; +-- many_Det = detLikeAdj Pl "viel" ; +-- more_CAdv = X.mkCAdv "mehr" "als" ; +-- most_Predet = {s = appAdj (regA "meist") ; c = NoCase} ; +-- much_Det = detLikeAdj Sg "viel" ; +-- must_VV = auxVV +-- (mkV +-- "müssen" "muß" "mußt" "muß" "müßt" "müß" +-- "mußte" "mußtest" "mußten" "mußtet" +-- "müßte" "gemußt" [] +-- VHaben) ; +----- one_Quant = DEPREC +-- only_Predet = {s = \\_,_,_ => "nur" ; c = NoCase} ; +-- no_Utt = ss "nein" ; +-----b no_Phr = ss "nein" ; +-- on_Prep = mkPrep "auf" Dat ; +-- or_Conj = {s1 = [] ; s2 = "oder" ; n = Sg} ; +-- otherwise_PConj = ss "sonst" ; +-- part_Prep = mkPrep "von" Dat ; +-- please_Voc = ss "bitte" ; +-- possess_Prep = mkPrep "von" Dat ; +-- quite_Adv = ss "ziemlich" ; +-- she_Pron = mkPronPers "sie" "sie" "ihr" "ihrer" "ihr" Fem Sg P3 ; +-- so_AdA = ss "so" ; +-- somebody_NP = nameNounPhrase {s = caselist "jemand" "jemanden" "jemandem" "jemands"} ; +-- somePl_Det = detLikeAdj Pl "einig" ; +-- someSg_Det = { +-- s,sp = \\g,c => "ein" + pronEnding ! GSg g ! c ; ---- einer,eines +-- n = Sg ; +-- a = Strong +-- } ; +-- something_NP = nameNounPhrase {s = \\_ => "etwas"} ; +-- somewhere_Adv = ss "irgendwo" ; +-- that_Quant = let +-- jener : Number => Gender => Case => Str = \\n => (detLikeAdj n "jen").s in +-- {s = \\_ => jener ; sp = jener ; a = Weak} ; +-----b that_NP = nameNounPhrase {s = caselist "das" "das" "denem" "dessen"} ; ---- +-- there_Adv = ss "da" ; +-- there7to_Adv = ss "dahin" ; +-- there7from_Adv = ss ["daher"] ; +-- therefore_PConj = ss "deshalb" ; +-----b these_NP = {s = caselist "diese" "diese" "diesen" "dieser" ; a = agrP3 Pl} ; +-- they_Pron = mkPronPers "sie" "sie" "ihnen" "ihrer" "ihr" Fem Pl P3 ; +-- this_Quant = let +-- dieser : Number => Gender => Case => Str = \\n => (detLikeAdj n "dies").s in +-- {s = \\_ => dieser ; sp = dieser ; a = Weak} ; +-----b this_NP = nameNounPhrase {s = caselist "dies" "dies" "diesem" "dieses"} ; ---- +-----b those_NP = {s = caselist "jene" "jene" "jenen" "jener" ; a = agrP3 Pl} ; +-- through_Prep = mkPrep "durch" Acc ; +-- too_AdA = ss "zu" ; +-- to_Prep = mkPrep "nach" Dat ; +-- under_Prep = mkPrep "unter" Dat ; +-- very_AdA = ss "sehr" ; +-- want_VV = auxVV +-- (mkV +-- "wollen" "will" "willst" "will" "wollt" "woll" +-- "wollte" "wolltest" "wollten" "wolltet" +-- "wollte" "gewollt" [] +-- VHaben) ; +-- we_Pron = mkPronPers "wir" "uns" "uns" "unser" "unser" Fem Pl P1 ; +-- +-- whatSg_IP = {s = caselist "was" "was" "was" "wessen" ; n = Sg} ; ---- +-- whatPl_IP = {s = caselist "was" "was" "was" "wessen" ; n = Pl} ; ---- +-- +-- when_IAdv = ss "wann" ; +-- when_Subj = ss "wenn" ; +-- where_IAdv = ss "wo" ; +-- which_IQuant = {s = \\n => (detLikeAdj n "welch").s} ; +-- +-- whoSg_IP = {s = caselist "wer" "wen" "wem" "wessen" ; n = Sg} ; +-- whoPl_IP = {s = caselist "wer" "wen" "wem" "wessen" ; n = Pl} ; +-- why_IAdv = ss "warum" ; +-- without_Prep = mkPrep "ohne" Acc ; +-- with_Prep = mkPrep "mit" Dat ; + youSg_Pron = mkPronoun "je" "je" "je" "jij" "jou" "je" "jouwe" Utr Sg P2 ; +-- youPl_Pron = mkPronPers "ihr" "euch" "euch" "eurer" "euer" Fem Pl P2 ; ---- poss +-- youPol_Pron = mkPronPers "Sie" "Sie" "Ihnen" "Ihrer" "Ihr" Fem Pl P3 ; +-- yes_Utt = ss "ja" ; +-- +-- not_Predet = {s = \\_,_,_ => "nicht" ; c = NoCase} ; +-- no_Quant = let +-- keiner : Number => Gender => Case => Str = table { +-- Sg => \\g,c => "kein" + pronEnding ! GSg g ! c ; +-- Pl => (detLikeAdj Pl "kein").s +-- } +-- in +-- {s = \\_ => keiner ; sp = keiner ; a = Strong} ; ---- sp +-- if_then_Conj = {s1 = "wenn" ; s2 = "dann" ; n = Sg ; lock_Conj = <>} ; +-- nobody_NP = +-- nameNounPhrase {s = caselist "niemand" "niemanden" "niemandem" "niemands"} ; +-- nothing_NP = +-- nameNounPhrase {s = \\_ => "nichts"} ; +-- at_least_AdN = ss "wenigstens" ; +-- at_most_AdN = ss "höchstens" ; +-- except_Prep = mkPrep "außer" Dat ; +-- +-- as_CAdv = X.mkCAdv "ebenso" "wie" ; +-- have_V2 = P.dirV2 IrregDut.haben_V ; +-- +-- lin language_title_Utt = ss "Deutsch" ; +-- +--} + +} diff --git a/lib/src/dutch/SymbolDut.gf b/lib/src/dutch/SymbolDut.gf new file mode 100644 index 000000000..467814685 --- /dev/null +++ b/lib/src/dutch/SymbolDut.gf @@ -0,0 +1,49 @@ +--# -path=.:../abstract:../common + +concrete SymbolDut of Symbol = CatDut ** open Prelude, ResDut in +{ +--{ +-- +--lin +-- SymbPN i = {s = \\c => i.s ; g = Neutr} ; --- c +-- IntPN i = {s = \\c => i.s ; g = Neutr} ; --- c +-- FloatPN i = {s = \\c => i.s ; g = Neutr} ; --- c +-- NumPN i = {s = i.s ! Neutr ; g = Neutr} ; --- c +-- +-- CNIntNP cn i = { +-- s = \\c => cn.s ! Weak ! Sg ! Nom ++ i.s ; +-- a = agrP3 Sg ; +-- isPron = False +-- } ; +-- CNSymbNP det cn xs = let g = cn.g in { +-- s = \\c => det.s ! g ! c ++ cn.s ! adjfCase det.a c ! det.n ! c ++ xs.s ; +-- a = agrP3 det.n ; +-- isPron = False +-- } ; +-- CNNumNP cn i = { +-- s = \\c => artDef ! (GSg cn.g) ! c ++ cn.s ! Weak ! Sg ! Nom ++ i.s ! Neutr ! c ; +-- a = agrP3 Sg ; +-- isPron = False +-- } ; +-- +-- SymbS sy = {s = \\_ => sy.s} ; +-- +-- SymbNum n = {s = \\_,_ => n.s ; n = Pl ; isNum = True} ; +-- SymbOrd n = {s = \\_ => n.s ++ "."} ; +-- +-- +--lincat +-- +-- Symb, [Symb] = SS ; +-- +--lin +-- +-- MkSymb s = s ; +-- +-- BaseSymb = infixSS "und" ; +-- ConsSymb = infixSS "," ; +-- +--} +-- + +} diff --git a/lib/src/dutch/VerbDut.gf b/lib/src/dutch/VerbDut.gf new file mode 100644 index 000000000..87f995aab --- /dev/null +++ b/lib/src/dutch/VerbDut.gf @@ -0,0 +1,82 @@ +concrete VerbDut of Verb = CatDut ** open Prelude, ResDut in { + + flags optimize=all_subs ; + + lin + UseV = predV ; + +-- ComplVV v vp = +-- let +-- vpi = infVP v.isAux vp +-- in +-- insertExtrapos vpi.p3 ( +-- insertInf vpi.p2 ( +-- insertObj vpi.p1 ( +-- predVGen v.isAux v))) ; +-- +-- ComplVS v s = +-- insertExtrapos (conjThat ++ s.s ! Sub) (predV v) ; +-- ComplVQ v q = +-- insertExtrapos (q.s ! QIndir) (predV v) ; +-- ComplVA v ap = insertObj (\\ _ => ap.s ! APred) (predV v) ; +-- + SlashV2a v = predV {s = v.s ; aux = v.aux} ** {c2 = v.c2} ; +-- +-- Slash2V3 v np = +-- insertObj (\\_ => appPrep v.c2 np.s) (predV v) ** {c2 = v.c3} ; +-- Slash3V3 v np = +-- insertObj (\\_ => appPrep v.c3 np.s) (predV v) ** {c2 = v.c2} ; +-- +-- SlashV2S v s = +-- insertExtrapos (conjThat ++ s.s ! Sub) (predV v) ** {c2 = v.c2} ; +-- SlashV2Q v q = +-- insertExtrapos (q.s ! QIndir) (predV v) ** {c2 = v.c2} ; +-- SlashV2V v vp = +-- let +-- vpi = infVP False vp +-- in +-- insertExtrapos vpi.p3 ( +-- insertInf vpi.p2 ( +-- insertObj vpi.p1 ((predV v)))) ** {c2 = v.c2} ; +-- +-- SlashV2A v ap = +-- insertObj (\\_ => ap.s ! APred) (predV v) ** {c2 = v.c2} ; +-- + ComplSlash vp np = insertObj (\\_ => appPrep vp.c2 np.s) vp ; +-- +-- SlashVV v vp = +-- let +-- vpi = infVP v.isAux vp +-- in +-- insertExtrapos vpi.p3 ( +-- insertInf vpi.p2 ( +-- insertObj vpi.p1 ( +-- predVGen v.isAux v))) ** {c2 = vp.c2} ; +-- +-- SlashV2VNP v np vp = +-- let +-- vpi = infVP False vp +-- in +-- insertExtrapos vpi.p3 ( +-- insertInf vpi.p2 ( +-- insertObj vpi.p1 ( +-- insertObj (\\_ => appPrep v.c2 np.s) ( +-- predV v)))) ** {c2 = v.c2} ; +-- + UseComp comp = insertAdv (comp.s ! agrP3 Sg) (predV zijn_V) ; -- agr not used + CompAP ap = {s = \\_ => ap.s ! APred} ; +-- CompNP np = {s = \\_ => np.s ! Nom} ; +-- CompAdv a = {s = \\_ => a.s} ; +-- +-- AdvVP vp adv = insertAdv adv.s vp ; +-- AdVVP adv vp = insertAdV adv.s vp ; +-- +-- ReflVP vp = insertObj (\\a => appPrep vp.c2 (reflPron ! a)) vp ; +-- +-- PassV2 v = insertInf (v.s ! VPastPart APred) (predV werdenPass) ; +-- +-----b UseVS, UseVQ = \v -> v ** {c2 = noPreposition Acc} ; +-- +--} + +}