From c1bd7f2ba14366072b4b09fd5301bac2ead60c02 Mon Sep 17 00:00:00 2001 From: aarne Date: Wed, 23 Apr 2008 07:21:26 +0000 Subject: [PATCH] french in exper started --- lib/resource/exper/french/AdjectiveFre.gf | 2 + lib/resource/exper/french/AdverbFre.gf | 2 + lib/resource/exper/french/BeschFre.gf | 102 ++ lib/resource/exper/french/CatFre.gf | 4 + lib/resource/exper/french/ConjunctionFre.gf | 2 + lib/resource/exper/french/DiffFre.gf | 211 +++ lib/resource/exper/french/ExtraFre.gf | 60 + lib/resource/exper/french/ExtraFreAbs.gf | 34 + lib/resource/exper/french/ExtraRomanceFre.gf | 2 + lib/resource/exper/french/French.gf | 7 + lib/resource/exper/french/FrenchAbs.gf | 5 + lib/resource/exper/french/GrammarFre.gf | 21 + lib/resource/exper/french/IdiomFre.gf | 45 + lib/resource/exper/french/IrregFre.gf | 395 ++++++ lib/resource/exper/french/IrregFreAbs.gf | 391 ++++++ lib/resource/exper/french/LangFre.gf | 10 + lib/resource/exper/french/LexiconFre.gf | 367 +++++ lib/resource/exper/french/MorphoFre.gf | 1238 +++++++++++++++++ lib/resource/exper/french/NounFre.gf | 2 + lib/resource/exper/french/NumeralFre.gf | 148 ++ lib/resource/exper/french/ParadigmsFre.gf | 447 ++++++ lib/resource/exper/french/PhonoFre.gf | 26 + lib/resource/exper/french/PhraseFre.gf | 2 + lib/resource/exper/french/QuestionFre.gf | 2 + lib/resource/exper/french/RelativeFre.gf | 2 + lib/resource/exper/french/ResFre.gf | 13 + lib/resource/exper/french/SentenceFre.gf | 2 + lib/resource/exper/french/StructuralFre.gf | 147 ++ lib/resource/exper/french/VerbFre.gf | 2 + .../exper/romance/AdjectiveRomance.gf | 41 + lib/resource/exper/romance/AdverbRomance.gf | 26 + lib/resource/exper/romance/CatRomance.gf | 102 ++ lib/resource/exper/romance/CommonRomance.gf | 216 +++ .../exper/romance/ConjunctionRomance.gf | 55 + lib/resource/exper/romance/DiffRomance.gf | 108 ++ lib/resource/exper/romance/ExtRomance.gf | 14 + lib/resource/exper/romance/ExtraRomance.gf | 21 + lib/resource/exper/romance/ExtraRomanceAbs.gf | 7 + lib/resource/exper/romance/NounRomance.gf | 130 ++ lib/resource/exper/romance/PhraseRomance.gf | 27 + lib/resource/exper/romance/QuestionRomance.gf | 76 + lib/resource/exper/romance/RelativeRomance.gf | 50 + lib/resource/exper/romance/ResRomance.gf | 250 ++++ lib/resource/exper/romance/SentenceRomance.gf | 89 ++ lib/resource/exper/romance/VerbRomance.gf | 61 + 45 files changed, 4964 insertions(+) create mode 100644 lib/resource/exper/french/AdjectiveFre.gf create mode 100644 lib/resource/exper/french/AdverbFre.gf create mode 100644 lib/resource/exper/french/BeschFre.gf create mode 100644 lib/resource/exper/french/CatFre.gf create mode 100644 lib/resource/exper/french/ConjunctionFre.gf create mode 100644 lib/resource/exper/french/DiffFre.gf create mode 100644 lib/resource/exper/french/ExtraFre.gf create mode 100644 lib/resource/exper/french/ExtraFreAbs.gf create mode 100644 lib/resource/exper/french/ExtraRomanceFre.gf create mode 100644 lib/resource/exper/french/French.gf create mode 100644 lib/resource/exper/french/FrenchAbs.gf create mode 100644 lib/resource/exper/french/GrammarFre.gf create mode 100644 lib/resource/exper/french/IdiomFre.gf create mode 100644 lib/resource/exper/french/IrregFre.gf create mode 100644 lib/resource/exper/french/IrregFreAbs.gf create mode 100644 lib/resource/exper/french/LangFre.gf create mode 100644 lib/resource/exper/french/LexiconFre.gf create mode 100644 lib/resource/exper/french/MorphoFre.gf create mode 100644 lib/resource/exper/french/NounFre.gf create mode 100644 lib/resource/exper/french/NumeralFre.gf create mode 100644 lib/resource/exper/french/ParadigmsFre.gf create mode 100644 lib/resource/exper/french/PhonoFre.gf create mode 100644 lib/resource/exper/french/PhraseFre.gf create mode 100644 lib/resource/exper/french/QuestionFre.gf create mode 100644 lib/resource/exper/french/RelativeFre.gf create mode 100644 lib/resource/exper/french/ResFre.gf create mode 100644 lib/resource/exper/french/SentenceFre.gf create mode 100644 lib/resource/exper/french/StructuralFre.gf create mode 100644 lib/resource/exper/french/VerbFre.gf create mode 100644 lib/resource/exper/romance/AdjectiveRomance.gf create mode 100644 lib/resource/exper/romance/AdverbRomance.gf create mode 100644 lib/resource/exper/romance/CatRomance.gf create mode 100644 lib/resource/exper/romance/CommonRomance.gf create mode 100644 lib/resource/exper/romance/ConjunctionRomance.gf create mode 100644 lib/resource/exper/romance/DiffRomance.gf create mode 100644 lib/resource/exper/romance/ExtRomance.gf create mode 100644 lib/resource/exper/romance/ExtraRomance.gf create mode 100644 lib/resource/exper/romance/ExtraRomanceAbs.gf create mode 100644 lib/resource/exper/romance/NounRomance.gf create mode 100644 lib/resource/exper/romance/PhraseRomance.gf create mode 100644 lib/resource/exper/romance/QuestionRomance.gf create mode 100644 lib/resource/exper/romance/RelativeRomance.gf create mode 100644 lib/resource/exper/romance/ResRomance.gf create mode 100644 lib/resource/exper/romance/SentenceRomance.gf create mode 100644 lib/resource/exper/romance/VerbRomance.gf diff --git a/lib/resource/exper/french/AdjectiveFre.gf b/lib/resource/exper/french/AdjectiveFre.gf new file mode 100644 index 000000000..28ff535b9 --- /dev/null +++ b/lib/resource/exper/french/AdjectiveFre.gf @@ -0,0 +1,2 @@ +concrete AdjectiveFre of Adjective = CatFre ** AdjectiveRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/AdverbFre.gf b/lib/resource/exper/french/AdverbFre.gf new file mode 100644 index 000000000..0fcc12dca --- /dev/null +++ b/lib/resource/exper/french/AdverbFre.gf @@ -0,0 +1,2 @@ +concrete AdverbFre of Adverb = CatFre ** AdverbRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/BeschFre.gf b/lib/resource/exper/french/BeschFre.gf new file mode 100644 index 000000000..9903e07ec --- /dev/null +++ b/lib/resource/exper/french/BeschFre.gf @@ -0,0 +1,102 @@ +resource BeschFre = open Prelude, MorphoFre in { + +flags optimize=noexpand ; -- faster and smaller than =all + +oper VerbeN = {s : VF => Str} ; +oper mkNV : Verbe -> VerbeN = \ve -> {s = vvf ve} ; + +oper conj : Str -> Verbe = conj1aimer ; --- temp. default + +oper v_nancy100inf : Str -> VerbeN = \ve -> {s = table { + VInfin _ => ve ; + _ => nonExist + } +} ; + + +oper v_besch1 : Str -> VerbeN = \s -> mkNV (conjAvoir s) ; +oper v_besch2 : Str -> VerbeN = \s -> mkNV (conjÊtre s) ; +-- 3-5 not used +oper v_besch6 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ; +oper v_besch7 : Str -> VerbeN = \s -> mkNV (conj1placer s) ; +oper v_besch8 : Str -> VerbeN = \s -> mkNV (conj1manger s) ; +oper v_besch9 : Str -> VerbeN = \s -> mkNV (conj1peser s) ; +oper v_besch10 : Str -> VerbeN = \s -> mkNV (conj1céder s) ; +oper v_besch11 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ; +oper v_besch12 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ; +oper v_besch13 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ; +oper v_besch14 : Str -> VerbeN = \s -> mkNV (conj1assiéger s) ; +oper v_besch15 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ; --- ? +oper v_besch16 : Str -> VerbeN = \s -> mkNV (conj1payer s) ; +oper v_besch17 : Str -> VerbeN = \s -> mkNV (conj1payer s) ; +oper v_besch18 : Str -> VerbeN = \s -> mkNV (conj1envoyer s) ; +oper v_besch19 : Str -> VerbeN = \s -> mkNV (conj2finir s) ; +oper v_besch20 : Str -> VerbeN = \s -> mkNV (conj2haïr s) ; +-- oper v_besch21 : Str -> VerbeN = \s -> mkNV (conj s) ; -- not used +oper v_besch22 : Str -> VerbeN = \s -> mkNV (conj3aller s) ; +oper v_besch23 : Str -> VerbeN = \s -> mkNV (conj3tenir s) ; +oper v_besch24 : Str -> VerbeN = \s -> mkNV (conj3quérir s) ; +oper v_besch25 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ; +oper v_besch26 : Str -> VerbeN = \s -> mkNV (conj3vêtir s) ; +oper v_besch27 : Str -> VerbeN = \s -> mkNV (conj3couvrir s) ; +oper v_besch28 : Str -> VerbeN = \s -> mkNV (conj3cueillir s) ; +oper v_besch29 : Str -> VerbeN = \s -> mkNV (conj3assaillir s) ; +oper v_besch30 : Str -> VerbeN = \s -> mkNV (conj3faillir s) ; +oper v_besch31 : Str -> VerbeN = \s -> mkNV (conj3bouillir s) ; +oper v_besch32 : Str -> VerbeN = \s -> mkNV (conj3dormir s) ; +oper v_besch33 : Str -> VerbeN = \s -> mkNV (conj3courir s) ; +oper v_besch34 : Str -> VerbeN = \s -> mkNV (conj3mourir s) ; +oper v_besch35 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ; +oper v_besch36 : Str -> VerbeN = \s -> mkNV (conj3fuir s) ; +oper v_besch37 : Str -> VerbeN = \s -> mkNV (conj3ouïr s) ; +oper v_besch38 : Str -> VerbeN = \s -> mkNV (conj3cevoir s) ; +oper v_besch39 : Str -> VerbeN = \s -> mkNV (conj3voir s) ; +oper v_besch40 : Str -> VerbeN = \s -> mkNV (conj3pourvoir s) ; +oper v_besch41 : Str -> VerbeN = \s -> mkNV (conj3savoir s) ; +oper v_besch42 : Str -> VerbeN = \s -> mkNV (conj3devoir s) ; +oper v_besch43 : Str -> VerbeN = \s -> mkNV (conj3pouvoir s) ; +oper v_besch44 : Str -> VerbeN = \s -> mkNV (conj3mouvoir s) ; +oper v_besch45 : Str -> VerbeN = \s -> mkNV (conj3pleuvoir s) ; +oper v_besch46 : Str -> VerbeN = \s -> mkNV (conj3falloir s) ; +oper v_besch47 : Str -> VerbeN = \s -> mkNV (conj3valoir s) ; +oper v_besch48 : Str -> VerbeN = \s -> mkNV (conj3vouloir s) ; +oper v_besch49 : Str -> VerbeN = \s -> mkNV (conj3asseoir s) ; +oper v_besch50 : Str -> VerbeN = \s -> mkNV (conj3messeoir s) ; --- ? +oper v_besch51 : Str -> VerbeN = \s -> mkNV (conj3surseoir s) ; +oper v_besch52 : Str -> VerbeN = \s -> mkNV (conj3choir s) ; +oper v_besch53 : Str -> VerbeN = \s -> mkNV (conj3rendre s) ; +oper v_besch54 : Str -> VerbeN = \s -> mkNV (conj3prendre s) ; +oper v_besch55 : Str -> VerbeN = \s -> mkNV (conj3battre s) ; +oper v_besch56 : Str -> VerbeN = \s -> mkNV (conj3mettre s) ; +oper v_besch57 : Str -> VerbeN = \s -> mkNV (conj3peindre s) ; +oper v_besch58 : Str -> VerbeN = \s -> mkNV (conj3joindre s) ; +oper v_besch59 : Str -> VerbeN = \s -> mkNV (conj3craindre s) ; +oper v_besch60 : Str -> VerbeN = \s -> mkNV (conj3vaincre s) ; +oper v_besch61 : Str -> VerbeN = \s -> mkNV (conj3traire s) ; +oper v_besch62 : Str -> VerbeN = \s -> mkNV (conj3faire s) ; +oper v_besch63 : Str -> VerbeN = \s -> mkNV (conj3plaire s) ; +oper v_besch64 : Str -> VerbeN = \s -> mkNV (conj3connaître s) ; +oper v_besch65 : Str -> VerbeN = \s -> mkNV (conj3naître s) ; +oper v_besch66 : Str -> VerbeN = \s -> mkNV (conj3paître s) ; +oper v_besch67 : Str -> VerbeN = \s -> mkNV (conj3croître s) ; +oper v_besch68 : Str -> VerbeN = \s -> mkNV (conj3croire s) ; +oper v_besch69 : Str -> VerbeN = \s -> mkNV (conj3boire s) ; +oper v_besch70 : Str -> VerbeN = \s -> mkNV (conj3clore s) ; +oper v_besch71 : Str -> VerbeN = \s -> mkNV (conj3conclure s) ; +oper v_besch72 : Str -> VerbeN = \s -> mkNV (conj3absoudre s) ; +oper v_besch73 : Str -> VerbeN = \s -> mkNV (conj3coudre s) ; +oper v_besch74 : Str -> VerbeN = \s -> mkNV (conj3moudre s) ; +oper v_besch75 : Str -> VerbeN = \s -> mkNV (conj3suivre s) ; +oper v_besch76 : Str -> VerbeN = \s -> mkNV (conj3vivre s) ; +oper v_besch77 : Str -> VerbeN = \s -> mkNV (conj3lire s) ; +oper v_besch78 : Str -> VerbeN = \s -> mkNV (conj3dire s) ; +oper v_besch79 : Str -> VerbeN = \s -> mkNV (conj3rire s) ; +oper v_besch80 : Str -> VerbeN = \s -> mkNV (conj3écrire s) ; +oper v_besch81 : Str -> VerbeN = \s -> mkNV (conj3confire s) ; +oper v_besch82 : Str -> VerbeN = \s -> mkNV (conj3cuire s) ; + +-- 83-99 not used + +oper v_besch100 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do +oper v_besch101 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do +} diff --git a/lib/resource/exper/french/CatFre.gf b/lib/resource/exper/french/CatFre.gf new file mode 100644 index 000000000..2daa7decc --- /dev/null +++ b/lib/resource/exper/french/CatFre.gf @@ -0,0 +1,4 @@ +--# -path=.:../romance:../common:../abstract:../common:prelude + +concrete CatFre of Cat = CommonX - [Tense,TPres,TPast,TFut,TCond] ** CatRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/ConjunctionFre.gf b/lib/resource/exper/french/ConjunctionFre.gf new file mode 100644 index 000000000..8397e141f --- /dev/null +++ b/lib/resource/exper/french/ConjunctionFre.gf @@ -0,0 +1,2 @@ +concrete ConjunctionFre of Conjunction = CatFre ** ConjunctionRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/DiffFre.gf b/lib/resource/exper/french/DiffFre.gf new file mode 100644 index 000000000..00a93935d --- /dev/null +++ b/lib/resource/exper/french/DiffFre.gf @@ -0,0 +1,211 @@ +--# -path=.:../romance:../abstract:../common:prelude + +instance DiffFre of DiffRomance = open CommonRomance, PhonoFre, Prelude in { + + flags optimize=noexpand ; +-- flags optimize=all ; + + param + Prepos = P_de | P_a ; + VType = VHabere | VEsse | VRefl ; + + oper + dative : Case = CPrep P_a ; + genitive : Case = CPrep P_de ; + + prepCase : Case -> Str = \c -> case c of { + Nom => [] ; + Acc => [] ; + CPrep P_a => "à" ; + CPrep P_de => elisDe + } ; + + artDef : Gender -> Number -> Case -> Str = \g,n,c -> + case of { + => pre {"du" ; ["de l'"] / voyelle} ; + => pre {"au" ; ["à l'"] / voyelle} ; + => elisLe ; + => prepCase c ++ elisLa ; + <_, Pl, CPrep P_de> => "des" ; + <_, Pl, CPrep P_a> => "aux" ; + <_, Pl, _ > => "les" + } ; + +-- In these two, "de de/du/des" becomes "de". + + artIndef = \g,n,c -> case of { + => prepCase c ++ genForms "un" "une" ! g ; + => elisDe ; + _ => prepCase c ++ "des" + } ; + + possCase = \_,_,c -> prepCase c ; + + partitive = \g,c -> case c of { + CPrep P_de => elisDe ; + _ => prepCase c ++ artDef g Sg (CPrep P_de) + } ; + + conjunctCase : NPForm -> NPForm = \c -> case c of { + Aton k => Ton k ; + _ => c + } ; + + auxVerb : VType -> (VF => Str) = \vtyp -> case vtyp of { + VHabere => avoir_V.s ; + _ => copula.s + } ; + + partAgr : VType -> VPAgr = \vtyp -> case vtyp of { + VHabere => vpAgrNone ; + _ => VPAgrSubj + } ; + + vpAgrClit : Agr -> VPAgr = \a -> + VPAgrClit (aagr a.g a.n) ; --- subty + +---- pronArg = pronArgGen Neg ; --- takes more space and time + + pronArg : Number -> Person -> CAgr -> CAgr -> Str * Str * Bool = + \n,p,acc,dat -> + let + pacc = case acc of { + CRefl => elision "s" ; --- use of reflPron incred. expensive + _ => argPron Fem n p Acc + },True> ; + CPron ag an ap => ; + _ => <[],False> + } ; + in + case dat of { + CPron ag an ap => let pdat = argPron ag an ap dative in case ap of { + P3 => ; + _ => + } ; + _ => + } ; + + +-- Positive polarity is used in the imperative: stressed for 1st and +-- 2nd persons. + + pronArgGen : Polarity -> Number -> Person -> CAgr -> CAgr -> Str * Str = + \b,n,p,acc,dat -> + let + cas : Person -> Case -> Case = \pr,c -> case of { + => CPrep P_de ; --- encoding in argPron + _ => c + } ; + pacc = case acc of { + CRefl => case p of { + P3 => elision "s" ; --- use of reflPron incred. expensive + _ => argPron Fem n p (cas p Acc) + } ; + CPron ag an ap => argPron ag an ap (cas ap Acc) ; + _ => [] + } ; + pdat = case dat of { + CPron ag an ap => argPron ag an ap (cas ap dative) ; + _ => [] + } ; + in + case dat of { + CPron _ _ P3 => ; + _ => + } ; + + mkImperative b p vp = { + s = \\pol,aag => + let + num = if_then_else Number b Pl aag.n ; + agr = {g = aag.g ; n = num ; p = p} ; + verb = (vp.s ! VPImperat).fin ! agr ; + neg = vp.neg ! pol ; + hascl = (pronArg agr.n agr.p vp.clAcc vp.clDat).p3 ; + clpr = pronArgGen pol agr.n agr.p vp.clAcc vp.clDat ; + compl = neg.p2 ++ clpr.p2 ++ vp.comp ! agr ++ vp.ext ! pol + in + case pol of { + Pos => verb ++ if_then_Str hascl "-" [] ++ clpr.p1 ++ compl ; + Neg => neg.p1 ++ clpr.p1 ++ verb ++ compl + } + } ; + + + negation : Polarity => (Str * Str) = table { + Pos => <[],[]> ; + Neg => + } ; + + conjThan = elisQue ; + conjThat = elisQue ; + + subjIf = "si" ; --- s' + + clitInf _ cli inf = cli ++ inf ; + + relPron : Bool => AAgr => Case => Str = \\b,a,c => + let + lequel = artDef a.g a.n c + quelPron ! a + in + case b of { + False => case c of { + Nom => "qui" ; + Acc => elisQue ; + CPrep P_de => "dont" ; + _ => lequel + } ; + _ => lequel + } ; + + pronSuch : AAgr => Str = aagrForms "tel" "telle" "tels" "telles" ; + + quelPron : AAgr => Str = aagrForms "quel" "quelle" "quels" "quelles" ; + + partQIndir = [] ; --- only for qui,que: elision "c" ; + + reflPron : Number -> Person -> Case -> Str = \n,p,c -> + let pron = argPron Fem n p c in + case of { + => elision "s" ; + => prepCase c ++ "soi" ; + _ => pron + } ; + + argPron : Gender -> Number -> Person -> Case -> Str = + let + cases : (x,y : Str) -> Case -> Str = \me,moi,c -> case c of { + Acc | CPrep P_a => me ; + _ => moi + } ; + cases3 : (x,y,z : Str) -> Case -> Str = \les,leur,eux,c -> case c of { + Acc => les ; + CPrep P_a => leur ; + _ => eux + } ; + in + \g,n,p -> case of { + <_,Sg,P1> => cases (elision "m") "moi" ; + <_,Sg,P2> => cases (elision "t") "toi" ; + <_,Pl,P1> => \_ -> "nous" ; + <_,Pl,P2> => \_ -> "vous" ; + => cases3 elisLa "lui" "elle" ; + <_,Sg,P3> => cases3 (elision "l") "lui" "lui" ; + => cases3 "les" "leur" "elles" ; + <_,Pl,P3> => cases3 "les" "leur" "eux" + } ; + + vRefl : VType = VRefl ; + isVRefl : VType -> Bool = \ty -> case ty of { + VRefl => True ; + _ => False + } ; + + auxPassive : Verb = copula ; + + copula : Verb = {s = table VF ["être";"être";"suis";"es";"est";"sommes";"êtes";"sont";"sois";"sois";"soit";"soyons";"soyez";"soient";"étais";"étais";"était";"étions";"étiez";"étaient";"fusse";"fusses";"fût";"fussions";"fussiez";"fussent";"fus";"fus";"fut";"fûmes";"fûtes";"furent";"serai";"seras";"sera";"serons";"serez";"seront";"serais";"serais";"serait";"serions";"seriez";"seraient";"sois";"soyons";"soyez";"été";"étés";"étée";"étées";"étant"]; vtyp=VHabere} ; + + avoir_V : Verb = {s=table VF ["avoir";"avoir";"ai";"as";"a";"avons";"avez";"ont";"aie";"aies";"ait";"ayons";"ayez";"aient";"avais";"avais";"avait";"avions";"aviez";"avaient";"eusse";"eusses";"eût";"eussions";"eussiez";"eussent";"eus";"eus";"eut";"eûmes";"eûtes";"eurent";"aurai";"auras";"aura";"aurons";"aurez";"auront";"aurais";"aurais";"aurait";"aurions";"auriez";"auraient";"aie";"ayons";"ayez";"eu";"eus";"eue";"eues";"ayant"];vtyp=VHabere}; + +} diff --git a/lib/resource/exper/french/ExtraFre.gf b/lib/resource/exper/french/ExtraFre.gf new file mode 100644 index 000000000..1877d8334 --- /dev/null +++ b/lib/resource/exper/french/ExtraFre.gf @@ -0,0 +1,60 @@ +concrete ExtraFre of ExtraFreAbs = ExtraRomanceFre ** + open CommonRomance, PhonoFre, MorphoFre, ParadigmsFre, ParamX, ResFre in { + + lin + EstcequeS qs = {s = "est-ce" ++ elisQue ++ qs.s ! Indic} ; + EstcequeIAdvS idet qs = {s = idet.s ++ "est-ce" ++ elisQue ++ qs.s ! Indic} ; + + QueestcequeIP = { + s = table { + c => prepQue c ++ "est-ce" ++ caseQue c + } ; + a = aagr Fem Pl + } ; + + QuiestcequeIP = { + s = table { + c => prepQue c ++ "qui" ++ "est-ce" ++ caseQue c + } ; + a = aagr Fem Pl + } ; + + i8fem_Pron = mkPronoun + (elision "j") (elision "m") (elision "m") "moi" "mon" (elisPoss "m") "mes" + Fem Sg P1 ; + these8fem_NP = makeNP ["celles-ci"] Fem Pl ; + they8fem_Pron = mkPronoun + "elles" "les" "leur" "eux" "leur" "leur" "leurs" + Fem Pl P3 ; + this8fem_NP = pn2np (mkPN ["celle-ci"] Fem) ; + those8fem_NP = makeNP ["celles-là"] Fem Pl ; + we8fem_Pron = mkPronoun "nous" "nous" "nous" "nous" "notre" "notre" "nos" + Fem Pl P1 ; + whoPl8fem_IP = + {s = \\c => artDef a.g a.n c + quelPron ! a ; a = a} + where {a = aagr Fem Sg} ; + whoSg8fem_IP = + {s = \\c => artDef a.g a.n c + quelPron ! a ; a = a} + where {a = aagr Fem Pl} ; + + youSg8fem_Pron = mkPronoun + "tu" (elision "t") (elision "t") "toi" "ton" (elisPoss "t") "tes" + Fem Sg P2 ; + youPl8fem_Pron, + youPol8fem_Pron = + mkPronoun + "vous" "vous" "vous" "vous" "votre" "votre" "vos" + Fem Pl P2 ; + + oper + prepQue : Case -> Str = \c -> case c of { + Nom | Acc => elisQue ; + _ => prepCase c ++ "qui" --- + } ; + caseQue : Case -> Str = \c -> case c of { + Nom => "qui" ; + _ => elisQue + } ; + + +} diff --git a/lib/resource/exper/french/ExtraFreAbs.gf b/lib/resource/exper/french/ExtraFreAbs.gf new file mode 100644 index 000000000..33f518ab7 --- /dev/null +++ b/lib/resource/exper/french/ExtraFreAbs.gf @@ -0,0 +1,34 @@ +-- Structures special for French. These are not implemented in other +-- Romance languages. + +abstract ExtraFreAbs = ExtraRomanceAbs ** { + +-- Notice: only direct (main-clause) questions are generated, and needed. + + fun + EstcequeS : S -> Utt ; -- est-ce qu'il pleut + EstcequeIAdvS : IAdv -> S -> Utt ; -- où est-ce qu'il pleut + +-- These also generate indirect (subordinate) questions. + + QueestcequeIP : IP ; -- qu'est-ce (que/qui) + QuiestcequeIP : IP ; -- qu'est-ce (que/qui) + +-- Feminine variants of pronouns (those in $Structural$ are +-- masculine, which is the default when gender is unknown). + + i8fem_Pron : Pron ; + these8fem_NP : NP ; + they8fem_Pron : Pron ; + this8fem_NP : NP ; + those8fem_NP : NP ; + + we8fem_Pron : Pron ; + whoPl8fem_IP : IP ; + whoSg8fem_IP : IP ; + + youSg8fem_Pron : Pron ; + youPl8fem_Pron : Pron ; + youPol8fem_Pron : Pron ; + +} diff --git a/lib/resource/exper/french/ExtraRomanceFre.gf b/lib/resource/exper/french/ExtraRomanceFre.gf new file mode 100644 index 000000000..ba7d7b160 --- /dev/null +++ b/lib/resource/exper/french/ExtraRomanceFre.gf @@ -0,0 +1,2 @@ +concrete ExtraRomanceFre of ExtraRomanceAbs = CatFre ** ExtraRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/French.gf b/lib/resource/exper/french/French.gf new file mode 100644 index 000000000..00371ec6e --- /dev/null +++ b/lib/resource/exper/french/French.gf @@ -0,0 +1,7 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete French of FrenchAbs = + LangFre, + IrregFre, + ExtraFre + ** {} ; diff --git a/lib/resource/exper/french/FrenchAbs.gf b/lib/resource/exper/french/FrenchAbs.gf new file mode 100644 index 000000000..e762e33c3 --- /dev/null +++ b/lib/resource/exper/french/FrenchAbs.gf @@ -0,0 +1,5 @@ +abstract FrenchAbs = + Lang, + IrregFreAbs, + ExtraFreAbs + ** {} ; diff --git a/lib/resource/exper/french/GrammarFre.gf b/lib/resource/exper/french/GrammarFre.gf new file mode 100644 index 000000000..698cea528 --- /dev/null +++ b/lib/resource/exper/french/GrammarFre.gf @@ -0,0 +1,21 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete GrammarFre of Grammar = + NounFre, + VerbFre, + AdjectiveFre, + AdverbFre, + NumeralFre, + SentenceFre, + QuestionFre, + RelativeFre, + ConjunctionFre, + PhraseFre, + TextX - [Tense,TPres,TPast,TFut,TCond], + IdiomFre, + StructuralFre + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/lib/resource/exper/french/IdiomFre.gf b/lib/resource/exper/french/IdiomFre.gf new file mode 100644 index 000000000..3f12683fa --- /dev/null +++ b/lib/resource/exper/french/IdiomFre.gf @@ -0,0 +1,45 @@ +concrete IdiomFre of Idiom = CatFre ** + open (P = ParamX), PhonoFre, MorphoFre, ParadigmsFre, Prelude in { + + flags optimize=all_subs ; + + lin + ImpersCl vp = mkClause "il" True (agrP3 Masc Sg) vp ; + GenericCl vp = mkClause "on" True (agrP3 Masc Sg) vp ; + + ExistNP np = + mkClause "il" True (agrP3 Masc Sg) + (insertClit2 "y" (insertComplement (\\_ => np.s ! Ton Acc) (predV avoir_V))) ; + + ExistIP ip = { + s = \\t,a,p,_ => + ip.s ! Nom ++ + (mkClause "il" True (agrP3 Masc Sg) + (insertClit2 "y" (predV avoir_V))).s + ! DDir ! t ! a ! p ! Indic ---- DInv + } ; + + CleftNP np rs = mkClause elisCe True (agrP3 Masc Sg) + (insertComplement (\\_ => rs.s ! Indic ! np.a) + (insertComplement (\\_ => np.s ! Ton rs.c) (predV copula))) ; + + CleftAdv ad s = mkClause elisCe True (agrP3 Masc Sg) + (insertComplement (\\_ => conjThat ++ s.s ! Indic) + (insertComplement (\\_ => ad.s) (predV copula))) ; + + + ProgrVP vp = + insertComplement + (\\a => "en" ++ "train" ++ elisDe ++ infVP vp a) + (predV copula) ; + + ImpPl1 vp = {s = + (mkImperative False P1 vp).s ! Pos ! {n = Pl ; g = Masc} --- fem + } ; + + oper + elisCe = elision "c" ; + +} + + diff --git a/lib/resource/exper/french/IrregFre.gf b/lib/resource/exper/french/IrregFre.gf new file mode 100644 index 000000000..748cb4361 --- /dev/null +++ b/lib/resource/exper/french/IrregFre.gf @@ -0,0 +1,395 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +-- Irregular verbs from Nancy, based on a list from Sylvain Pogodalla, 25/11/2004 +-- Translated to GF by Aarne Ranta +-- added extracted subcat information 29/11 + +concrete IrregFre of IrregFreAbs = CatFre ** + open DiffFre, MorphoFre, BeschFre, Prelude in { + + flags optimize=values ; + +-- all verbs in classes with "er" and "finir" are omitted + +lin + abattre_V2 = v_besch55 "abattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + absoudre_V2 = v_besch72 "absoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + abstenir_V = v_besch23 "abstenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + abstraire_V2 = v_besch61 "abstraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + accourir_V = v_besch33 "accourir" ** {vtyp = VHabere ; lock_V = <>} ; + accroître_V2 = v_besch73 "accroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + accueillir_V2 = v_besch28 "accueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + acquérir_V2 = v_besch24 "acquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + adjoindre_V2 = v_besch58 "adjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + admettre_V2 = v_besch56 "admettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + advenir_V = v_besch23 "advenir" ** {vtyp = VEsse ; lock_V = <>} ; + aller_V = v_besch22 "aller" ** {vtyp = VEsse ; lock_V = <>} ; + apercevoir_V2 = v_besch38 "apercevoir" ** {vtyp = VRefl ; lock_V2 = <> ; c2 = complGen} ; + apparaître_V = v_besch64 "apparaître" ** {vtyp = VHabere ; lock_V = <>} ; + appartenir_V2 = v_besch23 "appartenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + appendre_V2 = v_besch53 "appendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + apprendre_V2 = v_besch54 "apprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + assaillir_V2 = v_besch29 "assaillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + asseoir_V2 = v_besch49 "asseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + astreindre_V2 = v_besch57 "astreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + atteindre_V2 = v_besch57 "atteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + attendre_V2 = v_besch53 "attendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + avoir_V2 = v_besch1 "avoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + battre_V2 = v_besch55 "battre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + boire_V2 = v_besch69 "boire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + bouillir_V2 = v_besch31 "bouillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + braire_V = v_besch61 "braire" ** {vtyp = VHabere ; lock_V = <>} ; + ceindre_V2 = v_besch57 "ceindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + choir_V = v_besch52 "choir" ** {vtyp = VEsse ; lock_V = <>} ; + circonscrire_V2 = v_besch80 "circonscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + circonvenir_V2 = v_besch23 "circonvenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + clore_V2 = v_besch70 "clore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + combattre_V2 = v_besch55 "combattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + commettre_V2 = v_besch56 "commettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + comparaître_V2 = v_besch64 "comparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + complaire_V2 = v_besch63 "complaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + comprendre_V2 = v_besch54 "comprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + compromettre_V2 = v_besch56 "compromettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + concevoir_V2 = v_besch38 "concevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conclure_V2 = v_besch71 "conclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + concourir_V2 = v_besch33 "concourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + condescendre_V2 = v_besch53 "condescendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + conduire_V2 = v_besch82 "conduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + confire_V2 = v_besch81 "confire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + confondre_V2 = v_besch53 "confondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conjoindre_V2 = v_besch58 "conjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + connaître_V2 = v_besch64 "connaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conquérir_V2 = v_besch24 "conquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + consentir_V2 = v_besch25 "consentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + construire_V2 = v_besch82 "construire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contenir_V2 = v_besch23 "contenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contraindre_V2 = v_besch59 "contraindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrebattre_V2 = v_besch55 "contrebattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contredire_V2 = v_besch78 "contredire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrefaire_V2 = v_besch62 "contrefaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrevenir_V2 = v_besch23 "contrevenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + convaincre_V2 = v_besch60 "convaincre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + convenir_V2 = v_besch23 "convenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + correspondre_V2 = v_besch53 "correspondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + corrompre_V2 = v_besch53 "corrompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + coudre_V2 = v_besch73 "coudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + courir_V2 = v_besch33 "courir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + couvrir_V2 = v_besch27 "couvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + craindre_V2 = v_besch59 "craindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + croire_V2 = v_besch68 "croire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + croître_V = v_besch67 "croître" ** {vtyp = VEsse ; lock_V = <>} ; + cueillir_V2 = v_besch28 "cueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + cuire_V2 = v_besch82 "cuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + débattre_V2 = v_besch55 "débattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + débouillir_V2 = v_besch31 "débouillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décevoir_V2 = v_besch38 "décevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déchoir_V2 = v_besch52 "déchoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déclore_V2 = v_besch70 "déclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décommettre_V2 = v_besch56 "décommettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déconfire_V2 = v_besch81 "déconfire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + découdre_V2 = v_besch73 "découdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + découvrir_V2 = v_besch27 "découvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décrire_V2 = v_besch80 "décrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décroître_V2 = v_besch67 "décroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décuire_V2 = v_besch82 "décuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déduire_V2 = v_besch82 "déduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + défaillir_V = v_besch30 "défaillir" ** {vtyp = VHabere ; lock_V = <>} ; + défaire_V2 = v_besch62 "défaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + défendre_V2 = v_besch53 "défendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démentir_V2 = v_besch25 "démentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démettre_V2 = v_besch56 "démettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démordre_V = v_besch53 "démordre" ** {vtyp = VHabere ; lock_V = <>} ; + départir_V2 = v_besch25 "départir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + dépeindre_V2 = v_besch57 "dépeindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dépendre_V2 = v_besch53 "dépendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + déplaire_V = v_besch63 "déplaire" ** {vtyp = VHabere ; lock_V = <>} ; + dépourvoir_V2 = v_besch40 "dépourvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déprendre_V2 = v_besch54 "déprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + désapprendre_V2 = v_besch54 "désapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + descendre_V2 = v_besch53 "descendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + desservir_V2 = v_besch35 "desservir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déteindre_V2 = v_besch57 "déteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détendre_V2 = v_besch53 "détendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détenir_V2 = v_besch23 "détenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détordre_V2 = v_besch53 "détordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détruire_V2 = v_besch82 "détruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + devenir_V = v_besch23 "devenir" ** {vtyp = VEsse ; lock_V = <>} ; + dévêtir_V2 = v_besch26 "dévêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + devoir_V2 = v_besch42 "devoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dire_V2 = v_besch78 "dire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + disconvenir_V2 = v_besch23 "disconvenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + discourir_V2 = v_besch33 "discourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + disjoindre_V2 = v_besch58 "disjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + disparaître_V2 = v_besch64 "disparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dissoudre_V2 = v_besch72 "dissoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distendre_V2 = v_besch53 "distendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distordre_V2 = v_besch53 "distordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distraire_V2 = v_besch61 "distraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dormir_V2 = v_besch32 "dormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ébattre_V = v_besch55 "ébattre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + échoir_V2 = v_besch52 "échoir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ; + éclore_V2 = v_besch70 "éclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + éconduire_V2 = v_besch82 "éconduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + écrire_V2 = v_besch80 "écrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + élire_V2 = v_besch77 "élire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + embatre_V2 = v_besch55 "embatre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + embattre_V2 = v_besch55 "embattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + emboire_V = v_besch69 "emboire" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + émettre_V2 = v_besch56 "émettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + émoudre_V2 = v_besch74 "émoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + émouvoir_V2 = v_besch44 "émouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + empreindre_V2 = v_besch57 "empreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + enceindre_V2 = v_besch57 "enceindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enclore_V2 = v_besch70 "enclore" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + encourir_V2 = v_besch33 "encourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + endormir_V2 = v_besch32 "endormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enduire_V2 = v_besch82 "enduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enfreindre_V2 = v_besch57 "enfreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enfuir_V = v_besch36 "enfuir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + enjoindre_V2 = v_besch58 "enjoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enquérir_V = v_besch24 "enquérir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entendre_V2 = v_besch53 "entendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entr'apercevoir_V = v_besch38 "entr'apercevoir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entrebattre_V = v_besch55 "entrebattre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_détruire_V = v_besch82 "entre-détruire" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_haïr_V = v_besch20 "entre-haïr" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entremettre_V = v_besch56 "entremettre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_nuire_V = v_besch82 "entre-nuire" ** {vtyp = VHabere ; lock_V = <>} ; + entreprendre_V2 = v_besch54 "entreprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entretenir_V2 = v_besch23 "entretenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entrevoir_V2 = v_besch39 "entrevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entrouvrir_V2 = v_besch27 "entrouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + envoyer_V2 = v_besch18 "envoyer" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + épandre_V2 = v_besch53 "épandre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + éperdre_V = v_besch53 "éperdre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + éprendre_V = v_besch54 "éprendre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + équivaloir_V2 = v_besch47 "équivaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + éteindre_V2 = v_besch57 "éteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + étendre_V2 = v_besch53 "étendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + étreindre_V2 = v_besch57 "étreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + être_V = v_besch2 "être" ** {vtyp = VHabere ; lock_V = <>} ; + exclure_V2 = v_besch71 "exclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + extraire_V2 = v_besch61 "extraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + faillir_V2 = v_besch30 "faillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + faire_V2 = v_besch62 "faire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + falloir_V = v_besch46 "falloir" ** {vtyp = VHabere ; lock_V = <>} ; + feindre_V2 = v_besch57 "feindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fendre_V2 = v_besch53 "fendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fondre_V2 = v_besch53 "fondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + forfaire_V2 = v_besch62 "forfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + foutre_V2 = v_besch53 "foutre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + frire_V2 = v_besch81 "frire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fuir_V2 = v_besch36 "fuir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + geindre_V2 = v_besch57 "geindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + gésir_V2 = mkNV (conj3gésir "gésir") ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + haïr_V2 = v_besch20 "haïr" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + inclure_V2 = v_besch71 "inclure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + induire_V2 = v_besch82 "induire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + inscrire_V2 = v_besch80 "inscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + instruire_V2 = v_besch82 "instruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + interdire_V2 = v_besch78 "interdire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + interrompre_V2 = v_besch53 "interrompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + intervenir_V = v_besch23 "intervenir" ** {vtyp = VEsse ; lock_V = <>} ; + introduire_V2 = v_besch82 "introduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + joindre_V2 = v_besch58 "joindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + lire_V2 = v_besch77 "lire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + luire_V = v_besch82 "luire" ** {vtyp = VHabere ; lock_V = <>} ; + mainmettre_V2 = v_besch56 "mainmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + maintenir_V2 = v_besch23 "maintenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + méconnaître_V2 = v_besch64 "méconnaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mécroire_V2 = v_besch68 "mécroire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + médire_V2 = v_besch78 "médire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + mentir_V2 = v_besch25 "mentir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ; + méprendre_V2 = v_besch54 "méprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + messeoir_V2 = v_besch50 "messeoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mettre_V2 = v_besch56 "mettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mévendre_V2 = v_besch53 "mévendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mordre_V2 = v_besch53 "mordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + morfondre_V = v_besch53 "morfondre" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + moudre_V2 = v_besch74 "moudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mourir_V = v_besch34 "mourir" ** {vtyp = VEsse ; lock_V = <>} ; + mouvoir_V2 = v_besch44 "mouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + naître_V = v_besch65 "naître" ** {vtyp = VEsse ; lock_V = <>} ; + nuire_V2 = v_besch82 "nuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + obtenir_V2 = v_besch23 "obtenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + obvenir_V = v_besch23 "obvenir" ** {vtyp = VEsse ; lock_V = <>} ; + occlure_V2 = v_besch71 "occlure" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + offrir_V2 = v_besch27 "offrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + oindre_V2 = v_besch58 "oindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + omettre_V2 = v_besch56 "omettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ouïr_V2 = v_besch37 "ouïr" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ouvrir_V2 = v_besch27 "ouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + paître_V2 = v_besch66 "paître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + paître_V = v_besch66 "paître" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + paraître_V = v_besch64 "paraître" ** {vtyp = VHabere ; lock_V = <>} ; + parcourir_V2 = v_besch33 "parcourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + parfondre_V2 = v_besch53 "parfondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + partir_V = v_besch25 "partir" ** {vtyp = VEsse ; lock_V = <>} ; + parvenir_V = v_besch23 "parvenir" ** {vtyp = VEsse ; lock_V = <>} ; + peindre_V2 = v_besch57 "peindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pendre_V2 = v_besch53 "pendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + percevoir_V2 = v_besch38 "percevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + perdre_V2 = v_besch53 "perdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + permettre_V2 = v_besch56 "permettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + plaindre_V2 = v_besch59 "plaindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + plaire_V2 = v_besch63 "plaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + pleuvoir_V = v_besch45 "pleuvoir" ** {vtyp = VHabere ; lock_V = <>} ; + poindre_V2 = v_besch58 "poindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pondre_V2 = v_besch53 "pondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pourfendre_V2 = v_besch53 "pourfendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + poursuivre_V2 = v_besch75 "poursuivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pourvoir_V2 = v_besch40 "pourvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + pouvoir_V = v_besch43 "pouvoir" ** {vtyp = VHabere ; lock_V = <>} ; + prédire_V2 = v_besch78 "prédire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prendre_V2 = v_besch54 "prendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prescrire_V2 = v_besch80 "prescrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pressentir_V2 = v_besch25 "pressentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prétendre_V2 = v_besch53 "prétendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + prévaloir_V2 = v_besch47 "prévaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + prévenir_V2 = v_besch23 "prévenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prévoir_V2 = v_besch39 "prévoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + produire_V2 = v_besch82 "produire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + promettre_V2 = v_besch56 "promettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + promouvoir_V2 = v_besch44 "promouvoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + proscrire_V2 = v_besch80 "proscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + provenir_V = v_besch23 "provenir" ** {vtyp = VEsse ; lock_V = <>} ; + rabattre_V2 = v_besch55 "rabattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + raire_V2 = v_besch61 "raire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rapprendre_V2 = v_besch54 "rapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rasseoir_V2 = v_besch49 "rasseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réadmettre_V2 = v_besch56 "réadmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réapparaître_V = v_besch64 "réapparaître" ** {vtyp = VHabere ; lock_V = <>} ; + réapprendre_V2 = v_besch54 "réapprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rebattre_V2 = v_besch55 "rebattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recevoir_V2 = v_besch38 "recevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recomparaître_V2 = v_besch64 "recomparaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconduire_V2 = v_besch82 "reconduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconnaître_V2 = v_besch64 "reconnaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconquérir_V2 = v_besch24 "reconquérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconstruire_V2 = v_besch82 "reconstruire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recoudre_V2 = v_besch73 "recoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recourir_V2 = v_besch33 "recourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + recouvrir_V2 = v_besch27 "recouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + récrire_V2 = v_besch80 "récrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recroître_V2 = v_besch67 "recroître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recueillir_V2 = v_besch28 "recueillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recuire_V2 = v_besch82 "recuire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redécouvrir_V2 = v_besch27 "redécouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redéfaire_V2 = v_besch62 "redéfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redescendre_V2 = v_besch53 "redescendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redevenir_V = v_besch23 "redevenir" ** {vtyp = VEsse ; lock_V = <>} ; + redevoir_V2 = v_besch42 "redevoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redire_V2 = v_besch78 "redire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réduire_V2 = v_besch82 "réduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + réécrire_V2 = v_besch80 "réécrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réélire_V2 = v_besch77 "réélire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réentendre_V2 = v_besch53 "réentendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refaire_V2 = v_besch62 "refaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refendre_V2 = v_besch53 "refendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refondre_V2 = v_besch53 "refondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réinscrire_V2 = v_besch80 "réinscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réintroduire_V2 = v_besch82 "réintroduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rejoindre_V2 = v_besch58 "rejoindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + relire_V2 = v_besch77 "relire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reluire_V2 = v_besch82 "reluire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remettre_V2 = v_besch56 "remettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remordre_V2 = v_besch53 "remordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remoudre_V2 = v_besch74 "remoudre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + renaître_V2 = v_besch65 "renaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rendormir_V2 = v_besch32 "rendormir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rendre_V2 = v_besch53 "rendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rentraire_V2 = v_besch61 "rentraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rentrouvrir_V2 = v_besch27 "rentrouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + renvoyer_V2 = v_besch18 "renvoyer" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repaître_V2 = v_besch66 "repaître" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + répandre_V2 = v_besch53 "répandre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reparaître_V = v_besch64 "reparaître" ** {vtyp = VEsse ; lock_V = <>} ; + repartir_V = v_besch25 "repartir" ** {vtyp = VEsse ; lock_V = <>} ; + repeindre_V2 = v_besch57 "repeindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rependre_V2 = v_besch53 "rependre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repentir_V = v_besch25 "repentir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + reperdre_V2 = v_besch53 "reperdre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repleuvoir_V = v_besch45 "repleuvoir" ** {vtyp = VHabere ; lock_V = <>} ; + répondre_V2 = v_besch53 "répondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reprendre_V2 = v_besch54 "reprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reproduire_V2 = v_besch82 "reproduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + requérir_V2 = v_besch24 "requérir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + résoudre_V2 = mkNV (conj3résoudre "résoudre") ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ressentir_V2 = v_besch25 "ressentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + resservir_V2 = v_besch35 "resservir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ressortir_V = v_besch25 "ressortir" ** {vtyp = VEsse ; lock_V = <>} ; + ressouvenir_V = v_besch23 "ressouvenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + restreindre_V2 = v_besch57 "restreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reteindre_V2 = v_besch57 "reteindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retendre_V2 = v_besch53 "retendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retenir_V2 = v_besch23 "retenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retondre_V2 = v_besch53 "retondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retordre_V2 = v_besch53 "retordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retraduire_V2 = v_besch82 "retraduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retraire_V2 = v_besch61 "retraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retranscrire_V2 = v_besch80 "retranscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retransmettre_V2 = v_besch56 "retransmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rétreindre_V2 = v_besch57 "rétreindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revaloir_V2 = v_besch47 "revaloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revendre_V2 = v_besch53 "revendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revenir_V = v_besch23 "revenir" ** {vtyp = VEsse ; lock_V = <>} ; + revêtir_V2 = v_besch26 "revêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revivre_V2 = v_besch76 "revivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revoir_V2 = v_besch39 "revoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revouloir_V2 = v_besch48 "revouloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rire_V2 = v_besch79 "rire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complGen} ; + rompre_V2 = v_besch53 "rompre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rouvrir_V2 = v_besch27 "rouvrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + saillir_V2 = v_besch29 "saillir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + satisfaire_V2 = v_besch62 "satisfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + savoir_V2 = v_besch41 "savoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + secourir_V2 = v_besch33 "secourir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + séduire_V2 = v_besch82 "séduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sentir_V2 = v_besch25 "sentir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + seoir_V = v_besch50 "seoir" ** {vtyp = VHabere ; lock_V = <>} ; + servir_V2 = v_besch35 "servir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sortir_V = v_besch25 "sortir" ** {vtyp = VHabere ; lock_V = <>} ; + soubattre_V2 = v_besch55 "soubattre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + souffrir_V2 = v_besch27 "souffrir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soumettre_V2 = v_besch56 "soumettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + sourire_V2 = v_besch79 "sourire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + souscrire_V2 = v_besch80 "souscrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + sous_entendre_V2 = v_besch53 "sous-entendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sous_tendre_V2 = v_besch53 "sous-tendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soustraire_V2 = v_besch61 "soustraire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soutenir_V2 = v_besch23 "soutenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + souvenir_V = v_besch23 "souvenir" ** {vtyp = VHabere ; lock_V = <> ; c2 = complAcc} ; + subvenir_V2 = v_besch23 "subvenir" ** {vtyp = VEsse ; lock_V2 = <> ; c2 = complDat} ; + suffire_V2 = v_besch81 "suffire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + suivre_V2 = v_besch75 "suivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surfaire_V2 = v_besch62 "surfaire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surprendre_V2 = v_besch54 "surprendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surproduire_V2 = v_besch82 "surproduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surseoir_V2 = v_besch51 "surseoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + surtondre_V2 = v_besch53 "surtondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + survenir_V = v_besch23 "survenir" ** {vtyp = VEsse ; lock_V = <>} ; + survivre_V2 = v_besch76 "survivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + suspendre_V2 = v_besch53 "suspendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + taire_V2 = v_besch63 "taire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + teindre_V2 = v_besch57 "teindre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tendre_V2 = v_besch53 "tendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + tenir_V2 = v_besch23 "tenir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complDat} ; + tondre_V2 = v_besch53 "tondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tordre_V2 = v_besch53 "tordre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + traduire_V2 = v_besch82 "traduire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + traire_V2 = v_besch61 "traire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transcrire_V2 = v_besch80 "transcrire" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transmettre_V2 = v_besch56 "transmettre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transparaître_V = v_besch64 "transparaître" ** {vtyp = VHabere ; lock_V = <>} ; + tréfondre_V2 = v_besch53 "tréfondre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tressaillir_V = v_besch29 "tressaillir" ** {vtyp = VHabere ; lock_V = <>} ; + vaincre_V2 = v_besch60 "vaincre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + valoir_V2 = v_besch47 "valoir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vendre_V2 = v_besch53 "vendre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + venir_V = v_besch23 "venir" ** {vtyp = VEsse ; lock_V = <>} ; + vêtir_V2 = v_besch26 "vêtir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vivre_V2 = v_besch76 "vivre" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + voir_V2 = v_besch39 "voir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vouloir_V2 = v_besch48 "vouloir" ** {vtyp = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + +} diff --git a/lib/resource/exper/french/IrregFreAbs.gf b/lib/resource/exper/french/IrregFreAbs.gf new file mode 100644 index 000000000..f82d7c0a0 --- /dev/null +++ b/lib/resource/exper/french/IrregFreAbs.gf @@ -0,0 +1,391 @@ +--# -path=.:../romance:../abstract:../../prelude + +-- Irregular verbs from Nancy, based on a list from Sylvain Pogodalla, 25/11/2004 +-- Translated to GF by Aarne Ranta +-- added extracted subcat information 29/11 + +abstract IrregFreAbs = Cat ** { + +-- all verbs in classes with "er" and "ir" like "finir" are omitted + +fun + abattre_V2 : V2 ; + absoudre_V2 : V2 ; + abstenir_V : V ; + abstraire_V2 : V2 ; + accourir_V : V ; + accroître_V2 : V2 ; + accueillir_V2 : V2 ; + acquérir_V2 : V2 ; + adjoindre_V2 : V2 ; + admettre_V2 : V2 ; + advenir_V : V ; + aller_V : V ; + apercevoir_V2 : V2 ; + apparaître_V : V ; + appartenir_V2 : V2 ; + appendre_V2 : V2 ; + apprendre_V2 : V2 ; + assaillir_V2 : V2 ; + asseoir_V2 : V2 ; + astreindre_V2 : V2 ; + atteindre_V2 : V2 ; + attendre_V2 : V2 ; + avoir_V2 : V2 ; + battre_V2 : V2 ; + boire_V2 : V2 ; + bouillir_V2 : V2 ; + braire_V : V ; + ceindre_V2 : V2 ; + choir_V : V ; + circonscrire_V2 : V2 ; + circonvenir_V2 : V2 ; + clore_V2 : V2 ; + combattre_V2 : V2 ; + commettre_V2 : V2 ; + comparaître_V2 : V2 ; + complaire_V2 : V2 ; + comprendre_V2 : V2 ; + compromettre_V2 : V2 ; + concevoir_V2 : V2 ; + conclure_V2 : V2 ; + concourir_V2 : V2 ; + condescendre_V2 : V2 ; + conduire_V2 : V2 ; + confire_V2 : V2 ; + confondre_V2 : V2 ; + conjoindre_V2 : V2 ; + connaître_V2 : V2 ; + conquérir_V2 : V2 ; + consentir_V2 : V2 ; + construire_V2 : V2 ; + contenir_V2 : V2 ; + contraindre_V2 : V2 ; + contrebattre_V2 : V2 ; + contredire_V2 : V2 ; + contrefaire_V2 : V2 ; + contrevenir_V2 : V2 ; + convaincre_V2 : V2 ; + convenir_V2 : V2 ; + correspondre_V2 : V2 ; + corrompre_V2 : V2 ; + coudre_V2 : V2 ; + courir_V2 : V2 ; + couvrir_V2 : V2 ; + craindre_V2 : V2 ; + croire_V2 : V2 ; + croître_V : V ; + cueillir_V2 : V2 ; + cuire_V2 : V2 ; + débattre_V2 : V2 ; + débouillir_V2 : V2 ; + décevoir_V2 : V2 ; + déchoir_V2 : V2 ; + déclore_V2 : V2 ; + décommettre_V2 : V2 ; + déconfire_V2 : V2 ; + découdre_V2 : V2 ; + découvrir_V2 : V2 ; + décrire_V2 : V2 ; + décroître_V2 : V2 ; + décuire_V2 : V2 ; + déduire_V2 : V2 ; + défaillir_V : V ; + défaire_V2 : V2 ; + défendre_V2 : V2 ; + démentir_V2 : V2 ; + démettre_V2 : V2 ; + démordre_V : V ; + départir_V2 : V2 ; + dépeindre_V2 : V2 ; + dépendre_V2 : V2 ; + déplaire_V : V ; + dépourvoir_V2 : V2 ; + déprendre_V2 : V2 ; + désapprendre_V2 : V2 ; + descendre_V2 : V2 ; + desservir_V2 : V2 ; + déteindre_V2 : V2 ; + détendre_V2 : V2 ; + détenir_V2 : V2 ; + détordre_V2 : V2 ; + détruire_V2 : V2 ; + devenir_V : V ; + dévêtir_V2 : V2 ; + devoir_V2 : V2 ; + dire_V2 : V2 ; + disconvenir_V2 : V2 ; + discourir_V2 : V2 ; + disjoindre_V2 : V2 ; + disparaître_V2 : V2 ; + dissoudre_V2 : V2 ; + distendre_V2 : V2 ; + distordre_V2 : V2 ; + distraire_V2 : V2 ; + dormir_V2 : V2 ; + ébattre_V : V ; + échoir_V2 : V2 ; + éclore_V2 : V2 ; + éconduire_V2 : V2 ; + écrire_V2 : V2 ; + élire_V2 : V2 ; + embatre_V2 : V2 ; + embattre_V2 : V2 ; + emboire_V : V ; + émettre_V2 : V2 ; + émoudre_V2 : V2 ; + émouvoir_V2 : V2 ; + empreindre_V2 : V2 ; + enceindre_V2 : V2 ; + enclore_V2 : V2 ; + encourir_V2 : V2 ; + endormir_V2 : V2 ; + enduire_V2 : V2 ; + enfreindre_V2 : V2 ; + enfuir_V : V ; + enjoindre_V2 : V2 ; + enquérir_V : V ; + entendre_V2 : V2 ; + entr'apercevoir_V : V ; + entrebattre_V : V ; + entre_détruire_V : V ; + entre_haïr_V : V ; + entremettre_V : V ; + entre_nuire_V : V ; + entreprendre_V2 : V2 ; + entretenir_V2 : V2 ; + entrevoir_V2 : V2 ; + entrouvrir_V2 : V2 ; + envoyer_V2 : V2 ; + épandre_V2 : V2 ; + éperdre_V : V ; + éprendre_V : V ; + équivaloir_V2 : V2 ; + éteindre_V2 : V2 ; + étendre_V2 : V2 ; + étreindre_V2 : V2 ; + être_V : V ; + exclure_V2 : V2 ; + extraire_V2 : V2 ; + faillir_V2 : V2 ; + faire_V2 : V2 ; + falloir_V : V ; + feindre_V2 : V2 ; + fendre_V2 : V2 ; + fondre_V2 : V2 ; + forfaire_V2 : V2 ; + foutre_V2 : V2 ; + frire_V2 : V2 ; + fuir_V2 : V2 ; + geindre_V2 : V2 ; + gésir_V2 : V2 ; + haïr_V2 : V2 ; + inclure_V2 : V2 ; + induire_V2 : V2 ; + inscrire_V2 : V2 ; + instruire_V2 : V2 ; + interdire_V2 : V2 ; + interrompre_V2 : V2 ; + intervenir_V : V ; + introduire_V2 : V2 ; + joindre_V2 : V2 ; + lire_V2 : V2 ; + luire_V : V ; + mainmettre_V2 : V2 ; + maintenir_V2 : V2 ; + méconnaître_V2 : V2 ; + mécroire_V2 : V2 ; + médire_V2 : V2 ; + mentir_V2 : V2 ; + méprendre_V2 : V2 ; + messeoir_V2 : V2 ; + mettre_V2 : V2 ; + mévendre_V2 : V2 ; + mordre_V2 : V2 ; + morfondre_V : V ; + moudre_V2 : V2 ; + mourir_V : V ; + mouvoir_V2 : V2 ; + naître_V : V ; + nuire_V2 : V2 ; + obtenir_V2 : V2 ; + obvenir_V : V ; + occlure_V2 : V2 ; + offrir_V2 : V2 ; + oindre_V2 : V2 ; + omettre_V2 : V2 ; + ouïr_V2 : V2 ; + ouvrir_V2 : V2 ; + paître_V2 : V2 ; + paître_V : V ; + paraître_V : V ; + parcourir_V2 : V2 ; + parfondre_V2 : V2 ; + partir_V : V ; + parvenir_V : V ; + peindre_V2 : V2 ; + pendre_V2 : V2 ; + percevoir_V2 : V2 ; + perdre_V2 : V2 ; + permettre_V2 : V2 ; + plaindre_V2 : V2 ; + plaire_V2 : V2 ; + pleuvoir_V : V ; + poindre_V2 : V2 ; + pondre_V2 : V2 ; + pourfendre_V2 : V2 ; + poursuivre_V2 : V2 ; + pourvoir_V2 : V2 ; + pouvoir_V : V ; + prédire_V2 : V2 ; + prendre_V2 : V2 ; + prescrire_V2 : V2 ; + pressentir_V2 : V2 ; + prétendre_V2 : V2 ; + prévaloir_V2 : V2 ; + prévenir_V2 : V2 ; + prévoir_V2 : V2 ; + produire_V2 : V2 ; + promettre_V2 : V2 ; + promouvoir_V2 : V2 ; + proscrire_V2 : V2 ; + provenir_V : V ; + rabattre_V2 : V2 ; + raire_V2 : V2 ; + rapprendre_V2 : V2 ; + rasseoir_V2 : V2 ; + réadmettre_V2 : V2 ; + réapparaître_V : V ; + réapprendre_V2 : V2 ; + rebattre_V2 : V2 ; + recevoir_V2 : V2 ; + recomparaître_V2 : V2 ; + reconduire_V2 : V2 ; + reconnaître_V2 : V2 ; + reconquérir_V2 : V2 ; + reconstruire_V2 : V2 ; + recoudre_V2 : V2 ; + recourir_V2 : V2 ; + recouvrir_V2 : V2 ; + récrire_V2 : V2 ; + recroître_V2 : V2 ; + recueillir_V2 : V2 ; + recuire_V2 : V2 ; + redécouvrir_V2 : V2 ; + redéfaire_V2 : V2 ; + redescendre_V2 : V2 ; + redevenir_V : V ; + redevoir_V2 : V2 ; + redire_V2 : V2 ; + réduire_V2 : V2 ; + réécrire_V2 : V2 ; + réélire_V2 : V2 ; + réentendre_V2 : V2 ; + refaire_V2 : V2 ; + refendre_V2 : V2 ; + refondre_V2 : V2 ; + réinscrire_V2 : V2 ; + réintroduire_V2 : V2 ; + rejoindre_V2 : V2 ; + relire_V2 : V2 ; + reluire_V2 : V2 ; + remettre_V2 : V2 ; + remordre_V2 : V2 ; + remoudre_V2 : V2 ; + renaître_V2 : V2 ; + rendormir_V2 : V2 ; + rendre_V2 : V2 ; + rentraire_V2 : V2 ; + rentrouvrir_V2 : V2 ; + renvoyer_V2 : V2 ; + repaître_V2 : V2 ; + répandre_V2 : V2 ; + reparaître_V : V ; + repartir_V : V ; + repeindre_V2 : V2 ; + rependre_V2 : V2 ; + repentir_V : V ; + reperdre_V2 : V2 ; + repleuvoir_V : V ; + répondre_V2 : V2 ; + reprendre_V2 : V2 ; + reproduire_V2 : V2 ; + requérir_V2 : V2 ; + résoudre_V2 : V2 ; + ressentir_V2 : V2 ; + resservir_V2 : V2 ; + ressortir_V : V ; + ressouvenir_V : V ; + restreindre_V2 : V2 ; + reteindre_V2 : V2 ; + retendre_V2 : V2 ; + retenir_V2 : V2 ; + retondre_V2 : V2 ; + retordre_V2 : V2 ; + retraduire_V2 : V2 ; + retraire_V2 : V2 ; + retranscrire_V2 : V2 ; + retransmettre_V2 : V2 ; + rétreindre_V2 : V2 ; + revaloir_V2 : V2 ; + revendre_V2 : V2 ; + revenir_V : V ; + revêtir_V2 : V2 ; + revivre_V2 : V2 ; + revoir_V2 : V2 ; + revouloir_V2 : V2 ; + rire_V2 : V2 ; + rompre_V2 : V2 ; + rouvrir_V2 : V2 ; + saillir_V2 : V2 ; + satisfaire_V2 : V2 ; + savoir_V2 : V2 ; + secourir_V2 : V2 ; + séduire_V2 : V2 ; + sentir_V2 : V2 ; + seoir_V : V ; + servir_V2 : V2 ; + sortir_V : V ; + soubattre_V2 : V2 ; + souffrir_V2 : V2 ; + soumettre_V2 : V2 ; + sourire_V2 : V2 ; + souscrire_V2 : V2 ; + sous_entendre_V2 : V2 ; + sous_tendre_V2 : V2 ; + soustraire_V2 : V2 ; + soutenir_V2 : V2 ; + souvenir_V : V ; + subvenir_V2 : V2 ; + suffire_V2 : V2 ; + suivre_V2 : V2 ; + surfaire_V2 : V2 ; + surprendre_V2 : V2 ; + surproduire_V2 : V2 ; + surseoir_V2 : V2 ; + surtondre_V2 : V2 ; + survenir_V : V ; + survivre_V2 : V2 ; + suspendre_V2 : V2 ; + taire_V2 : V2 ; + teindre_V2 : V2 ; + tendre_V2 : V2 ; + tenir_V2 : V2 ; + tondre_V2 : V2 ; + tordre_V2 : V2 ; + traduire_V2 : V2 ; + traire_V2 : V2 ; + transcrire_V2 : V2 ; + transmettre_V2 : V2 ; + transparaître_V : V ; + tréfondre_V2 : V2 ; + tressaillir_V : V ; + vaincre_V2 : V2 ; + valoir_V2 : V2 ; + vendre_V2 : V2 ; + venir_V : V ; + vêtir_V2 : V2 ; + vivre_V2 : V2 ; + voir_V2 : V2 ; + vouloir_V2 : V2 ; +} diff --git a/lib/resource/exper/french/LangFre.gf b/lib/resource/exper/french/LangFre.gf new file mode 100644 index 000000000..6c70dc33e --- /dev/null +++ b/lib/resource/exper/french/LangFre.gf @@ -0,0 +1,10 @@ +--# -path=.:romance:abstract:../common:prelude + +concrete LangFre of Lang = + GrammarFre, + LexiconFre + ** { + +flags startcat = Phr ; unlexer = text ; lexer = text ; + +} ; diff --git a/lib/resource/exper/french/LexiconFre.gf b/lib/resource/exper/french/LexiconFre.gf new file mode 100644 index 000000000..ba555aefb --- /dev/null +++ b/lib/resource/exper/french/LexiconFre.gf @@ -0,0 +1,367 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +concrete LexiconFre of Lexicon = CatFre ** + open (M = MorphoFre), ParadigmsFre, IrregFre in { + +flags + optimize=values ; + +lin + airplane_N = regGenN "avion" masculine ; + answer_V2S = mkV2S (v2V répondre_V2) dative ; + apartment_N = regGenN "apartement" masculine ; + apple_N = regGenN "pomme" feminine ; + art_N = regGenN "art" feminine ; + ask_V2Q = mkV2Q (regV "demander") dative ; + baby_N = regGenN "bébé" masculine ; + bad_A = prefA (mkADeg (regA "mauvais") (regA "pire")) ; + bank_N = regGenN "banque" feminine ; + beautiful_A = prefA (regA "joli") ; ---- beau + become_VA = mkVA devenir_V ; + beer_N = regGenN "bière" feminine ; + beg_V2V = mkV2V (regV "demander") accusative dative ; + big_A = prefA (regA "grand") ; + bike_N = regGenN "vélo" masculine ; + bird_N = regGenN "oiseau" masculine ; + black_A = regA "noir" ; + blue_A = regA "bleu" ; + boat_N = regGenN "bateau" masculine ; + book_N = regGenN "livre" masculine ; + boot_N = regGenN "botte" feminine ; + boss_N = regGenN "chef" masculine ; + boy_N = regGenN "garçon" masculine ; + bread_N = regGenN "pain" masculine ; + break_V2 = dirV2 (regV "casser") ; + broad_A = regA "large" ; + brother_N2 = deN2 (regGenN "frère" masculine) ; + brown_A = regA "brun" ; + butter_N = regGenN "beurre" masculine ; + buy_V2 = dirV2 (reg3V "acheter" "achète" "achètera") ; + camera_N = compN (regGenN "appareil" masculine) ["de photo"] ; + cap_N = regGenN "casquette" feminine ; + car_N = regGenN "voiture" feminine ; + carpet_N = regGenN "tapis" masculine ; + cat_N = regGenN "chat" masculine ; + ceiling_N = regGenN "plafond" masculine ; + chair_N = regGenN "chaise" feminine ; + cheese_N = regGenN "fromage" masculine ; + child_N = regGenN "enfant" masculine ; + church_N = regGenN "église" feminine ; + city_N = regGenN "ville" feminine ; + clean_A = regA "propre" ; + clever_A = regA "sage" ; ---- + close_V2 = dirV2 (regV "fermer") ; + coat_N = regGenN "manteau" masculine ; + cold_A = regA "froid" ; + come_V = venir_V ; + computer_N = regGenN "ordinateur" masculine ; + country_N = regGenN "pays" masculine ; + cousin_N = regGenN "cousin" masculine ; ---- cousine + cow_N = regGenN "vache" feminine ; + die_V = mourir_V ; + dirty_A = regA "sale" ; + distance_N3 = mkN3 (regGenN "distance" feminine) genitive dative ; + doctor_N = regGenN "médecin" masculine ; + dog_N = regGenN "chien" masculine ; + door_N = regGenN "porte" feminine ; + drink_V2 = boire_V2 ; + easy_A2V = mkA2V (regA "facile") dative genitive ; + eat_V2 = dirV2 (regV "manger") ; + empty_A = regA "vide" ; + enemy_N = regGenN "ennemi" masculine ; + factory_N = regGenN "usine" feminine ; + father_N2 = deN2 (regGenN "père" masculine) ; + fear_VS = mkVS (v2V craindre_V2) ; + fear_V2 = dirV2 (v2V craindre_V2) ; + find_V2 = dirV2 (regV "trouver") ; + fish_N = regGenN "poisson" masculine ; + floor_N = regGenN "plancher" masculine ; + forget_V2 = dirV2 (regV "oublier") ; + fridge_N = regGenN "frigo" masculine ; + friend_N = regGenN "ami" masculine ; + fruit_N = regGenN "fruit" masculine ; + fun_AV = mkAV (regA "marrant") genitive ; + garden_N = regGenN "jardin" masculine ; + girl_N = regGenN "fille" feminine ; + glove_N = regGenN "gant" masculine ; + gold_N = regGenN "or" masculine ; + good_A = prefA (mkADeg (mkA "bon" "bonne" "bons" "bien") + (mkA "meilleur" "meilleure" "meilleurs" "mieux")) ; + go_V = aller_V ; + green_A = regA "vert" ; + harbour_N = regGenN "port" masculine ; + hate_V2 = haïr_V2 ; + hat_N = regGenN "chapeau" masculine ; + have_V2 = avoir_V2 ; + hear_V2 = entendre_V2 ; + hill_N = regGenN "colline" feminine ; + hope_VS = mkVS (reg3V "espérer" "espère" "espérera") ; + horse_N = regGenN "cheval" masculine ; + hot_A = regA "chaud" ; + house_N = regGenN "maison" feminine ; + important_A = regA "important" ; + industry_N = regGenN "industrie" feminine ; + iron_N = regGenN "fer" masculine ; + king_N = regGenN "roi" masculine ; + know_V2 = connaître_V2 ; ---- savoir_V2 : VS + lake_N = regGenN "lac" masculine ; + lamp_N = regGenN "lampe" feminine ; + learn_V2 = apprendre_V2 ; + leather_N = regGenN "cuir" masculine ; + leave_V2 = dirV2 (regV "quitter") ; + like_V2 = dirV2 (regV "aimer") ; + listen_V2 = dirV2 (regV "écouter") ; + live_V = v2V vivre_V2 ; + long_A = compADeg (mkA "long" "longue" "longs" "longuement") ; + lose_V2 = perdre_V2 ; + love_N = regGenN "amour" masculine ; + love_V2 = dirV2 (regV "aimer") ; + man_N = regGenN "homme" masculine ; + married_A2 = mkA2 (regA "marié") dative ; + meat_N = regGenN "viande" feminine ; + milk_N = regGenN "lait" masculine ; + moon_N = regGenN "lune" feminine ; + mother_N2 = deN2 (regGenN "mère" feminine) ; + mountain_N = regGenN "montagne" feminine ; + music_N = regGenN "musique" feminine ; + narrow_A = regA "étroit" ; + new_A = prefA (compADeg (mkA "nouveau" "nouvelle" "nouveaux" "nouvellement")) ; + newspaper_N = regGenN "journal" masculine ; + oil_N = regGenN "huile" feminine ; + old_A = + prefA (compADeg (mkA "vieux" "vieille" "vieux" "vieillement")) ; ---- vieil + open_V2 = ouvrir_V2 ; + paint_V2A = mkV2A (v2V peindre_V2) accusative (mkPrep "en") ; + paper_N = regGenN "papier" masculine ; + paris_PN = mkPN "Paris" masculine ; + peace_N = regGenN "paix" feminine ; + pen_N = regGenN "stylo" masculine ; + planet_N = regGenN "planète" feminine ; + plastic_N = regGenN "plastic" masculine ; + play_V2 = dirV2 (regV "jouer") ; + policeman_N = regGenN "policier" masculine ; + priest_N = regGenN "prêtre" masculine ; + probable_AS = mkAS (regA "probable") ; + queen_N = regGenN "reine" feminine ; + radio_N = regGenN "radio" feminine ; + rain_V0 = mkV0 (pleuvoir_V) ; + read_V2 = lire_V2 ; + red_A = regA "rouge" ; + religion_N = regGenN "religion" feminine ; + restaurant_N = regGenN "restaurant" masculine ; + river_N = regGenN "rivière" feminine ; + rock_N = regGenN "rocher" masculine ; + roof_N = regGenN "toit" masculine ; + rubber_N = regGenN "caoutchuc" masculine ; + run_V = v2V courir_V2 ; + say_VS = mkVS (v2V dire_V2) ; + school_N = regGenN "école" feminine ; + science_N = regGenN "science" feminine ; + sea_N = regGenN "mer" feminine ; + seek_V2 = dirV2 (regV "chercher") ; + see_V2 = voir_V2 ; + sell_V3 = dirV3 (v2V vendre_V2) dative ; + send_V3 = dirV3 (v2V envoyer_V2) dative ; + sheep_N = regGenN "mouton" masculine ; + ship_N = regGenN "bateau" masculine ; + shirt_N = regGenN "chemise" feminine ; + shoe_N = regGenN "chaussure" feminine ; + shop_N = regGenN "magasin" masculine ; + short_A = regA "court" ; ---- bref + silver_N = regGenN "argent" masculine ; + sister_N = regGenN "soeur" feminine ; + sleep_V = v2V dormir_V2 ; + small_A = prefA (regA "petit") ; + snake_N = regGenN "serpent" masculine ; + sock_N = regGenN "chaussette" feminine ; + speak_V2 = dirV2 (regV "parler") ; + star_N = regGenN "étoile" feminine ; + steel_N = regGenN "acier" masculine ; + stone_N = regGenN "pierre" feminine ; + stove_N = regGenN "four" masculine ; + student_N = regGenN "étudiant" masculine ; + stupid_A = regA "stupide" ; + sun_N = regGenN "soleil" masculine ; + switch8off_V2 = éteindre_V2 ; + switch8on_V2 = dirV2 (regV "allumer") ; ---- + table_N = regGenN "table" feminine ; + talk_V3 = mkV3 (regV "parler") dative genitive ; + teacher_N = regGenN "professeur" masculine ; + teach_V2 = dirV2 (regV "enseigner") ; + television_N = regGenN "télévision" feminine ; + thick_A = compADeg (mkA "épais" "épaisse" "épais" "épaissement") ; + thin_A = regA "fin" ; + train_N = regGenN "train" masculine ; + travel_V = regV "voyager" ; + tree_N = regGenN "arbre" masculine ; + ---- trousers_N = regGenN "pantalon" masculine ; + ugly_A = regA "laide" ; + understand_V2 = comprendre_V2 ; + university_N = regGenN "université" feminine ; + village_N = regGenN "village" masculine ; + wait_V2 = attendre_V2 ; ---- dative? + walk_V = regV "marcher" ; + warm_A = regA "chaud" ; + war_N = regGenN "guerre" masculine ; + watch_V2 = dirV2 (regV "regarder") ; + water_N = regGenN "eau" feminine ; + white_A = compADeg (mkA "blanc" "blanche" "blancs" "blanchement") ; + window_N = regGenN "fenêtre" feminine ; + wine_N = regGenN "vin" masculine ; + win_V2 = dirV2 (regV "gagner") ; ---- vaincre + woman_N = regGenN "femme" feminine ; + wonder_VQ = mkVQ (reflV (regV "étonner")) ; + wood_N = regGenN "bois" masculine ; + write_V2 = écrire_V2 ; + yellow_A = regA "jaune" ; + young_A = prefA (regA "jeune") ; + + do_V2 = faire_V2 ; + now_Adv = mkAdv "maintenant" ; + already_Adv = mkAdv "déjà" ; + song_N = regGenN "chanson" feminine ; + add_V3 = dirV3 (regV "ajouter") dative ; + number_N = regGenN "nombre" masculine ; ---- numéro + put_V2 = mettre_V2 ; + stop_V = reflV (regV "arrêter") ; + jump_V = regV "sauter" ; + + left_Ord = M.mkOrd (regA "gauche") ; + right_Ord = M.mkOrd (regA "droite") ; + far_Adv = mkAdv "loin" ; + correct_A = regA "correct" ; + dry_A = (mkA "sec" "sèche" "secs" "sèches") ; + dull_A = regA "émoussé" ; + full_A = regA "plein" ; + heavy_A = regA "lourd" ; + near_A = regA "proche" ; + rotten_A = regA "pourri" ; + round_A = regA "rond" ; + sharp_A = regA "tranchant" ; + smooth_A = regA "lisse" ; + straight_A = regA "droite" ; + wet_A = regA "mouillé" ; + wide_A = regA "large" ; + animal_N = regN "animal" ; + ashes_N = regGenN "cendre" masculine ; + back_N = regN "dos" ; + bark_N = regN "écorce" ; + belly_N = regGenN "ventre" masculine ; + blood_N = regN "sang" ; + bone_N = regN "os" ; + breast_N = regN "sein" ; --- poitrine + cloud_N = regGenN "nuage" masculine ; + day_N = regN "jour" ; + dust_N = regN "poussière" ; + ear_N = regN "oreille" ; + earth_N = regN "terre" ; + egg_N = regN "oeuf" ; + eye_N = mkN "oeil" "yeux" masculine ; + fat_N = regN "graisse" ; + feather_N = regN "plume" ; + fingernail_N = regGenN "ongle" masculine ; + fire_N = regN "feu" ; + flower_N = regGenN "fleur" feminine ; + fog_N = regN "brouillard" ; + foot_N = regN "pied" ; + forest_N = regGenN "forêt" feminine ; + grass_N = regN "herbe" ; + guts_N = regN "entraille" ; + hair_N = regN "cheveu" ; + hand_N = regGenN "main" feminine ; + head_N = regN "tête" ; + heart_N = regN "coeur" ; + horn_N = regGenN "corne" masculine ; + husband_N = regN "mari" ; + ice_N = regN "glace" ; + knee_N = regN "genou" ; + leaf_N = regN "feuille" ; + leg_N = regN "jambe" ; + liver_N = regGenN "foie" masculine ; + louse_N = regN "pou" ; + mouth_N = regN "bouche" ; + name_N = regN "nom" ; + neck_N = mkN "cou" "cous" masculine ; + night_N = regGenN "nuit" feminine ; + nose_N = regN "nez" ; + person_N = regN "personne" ; + rain_N = regN "pluie" ; + road_N = regN "route" ; + root_N = regN "racine" ; + rope_N = regN "corde" ; + salt_N = regN "sel" ; + sand_N = regGenN "sable" masculine ; + seed_N = regN "graine" ; + skin_N = regN "peau" ; + sky_N = mkN "ciel" "cieux" masculine ; + smoke_N = regN "fumée" ; + snow_N = regN "neige" ; + stick_N = regN "bâton" ; + tail_N = regN "queue" ; + tongue_N = regN "langue" ; + tooth_N = regGenN "dent" feminine ; + wife_N = regN "femme" ; + wind_N = regN "vent" ; + wing_N = regN "aile" ; + worm_N = regN "ver" ; + year_N = regN "an" ; --- année + bite_V2 = mordre_V2 ; + blow_V = regV "souffler" ; + breathe_V = regV "respirer" ; + burn_V = regV "brûler" ; + count_V2 = dirV2 (regV "conter") ; + cut_V2 = dirV2 (regV "tailler") ; + dig_V = regV "creuser" ; + fall_V = regV "tomber" ; + fight_V2 = dirV2 (regV "lutter") ; + float_V = regV "flotter" ; + flow_V = regV "couler" ; + fly_V = regV "voler" ; + freeze_V = reg3V "geler" "gèle" "gèlera" ; + give_V3 = dirdirV3 (regV "donner") ; + hit_V2 = dirV2 (regV "frapper") ; + hunt_V2 = dirV2 (regV "chasser") ; + kill_V2 = dirV2 (regV "tuer") ; + laugh_V = rire_V2 ; + lie_V = reflV (v2V étendre_V2) ; + play_V = regV "jouer" ; + pull_V2 = dirV2 (regV "tirer") ; + push_V2 = dirV2 (regV "pousser") ; + rub_V2 = dirV2 (regV "frotter") ; + scratch_V2 = dirV2 (regV "gratter") ; + sew_V = coudre_V2 ; + sing_V = regV "chanter" ; + sit_V = reflV (v2V asseoir_V2) ; + smell_V = v2V ( sentir_V2) ; + spit_V = regV "cracher" ; + squeeze_V2 = dirV2 (regV "serrer") ; + stab_V2 = dirV2 (regV "poignarder") ; + stand_V = reflV (reg3V "lever" "lève" "lèvera") ; + suck_V2 = dirV2 (regV "sucer") ; + swell_V = regV "gonfler" ; + swim_V = regV "nager" ; + think_V = regV "penser" ; + throw_V2 = dirV2 (regV "jeter") ; + tie_V2 = dirV2 (regV "lier") ; + turn_V = regV "tourner" ; + vomit_V = regV "vomir" ; + wash_V2 = dirV2 (regV "laver") ; + wipe_V2 = dirV2 (regV "essuyer") ; + + hold_V2 = tenir_V2 ; + split_V2 = fendre_V2 ; + sit_V = reflV (v2V asseoir_V2) ; + + grammar_N = regN "grammaire" ; + language_N = regN "langue" ; + rule_N = regN "règle" ; + + john_PN = regPN "Jean" ; + question_N = regN "question" ; + ready_A = regA "prêt" ; + reason_N = regGenN "raison" feminine ; + today_Adv = mkAdv "aujourd'hui" ; + uncertain_A = regA "incertain" ; + + +} ; diff --git a/lib/resource/exper/french/MorphoFre.gf b/lib/resource/exper/french/MorphoFre.gf new file mode 100644 index 000000000..a27c1ebf4 --- /dev/null +++ b/lib/resource/exper/french/MorphoFre.gf @@ -0,0 +1,1238 @@ +--# -path=.:../romance:../common:../../prelude + +--1 A Simple French Resource Morphology +-- +-- Aarne Ranta 2002 -- 2005 +-- +-- This resource morphology contains definitions needed in the resource +-- syntax. To build a lexicon, it is better to use $ParadigmsFre$, which +-- gives a higher-level access to this module. + +resource MorphoFre = CommonRomance, ResFre ** + open PhonoFre, Prelude, Predef in { + +flags optimize=all ; + +--2 Front vowels +-- +-- In verb conjugation, we will need the concept of frontal vowel. + +oper + voyelleFront : Strs = strs {"e" ; "i" ; "y" ; "é" ; "è"} ; + preVoyelleFront : (_,_ : Str) -> Str = \t,u -> pre {t ; u / voyelleFront} ; + + +--2 Nouns +-- +-- The following macro is useful for creating the forms of number-dependent +-- tables, such as common nouns. + + numForms : Str -> Str -> Number => Str = \bon,bons -> + table {Sg => bon ; Pl => bons} ; + +-- For example, the regular noun forms are defined as follows: + + nomReg : Str -> Number => Str = \bu -> numForms bu (bu + "s") ; + +-- Common nouns are inflected in number and have an inherent gender. + + CNom = {s : Number => Str ; g : Gender} ; + + mkCNom : (Number => Str) -> Gender -> CNom = \mecmecs,gen -> + {s = mecmecs ; g = gen} ; + + mkCNomIrreg : Str -> Str -> Gender -> CNom = \mec,mecs -> + mkCNom (numForms mec mecs) ; + + mkCNomReg : Str -> Gender -> CNom = \mec -> + mkCNom (nomReg mec) ; + + mkCNomNiveau : Str -> Gender -> CNom = \niveau -> + mkCNomIrreg niveau (niveau + "x") ; + + mkCNomCheval : Str -> Gender -> CNom = \cheval -> + let {cheva = Predef.tk 1 cheval} in + mkCNomIrreg cheval (cheva + "ux") ; + + mkCNomInvar : Str -> Gender -> CNom = \cas -> + mkCNomIrreg cas cas ; + + mkNomReg : Str -> Gender -> CNom = \cas -> + let cass = case Predef.dp 2 cas of { + "al" => init cas + "ux" ; + "au" => cas + "x" ; + "eu" => cas + "x" ; + "ou" => cas + "x" ; + _ => case last cas of { + "s" => cas ; + "x" => cas ; + "z" => cas ; + _ => cas + "s" + } + } + in mkCNomIrreg cas cass ; + + +--2 Adjectives +-- +-- Adjectives are conveniently seen as gender-dependent nouns. +-- Here are some patterns. First one that describes the worst case. + + mkAdj : (_,_,_,_ : Str) -> Adj = \vieux,vieuxs,vieille,vieillement -> + {s = table { + AF Masc n => numForms vieux vieuxs ! n ; + AF Fem n => nomReg vieille ! n ; + AA => vieillement + } + } ; + +-- Then the regular and invariant patterns. + + adjReg : Str -> Gender => Number => Str = \bu -> table { + Masc => (mkNomReg bu Masc).s ; + Fem => nomReg (case last bu of { + "e" => bu ; + _ => bu + "e" + }) + } ; + + adjInvar : Str -> Gender => Number => Str = \bien -> + \\_,_ => bien ; + +-- Adjectives themselves are records. Here the most common cases: + + adjGrand : Str -> Adj = \grand -> + let grande = case last grand of { + "e" => grand ; + _ => grand + "e" + } + in + mkAdj grand (grand + "s") grande (grande + "ment") ; + +-- Masculine form used for adverbial; also covers "carré". + + adjJoli : Str -> Adj = \joli -> + mkAdj joli (joli + "s") (joli + "e") (joli + "ment") ; + + adjHeureux : Str -> Adj = \heureux -> + let {heureu = Predef.tk 1 heureux} in + mkAdj heureux heureux (heureu+"se") (heureu+"sement") ; + + adjBanal : Str -> Adj = \banal -> + let {bana = Predef.tk 1 banal} in + mkAdj banal (bana + "ux") (banal+"e") (banal+"ement") ; + + adjJeune : Str -> Adj = \jeune -> + mkAdj jeune (jeune+"s") jeune (jeune+"ment") ; + + adjIndien : Str -> Adj = \indien -> + mkAdj indien (indien+"s") (indien+"ne") (indien+"nement") ; + + adjFrancais : Str -> Adj = \francais -> + mkAdj francais francais (francais+"e") (francais+"ement") ; + + adjCher : Str -> Adj = \cher -> + let {ch = Predef.tk 2 cher} in + mkAdj cher (cher + "s") (ch + "ère") (ch + "èrement") ; + + mkAdjReg : Str -> Adj = \creux -> + case Predef.dp 3 creux of { + "eux" => adjHeureux creux ; + _ => case Predef.dp 2 creux of { + "al" => adjBanal creux ; + "en" => adjIndien creux ; + "on" => adjIndien creux ; + "er" => adjCher creux ; + _ => case Predef.dp 1 creux of { + "s" => adjFrancais creux ; + "x" => adjFrancais creux ; + "e" => adjJeune creux ; + "é" => adjJoli creux ; + "i" => adjJoli creux ; + _ => adjGrand creux + } + } + } ; + + +--2 Personal pronouns +-- +-- All the eight personal pronouns can be built by the following macro. +-- The use of "en" as atonic genitive is debatable. + + mkPronoun : (_,_,_,_,_,_,_ : Str) -> + Gender -> Number -> Person -> Pronoun = + \il,le,lui,Lui,son,sa,ses,g,n,p -> + {s = table { + Ton x => prepCase x ++ Lui ; + Aton Nom => il ; + Aton Acc => le ; + Aton (CPrep P_de) => "en" ; --- hmm + Aton (CPrep P_a) => lui ; + Poss {n = Sg ; g = Masc} => son ; + Poss {n = Sg ; g = Fem} => sa ; + Poss {n = Pl} => ses + } ; + a = {g = g ; n = n ; p = p} ; + hasClit = True + } ; + + elisPoss : Str -> Str = \s -> + pre {s + "a" ; s + "on" / voyelle} ; + + +--2 Determiners +-- +-- Determiners, traditionally called indefinite pronouns, are inflected +-- in gender and number. It is usually enough to give the two singular +-- forms to form the plurals. + + pronForms : Str -> Str -> Gender -> Number -> Str = \tel,telle,g,n -> case g of { + Masc => nomReg tel ! n ; + Fem => nomReg telle ! n + } ; + +-- The following macro generates the phrases "est-ce que", "est-ce qu'", +-- and "est-ce qui" (the last one used e.g. in "qu'est-ce qui"). + + estCeQue : Case -> Str = \c -> + "est-ce" ++ case c of { + Nom => "qui" ; + Acc => elisQue ; + _ => nonExist --- dont? + } ; + + +--2 Verbs + +--3 Parameters + +-- The full conjunction is a table on $VForm$, as in "Bescherelle". + +param + Temps = Presn | Imparf | Passe | Futur ; + TSubj = SPres | SImparf ; + TPart = PPres | PPasse Gender Number ; + VForm = Inf + | Indi Temps Number Person + | Condi Number Person + | Subjo TSubj Number Person + | Imper NumPersI + | Part TPart ; + +-- This is a conversion to the type in $CommonRomance$. + +oper + vvf : (VForm => Str) -> (VF => Str) = \aller -> table { + VInfin _ => aller ! Inf ; + VFin (VPres Indic) n p => aller ! Indi Presn n p ; + VFin (VPres Subjunct) n p => aller ! Subjo SPres n p ; + VFin (VImperf Indic) n p => aller ! Indi Imparf n p ; --# notpresent + VFin (VImperf Subjunct) n p => aller ! Subjo SImparf n p ; --# notpresent + VFin VPasse n p => aller ! Indi Passe n p ; --# notpresent + VFin VFut n p => aller ! Indi Futur n p ; --# notpresent + VFin VCondit n p => aller ! Condi n p ; --# notpresent + VImper np => aller ! Imper np ; + VPart g n => aller ! Part (PPasse g n) ; + VGer => aller ! Part PPres -- *en* allant + } ; + +-- We very often form the verb stem by dropping out the infinitive ending. + + troncVerb : Tok -> Tok = Predef.tk 2 ; + + +--3 Affixes +-- +-- It is convenient to have sets of affixes as data objects. + + Affixe : Type = Person => Str ; + + lesAffixes : (_,_,_ : Str) -> Affixe = \x,y,z -> table { + P1 => x ; + P2 => y ; + P3 => z + } ; + +-- Much of variation can be described in terms of affix sets: + + affixSgE : Affixe = lesAffixes "e" "es" "e" ; + + affixSgS : Affixe = lesAffixes "s" "s" "t" ; + + affixSgSsansT : Affixe = lesAffixes "s" "s" [] ; + + affixSgX : Affixe = lesAffixes "x" "x" "t" ; + + affixPlOns : Affixe = lesAffixes "ons" "ez" "ent" ; + + affixSgAi : Affixe = lesAffixes "ai" "as" "a" ; + + affixSgAis : Affixe = \\p => "ai" + affixSgS ! p ; + + affixPlIons : Affixe = table { + P3 => "aient" ; + p => "i" + affixPlOns ! p + } ; + +-- Often affix sets come in pairs, for the singular and the plural. + + affixImparf : Number => Affixe = table { + Sg => affixSgAis ; + Pl => affixPlIons + } ; + + affixFutur : Number => Affixe = table { + Sg => affixSgAi ; + Pl => table { + P3 => "ont" ; + p => affixPlOns ! p + } + } ; + + affixSPres : Number => Affixe = table { + Sg => affixSgE ; + Pl => table { + P3 => "ent" ; + p => affixPlIons ! p + } + } ; + + affixPlMes : (_,_ : Str) -> Affixe = + \è, â -> lesAffixes (â + "mes") (â + "tes") (è + "rent") ; + + affixPasseAi : Number => Affixe = table { + Sg => affixSgAi ; + Pl => affixPlMes "è" "â" + } ; + + affixPasseS : (i,î : Str) -> Number => Affixe = \i,î -> table { + Sg => table {p => i + affixSgS ! p} ; + Pl => affixPlMes i î + } ; + + affixSImparfSse : (i,î : Str) -> Number => Affixe = \i,î -> table { + Sg => table { + P3 => î + "t" ; + p => i + "ss" + affixSgE ! p + } ; + Pl => table {p => i + "ss" + affixSPres ! Pl ! p} + } ; + + AffixPasse : Type = {ps : Number => Affixe ; si : Number => Affixe} ; + + affixPasse : (_,_ : Str) -> AffixPasse = \i, î -> + {ps = affixPasseS i î ; si = affixSImparfSse i î} ; + + affixPasseA : AffixPasse = {ps = affixPasseAi ; si = affixSImparfSse "a" "â"} ; + + affixPasseI : AffixPasse = affixPasse "i" "î" ; + + affixPasseU : AffixPasse = affixPasse "u" "û" ; + + affixPasseNonExist : AffixPasse = + let {aff : Number => Affixe = + table {_ => lesAffixes nonExist nonExist nonExist}} in + {ps = aff ; si = aff} ; + + affixImper : NumPersI => Str = table { + SgP2 => "e" ; + PlP1 => "ons" ; + PlP2 => "ez" + } ; + + formesPresAi : (v,all : Str) -> Number => Affixe = \v,all -> table { + Sg => \\p => v + affixSgAi ! p ; + Pl => table { + P3 => v + "ont" ; + p => all + affixPlOns ! p + } + } ; + +--3 Macros for the complete conjugation type +-- +-- The type $VForm$ has 55 forms, as defined in $types.Fra.gf$. +-- The worst-case macro takes 11 stems and two affix sets. +-- (We will actually never need all of these at the same time.) + + Verbe : Type = VForm => Str ; + + verbAffixes : + (a,b,c,d,e,f,g,h,i,j,k : Str) -> Affixe -> AffixPasse -> Verbe = + \tien, ten, tienn, t, tiendr, soi, soy, soie, tenu, tenus, tenir -> + \affpres, affpasse -> + table { + Inf => tenir ; + Indi Presn Sg p => tien + affpres ! p ; + Indi Presn Pl P3 => tienn + affixPlOns ! P3 ; + Indi Presn Pl p => ten + affixPlOns ! p ; + Indi Imparf n p => ten + affixImparf ! n ! p ; + Indi Passe n p => t + affpasse.ps ! n ! p ; + Indi Futur n p => tiendr + affixFutur ! n ! p ; + Condi n p => tiendr + affixImparf ! n ! p ; + Subjo SPres Sg p => soi + affixSPres ! Sg ! p ; + Subjo SPres Pl P3 => soi + "ent" ; + Subjo SPres Pl p => soy + affixSPres ! Pl ! p ; + Subjo SImparf n p => t + affpasse.si ! n ! p ; + Imper SgP2 => soie ; + Imper p => soy + affixImper ! p ; + Part PPres => ten + "ant" ; + Part (PPasse Masc Sg) => tenu ; + Part (PPasse Fem Sg) => tenu + "e" ; + Part (PPasse Masc Pl) => tenus ; + Part (PPasse Fem Pl) => tenu + "es" + } ; + +-- Almost always seven stems are more than enough. + + verbHabituel : + (a,b,c,d,e,f,g : Str) -> Affixe -> AffixPasse -> Verbe = + \tien, ten, tienn, t, tiendr, tenu, tenir -> + \affpres, affpasse -> + verbAffixes tien ten tienn t tiendr tienn ten + (tien + affpres ! P1) tenu (tenu+"s") tenir affpres affpasse ; + +--3 The first conjugation +-- +-- There is quite some phonologically explained variation in the first conjugation. +-- The worst case has three different stems. + + auxConj1 : Str -> Str -> Str -> Verbe = \jet, jett, jeter -> + verbHabituel jett jet jett jet jeter (jet+"é") (jet+"er") affixSgE affixPasseA ; + + conj1aimer : Str -> Verbe = \aimer -> + let {aim = troncVerb aimer} in + auxConj1 aim aim aimer ; + + conj1céder : Str -> Verbe = \céder -> + let { + ced = troncVerb céder ; + d = Predef.dp 1 ced ; + c = Predef.tk 2 ced ; + cèd = c + "è" + d ; + céd = c + "é" + d + } + in auxConj1 céd cèd céder ; + + conj1peser : Str -> Verbe = \céder -> ---- ? a verifier + let { + ced = troncVerb céder ; + d = Predef.dp 1 ced ; + c = Predef.tk 2 ced ; + cèd = c + "è" + d ; + céd = c + "e" + d + } + in auxConj1 céd cèd céder ; + + conj1jeter : Str -> Verbe = \jeter -> + let { + jet = troncVerb jeter ; + jett = jet + Predef.dp 1 jet + } + in auxConj1 jet jett (jett + "er") ; + + conj1placer : Str -> Verbe = \placer -> + let { + pla = Predef.tk 3 placer ; + plac = preVoyelleFront (pla+"ç") (pla+"c") + } in + auxConj1 plac plac placer ; + + conj1manger : Str -> Verbe = \manger -> + let { + mang = Predef.tk 2 manger ; + mange = preVoyelleFront (mang+"e") mang + } in + auxConj1 mange mange manger ; + + conj1assiéger : Str -> Verbe = \assiéger -> + let {assi = Predef.tk 4 assiéger} in + auxConj1 (preVoyelleFront (assi+"ége") (assi+"ég")) (assi+"èg") assiéger ; + + conj1payer : Str -> Verbe = \payer -> + let {pa = Predef.tk 3 payer} in + auxConj1 (pa + "y") (pa + "i") (pa + "ier") ; + + conj1envoyer : Str -> Verbe = \envoyer -> + let {renv = Predef.tk 4 envoyer} in + auxConj1 (renv + "oy") (renv + "oi") (renv + "err") ; + +-- This is a collective dispatcher. + + mkVerbReg : Str -> Verbe = \parler -> + case parler of { + _ + "ir" => conj2finir parler ; + _ + "re" => conj3rendre parler ; + _ + "éger" => conj1assiéger parler ; + _ + ("eler" | "eter") => conj1jeter parler ; + _ + "éder" => conj1céder parler ; + _ + "cer" => conj1placer parler ; + _ + "ger" => conj1manger parler ; + _ + "yer" => conj1payer parler ; + _ => conj1aimer parler + } ; + +{- + let + e = last (Predef.tk 4 parler) ; + c = last (Predef.tk 3 parler) ; + verb_é = pbool2bool (occur "é" (e + last (Predef.tk 3 parler))) ; + verb_e = andB (pbool2bool (occur e "e")) (pbool2bool (occur c "cmnprsv")) + in + case Predef.dp 4 parler of { + "éger" => conj1assiéger parler ; + "eler" => conj1jeter parler ; + "eter" => conj1jeter parler ; + _ => case verb_é of { + True => conj1céder parler ; + _ => case verb_e of { +---- True => conj1peser parler ; + False | _ => case Predef.dp 3 parler of { + "cer" => conj1placer parler ; + "ger" => conj1manger parler ; + "yer" => conj1payer parler ; + _ => case Predef.dp 2 parler of { + "ir" => conj2finir parler ; + "re" => conj3rendre parler ; + _ => conj1aimer parler + } + } + } + } + } ; +-} + +-- The following can be more reliable. + + mkVerb3Reg : Str -> Str -> Str -> Verbe = \jeter,jette,jettera -> + auxConj1 + (Predef.tk 2 jeter) + (Predef.tk 1 jette) + (Predef.tk 1 jettera) ; + +--3 The second conjugation +-- +-- There are just two different cases. + + conj2finir : Str -> Verbe = \finir -> + let { + fin = troncVerb finir ; + fini = fin + "i" ; + finiss = fin + "iss" + } in + verbHabituel fini finiss finiss fin finir fini finir affixSgS affixPasseI ; + + conj2haïr : Str -> Verbe = \haïr -> + let {ha = troncVerb haïr ; + hai = ha + "i" ; + haï = ha + "ï" ; + haiss = ha + "ïss" + } in + verbHabituel hai haiss haiss ha haïr haï haïr affixSgS (affixPasse "ï" "ï") ; + + +--3 The third conjugation +-- +-- This group is very heterogeneous. Most verbs have "re" in the infinitive, +-- but the first example does not! + + conj3tenir : Str -> Verbe = \tenir -> + let {t = Predef.tk 4 tenir} in + verbHabituel + (t+"ien") (t+"en") (t+"ienn") t (t+"iendr") (t+"enu") tenir + affixSgS (affixPasse "in" "în") ; + +-- Many verbs have "is" in the past participle. But there is so much variation +-- that the worst-case macro needs seven forms. + + auxConj3is : (_,_,_,_,_,_,_ : Str) -> Verbe = + \quier, quér, quièr, qu, querr, quis, quiss -> + verbAffixes + quier quér quièr qu querr quièr quér + (quier + "s") quis quiss (quér + "ir") affixSgS affixPasseI ; + + auxConj3ir : (_,_,_ : Str) -> Verbe = \sen, sent, i -> + auxConj3is sen sent sent sent (sent+"ir") (sent+i) (sent+i+"s") ; + + conj3quérir : Str -> Verbe = \quérir -> + let {qu = Predef.tk 4 quérir} in + auxConj3is (qu+"ier") (qu+"ér") (qu+"ièr") qu (qu+"err") (qu+"is") (qu+"is") ; + + conj3sentir : Str -> Verbe = \sentir -> + let { + sent = troncVerb sentir ; + sen = Predef.tk 1 sent + } in + auxConj3ir sen sent "i" ; + + conj3vêtir : Str -> Verbe = \vêtir -> + let { + s = Predef.tk 5 vêtir ; + vet = auxConj3ir "vêt" "vêt" "u" + } in + table { + Indi Presn Sg P3 => s + "vêt" ; + p => s + vet ! p + }; + + auxConj3vrir : (_,_,_ : Str) -> Verbe = \ouvr, i, ouvert -> + verbAffixes + ouvr ouvr ouvr ouvr (ouvr + i + "r") ouvr ouvr + (ouvr + "e") ouvert (ouvert + "s") (ouvr + "ir") affixSgE affixPasseI ; + + conj3couvrir : Str -> Verbe = \couvrir -> + let {couv = Predef.tk 3 couvrir} in + auxConj3vrir (couv+"r") "i" (couv+"ert") ; + + conj3cueillir : Str -> Verbe = \cueillir -> + let {cueill = troncVerb cueillir} in + auxConj3vrir cueill "e" (cueill + "i") ; + + conj3assaillir : Str -> Verbe = \assaillir -> + let {assaill = troncVerb assaillir} in + auxConj3vrir assaill "i" (assaill + "i") ; + +-- The verb "faillir" has lots of alternatives forms. + + conj3faillir : Str -> Verbe = \faillir -> + let { + fa = Predef.tk 5 faillir ; + faudr = fa + "udr" ; + tfa = conj3assaillir faillir + } in + table { + Indi Presn Sg p => fa + "u" + affixSgX ! p ; + Subjo SPres n p => fa + variants {"illiss" ; "ill"} + affixSPres ! n ! p ; + + Indi Futur n p => variants {tfa ! Indi Futur n p ; faudr + affixFutur ! n ! p} ; + Condi n p => variants {tfa ! Condi n p ; faudr + affixImparf ! n ! p} ; + + Imper _ => nonExist ; + p => tfa ! p + }; + + conj3bouillir : Str -> Verbe = \bouillir -> + let { + bou = Predef.tk 5 bouillir ; + tbou = conj3assaillir bouillir + } in + table { + Indi Presn Sg p => bou + affixSgS ! p ; + Imper SgP2 => bou + "s" ; + p => tbou ! p + }; + +-- Notice that here we don't need another conjugation, as Bescherelle does. + + conj3dormir : Str -> Verbe = conj3sentir ; + +-- The verbs "mourir" and "courir" have much in common, except the first two +-- persons in the present indicative singular, and the past participles. + + auxConj3ourir : (_,_,_ : Str) -> Verbe = \meur, mour, mort -> + verbAffixes + meur mour meur mour (mour + "r") meur mour + (meur + "s") mort (mort + "s") (mour + "ir") affixSgS affixPasseU ; + + conj3courir : Str -> Verbe = \courir -> + let {cour = troncVerb courir} in + auxConj3ourir cour cour (cour + "u") ; + + conj3mourir : Str -> Verbe = \mourir -> + let {m = Predef.tk 5 mourir} in + auxConj3ourir (m + "eur") (m + "our") (m + "ort") ; + +-- A little auxiliary to cover "fuir" and "ouïr". +-- *N.B.* some alternative forms for "ouïr" are still missing. + + auxConj3ui : AffixPasse -> (_,_,_ : Str) -> Verbe = \affpasse, o, ou, ouï -> + let {oi : Str = o + "i" ; oy : Str = o + "y" ; ouïr : Str = ouï + "r"} in + verbHabituel oi oy oi ou ouïr ouï ouïr affixSgS affpasse ; + + conj3fuir : Str -> Verbe = \fuir -> + let {fu = troncVerb fuir} in + auxConj3ui affixPasseI fu fu (fu + "i") ; + + conj3ouïr : Str -> Verbe = \ouir -> + let {o = Predef.tk 3 ouir} in + auxConj3ui (affixPasse "ï" "ï") o (o + "u") (o + "uï") ; + +-- The verb "gésir" lacks many forms. + + conj3gésir : Str -> Verbe = \gésir -> + let {g = Predef.tk 4 gésir} in + table { + Inf => g + "ésir" ; + Indi Presn Sg p => g + lesAffixes "is" "is" "ît" ! p ; + Indi Presn Pl p => g + "is" + affixPlOns ! p ; + Indi Imparf n p => g + "is" + affixImparf ! n ! p ; + Part PPres => g + "isant" ; + _ => nonExist + } ; + +-- Here is an auxiliary for a large, and heterogeneous, group of verbs whose +-- infinitive ends in "oir". It has two special cases, depending on the ending +-- of the first two persions in the present indicative singular. + + auxConj3oir : Affixe -> AffixPasse -> (_,_,_,_,_,_,_,_ : Str) -> Verbe = + \affpres, affpasse -> + \peu, pouv, peuv, p, pourr, veuill, voul, v -> + let {pu : Str = p + "u"} in + verbAffixes + peu pouv peuv p pourr veuill voul (peu+affpres!P1) pu (pu+"s") (v+"oir") + affpres affpasse ; + + auxConj3usX : (_,_,_,_,_,_,_,_ : Str) -> Verbe = + auxConj3oir affixSgX affixPasseU ; + auxConj3usS : (_,_,_,_,_,_,_,_ : Str) -> Verbe = + auxConj3oir affixSgS affixPasseU ; + + conj3cevoir : Str -> Verbe = \cevoir -> + let {re = Predef.tk 6 cevoir} in + auxConj3usS (re+"çoi") (re+"cev") (re+"çoiv") (re+"ç") + (re+"cevr") (re+"çoiv") (re+"cev") (re+"cev") ; + + conj3voir : Str -> Verbe = \voir -> + let { + v = Predef.tk 3 voir ; + voi = v + "oi" + } in + auxConj3oir + affixSgS affixPasseI voi (v + "oy") voi v (v + "err") voi (v + "oy") v ; + + conj3pourvoir : Str -> Verbe = \pourvoir -> + let { + pourv = Predef.tk 3 pourvoir ; + pourvoi = pourv + "oi" ; + pourvoy = pourv + "oy" + } in + auxConj3usS pourvoi pourvoy pourvoi pourv pourvoir pourvoi pourvoy pourv ; + + conj3savoir : Str -> Verbe = \savoir -> + let { + s = Predef.tk 5 savoir ; + tsavoir = auxConj3usS "ai" "av" "av" "" "aur" "ach" "ach" "av" + } in + table { + Imper p => s + "ach" + affixImper ! p ; + Part PPres => s + "achant" ; + p => s + tsavoir ! p + } ; + + conj3devoir : Str -> Verbe = \devoir -> + let { + s = Predef.tk 6 devoir ; + tdevoir = auxConj3usS "doi" "dev" "doiv" "d" "devr" "doiv" "dev" "dev" + } in + table { + Part (PPasse Masc Sg) => s + "dû" ; + p => s + tdevoir ! p + } ; + + conj3pouvoir : Str -> Verbe = \pouvoir -> + let { + p = Predef.tk 6 pouvoir ; + tpouvoir = auxConj3usX "eu" "ouv" "euv" "" "ourr" "uiss" "uiss" "ouv" + } in + table { + Indi Presn Sg P1 => p + variants {"eux" ; "uis"} ; + t => p + tpouvoir ! t + } ; + + conj3mouvoir : Str -> Verbe = \mouvoir -> + let { + s = Predef.tk 7 mouvoir ; + mu = adjReg "mû" ; + tmouvoir = auxConj3usS "meu" "mouv" "meuv" "m" "mouvr" "meuv" "mouv" "mouv" + } in + table { + Part (PPasse g n) => s + mu ! g ! n ; + p => s + tmouvoir ! p + } ; + + auxConj3seul3sg : (_,_,_,_,_ : Str) -> Verbe = + \faut, fall, pl, faudr, faill -> table { + Inf => fall + "oir" ; + Indi Presn Sg P3 => faut ; + Indi Imparf Sg P3 => fall + "ait" ; + Indi Passe Sg P3 => pl + "ut" ; + Indi Futur Sg P3 => faudr + "a" ; + Condi Sg P3 => faudr + "ait" ; + Subjo SPres Sg P3 => faill + "e" ; + Subjo SImparf Sg P3 => pl + "ût" ; + Part PPres => fall + "ant" ; + Part (PPasse g n) => adjReg (pl + "u") ! g ! n ; + _ => nonExist + } ; + + conj3pleuvoir : Str -> Verbe = \pleuvoir -> + let { + pleuv = Predef.tk 3 pleuvoir ; + pl = Predef.tk 3 pleuv + } in + auxConj3seul3sg (pl + "eut") pleuv pl (pleuv + "r") pleuv ; + + conj3falloir : Str -> Verbe = \falloir -> + let { + fa = Predef.tk 5 falloir ; + fau = fa + "u" ; + fall = Predef.tk 3 falloir + } in + auxConj3seul3sg (fau + "t") fall fall (fau + "dr") (fa + "ill") ; + + conj3valoir : Str -> Verbe = \valoir -> + let { + va = Predef.tk 4 valoir ; + val = va + "l" + } in + auxConj3usX (va + "u") val val val (va + "udr") (va + "ill") val val ; + + conj3vouloir : Str -> Verbe = \vouloir -> + let { + v = Predef.tk 6 vouloir ; + vo = v + "o" ; + voul = vo + "ul" ; + veul = v + "eul" + } in + auxConj3usX (v + "eu") voul veul voul (vo + "udr") (v + "euill") voul voul ; + +-- The following two are both "asseoir" in the Bescherelle, which however +-- points out that the latter conjugation has an infinitive form without "e" +-- since the orthographic rectifications of 1990. + + conj3asseoir : Str -> Verbe = \asseoir -> + let { + ass = Predef.tk 4 asseoir ; + tasseoir = auxConj3is "ied" "ey" "ey" "" "iér" "is" "is" + } in + table { + Inf => ass + "eoir" ; + Indi Presn Sg P3 => ass + "ied" ; + t => ass + tasseoir ! t + } ; + + conj3assoir : Str -> Verbe = \assoir -> + let { + ass = Predef.tk 3 assoir ; + tassoir = auxConj3is "oi" "oy" "oi" "" "oir" "is" "is" + } in + table { + Inf => ass + variants {"oir" ; "eoir"} ; + t => ass + tassoir ! t + } ; + + conj3seoir : Str -> Verbe = \seoir -> + let { + s = Predef.tk 4 seoir ; + tseoir = conj3asseoir seoir + } in + table { + Indi Presn Pl P3 => s + "iéent" ; + Indi _ _ P1 => nonExist ; + Indi _ _ P2 => nonExist ; + Indi Passe _ _ => nonExist ; + Condi _ P1 => nonExist ; + Condi _ P2 => nonExist ; + Subjo SPres Sg P3 => s + "iée" ; + Subjo SPres Pl P3 => s + "iéent" ; + Subjo _ _ _ => nonExist ; + Imper _ => nonExist ; + Part PPres => s + "éant" ; + t => tseoir ! t + } ; + +-- Here we don't need a new conjugation. + + conj3messeoir : Str -> Verbe = \messeoir -> + let {tmesseoir = conj3seoir messeoir} in + table { + Part (PPasse _ _) => nonExist ; + p => tmesseoir ! p + } ; + + conj3surseoir : Str -> Verbe = \surseoir -> + let { + surs = Predef.tk 4 surseoir ; + tsurseoir = auxConj3is "oi" "oy" "oi" "" "eoir" "is" "is" + } in + table { + Inf => surseoir ; + t => surs + tsurseoir ! t + } ; + +-- Here we interpolate and include the imperfect and subjunctive forms, +-- which Bescherelle leaves out. + + conj3choir : Str -> Verbe = \choir -> + let { + e = Predef.tk 5 choir ; + tchoir = + auxConj3usS "choi" "choy" "choi" "ch" + (variants {"choir" ; "cherr"}) "choi" "choy" "ch" + } in + \\p => e + tchoir ! p ; + + conj3échoir : Str -> Verbe = \échoir -> + let {techoir = conj3choir échoir} in + table { + Indi _ _ P1 => nonExist ; + Indi _ _ P2 => nonExist ; + Indi Presn Pl P3 => Predef.tk 3 échoir + variants {"oient" ; "éent"} ; + Subjo _ _ P1 => nonExist ; + Subjo _ _ P2 => nonExist ; + Condi _ P1 => nonExist ; + Condi _ P2 => nonExist ; + Imper _ => nonExist ; + Part PPres => Predef.tk 3 échoir + "éant" ; + t => techoir ! t + } ; + +-- Verbs with the infinitive ending "re" are a major group within the third +-- conjugation. The worst-case macro takes 2 sets of affixes and 7 stems. + + auxConj3re : Affixe -> AffixPasse -> (_,_,_,_,_,_,_ : Str) -> Verbe = + \affpr, affp -> \prend, pren, prenn, pr, prendr, pris, priss -> + verbAffixes prend pren prenn pr prendr prenn pren + (prend + affpr ! P1) pris priss (prendr + "e") affpr affp ; + + auxConj3tre : (_,_ : Str) -> Verbe = \bat, batt -> + auxConj3re affixSgSsansT affixPasseI + bat batt batt batt (batt + "r") (batt + "u") (batt + "us") ; + + conj3rendre : Str -> Verbe = \rendre -> + let {rend = troncVerb rendre} in + auxConj3tre rend rend ; + + conj3battre : Str -> Verbe = \battre -> + let {bat = Predef.tk 3 battre} in + auxConj3tre bat (bat + "t") ; + + conj3prendre : Str -> Verbe = \prendre -> + let {pr = Predef.tk 5 prendre} in + auxConj3re + affixSgSsansT affixPasseI (pr + "end") (pr + "en") + (pr + "enn") pr (pr + "endr") (pr + "is") (pr + "is") ; + + conj3mettre : Str -> Verbe = \mettre -> + let {m = Predef.tk 5 mettre ; met = m + "et"} in + auxConj3re + affixSgSsansT affixPasseI met (met + "t") + (met + "t") m (met + "tr") (m + "is") (m + "is") ; + + conj3peindre : Str -> Verbe = \peindre -> + let {pe = Predef.tk 5 peindre ; peign = pe + "ign"} in + auxConj3re + affixSgS affixPasseI + (pe + "in") peign peign peign (pe + "indr") (pe + "int") (pe + "ints") ; + +-- We don't need a separate conjugation for "joindre" and "craindre". + + conj3joindre = conj3peindre ; + + conj3craindre = conj3peindre ; + + conj3vaincre : Str -> Verbe = \vaincre -> + let { + vainc = troncVerb vaincre ; + vainqu = Predef.tk 1 vainc + "qu" + } in + auxConj3re + affixSgSsansT affixPasseI + vainc vainqu vainqu vainqu (vainc + "r") (vainc + "u") (vainc + "us") ; + + conj3traire : Str -> Verbe = \traire -> + let { + tra = Predef.tk 3 traire ; + trai = tra + "i" ; + tray = tra + "y" + } in + auxConj3re + affixSgS affixPasseNonExist + trai tray trai [] (trai + "r") (trai + "t") (trai + "ts") ; + +-- The verb "faire" has a great many irregularities. Following Bescherelle, +-- we have left out the plural 2nd person variant "faisez", which is a +-- 'grossier barbarisme'. + + conj3faire : Str -> Verbe = \faire -> + let { + fai = troncVerb faire ; + fais = fai + "s" ; + f = Predef.tk 2 fai ; + tfaire = auxConj3re + affixSgS affixPasseI + fai fais (f + "ass") f (f + "er") (fai + "t") (fai + "ts") + } in + table { + Inf => faire ; + Indi Presn Pl P2 => fai + "tes" ; + Indi Presn Pl P3 => f + "ont" ; + Subjo SPres Pl p => f + "ass" + affixSPres ! Pl ! p ; + Imper PlP2 => fai + "tes" ; + t => tfaire ! t + } ; + + auxConj3oire : (_,_,_,_ : Str) -> Verbe = \boi, buv, boiv, b -> + auxConj3re + affixSgS affixPasseU boi buv boiv b (boi + "r") (b + "u") (b + "us") ; + + auxConj3ît : Verbe -> Str -> Verbe = \conj,plaît -> + table { + Indi Presn Sg P3 => plaît ; + t => conj ! t + } ; + + conj3plaire : Str -> Verbe = \plaire -> + let { + pl = Predef.tk 4 plaire ; + tplaire = auxConj3oire (pl + "ai") (pl + "ais") (pl + "ais") pl + } in + auxConj3ît tplaire (pl + "aît") ; + + conj3connaître : Str -> Verbe = \connaître -> + let { + conn = Predef.tk 5 connaître ; + connaiss = conn + "aiss" ; + tconnaitre = + auxConj3re + affixSgS affixPasseU (conn + "ai") connaiss connaiss + conn (conn + "aîtr") (conn + "u") (conn + "us") + } in + auxConj3ît tconnaitre (conn + "aît") ; + + conj3naître : Str -> Verbe = \naître -> + let { + n = Predef.tk 5 naître ; + tnaitre = auxConj3re + affixSgS affixPasseI + (n + "ai") (n + "aiss") (n + "aiss") (n + "aqu") + (n + "aîtr") (n + "é") (n + "és") + } in + auxConj3ît tnaitre (n + "aît") ; + +-- The conjugation of "paître" is defective in a curious way, especially +-- if compared with "repaître". According to Bescherelle, the invariable +-- past participle is only used as a term of "fauconnerie" (one would expect it +-- to be defective rather than invariable). + + conj3paître : Str -> Verbe = \paître -> + let {tpaitre = conj3connaître paître} in + table { + Indi Passe _ _ => nonExist ; + Subjo SImparf _ _ => nonExist ; + Part (PPasse _ _) => Predef.tk 5 paître + "u" ; + p => tpaitre ! p + } ; + + conj3repaître = conj3connaître ; + + conj3croître : Str -> Verbe = \croître -> + let {cr = Predef.tk 5 croître} in + auxConj3re + affixSgS (affixPasse "û" "û") (cr + "oî") (cr + "oiss") + (cr + "oiss") cr (cr + "oîtr") (cr + "û") (cr + "ûs") ; + + conj3croire : Str -> Verbe = \croire -> + let {cr = Predef.tk 4 croire} in + auxConj3oire (cr + "oi") (cr + "oy") (cr + "oi") cr ; + + conj3boire : Str -> Verbe = \boire -> + let {b = Predef.tk 4 boire} in + auxConj3oire (b + "oi") (b + "uv") (b + "oiv") b ; + +-- The verb "clore" shows a systematic absence of past forms, +-- including the imperfect indicative. What is more capricious, is the absence +-- of the plural first and second persons in the present indicative and +-- the imperative. + + conj3clore : Str -> Verbe = \clore -> + let { + clo = troncVerb clore ; + clos = clo + "s" ; + tclore = auxConj3re + affixSgS affixPasseNonExist clo clos clos + nonExist (clo + "r") clos clos + } in + table { + Indi Presn Sg P3 => Predef.tk 1 clo + "ôt" ; + Indi Presn Pl P1 => nonExist ; + Indi Presn Pl P2 => nonExist ; + Indi Imparf _ _ => nonExist ; + Imper PlP1 => nonExist ; + Imper PlP2 => nonExist ; + t => tclore ! t + } ; + + conj3conclure : Str -> Verbe = \conclure -> + let { + conclu = troncVerb conclure ; + concl = Predef.tk 1 conclu + } in + auxConj3re + affixSgS affixPasseU + conclu conclu conclu concl (conclu + "r") conclu (conclu + "s") ; + + conj3absoudre : Str -> Verbe = \absoudre -> + let { + abso = Predef.tk 4 absoudre ; + tabsoudre = conj3résoudre absoudre + } in + table { + Indi Passe _ _ => nonExist ; + Subjo SImparf _ _ => nonExist ; + Part (PPasse Masc _) => abso + "us" ; + Part (PPasse Fem n) => nomReg (abso + "ute") ! n ; + p => tabsoudre ! p + } ; + + conj3résoudre : Str -> Verbe = \résoudre -> + let {reso = Predef.tk 4 résoudre} in + auxConj3re + affixSgS affixPasseU (reso + "u") (reso + "lv") (reso + "lv") + (reso + "l") (reso + "udr") (reso + "lu") (reso + "lus") ; + + conj3coudre : Str -> Verbe = \coudre -> + let { + cou = Predef.tk 3 coudre ; + cous = cou + "s" + } in + auxConj3re + affixSgSsansT affixPasseI + (cou +"d") cous cous cous (cou + "dr") (cous + "u") (cous + "us") ; + + conj3moudre : Str -> Verbe = \moudre -> + let { + mou = Predef.tk 3 moudre ; + moul = mou + "l" + } in + auxConj3re + affixSgSsansT affixPasseU + (mou + "d") moul moul moul (mou + "dr") (moul + "u") (moul + "us") ; + + conj3suivre : Str -> Verbe = \suivre -> + let { + suiv = troncVerb suivre ; + sui = Predef.tk 1 suiv ; + suivi = suiv + "i" + } in + auxConj3re + affixSgS affixPasseI sui suiv suiv suiv (suiv + "r") suivi (suivi+"s") ; + + conj3vivre : Str -> Verbe = \vivre -> + let { + viv = troncVerb vivre ; + vi = Predef.tk 1 viv ; + véc = Predef.tk 1 vi + "éc" + } in + auxConj3re + affixSgS affixPasseU vi viv viv véc (viv + "r") (véc + "u") (véc + "us") ; + + conj3lire : Str -> Verbe = \lire -> + let { + li = troncVerb lire ; + lis = li + "s" ; + l = Predef.tk 1 li + } in + auxConj3re affixSgS affixPasseU li lis lis l (li + "r") (l + "u") (l + "us") ; + + conj3dire : Str -> Verbe = \dire -> + let { + di = troncVerb dire ; + dis = di + "s" ; + dit = di + "t" ; + d = Predef.tk 1 di ; + tdire = auxConj3re + affixSgS affixPasseI di dis dis d (di + "r") dit (dit+"s") + } in + table { + Indi Presn Pl P2 => di + "tes" ; + Imper PlP2 => di + "tes" ; + t => tdire ! t + } ; + + conj3rire : Str -> Verbe = \rire -> + let { + ri = troncVerb rire ; + r = Predef.tk 1 ri + } in + auxConj3re affixSgS affixPasseI ri ri ri r (ri + "r") ri (ri+"s") ; + + auxConj3scrire : (_,_,_,_: Str) -> Verbe = \ecri, ecriv, ecrivi, ecrit -> + auxConj3re + affixSgS affixPasseI ecri ecriv ecriv ecrivi (ecri + "r") ecrit (ecrit+"s") ; + + conj3écrire : Str -> Verbe = \écrire -> + let {écri = troncVerb écrire} in + auxConj3scrire écri (écri + "v") (écri + "v") (écri + "t") ; + + conj3confire : Str -> Verbe = \confire -> + let {confi = troncVerb confire} in + auxConj3scrire confi (confi + "s") (Predef.tk 1 confi) (confi + "t") ; + + conj3cuire : Str -> Verbe = \cuire -> + let {cui = troncVerb cuire} in + auxConj3scrire cui (cui + "s") (cui + "s") (cui + "t") ; + + +--3 Very irregular verbs +-- +-- Here we cannot do even with the 'worst case macro'. + + conj3aller : Str -> Verbe = \aller -> + let { + s = Predef.tk 5 aller ; + pres = formesPresAi "v" "all" ; + taller = verbHabituel + "all" "all" "aill" "all" "ir" "allé" "aller" + affixSgS affixPasseA + } in + table { + Indi Presn Sg P1 => s + "vais" ; + Indi Presn n p => s + pres ! n ! p ; + Indi Imparf n p => s + "all" + affixImparf ! n ! p ; + Imper SgP2 => s + "va" ; + t => s + taller ! t + } ; + + conjÊtre : Str -> Verbe = \etre -> + let { + s = Predef.tk 4 etre ; + sg = lesAffixes "suis" "es" "est" ; + pl = lesAffixes "sommes" "êtes" "sont" ; + tetre = verbHabituel + "soi" "soy" "soi" "f" "ser" "été" "être" affixSgS affixPasseU + } in + table { + Indi Presn Sg p => s + sg ! p ; + Indi Presn Pl p => s + pl ! p ; + Indi Imparf n p => s + "ét" + affixImparf ! n ! p ; + Subjo SPres Sg p => s + "soi" + affixSgS ! p ; + Subjo SPres Pl P3 => s + "soient" ; + Subjo SPres Pl p => s + "soy" + affixPlOns ! p ; + Part PPres => s + "étant" ; + t => s + tetre ! t + } ; + + conjAvoir : Str -> Verbe = \avoir -> + let { + s = Predef.tk 5 avoir ; + pres = formesPresAi [] "av" ; + tavoir = verbHabituel + "ai" "ay" "ai" "e" "aur" "eu" "avoir" affixSgS affixPasseU + } in + table { + Indi Presn n p => s + pres ! n ! p ; + Indi Imparf n p => s + "av" + affixImparf ! n ! p ; + Subjo SPres Sg P3 => s + "ait" ; + Subjo SPres Pl P3 => s + "aient" ; + Subjo SPres Pl p => s + "ay" + affixPlOns ! p ; + Imper SgP2 => s + "aie" ; + t => s + tavoir ! t + } ; + +--- for Numerals + +param DForm = unit | teen | jten | ten | tenplus ; +param Place = indep | attr ; + +} diff --git a/lib/resource/exper/french/NounFre.gf b/lib/resource/exper/french/NounFre.gf new file mode 100644 index 000000000..ef8c9cffc --- /dev/null +++ b/lib/resource/exper/french/NounFre.gf @@ -0,0 +1,2 @@ +concrete NounFre of Noun = CatFre ** NounRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/NumeralFre.gf b/lib/resource/exper/french/NumeralFre.gf new file mode 100644 index 000000000..23a8ab43d --- /dev/null +++ b/lib/resource/exper/french/NumeralFre.gf @@ -0,0 +1,148 @@ +concrete NumeralFre of Numeral = CatFre ** + open CommonRomance, ResRomance, MorphoFre, Prelude in { + +-- originally written in 1998, automatically translated to current notation... +-- last modified 24/1/2006, adding ordinals + +-- Auxiliaries + +oper + digitPl : {s : DForm => Str; inh : DForm ; n : Number} -> + {s : CardOrd => DForm => Str ; inh : DForm ; n : Number} = \d -> { + s = \\co,df => let ds = d.s ! df in + case co of { + NCard _ => ds ; + NOrd _ _ => case last ds of { + "q" => "uième" ; + "e" => init ds + "ième" ; + _ => ds + "ième" + } + } ; + inh = d.inh ; n = d.n + } ; + + cardOrd : CardOrd -> Str -> Str -> Str = \co, x,y -> case co of { + NCard _ => x ; + NOrd _ _ => y + } ; + +lincat + Digit = {s : CardOrd => DForm => Str ; inh : DForm ; n : Number} ; + Sub10 = {s : CardOrd => {p1 : DForm ; p2 : Place} => Str ; inh : Number} ; + Sub100 = {s : CardOrd => Place => Str ; n : Number} ; + Sub1000 = {s : CardOrd => Place => Str ; n : Number} ; + Sub1000000 = {s : CardOrd => Str ; n : Number} ; + +lin num x0 = x0 ; + +lin n2 = + digitPl {inh = unit ; n = Sg ; s = table {unit => "deux" ; teen => "douze" ; jten => "vingt" ; ten => "vingt" ; tenplus => "vingt"}} ; +lin n3 = + digitPl {inh = unit ; n = Sg ; s = table {unit => "trois" ; teen => "treize" ; jten => "trente" ; ten => "trente" ; tenplus => "trente"}} ; +lin n4 = + digitPl {inh = unit ; n = Sg ; s = table {unit => "quatre" ; teen => "quatorze" ; jten => "quarante" ; ten => "quarante" ; tenplus => "quarante"}} ; +lin n5 = + digitPl {inh = unit ; n = Sg ; s = table {unit => "cinq" ; teen => "quinze" ; jten => "cinquante" ; ten => "cinquante" ; tenplus => "cinquante"}} ; +lin n6 = + digitPl {inh = unit ; n = Sg ; s = table {unit => "six" ; teen => "seize" ; jten => "soixante" ; ten => "soixante" ; tenplus => "soixante"}} ; +lin n7 = + digitPl {inh = teen ; n = Sg ; s = table {unit => "sept" ; teen => "dix-sept" ; jten => "soixante-dix" ; ten => "soixante-dix" ; tenplus => "soixante"}} ; +lin n8 = + digitPl {inh = unit ; n = Pl ; s = table {unit => "huit" ; teen => "dix-huit" ; jten => "quatre-vingts" ; ten => "quatre-vingt" ; tenplus => "quatre-vingt"}} ; +lin n9 = + digitPl {inh = teen ; n = Pl ; s = table {unit => "neuf" ; teen => "dix-neuf" ; jten => "quatre-vingt-dix" ; ten => "quatre-vingt-dix" ; tenplus => "quatre-vingt"}} ; + +lin pot01 = + {inh = Sg ; s = \\g => let dix = cardOrd g "dix" "dixième" in table { + {p1 = unit ; p2 = indep} => cardOrd g "un" "unième" ; {p1 = unit ; p2 = attr} => [] ; {p1 = teen ; + p2 = indep} => cardOrd g "onze" "onzième" ; {p1 = teen ; p2 = attr} => [] ; {p1 = jten ; + p2 = indep} => dix ; {p1 = jten ; p2 = attr} => [] ; {p1 = ten ; + p2 = indep} => dix ; {p1 = ten ; p2 = attr} => [] ; {p1 = tenplus + ; p2 = indep} => dix ; {p1 = tenplus ; p2 = attr} => []} ; n = Sg} ; +lin pot0 d = + {inh = Pl ; s = \\g => table {{p1 = unit ; p2 = indep} => d.s ! g ! unit + ; {p1 = unit ; p2 = attr} => d.s ! g ! unit ; {p1 = teen ; p2 = indep} + => d.s ! g ! teen ; {p1 = teen ; p2 = attr} => d.s ! g ! teen ; {p1 = jten ; + p2 = indep} => d.s ! g ! jten ; {p1 = jten ; p2 = attr} => d.s ! g ! jten ; + {p1 = ten ; p2 = indep} => d.s ! g ! ten ; {p1 = ten ; p2 = attr} => d.s + ! g ! ten ; {p1 = tenplus ; p2 = indep} => d.s ! g ! tenplus ; {p1 = tenplus + ; p2 = attr} => d.s ! g ! tenplus} ; n = Pl} ; + +lin pot110 = + {s = \\g => table {_ => cardOrd g "dix" "dixième"} ; n = Pl} ; +lin pot111 = + {s = \\g => table {_ => cardOrd g "onze" "onzième"} ; n = Pl} ; +lin pot1to19 d = + {s = \\g => table {indep => d.s ! g ! teen ; attr => d.s ! g ! teen} ; n = Pl} ; +lin pot0as1 n = + {s = \\g => table {indep => n.s ! g ! {p1 = unit ; p2 = indep} ; + attr => n.s ! g ! {p1 = unit ; p2 = attr}} ; n = n.inh} ; +lin pot1 d = + {s = \\g => table {indep => d.s ! g ! jten ; attr => d.s ! g ! ten} + ; n = Pl} ; +lin pot1plus d e = + {s = \\g => table {indep => (d.s ! (NCard Masc) ! tenplus) ++ (table {{p1 = Sg + ; p2 = Sg} => "et" ; {p1 = Sg ; p2 = pl} => "-" ; {p1 = Pl ; p2 = + Sg} => "-" ; {p1 = Pl ; p2 = pl} => "-"} ! {p1 = d.n ; p2 = + e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 = indep} ; attr => (d.s ! (NCard Masc) ! + tenplus) ++ (table {{p1 = Sg ; p2 = Sg} => "et" ; {p1 = Sg ; p2 = + pl} => "-" ; {p1 = Pl ; p2 = Sg} => "-" ; {p1 = Pl ; p2 = pl} => + "-"} ! {p1 = d.n ; p2 = e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 = + indep}} ; n = Pl} ; +lin pot1as2 n = n ; +lin pot2 d = + {s = \\g => table {indep => (d.s ! NCard Masc ! {p1 = unit ; p2 = attr}) + ++ table {Sg => cardOrd g "cent" "centième" ; Pl => cardOrd g "cents" "centième"} ! (d.inh) ; attr => (d.s ! + NCard Masc ! {p1 = unit ; p2 = attr}) ++ cardOrd g "cent" "centième"} ; n = Pl} ; +lin pot2plus d e = + {s = \\g => table {indep => (d.s ! NCard Masc ! {p1 = unit ; p2 = attr}) + ++ "cent" ++ e.s ! g ! indep ; attr => (d.s ! NCard Masc ! {p1 = unit ; p2 + = attr}) ++ "cent" ++ e.s ! g ! indep} ; n = Pl} ; +lin pot2as3 n = + {s = \\g => n.s ! g ! indep ; n = n.n} ; +lin pot3 n = + {s = \\g => (n.s ! NCard Masc ! attr) ++ cardOrd g "mille" "millième" ; n = Pl} ; +lin pot3plus n m = + {s = \\g => (n.s ! NCard Masc ! attr) ++ "mille" ++ m.s ! g ! indep ; n = + Pl} ; + + +-- numerals as sequences of digits + + lincat + Dig = TDigit ; + + lin + IDig d = d ; + + IIDig d i = { + s = \\o => d.s ! NCard Masc ++ i.s ! o ; + n = Pl + } ; + + D_0 = mkDig "0" ; + D_1 = mk3Dig "1" "1er" Sg ; ---- gender + D_2 = mk2Dig "2" "2ème" ; + D_3 = mk2Dig "3" "3ème" ; + 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 + "ème") ; + + mk3Dig : Str -> Str -> Number -> TDigit = \c,o,n -> { + s = table {NCard _ => c ; NOrd _ _ => o} ; ---- gender + n = n + } ; + + TDigit = { + n : Number ; + s : CardOrd => Str + } ; + +} diff --git a/lib/resource/exper/french/ParadigmsFre.gf b/lib/resource/exper/french/ParadigmsFre.gf new file mode 100644 index 000000000..7a25d00c8 --- /dev/null +++ b/lib/resource/exper/french/ParadigmsFre.gf @@ -0,0 +1,447 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +--1 French Lexical Paradigms +-- +-- Aarne Ranta 2001 - 2006 +-- +-- 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 main difference with $MorphoFre.gf$ is that the types +-- referred to are compiled resource grammar types. We have moreover +-- had the design principle of always having existing forms, rather +-- than stems, as string arguments of the paradigms. +-- +-- The structure of functions for each word class $C$ is the following: +-- first we give a handful of patterns that aim to cover all +-- regular cases. Then we give a worst-case function $mkC$, which serves as an +-- escape to construct the most irregular words of type $C$. +-- However, this function should only seldom be needed: we have a +-- separate module [``IrregFre`` ../../french/IrregFre.gf], +-- which covers all irregularly inflected verbs. + +resource ParadigmsFre = + open + (Predef=Predef), + Prelude, + CommonRomance, + ResFre, + MorphoFre, + CatFre in { + + flags optimize=all ; + +--2 Parameters +-- +-- To abstract over gender names, we define the following identifiers. + +oper + Gender : Type ; + + masculine : Gender ; + feminine : Gender ; + +-- To abstract over number names, we define the following. + + Number : Type ; + + singular : Number ; + plural : Number ; + +-- Prepositions used in many-argument functions are either strings +-- (including the 'accusative' empty string) or strings that +-- amalgamate with the following word (the 'genitive' "de" and the +-- 'dative' "à"). + + accusative : Prep ; + genitive : Prep ; + dative : Prep ; + + mkPrep : Str -> Prep ; + + +--2 Nouns + + mkN : overload { + +-- The regular function uses heuristics to compute the +-- plural and the gender from the singular. The plural +-- heuristic currently +-- covers the cases "pas-pas", "prix-prix", "nez-nez", +-- "bijou-bijoux", "cheveu-cheveux", "plateau-plateaux", "cheval-chevaux". +-- The gender heuristic is less reliable: it treats as feminine all +-- nouns ending with "e" and "ion", all others as masculine. + + mkN : (cheval : Str) -> N ; + +-- Adding gender information widens the scope of the regular pattern. + + mkN : (foie : Str) -> Gender -> N ; + +-- In the worst case, both singular and plural forms and the gender are needed. + + mkN : (oeil,yeux : Str) -> Gender -> N ; + +--3 Compound nouns +-- +-- Some nouns are ones where the first part is inflected as a noun but +-- the second part is not inflected. e.g. "numéro de téléphone". +-- They could be formed in syntax, but we give a shortcut here since +-- they are frequent in lexica. + + mkN : N -> Str -> N + } ; + + + + +--3 Relational nouns +-- +-- Relational nouns ("fille de x") need a case and a preposition. + + mkN2 : N -> Prep -> N2 ; + +-- The most common cases are the genitive "de" and the dative "à", +-- with the empty preposition. + + deN2 : N -> N2 ; + aN2 : N -> N2 ; + +-- Three-place relational nouns ("la connection de x à y") need two prepositions. + + mkN3 : N -> Prep -> Prep -> N3 ; + + +--3 Relational common noun phrases +-- +-- In some cases, you may want to make a complex $CN$ into a +-- relational noun (e.g. "la vieille église de"). However, $N2$ and +-- $N3$ are purely lexical categories. But you can use the $AdvCN$ +-- and $PrepNP$ constructions to build phrases like this. + +-- +--3 Proper names and noun phrases +-- +-- Proper names need a string and a gender. If no gender is given, the +-- feminine is used for strings ending with "e", the masculine for other strings. + + mkPN : overload { + mkPN : Str -> PN ; + mkPN : Str -> Gender -> PN + } ; + + + +--2 Adjectives + + mkA : overload { + +-- For regular adjectives, all forms are derived from the +-- masculine singular. The heuristic takes into account certain +-- deviant endings: "banal-banale-banaux", "chinois-chinoise-chinois", +-- "heureux-heureuse-heureux", "italien-italienne", "jeune-jeune", +-- "amer-amère", "carré- - -carrément", "joli- - -joliment". + + mkA : (cher : Str) -> A ; + +-- Often just the feminine singular is deviant. + + mkA : (sec,seche : Str) -> A ; + +-- This is the worst-case paradigm for the positive forms. + + mkA : (banal,banale,banaux,banalement : Str) -> A ; + +-- If comparison forms are irregular (i.e. not formed by "plus", e.g. +-- "bon-meilleur"), the positive and comparative can be given as separate +-- adjectives. + + mkA : A -> A -> A + } ; + +-- The functions create by default postfix adjectives. To switch +-- them to prefix ones (i.e. ones placed before the noun in +-- modification, as in "petite maison"), the following function is +-- provided. + + prefixA : A -> A ; + + +--3 Two-place adjectives +-- +-- Two-place adjectives need a preposition for their second argument. + + mkA2 : A -> Prep -> A2 ; + + +--2 Adverbs + +-- Adverbs are not inflected. Most lexical ones have position +-- after the verb. + + mkAdv : Str -> Adv ; + +-- Some appear next to the verb (e.g. "toujours"). + + mkAdV : Str -> AdV ; + +-- Adverbs modifying adjectives and sentences can also be formed. + + mkAdA : Str -> AdA ; + + +--2 Verbs +-- +-- Irregular verbs are given in the module $IrregFre$. +-- If a verb should be missing in that list, the module +-- $BeschFre$ gives all the patterns of the "Bescherelle" book. +-- +-- Regular verbs are ones with the infinitive "er" or "ir", the +-- latter with plural present indicative forms as "finissons". +-- The regular verb function in the first conjugation recognizes +-- these endings, as well as the variations among +-- "aimer, céder, placer, peser, jeter, placer, manger, assiéger, payer". +-- +-- Sometimes, however, it is not predictable which variant of the "er" +-- conjugation is to be selected. Then it is better to use the function +-- that gives the third person singular present indicative and future +-- (("il") "jette", "jettera") as second argument. + + mkV : overload { + mkV : (finir : Str) -> V ; + mkV : (jeter,jette,jettera : Str) -> V ; + +-- The $IrregFre$ list gives some verbs as two-place. These verbs can be +-- reused as one-place verbs. + + mkV : V2 -> V + } ; + +-- The function $mkV$ gives the default compound auxiliary "avoir". +-- To change it to "être", use the following function. + + etreV : V -> V ; + +-- This function turns a verb into reflexive, which implies the auxiliary "être". + + reflV : V -> V ; + + +--3 Two-place verbs +-- +-- Two-place verbs need a preposition, except the special case with direct object. +-- (transitive verbs). + + mkV2 = overload { + mkV2 : V -> V2 = dirV2 ; + mkV2 : V -> Prep -> V2 = mmkV2 + } ; + + +--3 Three-place verbs +-- +-- Three-place (ditransitive) verbs need two prepositions, of which +-- the first one or both can be absent. + + mkV3 : overload { + mkV3 : V -> V3 ; -- donner,_,_ + mkV3 : V -> Prep -> V3 ; -- placer,_,dans + mkV3 : V -> Prep -> Prep -> V3 -- parler, à, de + } ; + +--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 ; -- plain infinitive: "je veux parler" + deVV : V -> VV ; -- "j'essaie de parler" + aVV : V -> VV ; -- "j'arrive à parler" + mkV2V : V -> Prep -> Prep -> V2V ; + mkVA : V -> VA ; + mkV2A : V -> Prep -> Prep -> V2A ; + mkVQ : V -> VQ ; + mkV2Q : V -> Prep -> V2Q ; + + mkAS : A -> AS ; + mkA2S : A -> Prep -> A2S ; + mkAV : A -> Prep -> AV ; + mkA2V : A -> Prep -> 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 the paradigms +-- +-- The definitions should not bother the user of the API. So they are +-- hidden from the document. + + + Gender = MorphoFre.Gender ; + Number = MorphoFre.Number ; + masculine = Masc ; + feminine = Fem ; + singular = Sg ; + plural = Pl ; + + Preposition = Compl ; + accusative = complAcc ** {lock_Prep = <>} ; + genitive = complGen ** {lock_Prep = <>} ; + dative = complDat ** {lock_Prep = <>} ; + mkPrep p = {s = p ; c = Acc ; isDir = False ; lock_Prep = <>} ; + + --- obsolete + Preposition : Type ; + mkPreposition : Str -> Preposition ; + mkPreposition = mkPrep ; + + regGenN : Str -> Gender -> N ; + regN : Str -> N ; + mk2N : (oeil,yeux : Str) -> Gender -> N ; + mk2N x y g = mkCNomIrreg x y g ** {lock_N = <>} ; + regN x = regGenN x g where { + g = case of { + _ + ("e" | "ion") => Fem ; + _ => Masc + } + } ; + regGenN x g = mkNomReg x g ** {lock_N = <>} ; + compN : N -> Str -> N ; + compN x y = {s = \\n => x.s ! n ++ y ; g = x.g ; lock_N = <>} ; + + mkN = overload { + mkN : Str -> N = regN ; + mkN : Str -> Gender -> N = regGenN ; + mkN : (oeil,yeux : Str) -> Gender -> N = mk2N ; + mkN : N -> Str -> N = compN + } ; + + + mkN2 = \n,p -> n ** {lock_N2 = <> ; c2 = p} ; + deN2 n = mkN2 n genitive ; + aN2 n = mkN2 n dative ; + mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c2 = p ; c3 = q} ; + + regPN x = mk2PN x g where { + g = case last x of { + "e" => feminine ; + _ => masculine + } + } ; + + mkPN = overload { + mkPN : Str -> PN = regPN ; + mkPN : Str -> Gender -> PN = \x,g -> {s = x ; g = g} ** {lock_PN = <>} ; + } ; + + mk4A a b c d = compADeg {s = \\_ => (mkAdj a c b d).s ; isPre = False ; lock_A = <>} ; + regA a = compADeg {s = \\_ => (mkAdjReg a).s ; isPre = False ; lock_A = <>} ; + prefA a = {s = a.s ; isPre = True ; lock_A = <>} ; + + mkA2 a p = a ** {c2 = p ; lock_A2 = <>} ; + + mkA = overload { + mkA : Str -> A = regA ; + mkA : (sec,seche : Str) -> A = \sec,seche -> mk4A sec seche (sec + "s") (seche + "ment") ; + mkA : (banal,banale,banaux,banalement : Str) -> A = mk4A ; + mkA : A -> A -> A = mkADeg + }; + + prefixA a = {s = a.s ; isPre = True ; lock_A = <>} ; + + mkAdv x = ss x ** {lock_Adv = <>} ; + mkAdV x = ss x ** {lock_AdV = <>} ; + mkAdA x = ss x ** {lock_AdA = <>} ; + + regV x = let v = vvf (mkVerbReg x) in {s = v ; vtyp = VHabere ; lock_V = <>} ; + reg3V x y z = let v = vvf (mkVerb3Reg x y z) in {s = v ; vtyp = VHabere ; lock_V = <>} ; + etreV v = {s = v.s ; vtyp = VEsse ; lock_V = <>} ; + reflV v = {s = v.s ; vtyp = VRefl ; lock_V = <>} ; + + mmkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; + dirV3 v p = mmkV3 v accusative p ; + dirdirV3 v = dirV3 v dative ; + + mkV3 = overload { + mkV3 : V -> V3 = dirdirV3 ; -- donner,_,_ + mkV3 : V -> Prep -> V3 = dirV3 ; -- placer,_,sur + mkV3 : V -> Prep -> Prep -> V3 = mmkV3 -- parler, à, de + } ; + + V0 : Type = V ; + AS, AV : Type = A ; + A2S, A2V : Type = A2 ; + + mkV0 v = v ** {lock_V0 = <>} ; + mkVS v = v ** {m = \\_ => Indic ; lock_VS = <>} ; ---- more moods + mkV2S v p = mmkV2 v p ** {mn,mp = Indic ; lock_V2S = <>} ; + mkVV v = v ** {c2 = complAcc ; lock_VV = <>} ; + deVV v = v ** {c2 = complGen ; lock_VV = <>} ; + aVV v = v ** {c2 = complDat ; lock_VV = <>} ; + mkV2V v p q = mmkV3 v p q ** {lock_V2V = <>} ; + mkVA v = v ** {lock_VA = <>} ; + mkV2A v p q = mmkV3 v p q ** {lock_V2A = <>} ; + mkVQ v = v ** {lock_VQ = <>} ; + mkV2Q v p = mmkV2 v p ** {lock_V2Q = <>} ; + + mkAS v = v ** {lock_AS = <>} ; ---- more moods + mkA2S v p = mkA2 v p ** {lock_A2S = <>} ; + mkAV v p = v ** {c = p.p1 ; s2 = p.p2 ; lock_AV = <>} ; + mkA2V v p q = mkA2 v p ** {s3 = q.p2 ; c3 = q.p1 ; lock_A2V = <>} ; + +--------------------------- obsolete + + makeNP : Str -> Gender -> Number -> NP ; + makeNP x g n = {s = (pn2np {s=x;g= g}).s; a = agrP3 g n ; hasClit = False} ** {lock_NP = <>} ; + regPN : Str -> PN ; + mk2PN : Str -> Gender -> PN = \x,g -> {s = x ; g = g} ** {lock_PN = <>} ; + + mkADeg : A -> A -> A ; + compADeg : A -> A ; + + regA : Str -> A ; + mk4A : (banal,banale,banaux,banalement : Str) -> A ; + + prefA : A -> A ; + + mkADeg a b = + {s = table {Posit => a.s ! Posit ; _ => b.s ! Posit} ; isPre = a.isPre ; lock_A = <>} ; + compADeg a = + {s = table {Posit => a.s ! Posit ; _ => \\f => "plus" ++ a.s ! Posit ! f} ; + isPre = a.isPre ; + lock_A = <>} ; + prefA a = {s = a.s ; isPre = True ; lock_A = <>} ; + + mkV = overload { + mkV : Str -> V = regV ; + mkV : (jeter,jette,jettera : Str) -> V = reg3V ; + mkV : V2 -> V = v2V + } ; + + regV : Str -> V ; + reg3V : (jeter,jette,jettera : Str) -> V ; + + mmkV2 : V -> Prep -> V2 ; + mmkV2 v p = v ** {c2 = p ; lock_V2 = <>} ; + dirV2 : V -> V2 = \v -> mmkV2 v accusative ; + v2V : V2 -> V ; + v2V v = v ** {lock_V = <>} ; + + mmkV3 : V -> Prep -> Prep -> V3 ; -- parler, à, de + dirV3 : V -> Prep -> V3 ; -- donner,_,à + dirdirV3 : V -> V3 ; -- donner,_,_ + + +} ; diff --git a/lib/resource/exper/french/PhonoFre.gf b/lib/resource/exper/french/PhonoFre.gf new file mode 100644 index 000000000..df969994d --- /dev/null +++ b/lib/resource/exper/french/PhonoFre.gf @@ -0,0 +1,26 @@ +resource PhonoFre = open Prelude in { + +oper + voyelle : Strs = strs { + "a" ; "à" ; "â " ; "e" ; "é" ; "è" ; "ê¨" ; + "h" ; + "i" ; "î" ; "o" ; "ô" ; "u" ; "û" ; "y" + } ; + + elision : Str -> Str = \d -> d + pre {"e" ; "'" / voyelle} ; + +-- The following morphemes are the most common uses of elision. + + elisDe = elision "d" ; + elisLa = pre {"la" ; "l'" / voyelle} ; + elisLe = elision "l" ; + elisNe = elision "n" ; + elisQue = elision "qu" ; + +-- The subjunction "si" has a special kind of elision. The rule is +-- only approximatively correct, for "si" is not really elided before +-- the string "il" in general, but before the pronouns "il" and "ils". + + elisSi = pre {"si" ; "s'" / strs {"il"}} ; + +} diff --git a/lib/resource/exper/french/PhraseFre.gf b/lib/resource/exper/french/PhraseFre.gf new file mode 100644 index 000000000..defc9fa14 --- /dev/null +++ b/lib/resource/exper/french/PhraseFre.gf @@ -0,0 +1,2 @@ +concrete PhraseFre of Phrase = CatFre ** PhraseRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/QuestionFre.gf b/lib/resource/exper/french/QuestionFre.gf new file mode 100644 index 000000000..979b7226d --- /dev/null +++ b/lib/resource/exper/french/QuestionFre.gf @@ -0,0 +1,2 @@ +concrete QuestionFre of Question = CatFre ** QuestionRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/RelativeFre.gf b/lib/resource/exper/french/RelativeFre.gf new file mode 100644 index 000000000..cc84b6cb1 --- /dev/null +++ b/lib/resource/exper/french/RelativeFre.gf @@ -0,0 +1,2 @@ +concrete RelativeFre of Relative = CatFre ** RelativeRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/ResFre.gf b/lib/resource/exper/french/ResFre.gf new file mode 100644 index 000000000..3641d1da7 --- /dev/null +++ b/lib/resource/exper/french/ResFre.gf @@ -0,0 +1,13 @@ +--1 French auxiliary operations. +-- +---- This module contains operations that are needed to make the +---- resource syntax work. To define everything that is needed to +---- implement $Test$, it moreover contains regular lexical +---- patterns needed for $Lex$. +-- + +instance ResFre of ResRomance = DiffFre ** open CommonRomance, Prelude in { + +flags optimize=noexpand ; + +} ; diff --git a/lib/resource/exper/french/SentenceFre.gf b/lib/resource/exper/french/SentenceFre.gf new file mode 100644 index 000000000..ac2fe131d --- /dev/null +++ b/lib/resource/exper/french/SentenceFre.gf @@ -0,0 +1,2 @@ +concrete SentenceFre of Sentence = CatFre ** SentenceRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/french/StructuralFre.gf b/lib/resource/exper/french/StructuralFre.gf new file mode 100644 index 000000000..466a0f96b --- /dev/null +++ b/lib/resource/exper/french/StructuralFre.gf @@ -0,0 +1,147 @@ +--# -path=.:../abstract:../romance:../common:prelude + +concrete StructuralFre of Structural = CatFre ** + open PhonoFre, MorphoFre, ParadigmsFre, IrregFre, Prelude in { + + flags optimize=all ; + +lin + + above_Prep = {s = ["au dessus"] ; c = MorphoFre.genitive ; isDir = False} ; + after_Prep = mkPreposition "après" ; + all_Predet = { + s = \\a,c => prepCase c ++ aagrForms "tout" "toute" "tous" "toutes" ! a ; + c = Nom + } ; + almost_AdA, almost_AdN = ss "presque" ; + always_AdV = ss "toujours" ; + although_Subj = ss ("bien" ++ elisQue) ** {m = Conjunct} ; + and_Conj = ss "et" ** {n = Pl} ; + because_Subj = ss ("parce" ++ elisQue) ** {m = Indic} ; + before_Prep = mkPreposition "avant" ; + behind_Prep = mkPreposition "derrière" ; + between_Prep = mkPreposition "entre" ; + both7and_DConj = {s1,s2 = "et" ; n = Pl} ; + but_PConj = ss "mais" ; + by8agent_Prep = mkPreposition "par" ; + by8means_Prep = mkPreposition "par" ; + can8know_VV = mkVV (savoir_V2 ** {lock_V = <>}) ; + can_VV = mkVV pouvoir_V ; + during_Prep = mkPreposition "pendant" ; + either7or_DConj = {s1,s2 = "ou" ; n = Pl} ; + everybody_NP = pn2np (mkPN ["tout le monde"] Masc) ; + every_Det = {s = \\_,_ => "chaque" ; n = Sg} ; + everything_NP = pn2np (mkPN ["tout"] Masc) ; + everywhere_Adv = ss "partout" ; + few_Det = {s = \\g,c => prepCase c ++ "peu" ++ elisDe ; n = Pl} ; +--- DEPREC first_Ord = {s = \\ag => (regA "premier").s ! Posit ! AF ag.g ag.n} ; + for_Prep = mkPreposition "pour" ; + from_Prep = complGen ; --- + he_Pron = + mkPronoun + "il" (elision "l") "lui" "lui" "son" (elisPoss "s") "ses" + Masc Sg P3 ; + here7from_Adv = ss "d'ici" ; + here7to_Adv = ss "ici" ; + here_Adv = ss "ici" ; + how_IAdv = ss "comment" ; + how8many_IDet = {s = \\_,c => prepCase c ++ "combien" ++ elisDe ; n = Pl} ; + if_Subj = ss elisSi ** {m = Indic} ; + in8front_Prep = mkPreposition "devant" ; + i_Pron = + mkPronoun + (elision "j") (elision "m") (elision "m") "moi" "mon" (elisPoss "m") "mes" + Masc Sg P1 ; + in_Prep = mkPreposition "dans" ; + it_Pron = + mkPronoun + "il" (elision "l") "lui" "lui" "son" (elisPoss "s") "ses" + Masc Sg P3 ; + less_CAdv = ss "moins" ; + many_Det = {s = \\_,c => prepCase c ++ "plusieurs" ; n = Pl} ; + more_CAdv = ss "plus" ; + most_Predet = {s = \\_,c => prepCase c ++ ["la plupart"] ; c = CPrep P_de} ; + much_Det = {s = \\_,c => prepCase c ++ "beaucoup" ++ elisDe ; n = Pl} ; + must_VV = mkVV (devoir_V2 ** {lock_V = <>}) ; + no_Phr = ss "non" ; + on_Prep = mkPreposition "sur" ; +--- DEPREC one_Quant = {s = \\g,c => prepCase c ++ genForms "un" "une" ! g} ; + only_Predet = {s = \\_,c => prepCase c ++ "seulement" ; c = Nom} ; --- seul(e)(s) + or_Conj = {s = "ou" ; n = Sg} ; + otherwise_PConj = ss "autrement" ; + part_Prep = complGen ; + please_Voc = ss ["s'il vous plaît"] ; + possess_Prep = complGen ; + quite_Adv = ss "assez" ; + she_Pron = + mkPronoun + "elle" elisLa "lui" "elle" "son" (elisPoss "s") "ses" + Fem Sg P3 ; + + so_AdA = ss "si" ; + somebody_NP = pn2np (mkPN ["quelqu'un"] Masc) ; + somePl_Det = {s = \\_,c => prepCase c ++ "quelques" ; n = Pl} ; + someSg_Det = {s = \\_,c => prepCase c ++ elision "quelqu" ; n = Sg} ; + something_NP = pn2np (mkPN ["quelque chose"] Masc) ; + somewhere_Adv = ss ["quelque part"] ; --- ne - pas + that_Quant = {s = \\_ => + table { + Sg => \\g,c => prepCase c ++ genForms "ce" "cette" ! g ; ---- cet ; là + Pl => \\_,_ => "ces" + } + } ; +---b that_NP = makeNP ["cela"] Masc Sg ; + there7from_Adv = ss ["de là"] ; + there7to_Adv = ss "là" ; --- y + there_Adv = ss "là" ; + therefore_PConj = ss "donc" ; +---b these_NP = makeNP ["ceux-ci"] Masc Pl ; + they_Pron = mkPronoun + "ils" "les" "leur" "eux" "leur" "leur" "leurs" + Masc Pl P3 ; + this_Quant = {s = \\_ => + table { + Sg => \\g,c => + prepCase c ++ + genForms (pre {"ce" ; "cet" / voyelle}) "cette" ! g ; --- ci + Pl => \\_,_ => "ces" + } + } ; +---b this_NP = pn2np (mkPN ["ceci"] Masc) ; +---b those_NP = makeNP ["ceux-là"] Masc Pl ; + through_Prep = mkPreposition "par" ; + too_AdA = ss "trop" ; + to_Prep = complDat ; + under_Prep = mkPreposition "sous" ; + very_AdA = ss "très" ; + want_VV = mkVV (vouloir_V2 ** {lock_V = <>}) ; + we_Pron = + mkPronoun "nous" "nous" "nous" "nous" "notre" "notre" "nos" + Masc Pl P1 ; + whatSg_IP = + {s = \\c => prepCase c ++ "quoi" ; a = a} + where {a = aagr Masc Sg} ; + whatPl_IP = + {s = \\c => prepCase c ++ "quoi" ; a = a} + where {a = aagr Masc Pl} ; + when_IAdv = ss "quand" ; + when_Subj = ss "quand" ** {m = Indic} ; + where_IAdv = ss "où" ; + whichSg_IDet = {s = \\g,c => prepCase c ++ genForms "quel" "quelle" ! g ; n = Sg} ; + whichPl_IDet = {s = \\g,c => prepCase c ++ genForms "quels" "quelles" ! g; n = Pl} ; + whoPl_IP = {s = \\c => prepCase c ++ "qui" ; a = aagr Masc Pl} ; + whoSg_IP = {s = \\c => prepCase c ++ "qui" ; a = aagr Masc Sg} ; + why_IAdv = ss "pourquoi" ; + without_Prep = mkPreposition "sans" ; + with_Prep = mkPreposition "avec" ; + yes_Phr = ss "oui" ; --- si + youSg_Pron = mkPronoun + "tu" (elision "t") (elision "t") "toi" "ton" (elisPoss "t") "tes" + Masc Sg P2 ; + youPl_Pron, youPol_Pron = + mkPronoun + "vous" "vous" "vous" "vous" "votre" "votre" "vos" + Masc Pl P2 ; + +} + diff --git a/lib/resource/exper/french/VerbFre.gf b/lib/resource/exper/french/VerbFre.gf new file mode 100644 index 000000000..492604e7b --- /dev/null +++ b/lib/resource/exper/french/VerbFre.gf @@ -0,0 +1,2 @@ +concrete VerbFre of Verb = CatFre ** VerbRomance with + (ResRomance = ResFre) ; diff --git a/lib/resource/exper/romance/AdjectiveRomance.gf b/lib/resource/exper/romance/AdjectiveRomance.gf new file mode 100644 index 000000000..5ff9babb0 --- /dev/null +++ b/lib/resource/exper/romance/AdjectiveRomance.gf @@ -0,0 +1,41 @@ +incomplete concrete AdjectiveRomance of Adjective = + CatRomance ** open CommonRomance, ResRomance, Prelude in { + + lin + + PositA a = { + s = a.s ! Posit ; + isPre = a.isPre + } ; + ComparA a np = { + s = \\af => a.s ! Compar ! af ++ conjThan ++ np.s ! Ton Nom ; + isPre = False + } ; + +-- $SuperlA$ belongs to determiner syntax in $Noun$. + + ComplA2 adj np = { + s = \\af => adj.s ! Posit ! af ++ appCompl adj.c2 np.s ; + isPre = False + } ; + + ReflA2 adj = { + s = \\af => + adj.s ! Posit ! af ++ adj.c2.s ++ + adj.c2.s ++ prepCase adj.c2.c ++ reflPron Sg P3 Nom ; --- agr + isPre = False + } ; + + SentAP ap sc = { + s = \\a => ap.s ! a ++ sc.s ; --- mood + isPre = False + } ; + + AdAP ada ap = { + s = \\a => ada.s ++ ap.s ! a ; + isPre = ap.isPre + } ; + + UseA2 a = a ** {isPre = False} ; + +} diff --git a/lib/resource/exper/romance/AdverbRomance.gf b/lib/resource/exper/romance/AdverbRomance.gf new file mode 100644 index 000000000..8f818f023 --- /dev/null +++ b/lib/resource/exper/romance/AdverbRomance.gf @@ -0,0 +1,26 @@ +incomplete concrete AdverbRomance of Adverb = + CatRomance ** open CommonRomance, ResRomance, Prelude in { + + lin + PositAdvAdj a = { + s = a.s ! Posit ! AA + } ; + ComparAdvAdj cadv a np = { + s = cadv.s ++ a.s ! Posit ! AA ++ conjThan ++ np.s ! Ton Nom + } ; + ComparAdvAdjS cadv a s = { + s = cadv.s ++ a.s ! Posit ! AA ++ conjThan ++ s.s ! Conjunct --- ne + } ; + + PrepNP prep np = {s = prep.s ++ np.s ! case2npform prep.c} ; + + AdAdv = cc2 ; + + SubjS subj s = { + s = subj.s ++ s.s ! subj.m + } ; + AdvSC s = s ; + + AdnCAdv cadv = {s = cadv.s ++ conjThan} ; + +} diff --git a/lib/resource/exper/romance/CatRomance.gf b/lib/resource/exper/romance/CatRomance.gf new file mode 100644 index 000000000..2e57bcdb8 --- /dev/null +++ b/lib/resource/exper/romance/CatRomance.gf @@ -0,0 +1,102 @@ +incomplete concrete CatRomance of Cat = + CommonX - [Tense,TPres,TPast,TFut,TCond] + ** open Prelude, CommonRomance, ResRomance, (R = ParamX) in { + + flags optimize=all_subs ; + + lincat + +-- Tensed/Untensed + + S = {s : Mood => Str} ; + QS = {s : QForm => Str} ; + RS = {s : Mood => Agr => Str ; c : Case} ; + SSlash = { + s : AAgr => Mood => Str ; + c2 : Compl + } ; + + +-- Sentence + + Cl = {s : Direct => RTense => Anteriority => Polarity => Mood => Str} ; + ClSlash = { + s : Direct => AAgr => RTense => Anteriority => Polarity => Mood => Str ; + c2 : Compl + } ; + Imp = {s : Polarity => ImpForm => Gender => Str} ; + +-- Question + + QCl = {s : RTense => Anteriority => Polarity => QForm => Str} ; + IP = {s : Case => Str ; a : AAgr} ; + IComp = {s : AAgr => Str} ; + IDet = {s : Gender => Case => Str ; n : Number} ; + +-- Relative + + RCl = { + s : Agr => RTense => Anteriority => Polarity => Mood => Str ; + c : Case + } ; + RP = {s : Bool => AAgr => Case => Str ; a : AAgr ; hasAgr : Bool} ; + +-- Verb + + VP = CommonRomance.VP ; + VPSlash = CommonRomance.VP ** {c2 : Compl} ; + Comp = {s : Agr => Str} ; + +-- Adjective + + AP = {s : AForm => Str ; isPre : Bool} ; + +-- Noun + + CN = {s : Number => Str ; g : Gender} ; + NP,Pron = Pronoun ; + Det = {s : Gender => Case => Str ; n : Number} ; +--- QuantSg = {s : Gender => Case => Str} ; +--- QuantPl = {s : Bool => Gender => Case => Str} ; + Quant = {s : Bool => Number => Gender => Case => Str} ; + Predet = {s : AAgr => Case => Str ; c : Case} ; -- c : la plupart de + Num = {s : Gender => Str ; isNum : Bool ; n : Number} ; + Ord = {s : AAgr => Str} ; + +-- Numeral + + Numeral = {s : CardOrd => Str ; n : Number} ; + Digits = {s : CardOrd => Str ; n : Number} ; + +-- Structural + + Conj = {s : Str ; n : Number} ; + DConj = {s1,s2 : Str ; n : Number} ; + Subj = {s : Str ; m : Mood} ; + Prep = {s : Str ; c : Case ; isDir : Bool} ; + +-- Open lexical classes, e.g. Lexicon + + V, VQ, VA = Verb ; + V2, VV, V2S, V2Q = Verb ** {c2 : Compl} ; + V3, V2A, V2V = Verb ** {c2,c3 : Compl} ; + VS = Verb ** {m : Polarity => Mood} ; + + A = {s : Degree => AForm => Str ; isPre : Bool} ; + A2 = {s : Degree => AForm => Str ; c2 : Compl} ; + + N = Noun ; + N2 = Noun ** {c2 : Compl} ; + N3 = Noun ** {c2,c3 : Compl} ; + PN = {s : Str ; g : Gender} ; + +-- tense augmented with passé simple + + Tense = {s : Str ; t : RTense} ; + lin + TPres = {s = []} ** {t = RPres} ; + TPast = {s = []} ** {t = RPast} ; --# notpresent + TFut = {s = []} ** {t = RFut} ; --# notpresent + TCond = {s = []} ** {t = RCond} ; --# notpresent + +} diff --git a/lib/resource/exper/romance/CommonRomance.gf b/lib/resource/exper/romance/CommonRomance.gf new file mode 100644 index 000000000..9224e1204 --- /dev/null +++ b/lib/resource/exper/romance/CommonRomance.gf @@ -0,0 +1,216 @@ +----1 Auxiliary operations common for Romance languages +-- +-- This module contains operations that are shared by the Romance +-- languages. The complete set of auxiliary operations needed to +-- implement [Test Test.html] is defined in [ResRomance ResRomance.html], +-- which depends on [DiffRomance DiffRomance.html]. +-- + +resource CommonRomance = ParamX ** open Prelude in { + + flags optimize=all ; + +--2 Enumerated parameter types for morphology +-- +-- These types are the ones found in school grammars. +-- Their parameter values are atomic. + +param + + Gender = Masc | Fem ; + + Mood = Indic | Conjunct ; + + Direct = DDir | DInv ; + +-- Adjectives are inflected in gender and number, and there is also an +-- adverbial form (e.g. "infiniment"), which has different paradigms and +-- can even be irregular ("bien"). +-- Comparative adjectives are moreover inflected in degree +-- (which in Romance is usually syntactic, though). + + AForm = AF Gender Number | AA ; + +-- Gender is not morphologically determined for first and second person pronouns. + + PronGen = PGen Gender | PNoGen ; + +-- Cardinal numerals have gender, ordinal numerals have full number as well. + + CardOrd = NCard Gender | NOrd Gender Number ; + +-- The following coercions are useful: + +oper + prongen2gender : PronGen -> Gender = \p -> case p of { + PGen g => g ; + PNoGen => variants {Masc ; Fem} --- the best we can do for je, tu, nous, vous + } ; + + + aform2gender : AForm -> Gender = \a -> case a of { + AF g _ => g ; + _ => Masc -- "le plus lentement" + } ; + aform2number : AForm -> Number = \a -> case a of { + AF _ n => n ; + _ => Sg -- "le plus lentement" + } ; + + conjGender : Gender -> Gender -> Gender = \m,n -> + case of { + => Fem ; + _ => Fem + } ; + + conjAgr : Agr -> Agr -> Agr = \a,b -> { + g = conjGender a.g b.g ; + n = conjNumber a.n b.n ; + p = conjPerson a.p b.p + } ; + + +--3 Verbs +-- +-- In the current syntax, we use +-- a reduced conjugation with only the present tense infinitive, +-- indicative, subjunctive, and imperative forms. +-- But our morphology has full Bescherelle conjunctions: +-- so we use a coercion between full and reduced verbs. +-- The full conjugations and the coercions are defined separately for French +-- and Italian, since they are not identical. The differences are mostly due +-- to Bescherelle structuring the forms in different groups; the +-- gerund and the present participles show real differences. +-- +-- For Italian contracted forms, $VInfin$ should have +-- an alternative form, whose proper place is $Diff$. + +param + VF = + VInfin Bool + | VFin TMood Number Person + | VImper NumPersI + | VPart Gender Number + | VGer + ; + + TMood = + VPres Mood + | VImperf Mood --# notpresent + | VPasse --# notpresent + | VFut --# notpresent + | VCondit --# notpresent + ; + + NumPersI = SgP2 | PlP1 | PlP2 ; + + VPForm = + VPFinite TMood Anteriority + | VPImperat + | VPGerund + | VPInfinit Anteriority Bool ; + + RTense = + RPres + | RPast --# notpresent + | RPasse --# notpresent + | RFut --# notpresent + | RCond --# notpresent + ; + +-- Agreement of adjectives, verb phrases, and relative pronouns. + +oper + AAgr : Type = {g : Gender ; n : Number} ; + Agr : Type = AAgr ** {p : Person} ; + +param + RAgr = RAg {g : Gender ; n : Number} | RNoAg ; --- AAgr + +-- Clitic slots. + + CAgr = CPron Gender Number Person | CRefl | CNone ; --- Agr +--- CAgr = CPron {g : Gender ; n : Number ; p : Person} | CRefl | CNone ; --- Agr + +oper + aagr : Gender -> Number -> AAgr = \g,n -> + {g = g ; n = n} ; + agrP3 : Gender -> Number -> Agr = \g,n -> + aagr g n ** {p = P3} ; + + + vf2numpers : VF -> (Number * Person) = \v -> case v of { + VFin _ n p => ; + _ => ---- + } ; + + presInd = VPres Indic ; + +-- The imperative forms depend on number and person. + + vImper : Number -> Person -> VF = \n,p -> case of { + => VImper SgP2 ; + => VImper PlP1 ; + => VImper PlP2 ; + _ => VInfin False + } ; + +--- + + oper + genForms : Str -> Str -> Gender => Str = \bon,bonne -> + table { + Masc => bon ; + Fem => bonne + } ; + + aagrForms : (x1,_,_,x4 : Str) -> (AAgr => Str) = \tout,toute,tous,toutes -> + table { + {g = g ; n = Sg} => genForms tout toute ! g ; + {g = g ; n = Pl} => genForms tous toutes ! g + } ; + + Noun = {s : Number => Str ; g : Gender} ; + + Adj = {s : AForm => Str} ; + + appVPAgr : VPAgr -> AAgr -> AAgr = \vp,agr -> + case vp of { + VPAgrSubj => agr ; + VPAgrClit a => a + } ; + + vpAgrNone : VPAgr = VPAgrClit (aagr Masc Sg) ; + + oper + mkOrd : {s : Degree => AForm => Str} -> {s : AAgr => Str} ; + mkOrd x = {s = \\ag => x.s ! Posit ! AF ag.g ag.n} ; + +-- This is used in Spanish and Italian to bind clitics with preceding verb. + + bindIf : Bool -> Str = \b -> if_then_Str b BIND [] ; + + param + VPAgr = + VPAgrSubj -- elle est partie, elle s'est vue + | VPAgrClit -- elle a dormi; elle les a vues + {g : Gender ; n : Number} ; + + oper + VP : Type = { + s : VPForm => { + fin : Agr => Str ; -- ai + inf : AAgr => Str -- dit + } ; + agr : VPAgr ; -- dit/dite dep. on verb, subj, and clitic + neg : Polarity => (Str * Str) ; -- ne-pas + clAcc : CAgr ; -- le/se + clDat : CAgr ; -- lui + clit2 : Str ; -- y en + comp : Agr => Str ; -- content(e) ; à ma mère ; hier + ext : Polarity => Str ; -- que je dors / que je dorme + } ; + + +} + diff --git a/lib/resource/exper/romance/ConjunctionRomance.gf b/lib/resource/exper/romance/ConjunctionRomance.gf new file mode 100644 index 000000000..cdfbb97a2 --- /dev/null +++ b/lib/resource/exper/romance/ConjunctionRomance.gf @@ -0,0 +1,55 @@ +incomplete concrete ConjunctionRomance of Conjunction = + CatRomance ** open CommonRomance, ResRomance, Coordination, Prelude in { + + flags optimize=all_subs ; + + lin + + ConjS conj ss = conjunctTable Mood conj ss ; + DConjS conj ss = conjunctDistrTable Mood conj ss ; + + ConjAdv conj ss = conjunctSS conj ss ; + DConjAdv conj ss = conjunctDistrSS conj ss ; + + ConjNP conj ss = conjunctTable NPForm conj ss ** { + a = {g = ss.a.g ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} ; + hasClit = False + } ; + DConjNP conj ss = conjunctDistrTable NPForm conj ss ** { + a = {g = ss.a.g ; n = conjNumber conj.n ss.a.n ; p = ss.a.p} ; + hasClit = False + } ; + + ConjAP conj ss = conjunctTable AForm conj ss ** { + isPre = ss.isPre + } ; + DConjAP conj ss = conjunctDistrTable AForm conj ss ** { + isPre = ss.isPre + } ; + +-- These fun's are generated from the list cat's. + + BaseS = twoTable Mood ; + ConsS = consrTable Mood comma ; + BaseAdv = twoSS ; + ConsAdv = consrSS comma ; + BaseNP x y = { + s1 = \\c => x.s ! stressedCase c ; + s2 = \\c => y.s ! (conjunctCase c) ; + a = conjAgr x.a y.a + } ; + ConsNP x xs = { + s1 = \\c => x.s ! stressedCase c ++ comma ++ xs.s1 ! (conjunctCase c) ; + s2 = \\c => xs.s2 ! (conjunctCase c) ; + a = conjAgr x.a xs.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} ; + + lincat + [S] = {s1,s2 : Mood => Str} ; + [Adv] = {s1,s2 : Str} ; + [NP] = {s1,s2 : NPForm => Str ; a : Agr} ; + [AP] = {s1,s2 : AForm => Str ; isPre : Bool} ; + +} diff --git a/lib/resource/exper/romance/DiffRomance.gf b/lib/resource/exper/romance/DiffRomance.gf new file mode 100644 index 000000000..acf44cb9b --- /dev/null +++ b/lib/resource/exper/romance/DiffRomance.gf @@ -0,0 +1,108 @@ +--1 Differences between Romance languages + +interface DiffRomance = open CommonRomance, Prelude in { + +-- The first eight constants show the essential differences +-- between French, Italian, and Romance syntaxes (as regards the +-- resource API). The other constants are either derivatively +-- dependent, or have as values strings, which are language-dependent +-- anyway. + + +--2 Constants whose definitions fundamentally depend on language + +-- Prepositions that fuse with the article +-- (Fre, Spa "de", "a"; Ita also "con", "da", "in", "su). + + param Prepos ; + +-- Which types of verbs exist, in terms of auxiliaries. +-- (Fre, Ita "avoir", "être", and refl; Spa only "haber" and refl). + + param VType ; + +-- Derivatively, if/when the participle agrees to the subject. +-- (Fre "elle est partie", Ita "lei è partita", Spa not) + + oper partAgr : VType -> VPAgr ; + +-- Whether participle agrees to foregoing clitic. +-- (Fre "je l'ai vue", Spa "yo la he visto") + + oper vpAgrClit : Agr -> VPAgr ; + +-- Whether a preposition is repeated in conjunction +-- (Fre "la somme de 3 et de 4", Ita "la somma di 3 e 4"). + + oper conjunctCase : NPForm -> NPForm ; + +-- How infinitives and clitics are placed relative to each other +-- (Fre "la voir", Ita "vederla"). The $Bool$ is used for indicating +-- if there are any clitics. + + oper clitInf : Bool -> Str -> Str -> Str ; + +-- To render pronominal arguments as clitics and/or ordinary complements. +-- Returns $True$ if there are any clitics. + + oper pronArg : Number -> Person -> CAgr -> CAgr -> Str * Str * Bool ; + +-- To render imperatives (with their clitics etc). + + oper mkImperative : Bool -> Person -> CommonRomance.VP -> {s : Polarity => AAgr => Str} ; + + +--2 Constants that must derivatively depend on language + + param NPForm = Ton Case | Aton Case | Poss {g : Gender ; n : Number} ; --- AAgr + + oper dative : Case ; + oper genitive : Case ; + + vRefl : VType ; + isVRefl : VType -> Bool ; + + +--2 Strings + + prepCase : Case -> Str ; + + partitive : Gender -> Case -> Str ; + + artDef : Gender -> Number -> Case -> Str ; + artIndef : Gender -> Number -> Case -> Str ; + +-- This is the definite article in Italian, $prepCase c$ in French and Spanish. + + possCase : Gender -> Number -> Case -> Str ; + + auxVerb : VType -> (VF => Str) ; + negation : Polarity => (Str * Str) ; + copula : Verb ; + + conjThan : Str ; + conjThat : Str ; + + subjIf : Str ; + + relPron : Bool => AAgr => Case => Str ; + pronSuch : AAgr => Str ; + + partQIndir : Str ; -- ce, ciò + + reflPron : Number -> Person -> Case -> Str ; +-- argPron : Gender -> Number -> Person -> Case -> Str ; + + auxPassive : Verb ; + + +--2 Contants needed in type signatures above + +param + Case = Nom | Acc | CPrep Prepos ; + +oper + Verb = {s : VF => Str ; vtyp : VType} ; + +} + diff --git a/lib/resource/exper/romance/ExtRomance.gf b/lib/resource/exper/romance/ExtRomance.gf new file mode 100644 index 000000000..a5586d715 --- /dev/null +++ b/lib/resource/exper/romance/ExtRomance.gf @@ -0,0 +1,14 @@ +incomplete concrete ExtRomance of ExtRomanceAbs = + CatRomance ** open DiffRomance, ResRomance in { + + lin + DefSgN predet noun = let g = noun.g in { + s = \\c => predet.s ! gennum g Sg ++ noun.s ! Sg ! Def ! caseNP c ; + a = agrP3 g Sg + } ; + DefPlN predet noun = let g = noun.g in { + s = \\c => predet.s ! Plg ++ noun.s ! Pl ! Def ! caseNP c ; + a = agrP3 g Sg + } ; + +} diff --git a/lib/resource/exper/romance/ExtraRomance.gf b/lib/resource/exper/romance/ExtraRomance.gf new file mode 100644 index 000000000..cd70f2c08 --- /dev/null +++ b/lib/resource/exper/romance/ExtraRomance.gf @@ -0,0 +1,21 @@ +incomplete concrete ExtraRomance of ExtraRomanceAbs = CatRomance ** + open + CommonRomance, + Coordination, + ResRomance in { + + lin TPasseSimple = {s = []} ** {t = RPasse} ; --# notpresent + + lincat + VPI = {s : Str} ; + [VPI] = {s1,s2 : Str} ; + lin + BaseVPI = twoSS ; + ConsVPI = consrSS comma ; + + MkVPI vp = {s = infVP vp (agrP3 Masc Sg)} ; + ConjVPI = conjunctSS ; + ComplVPIVV v vpi = + insertComplement (\\a => prepCase v.c2.c ++ vpi.s) (predV v) ; + +} diff --git a/lib/resource/exper/romance/ExtraRomanceAbs.gf b/lib/resource/exper/romance/ExtraRomanceAbs.gf new file mode 100644 index 000000000..ff5263e98 --- /dev/null +++ b/lib/resource/exper/romance/ExtraRomanceAbs.gf @@ -0,0 +1,7 @@ +abstract ExtraRomanceAbs = Cat, Extra[ + VPI,ListVPI,BaseVPI,ConsVPI,MkVPI,ComplVPIVV,ConjVPI, + VV,VP,Conj] ** { + + fun TPasseSimple : Tense ; --# notpresent + +} diff --git a/lib/resource/exper/romance/NounRomance.gf b/lib/resource/exper/romance/NounRomance.gf new file mode 100644 index 000000000..609676e60 --- /dev/null +++ b/lib/resource/exper/romance/NounRomance.gf @@ -0,0 +1,130 @@ +incomplete concrete NounRomance of Noun = + CatRomance ** open CommonRomance, ResRomance, Prelude in { + + flags optimize=all_subs ; + + lin + DetCN det cn = + let + g = cn.g ; + n = det.n + in { + s = \\c => let cs = npform2case c in + det.s ! g ! cs ++ cn.s ! n ; + a = agrP3 g n ; + hasClit = False + } ; + + UsePN = pn2np ; + + UsePron p = p ; + + PredetNP pred np = { + s = \\c => pred.s ! aagr (np.a.g) (np.a.n) ! npform2case c ++ --- subtype + np.s ! case2npform pred.c ; + a = np.a ; + hasClit = False + } ; + + PPartNP np v2 = { + s = \\c => np.s ! c ++ v2.s ! VPart np.a.g np.a.n ; + a = np.a ; + hasClit = False + } ; + + AdvNP np adv = { + s = \\c => np.s ! c ++ adv.s ; + a = np.a ; + hasClit = False + } ; + + DetSg quant ord = { + s = \\g,c => quant.s ! False ! Sg ! g ! c ++ ord.s ! aagr g Sg ; + n = Sg + } ; + DetPl quant num ord = { + s = \\g,c => quant.s ! num.isNum ! num.n ! g ! c ++ num.s ! g ++ + ord.s ! aagr g Pl ; + n = num.n + } ; + +--- DEPREC SgQuant q = {s = q.s ! False ! Sg} ; +--- DEPREC PlQuant q = {s = \\b,g,c => q.s ! b ! Pl ! g ! c} ; + --- part app: cf NounScand. AR 8/7/2007 + + PossPron p = { + s = \\_,n,g,c => possCase g n c ++ p.s ! Poss (aagr g n) ---- il mio! + } ; + + NoNum = {s = \\_ => [] ; isNum = False ; n = Pl} ; + NoOrd = {s = \\_ => []} ; + + NumInt n = {s = \\_ => n.s ; isNum = True ; n = Pl} ; + OrdInt n = {s = \\_ => n.s ++ "."} ; --- + + NumDigits nu = {s = \\g => nu.s ! NCard g ; isNum = True ; n = nu.n} ; + OrdDigits nu = {s = \\a => nu.s ! NOrd a.g a.n} ; + + NumNumeral nu = {s = \\g => nu.s ! NCard g ; isNum = True ; n = nu.n} ; + OrdNumeral nu = {s = \\a => nu.s ! NOrd a.g a.n} ; + + AdNum adn num = {s = \\a => adn.s ++ num.s ! a ; isNum = num.isNum ; n = num.n} ; + + OrdSuperl adj = {s = \\a => adj.s ! Superl ! AF a.g a.n} ; + + DefArt = { + s = \\_,n,g,c => artDef g n c + } ; + + IndefArt = { + s = \\b,n,g,c => if_then_Str b [] (artIndef g n c) ; + } ; + + MassDet = { + s = \\b,n,g,c => case of { + => partitive g c ; + _ => prepCase genitive ---- + } + } ; + +-- This is based on record subtyping. + + UseN, UseN2, UseN3 = \noun -> noun ; + + ComplN2 f x = { + s = \\n => f.s ! n ++ appCompl f.c2 x.s ; + g = f.g ; + } ; + ComplN3 f x = { + s = \\n => f.s ! n ++ appCompl f.c2 x.s ; + g = f.g ; + c2 = f.c3 + } ; + + AdjCN ap cn = + let + g = cn.g + in { + s = \\n => preOrPost ap.isPre (ap.s ! (AF g n)) (cn.s ! n) ; + g = g ; + } ; + + RelCN cn rs = let g = cn.g in { + s = \\n => cn.s ! n ++ rs.s ! Indic ! agrP3 g n ; --- mood + g = g + } ; + SentCN cn sc = let g = cn.g in { + s = \\n => cn.s ! n ++ sc.s ; + g = g + } ; + AdvCN cn sc = let g = cn.g in { + s = \\n => cn.s ! n ++ sc.s ; + g = g + } ; + + ApposCN cn np = let g = cn.g in { + s = \\n => cn.s ! n ++ np.s ! Ton Nom ; + g = g + } ; + +} diff --git a/lib/resource/exper/romance/PhraseRomance.gf b/lib/resource/exper/romance/PhraseRomance.gf new file mode 100644 index 000000000..e45f1beff --- /dev/null +++ b/lib/resource/exper/romance/PhraseRomance.gf @@ -0,0 +1,27 @@ +incomplete concrete PhraseRomance of Phrase = + CatRomance ** open CommonRomance, ResRomance, Prelude in { + + flags optimize = all_subs ; + + lin + PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; + + UttS s = {s = s.s ! Indic} ; + UttQS qs = {s = qs.s ! QDir} ; + UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg False ! Fem} ; + UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Pl False ! Fem} ; + UttImpPol pol imp = {s = pol.s ++ imp.s ! pol.p ! ImpF Sg True ! Fem} ; + + UttIP ip = {s = ip.s ! Nom} ; --- Acc also + UttIAdv iadv = iadv ; + UttNP np = {s = np.s ! Ton Nom} ; + UttVP vp = {s = infVP vp (agrP3 Fem Sg)} ; --- Agr + UttAdv adv = adv ; + + NoPConj = {s = []} ; + PConjConj conj = conj ; + + NoVoc = {s = []} ; + VocNP np = {s = "," ++ np.s ! Ton Nom} ; + +} diff --git a/lib/resource/exper/romance/QuestionRomance.gf b/lib/resource/exper/romance/QuestionRomance.gf new file mode 100644 index 000000000..bb878abe9 --- /dev/null +++ b/lib/resource/exper/romance/QuestionRomance.gf @@ -0,0 +1,76 @@ +incomplete concrete QuestionRomance of Question = + CatRomance ** open CommonRomance, ResRomance, Prelude in { + + flags optimize=all_subs ; + + lin + + QuestCl cl = { + s = \\t,a,p => + let cls = cl.s ! DDir ! t ! a ! p ---- DInv? + in table { + QDir => cls ! Indic ; + QIndir => subjIf ++ cls ! Indic + } + } ; + + QuestVP qp vp = { + s = \\t,a,b,_ => + let + cl = mkClause (qp.s ! Nom) False (agrP3 qp.a.g qp.a.n) vp + in + cl.s ! DDir ! t ! a ! b ! Indic + } ; + + QuestSlash ip slash = { + s = \\t,a,p => + let + cls : Direct -> Str = + \d -> slash.s ! d ! ip.a ! t ! a ! p ! Indic ; + who = slash.c2.s ++ ip.s ! slash.c2.c + in table { + QDir => who ++ cls DInv ; + QIndir => partQIndir ++ who ++ cls DDir + } + } ; + + QuestIAdv iadv cl = { + s = \\t,a,p,_ => + let + cls = cl.s ! DInv ! t ! a ! p ! Indic ; + why = iadv.s + in why ++ cls + } ; + + QuestIComp icomp np = { + s = \\t,a,p,_ => + let + vp = predV copula ; + cls = (mkClause (np.s ! Aton Nom) np.hasClit np.a vp).s ! + DInv ! t ! a ! p ! Indic ; + why = icomp.s ! {g = np.a.g ; n = np.a.n} + in why ++ cls + } ; + + PrepIP p ip = { + s = p.s ++ ip.s ! p.c + } ; + + AdvIP ip adv = { + s = \\c => ip.s ! c ++ adv.s ; + a = ip.a + } ; + + IDetCN idet num ord cn = + let + g = cn.g ; + n = idet.n ; + a = aagr g n + in { + s = \\c => idet.s ! g ! c ++ num.s ! g ++ ord.s ! a ++ cn.s ! n ; + a = a + } ; + + CompIAdv a = {s = \\_ => a.s} ; + +} diff --git a/lib/resource/exper/romance/RelativeRomance.gf b/lib/resource/exper/romance/RelativeRomance.gf new file mode 100644 index 000000000..2051c283d --- /dev/null +++ b/lib/resource/exper/romance/RelativeRomance.gf @@ -0,0 +1,50 @@ +incomplete concrete RelativeRomance of Relative = + CatRomance ** open Prelude, CommonRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + + RelCl cl = { + s = \\ag,t,a,p,m => pronSuch ! ag ++ conjThat ++ + cl.s ! DDir ! t ! a ! p ! m ; + c = Nom + } ; + + --- more efficient to compile than case inside mkClause; see log.txt + RelVP rp vp = case rp.hasAgr of { + True => {s = \\ag => + (mkClause + (rp.s ! False ! {g = ag.g ; n = ag.n} ! Nom) False + {g = rp.a.g ; n = rp.a.n ; p = P3} + vp).s ! DDir ; c = Nom} ; + False => {s = \\ag => + (mkClause + (rp.s ! False ! {g = ag.g ; n = ag.n} ! Nom) False + ag + vp).s ! DDir ; c = Nom + } + } ; + + RelSlash rp slash = { + s = \\ag,t,a,p,m => + let aag = {g = ag.g ; n = ag.n} + in + slash.c2.s ++ + rp.s ! False ! aag ! slash.c2.c ++ + slash.s ! DDir ! aag ! t ! a ! p ! m ; --- ragr + c = Acc + } ; + + FunRP p np rp = { + s = \\_,a,c => np.s ! Ton Nom ++ p.s ++ rp.s ! True ! a ! p.c ; + a = {g = np.a.g ; n = np.a.n} ; + hasAgr = True + } ; + IdRP = { + s = relPron ; + a = {g = Masc ; n = Sg} ; + hasAgr = False + } ; + +} diff --git a/lib/resource/exper/romance/ResRomance.gf b/lib/resource/exper/romance/ResRomance.gf new file mode 100644 index 000000000..fc29c0af5 --- /dev/null +++ b/lib/resource/exper/romance/ResRomance.gf @@ -0,0 +1,250 @@ +--1 Romance auxiliary operations. +-- + +interface ResRomance = DiffRomance ** open CommonRomance, Prelude in { + +flags optimize=all ; + +--2 Constants uniformly defined in terms of language-dependent constants + +oper + + nominative : Case = Nom ; + accusative : Case = Acc ; + + Pronoun = {s : NPForm => Str ; a : Agr ; hasClit : Bool} ; + + Compl : Type = {s : Str ; c : Case ; isDir : Bool} ; + + complAcc : Compl = {s = [] ; c = accusative ; isDir = True} ; + complGen : Compl = {s = [] ; c = genitive ; isDir = False} ; + complDat : Compl = {s = [] ; c = dative ; isDir = True} ; + + pn2np : {s : Str ; g : Gender} -> Pronoun = \pn -> { + s = \\c => prepCase (npform2case c) ++ pn.s ; + a = agrP3 pn.g Sg ; + hasClit = False + } ; + + npform2case : NPForm -> Case = \p -> case p of { + Ton x => x ; + Poss _ => genitive ; + Aton x => x + } ; + + case2npform : Case -> NPForm = \c -> case c of { + Nom => Ton Nom ; + Acc => Ton Acc ; + _ => Ton c + } ; + +-- Pronouns in $NP$ lists are always in stressed forms. + + stressedCase : NPForm -> NPForm = \c -> case c of { + Aton k => Ton k ; + _ => c + } ; + + appCompl : Compl -> (NPForm => Str) -> Str = \comp,np -> + comp.s ++ np ! Ton comp.c ; + + predV : Verb -> VP = \verb -> + let + vfin : TMood -> Agr -> Str = \tm,a -> verb.s ! VFin tm a.n a.p ; + vpart : AAgr -> Str = \a -> verb.s ! VPart a.g a.n ; + vinf : Bool -> Str = \b -> verb.s ! VInfin b ; + vger = verb.s ! VGer ; + + typ = verb.vtyp ; + aux = auxVerb typ ; + + habet : TMood -> Agr -> Str = \tm,a -> aux ! VFin tm a.n a.p ; + habere : Str = aux ! VInfin False ; + + vimp : Agr -> Str = \a -> case of { + => verb.s ! VImper PlP1 ; + <_, P3> => verb.s ! VFin (VPres Conjunct) a.n P3 ; + => verb.s ! VImper SgP2 ; + => verb.s ! VImper PlP2 + } ; + + vf : (Agr -> Str) -> (AAgr -> Str) -> { + fin : Agr => Str ; + inf : AAgr => Str + } = + \fin,inf -> { + fin = \\a => fin a ; + inf = \\a => inf a + } ; + + in { + s = table { + VPFinite t Simul => vf (vfin t) (\_ -> []) ; + VPFinite t Anter => vf (habet t) vpart ; --# notpresent + VPInfinit Anter b=> vf (\_ -> []) (\a -> habere ++ vpart a) ; --# notpresent + VPImperat => vf vimp (\_ -> []) ; + VPGerund => vf (\_ -> []) (\_ -> vger) ; + VPInfinit Simul b=> vf (\_ -> []) (\_ -> vinf b) + } ; + agr = partAgr typ ; + neg = negation ; + clAcc = case isVRefl typ of { + True => CRefl ; + _ => CNone + } ; + clDat = CNone ; --- no dative refls + clit2 = [] ; + comp = \\a => [] ; + ext = \\p => [] + } ; + + insertObject : Compl -> Pronoun -> VP -> VP = \c,np,vp -> + let + vpacc = vp.clAcc ; + vpdat = vp.clDat ; + vpagr = vp.agr ; + npa = np.a ; + cpron = CPron npa.g npa.n npa.p ; + noNewClit = ; + + cc : CAgr * CAgr * Str * VPAgr = case of { + => case c.c of { + Acc => ; + _ => -- must be dat + } ; + _ => noNewClit + } ; + + in { + s = vp.s ; + agr = cc.p4 ; + clAcc = cc.p1 ; + clDat = cc.p2 ; + clit2 = vp.clit2 ; + neg = vp.neg ; + comp = \\a => vp.comp ! a ++ cc.p3 ; + ext = vp.ext ; + } ; + + insertComplement : (Agr => Str) -> VP -> VP = \co,vp -> { + s = vp.s ; + agr = vp.agr ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ; + neg = vp.neg ; + comp = \\a => vp.comp ! a ++ co ! a ; + ext = vp.ext ; + } ; + +-- Agreement with preceding relative or interrogative: +-- "les femmes que j'ai aimées" + + insertAgr : AAgr -> VP -> VP = \ag,vp -> { + s = vp.s ; + agr = vpAgrClit (agrP3 ag.g ag.n) ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ; + neg = vp.neg ; + comp = vp.comp ; + ext = vp.ext ; + } ; + + insertAdv : Str -> VP -> VP = \co,vp -> { + s = vp.s ; + agr = vp.agr ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ; + neg = vp.neg ; + comp = \\a => vp.comp ! a ++ co ; + ext = vp.ext ; + } ; + + insertAdV : Str -> VP -> VP = \co,vp -> { + s = vp.s ; + agr = vp.agr ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ; + neg = \\b => let vpn = vp.neg ! b in {p1 = vpn.p1 ; p2 = vpn.p2 ++ co} ; + comp = vp.comp ; + ext = vp.ext ; + } ; + + insertClit2 : Str -> VP -> VP = \co,vp -> { + s = vp.s ; + agr = vp.agr ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ++ co ; ---- y en + neg = vp.neg ; + comp = vp.comp ; + ext = vp.ext ; + } ; + + insertExtrapos : (Polarity => Str) -> VP -> VP = \co,vp -> { + s = vp.s ; + agr = vp.agr ; + clAcc = vp.clAcc ; + clDat = vp.clDat ; + clit2 = vp.clit2 ; + neg = vp.neg ; + comp = vp.comp ; + ext = \\p => vp.ext ! p ++ co ! p ; + } ; + + mkClause : Str -> Bool -> Agr -> VP -> + {s : Direct => RTense => Anteriority => Polarity => Mood => Str} = + \subj,hasClit,agr,vp -> { + s = \\d,t,a,b,m => + let + tm = case t of { + RPast => VImperf m ; --# notpresent + RFut => VFut ; --# notpresent + RCond => VCondit ; --# notpresent + RPasse => VPasse ; --# notpresent + RPres => VPres m + } ; + vps = vp.s ! VPFinite tm a ; + verb = vps.fin ! agr ; + inf = vps.inf ! (appVPAgr vp.agr (aagr agr.g agr.n)) ; --- subtype bug + neg = vp.neg ! b ; + clpr = pronArg agr.n agr.p vp.clAcc vp.clDat ; + compl = clpr.p2 ++ vp.comp ! agr ++ vp.ext ! b + in + case d of { + DDir => + subj ++ neg.p1 ++ clpr.p1 ++ vp.clit2 ++ verb ++ neg.p2 ++ inf ; + DInv => + neg.p1 ++ clpr.p1 ++ vp.clit2 ++ verb ++ + preOrPost hasClit subj (neg.p2 ++ inf) + } + ++ compl + } ; +--- in French, pronouns should +--- have a "-" with possibly a special verb form with "t": +--- "comment fera-t-il" vs. "comment fera Pierre" + + infVP : VP -> Agr -> Str = \vp,agr -> + let + clpr = pronArg agr.n agr.p vp.clAcc vp.clDat ; + inf = (vp.s ! VPInfinit Simul clpr.p3).inf ! (aagr agr.g agr.n) ; + neg = vp.neg ! Pos ; --- Neg not in API + obj = neg.p2 ++ clpr.p2 ++ vp.comp ! agr ++ vp.ext ! Pos ---- pol + in + clitInf clpr.p3 (clpr.p1 ++ vp.clit2) inf ++ obj ; + +} + +-- insertObject: +-- p -cat=Cl -tr "la femme te l' envoie" +-- PredVP (DetCN (DetSg DefSg NoOrd) (UseN woman_N)) +-- (ComplV3 send_V3 (UsePron he_Pron) (UsePron thou_Pron)) +-- la femme te l' a envoyé +-- +-- p -cat=Cl -tr "la femme te lui envoie" +-- PredVP (DetCN (DetSg DefSg NoOrd) (UseN woman_N)) +-- (ComplV3 send_V3 (UsePron thou_Pron) (UsePron he_Pron)) +-- la femme te lui a envoyée diff --git a/lib/resource/exper/romance/SentenceRomance.gf b/lib/resource/exper/romance/SentenceRomance.gf new file mode 100644 index 000000000..60d8d4df1 --- /dev/null +++ b/lib/resource/exper/romance/SentenceRomance.gf @@ -0,0 +1,89 @@ +incomplete concrete SentenceRomance of Sentence = + CatRomance ** open Prelude, CommonRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + PredVP np vp = mkClause (np.s ! Aton Nom) np.hasClit np.a vp ; + + PredSCVP sc vp = mkClause sc.s False (agrP3 Masc Sg) vp ; + + ImpVP vp = { + s = \\p,i,g => case i of { + ImpF n b => (mkImperative b P2 vp).s ! p ! (aagr g n) + } + } ; + + SlashVP np v2 = + {s = \\d,ag =>case of { + => + (mkClause (np.s ! Aton Nom) np.hasClit np.a + (insertAgr ag v2)).s ! d ; + _ => (mkClause (np.s ! Aton Nom) np.hasClit np.a v2).s ! d + } ; + c2 = v2.c2 + } ; + +{---b + SlashV2 np v2 = + {s = \\d,ag =>case of { + => + (mkClause (np.s ! Aton Nom) np.hasClit np.a + (insertAgr ag (predV v2))).s ! d ; + _ => (mkClause (np.s ! Aton Nom) np.hasClit np.a (predV v2)).s ! d + } ; + c2 = v2.c2 + } ; + + SlashVVV2 np vv v2 = + {s = \\d,_ => + (mkClause + (np.s ! Aton Nom) np.hasClit np.a + (insertComplement + (\\a => prepCase vv.c2.c ++ v2.s ! VInfin False) (predV vv))).s ! d; + c2 = v2.c2 + } ; +-} + AdvSlash slash adv = { + s = \\d,ag,t,a,b,m => slash.s ! d! ag ! t ! a ! b ! m ++ adv.s ; + c2 = slash.c2 + } ; + + SlashPrep cl prep = { + s = \\d,_ => cl.s ! d ; + c2 = {s = prep.s ; c = prep.c ; isDir = False} + } ; + + SlashVS np vs slash = + {s = \\d,ag => + (mkClause + (np.s ! Aton Nom) np.hasClit np.a + (insertExtrapos (\\b => conjThat ++ slash.s ! ag ! (vs.m ! b)) --- ag? + (predV vs)) + ).s ! d ; + c2 = slash.c2 + } ; + + EmbedS s = {s = conjThat ++ s.s ! Indic} ; --- mood + EmbedQS qs = {s = qs.s ! QIndir} ; + EmbedVP vp = {s = infVP vp (agrP3 Masc Sg)} ; --- agr ---- compl + + UseCl t a p cl = { + s = \\o => t.s ++ a.s ++ p.s ++ cl.s ! DDir ! t.t ! a.a ! p.p ! o + } ; + UseQCl t a p cl = { + s = \\q => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ! q + } ; + UseRCl t a p cl = { + s = \\r,ag => t.s ++ a.s ++ p.s ++ cl.s ! ag ! t.t ! a.a ! p.p ! r ; + c = cl.c + } ; + UseSlash t a p cl = { + s = \\agr,mo => + t.s ++ a.s ++ p.s ++ cl.s ! DDir ! agr ! t.t ! a.a ! p.p ! mo ; + c2 = cl.c2 + } ; + + AdvS a s = {s = \\o => a.s ++ "," ++ s.s ! o} ; + +} diff --git a/lib/resource/exper/romance/VerbRomance.gf b/lib/resource/exper/romance/VerbRomance.gf new file mode 100644 index 000000000..51e68df14 --- /dev/null +++ b/lib/resource/exper/romance/VerbRomance.gf @@ -0,0 +1,61 @@ +incomplete concrete VerbRomance of Verb = + CatRomance ** open Prelude, CommonRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + UseV = predV ; + +{---b + ComplV2 v np1 = insertObject v.c2 np1 (predV v) ; + + ComplV3 v np1 np2 = insertObject v.c3 np2 (insertObject v.c2 np1 (predV v)) ; + + ComplVV v vp = + insertComplement (\\a => prepCase v.c2.c ++ infVP vp a) (predV v) ; + ComplVS v s = insertExtrapos (\\b => conjThat ++ s.s ! (v.m ! b)) (predV v) ; + ComplVQ v q = insertExtrapos (\\_ => q.s ! QIndir) (predV v) ; + ComplVA v ap = + insertComplement (\\a => ap.s ! AF a.g a.n) (predV v) ; + + ComplV2V v np vp = + insertComplement (\\a => prepCase v.c2.c ++ infVP vp a) + (insertObject v.c2 np (predV v)) ; + ComplV2S v np s = + insertExtrapos (\\b => s.s ! Indic) ---- mood + (insertObject v.c2 np (predV v)) ; + ComplV2Q v np q = + insertExtrapos (\\_ => q.s ! QIndir) + (insertObject v.c2 np (predV v)) ; + + ComplV2A v np ap = + let af = case v.c3.isDir of { + True => AF np.a.g np.a.n ; -- ... bleues + _ => AF Masc Sg -- il les peint en bleu + } + in + insertComplement + (\\a => v.c3.s ++ prepCase v.c3.c ++ ap.s ! af) + (insertObject v.c2 np (predV v)) ; + + ReflV2 v = case v.c2.isDir of { + True => predV {s = v.s ; vtyp = vRefl} ; + False => insertComplement + (\\a => v.c2.s ++ reflPron a.n a.p v.c2.c) (predV v) + } ; + +-} + UseComp comp = insertComplement comp.s (predV copula) ; + + CompAP ap = {s = \\ag => ap.s ! AF ag.g ag.n} ; + CompNP np = {s = \\_ => np.s ! Ton Acc} ; + CompAdv a = {s = \\_ => a.s} ; + + AdvVP vp adv = insertAdv adv.s vp ; + AdVVP adv vp = insertAdV adv.s vp ; + + PassV2 v = insertComplement (\\a => v.s ! VPart a.g a.n) (predV auxPassive) ; + + UseVS, UseVQ = \vv -> {s = vv.s ; c2 = complAcc ; vtyp = vv.vtyp} ; + +}