diff --git a/lib/resource-1.0/french/AdjectiveFre.gf b/lib/resource-1.0/french/AdjectiveFre.gf new file mode 100644 index 000000000..c7d09b597 --- /dev/null +++ b/lib/resource-1.0/french/AdjectiveFre.gf @@ -0,0 +1,2 @@ +concrete AdjectiveFre of Adjective = CatFre ** AdjectiveRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/AdverbFre.gf b/lib/resource-1.0/french/AdverbFre.gf new file mode 100644 index 000000000..920bd87b3 --- /dev/null +++ b/lib/resource-1.0/french/AdverbFre.gf @@ -0,0 +1,2 @@ +concrete AdverbFre of Adverb = CatFre ** AdverbRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/BasicFre.gf b/lib/resource-1.0/french/BasicFre.gf new file mode 100644 index 000000000..be40e373c --- /dev/null +++ b/lib/resource-1.0/french/BasicFre.gf @@ -0,0 +1,233 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +concrete BasicFre of Basic = CatFre ** open ParadigmsFre, VerbsFre in { + +flags + optimize=values ; + +lin + airplane_N = regN "avion" masculine ; + answer_V2S = mkV2S (v2V répondre_V2) dative ; + apartment_N = regN "apartement" masculine ; + apple_N = regN "pomme" feminine ; + art_N = regN "art" feminine ; + ask_V2Q = mkV2Q (regV "demander") dative ; + baby_N = regN "bébé" masculine ; + bad_A = prefA (mkADeg (regA "mauvais") (regA "pire")) ; + bank_N = regN "banque" feminine ; + beautiful_A = prefA (regA "joli") ; ---- beau + become_VA = mkVA devenir_V ; + beer_N = regN "bière" feminine ; + beg_V2V = mkV2V (regV "demander") accusative dative ; + big_A = prefA (regA "grand") ; + bike_N = regN "vélo" masculine ; + bird_N = regN "oiseau" masculine ; + black_A = regA "noir" ; + blue_A = regA "bleu" ; + boat_N = regN "bateau" masculine ; + book_N = regN "livre" masculine ; + boot_N = regN "botte" feminine ; + boss_N = regN "chef" masculine ; + boy_N = regN "garçon" masculine ; + bread_N = regN "pain" masculine ; + break_V2 = dirV2 (regV "casser") ; + broad_A = regA "large" ; + brother_N2 = deN2 (regN "frère" masculine) ; + brown_A = regA "brun" ; + butter_N = regN "beurre" masculine ; + buy_V2 = dirV2 (reg3V "acheter" "achète" "achètera") ; + camera_N = compN (regN "appareil" masculine) ["de photo"] ; + cap_N = regN "casquette" feminine ; + car_N = regN "voiture" feminine ; + carpet_N = regN "tapis" masculine ; + cat_N = regN "chat" masculine ; + ceiling_N = regN "plafond" masculine ; + chair_N = regN "chaise" feminine ; + cheese_N = regN "fromage" masculine ; + child_N = regN "enfant" masculine ; + church_N = regN "église" feminine ; + city_N = regN "ville" feminine ; + clean_A = regA "propre" ; + clever_A = regA "sage" ; ---- + close_V2 = dirV2 (regV "fermer") ; + coat_N = regN "manteau" masculine ; + cold_A = regA "froid" ; + come_V = venir_V ; + computer_N = regN "ordinateur" masculine ; + country_N = regN "pays" masculine ; + cousin_N = regN "cousin" masculine ; ---- cousine + cow_N = regN "vache" feminine ; + die_V = mourir_V ; + dirty_A = regA "sale" ; + distance_N3 = mkN3 (regN "distance" feminine) genitive dative ; + doctor_N = regN "médecin" masculine ; + dog_N = regN "chien" masculine ; + door_N = regN "porte" feminine ; + drink_V2 = boire_V2 ; + easy_A2V = mkA2V (regA "facile") dative genitive ; + eat_V2 = dirV2 (regV "manger") ; + empty_A = regA "vide" ; + enemy_N = regN "ennemi" masculine ; + factory_N = regN "usine" feminine ; + father_N2 = deN2 (regN "père" masculine) ; + fear_VS = mkVS (v2V craindre_V2) ; + find_V2 = dirV2 (regV "trouver") ; + fish_N = regN "poisson" masculine ; + floor_N = regN "plancher" masculine ; + forget_V2 = dirV2 (regV "oublier") ; + fridge_N = regN "frigo" masculine ; + friend_N = regN "ami" masculine ; + fruit_N = regN "fruit" masculine ; + fun_AV = mkAV (regA "marrant") genitive ; + garden_N = regN "jardin" masculine ; + girl_N = regN "fille" feminine ; + glove_N = regN "gant" masculine ; + gold_N = regN "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 = regN "port" masculine ; + hate_V2 = haïr_V2 ; + hat_N = regN "chapeau" masculine ; + have_V2 = avoir_V2 ; + hear_V2 = entendre_V2 ; + hill_N = regN "colline" feminine ; + hope_VS = mkVS (reg3V "espérer" "espère" "espérera") ; + horse_N = regN "cheval" masculine ; + hot_A = regA "chaud" ; + house_N = regN "maison" feminine ; + important_A = regA "important" ; + industry_N = regN "industrie" feminine ; + iron_N = regN "fer" masculine ; + king_N = regN "roi" masculine ; + know_V2 = connaître_V2 ; ---- savoir_V2 : VS + lake_N = regN "lac" masculine ; + lamp_N = regN "lampe" feminine ; + learn_V2 = apprendre_V2 ; + leather_N = regN "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 = regN "amour" masculine ; + love_V2 = dirV2 (regV "aimer") ; + man_N = regN "homme" masculine ; + married_A2 = mkA2 (regA "marié") dative ; + meat_N = regN "viande" feminine ; + milk_N = regN "lait" masculine ; + moon_N = regN "lune" feminine ; + mother_N2 = deN2 (regN "mère" feminine) ; + mountain_N = regN "montagne" feminine ; + music_N = regN "musique" feminine ; + narrow_A = regA "étroit" ; + new_A = prefA (compADeg (mkA "nouveau" "nouvelle" "nouveaux" "nouvellement")) ; + newspaper_N = regN "journal" masculine ; + oil_N = regN "huile" feminine ; + old_A = + prefA (compADeg (mkA "vieux" "vieille" "vieux" "vieillement")) ; ---- vieil + open_V2 = ouvrir_V2 ; + paint_V2A = mkV2A (v2V peindre_V2) accusative ; + paper_N = regN "papier" masculine ; + peace_N = regN "paix" feminine ; + pen_N = regN "stylo" masculine ; + planet_N = regN "planète" feminine ; + plastic_N = regN "plastic" masculine ; + play_V2 = dirV2 (regV "jouer") ; + policeman_N = regN "policier" masculine ; + priest_N = regN "prêtre" masculine ; + probable_AS = mkAS (regA "probable") ; + queen_N = regN "reine" feminine ; + radio_N = regN "radio" feminine ; + rain_V0 = mkV0 (pleuvoir_V) ; + read_V2 = lire_V2 ; + red_A = regA "rouge" ; + religion_N = regN "religion" feminine ; + restaurant_N = regN "restaurant" masculine ; + river_N = regN "rivière" feminine ; + rock_N = regN "rocher" masculine ; + roof_N = regN "toit" masculine ; + rubber_N = regN "caoutchuc" masculine ; + run_V = v2V courir_V2 ; + say_VS = mkVS (v2V dire_V2) ; + school_N = regN "école" feminine ; + science_N = regN "science" feminine ; + sea_N = regN "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 = regN "mouton" masculine ; + ship_N = regN "bateau" masculine ; + shirt_N = regN "chemise" feminine ; + shoe_N = regN "chaussure" feminine ; + shop_N = regN "magasin" masculine ; + short_A = regA "court" ; ---- bref + silver_N = regN "argent" masculine ; + sister_N = regN "soeur" feminine ; + sleep_V = v2V dormir_V2 ; + small_A = prefA (regA "petit") ; + snake_N = regN "serpent" masculine ; + sock_N = regN "chaussette" feminine ; + speak_V2 = dirV2 (regV "parler") ; + star_N = regN "étoile" feminine ; + steel_N = regN "acier" masculine ; + stone_N = regN "pierre" feminine ; + stove_N = regN "four" masculine ; + student_N = regN "étudiant" masculine ; + stupid_A = regA "stupide" ; + sun_N = regN "soleil" masculine ; + switch8off_V2 = éteindre_V2 ; + switch8on_V2 = dirV2 (regV "allumer") ; ---- + table_N = regN "table" feminine ; + talk_V3 = mkV3 (regV "parler") dative genitive ; + teacher_N = regN "professeur" masculine ; + teach_V2 = dirV2 (regV "enseigner") ; + television_N = regN "télévision" feminine ; + thick_A = compADeg (mkA "épais" "épaisse" "épais" "épaissement") ; + thin_A = regA "fin" ; + train_N = regN "train" masculine ; + travel_V = regV "voyager" ; + tree_N = regN "arbre" masculine ; + ---- trousers_N = regN "pantalon" masculine ; + ugly_A = regA "laide" ; + understand_V2 = comprendre_V2 ; + university_N = regN "université" feminine ; + village_N = regN "village" masculine ; + wait_V2 = attendre_V2 ; ---- dative? + walk_V = regV "marcher" ; + warm_A = regA "chaud" ; + war_N = regN "guerre" masculine ; + watch_V2 = dirV2 (regV "regarder") ; + water_N = regN "eau" feminine ; + white_A = compADeg (mkA "blanc" "blanche" "blancs" "blanchement") ; + window_N = regN "fenêtre" feminine ; + wine_N = regN "vin" masculine ; + win_V2 = dirV2 (regV "gagner") ; ---- vaincre + woman_N = regN "femme" feminine ; + wonder_VQ = mkVQ (regV "étonner") ; ----- s'étonner + wood_N = regN "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 = regN "chanson" feminine ; + add_V3 = dirV3 (regV "ajouter") dative ; + number_N = regN "nombre" masculine ; ---- numéro + put_V2 = mettre_V2 ; + stop_V = regV "arrêter" ; ---- s'arrêter + jump_V = regV "sauter" ; +{- + here_Adv = mkAdv "ici" ; + here7to_Adv = mkAdv "ici" ; + here7from_Adv = mkAdv ["d'ici"] ; + there_Adv = mkAdv "là" ; ---- y, là-bas + there7to_Adv = mkAdv "là" ; --- y + there7from_Adv = mkAdv ["de là"] ; ---- en +-} +} ; diff --git a/lib/resource-1.0/french/BeschFre.gf b/lib/resource-1.0/french/BeschFre.gf new file mode 100644 index 000000000..6e66a258b --- /dev/null +++ b/lib/resource-1.0/french/BeschFre.gf @@ -0,0 +1,100 @@ +resource BeschFre = open Prelude, MorphoFre in { + +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-1.0/french/CatFre.gf b/lib/resource-1.0/french/CatFre.gf new file mode 100644 index 000000000..47b1d972c --- /dev/null +++ b/lib/resource-1.0/french/CatFre.gf @@ -0,0 +1,4 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete CatFre of Cat = CatRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/ConjunctionFre.gf b/lib/resource-1.0/french/ConjunctionFre.gf new file mode 100644 index 000000000..584df893c --- /dev/null +++ b/lib/resource-1.0/french/ConjunctionFre.gf @@ -0,0 +1,2 @@ +concrete ConjunctionFre of Conjunction = CatFre ** ConjunctionRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/DiffFre.gf b/lib/resource-1.0/french/DiffFre.gf new file mode 100644 index 000000000..4fec4cf27 --- /dev/null +++ b/lib/resource-1.0/french/DiffFre.gf @@ -0,0 +1,48 @@ +--# -path=.:../romance:../abstract:../common:prelude + +instance DiffFre of DiffRomance = open ResRomance, PhonoFre, Prelude in { + + param + Prep = P_de | P_a ; + VAux = VHabere | VEsse ; + + oper + dative : Case = CPrep P_a ; + genitive : Case = CPrep P_de ; + + complAcc : Compl = {s = [] ; c = Acc} ; + complGen : Compl = {s = [] ; c = genitive} ; + complDat : Compl = {s = [] ; c = dative} ; + + 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" + } ; + + partitive = \g,c -> case c of { + CPrep P_de => elisDe ; + _ => prepCase c ++ artDef g Sg (CPrep P_de) + } ; + +} diff --git a/lib/resource-1.0/french/LangFre.gf b/lib/resource-1.0/french/LangFre.gf new file mode 100644 index 000000000..4802cf89a --- /dev/null +++ b/lib/resource-1.0/french/LangFre.gf @@ -0,0 +1,21 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete LangFre of Lang = + NounFre, +-- VerbFre, +-- AdjectiveFre, +-- AdverbFre, +-- NumeralFre, +-- SentenceFre, +-- QuestionFre, +-- RelativeFre, +-- ConjunctionFre, +-- PhraseFre, +-- TensedFre, +-- StructuralFre, + BasicFre + ** { + +flags startcat = Phr ; + +} ; diff --git a/lib/resource-1.0/french/LexFre.gf b/lib/resource-1.0/french/LexFre.gf new file mode 100644 index 000000000..4cd06483d --- /dev/null +++ b/lib/resource-1.0/french/LexFre.gf @@ -0,0 +1,82 @@ +concrete LexFre of Lex = CatFre ** open ResFre, Prelude in { + + lin + walk_V = + mkVerb "gå" "går" "gå" "gick" "gått" "gången" "gånget" "gångna" ; + help_V2 = + mkVerb "hjälpa" "hjälper" "hjälp" "hjälpte" "hjälpt" "hjälpt" "hjälpt" "hjälpta" + ** {c2 = []} ; + show_V3 = + mkVerb "visa" "visar" "visa" "visade" "visat" "visad" "visat" "visade" + ** {c2 = [] ; c3 = "to"} ; + want_VV = + mkVerb "vilja" "vill" "vilj" "ville" "velat" "velad" "velat" "velade" --- + ** {c2 = []} ; + claim_VS = + mkVerb "hävda" "hävdar" "hävda" "hävdade" "hävdat" "hävdad" "hävdat" "hävdade" ; + ask_VQ = + mkVerb "fråga" "frågar" "fråga" "frågade" "frågat" "frågad" "frågat" "frågade" ; + + dog_N = mkNoun "hund" "hunden" "hundar" "hundarna" utrum ; + son_N2 = mkNoun "son" "sonen" "söner" "sönerna" utrum ** {c2 = "till"} ; + way_N3 = mkNoun "väg" "vägen" "vägar" "vägarna" utrum ** {c2 = "från" ; c3 = "till"} ; + + warm_A = + mkAdjective "varm" "varmt" "varma" "varma" "varmare" "varmast" "varmaste" ; + close_A2 = + mkAdjective "nära" "nära" "nära" "nära" "närmare" "närmast" "närmaste" + ** {c2 = "till"} ; + + here_Adv = {s = "här"} ; + very_AdA = {s = "mycket"} ; + always_AdV = {s = "alltid"} ; + + only_Predet = {s = \\_ => "bara"} ; + all_Predet = {s = gennumForms "all" "allt" "alla"} ; + this_Quant = {s = \\_ => genderForms "denna" "detta" ; n = Sg ; det = DDef Indef} ; + these_Quant = {s = \\_,_ => "dessa" ; n = Pl ; det = DDef Indef} ; + + i_Pron = mkNP "jag" "mig" "min" "mitt" "mina" SgUtr P1 ; + he_Pron = mkNP "han" "honom" "hans" "hans" "hans" SgUtr P3 ; + we_Pron = mkNP "vi" "oss" "vår" "vårt" "våra" Plg P1 ; + + whoSg_IP = {s = vem.s ; gn = SgUtr} ; + whoPl_IP = {s = vem.s ; gn = Plg} ; + + when_IAdv = {s = "när"} ; + where_IAdv = {s = "var"} ; + why_IAdv = {s = "varför"} ; + + whichSg_IDet = {s = genderForms "vilken" "vilket" ; n = Sg ; det = DDef Indef} ; + whichPl_IDet = {s = \\_ => "vilka" ; n = Pl ; det = DDef Indef} ; + + forty_Numeral = { + s = table { + NCard _ => "fyrtio" ; + NOrd _ => "fyrtionde" + } ; + n = Sg + } ; + + in_Prep = {s = "i"} ; + of_Prep = {s = "av"} ; + + and_Conj = {s = "och" ; n = Pl} ; + either7or_DConj = {s1 = "antingen" ; s2 = "eller" ; n = Sg} ; + + if_Subj = ss "om" ; + because_Subj = ss "eftersom" ; + + but_PConj = {s = "men"} ; + + please_Voc = {s = "," ++ "tack"} ; + + more_CAdv = ss "mera" ; + less_CAdv = ss "mindre" ; + +-- Auxiliaries that are used repeatedly. + + oper + vem = mkNP "vem" "vem" "vems" "vems" "vems" SgUtr P3 ; + +} diff --git a/lib/resource-1.0/french/MathFre.gf b/lib/resource-1.0/french/MathFre.gf new file mode 100644 index 000000000..582b2f9d1 --- /dev/null +++ b/lib/resource-1.0/french/MathFre.gf @@ -0,0 +1,2 @@ +concrete MathFre of Math = CatFre ** MathRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/MorphoFre.gf b/lib/resource-1.0/french/MorphoFre.gf new file mode 100644 index 000000000..04f4cffac --- /dev/null +++ b/lib/resource-1.0/french/MorphoFre.gf @@ -0,0 +1,1366 @@ +--# -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 = ResRomance, DiffFre ** + 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. + + Adj = {s : AForm => Str} ; + + 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 (heureu+"s") (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. + + Pronoun = {s : NPForm => Str ; a : Agr ; c : ClitType} ; + + mkPronoun : (_,_,_,_,_,_,_ : Str) -> + Gender -> Number -> Person -> ClitType -> Pronoun = + \il,le,lui,Lui,son,sa,ses,g,n,p,c -> + {s = table { + Ton x => prepCase x ++ Lui ; + Aton Nom => il ; + Aton Acc => le ; + Aton Gen => "en" ; --- hmm + Aton Dat => lui ; + Poss {n = Sg ; g = Masc} => son ; + Poss {n = Sg ; g = Fem} => sa ; + Poss {n = Pl} => ses + } ; + a = {g = g ; n = n ; p = p} ; + c = c + } ; + + elisPoss : Str -> Str = \s -> + pre {s + "a" ; s + "on" / voyelle} ; +{- + pronJe = mkPronoun + (elision "j") + (elision "m") + (elision "m") + "moi" + "mon" (elisPoss "m") "mes" + PNoGen -- gender cannot be known from pronoun alone + Sg + P1 + Clit1 ; + + pronTu = mkPronoun + "tu" + (elision "t") + (elision "t") + "toi" + "ton" (elisPoss "t") "tes" + PNoGen + Sg + P2 + Clit1 ; + + pronIl = mkPronoun + "il" + (elision "l") + "lui" + "lui" + "son" (elisPoss "s") "ses" + (PGen Masc) + Sg + P3 + Clit2 ; + +---- A hack to get the dative form "y". + pronY = mkPronoun + "il" + (elision "l") + "y" + "lui" + "en" "en" "en" + (PGen Masc) + Sg + P3 + Clit2 ; + + pronElle = mkPronoun + "elle" + elisLa + "lui" + "elle" + "son" (elisPoss "s") "ses" + (PGen Fem) + Sg + P3 + Clit2 ; + + pronNous = mkPronoun + "nous" + "nous" + "nous" + "nous" + "notre" "notre" "nos" + PNoGen + Pl + P1 + Clit3 ; + + pronVous = mkPronoun + "vous" + "vous" + "vous" + "vous" + "votre" "votre" "vos" + PNoGen + Pl --- depends! + P2 + Clit3 ; + + pronIls = mkPronoun + "ils" + "les" + "leur" + "eux" + "leur" "leur" "leurs" + (PGen Masc) + Pl + P3 + Clit1 ; + + pronElles = mkPronoun + "elles" + "les" + "leur" + "elles" + "leur" "leur" "leurs" + (PGen Fem) + Pl + P3 + Clit1 ; + + personPron : Gender -> Number -> Person -> Pronoun = \g,n,p -> + case of { + => pronJe ; + => pronTu ; + => case g of { + Masc => pronIl ; + Fem => pronElle + } ; + => pronNous ; + => pronVous ; + => case g of { + Masc => pronIls ; + Fem => pronElles + } + } ; +-} +-- Reflexive pronouns are defined in $SyntaxFre$. + +-- The composable pronoun "lequel" is inflected by varying the definite +-- article and the determiner "quel" in the expected way. + + lequelPron : Gender -> Number -> Case -> Str = \g,n,c -> + artDef g n c + quelPron g n ; + + +--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 + } ; + + quelPron : Gender -> Number -> Str = pronForms "quel" "quelle" ; + + telPron : Gender -> Number -> Str = pronForms "tel" "telle" ; + + toutPron : Gender -> Number -> Str = \g,n -> case g of { + Masc => numForms "tout" "tous" ! n ; + Fem => nomReg "toutee" ! 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 $ParamRomance$. + +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 ; + VFin (VImperf Subjunct) n p => aller ! Subjo SImparf n p ; + VFin VPasse n p => aller ! Indi Passe n p ; + VFin VFut n p => aller ! Indi Futur n p ; + VFin VCondit n p => aller ! Condi n p ; + 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 -> + let + e = last (Predef.tk 4 parler) ; + c = last (Predef.tk 3 parler) ; + verb_é = pbool2bool (occur "é" (e + last (Predef.tk 5 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 ; + _ => 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 NumeralsFre + +param DForm = unit | teen | jten | ten | tenplus ; +param Place = indep | attr ; + +oper + digitPl : + {inh : DForm ; inh1 : Number ; s : DForm => Str} -> + {inh : DForm ; inh1 : Number ; s : Gender => DForm => Str ; n : Number} = \d -> + {inh = d.inh ; inh1 = d.inh1 ; s = \\_ => d.s ; n = Pl} ; + +} diff --git a/lib/resource-1.0/french/NounFre.gf b/lib/resource-1.0/french/NounFre.gf new file mode 100644 index 000000000..5d71c7825 --- /dev/null +++ b/lib/resource-1.0/french/NounFre.gf @@ -0,0 +1,2 @@ +concrete NounFre of Noun = CatFre ** NounRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/NumeralFre.gf b/lib/resource-1.0/french/NumeralFre.gf new file mode 100644 index 000000000..ed397e51a --- /dev/null +++ b/lib/resource-1.0/french/NumeralFre.gf @@ -0,0 +1,47 @@ +concrete NumeralFre of Numeral = CatFre ** open ResRomance, MorphoFre in { + +lincat + Digit = {s : DForm => CardOrd => Str} ; + Sub10 = {s : DForm => CardOrd => Str ; n : Number} ; + Sub100, Sub1000, Sub1000000 = + {s : CardOrd => Str ; n : Number} ; + +lin + num x = x ; + + n2 = mkTal "två" "tolv" "tjugo" "andra" "tolfte" ; + n3 = mkTal "tre" "tretton" "trettio" "tredje" "trettonde" ; + n4 = mkTal "fyra" "fjorton" "fyrtio" "fjärde" "fjortonde" ; + n5 = mkTal "fem" "femton" "femtio" "femte" "femtonde" ; + n6 = mkTal "sex" "sexton" "sextion" "sjätte" "sextonde" ; + n7 = mkTal "sju" "sjutton" "sjuttio" "sjunde" "sjuttonde" ; + n8 = mkTal "åtta" "arton" "åttio" "åttonde" "artonde" ; + n9 = mkTal "nio" "nitton" "nittio" "nionde" "nittonde" ; + + pot01 = { + s = \\f => table { + NCard g => case g of {Neutr => "ett" ; _ => "en"} ; + _ => "första" + } ; + n = Sg + } ; + pot0 d = {s = \\f,g => d.s ! f ! g ; n = Pl} ; + pot110 = numPl (cardReg "tio") ; + pot111 = numPl (cardOrd "elva" "elfte") ; + pot1to19 d = numPl (d.s ! ton) ; + pot0as1 n = {s = n.s ! ental ; n = n.n} ; + pot1 d = numPl (d.s ! tiotal) ; + pot1plus d e = {s = \\g => d.s ! tiotal ! invNum ++ e.s ! ental ! g ; n = Pl} ; + pot1as2 n = n ; + pot2 d = + numPl (\\g => d.s ! ental ! invNum ++ cardOrd "hundra" "hundrade" ! g) ; + pot2plus d e = + {s = \\g => d.s ! ental ! invNum ++ "hundra" ++ e.s ! g ; n = Pl} ; + pot2as3 n = n ; + pot3 n = + numPl (\\g => n.s ! invNum ++ "tusen" ++ cardOrd "tusen" "tusende" ! g) ; + pot3plus n m = + {s = \\g => n.s ! invNum ++ "tusen" ++ m.s ! g ; n = Pl} ; + +} + diff --git a/lib/resource-1.0/french/ParadigmsFre.gf b/lib/resource-1.0/french/ParadigmsFre.gf new file mode 100644 index 000000000..47a1fb367 --- /dev/null +++ b/lib/resource-1.0/french/ParadigmsFre.gf @@ -0,0 +1,356 @@ +--# -path=.:../romance:../common:../abstract:../../prelude + +--1 French Lexical Paradigms +-- +-- Aarne Ranta 2003 +-- +-- This is an API to 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 $IrregularEng$, which covers all irregularly inflected +-- words. + +resource ParadigmsFre = + open + (Predef=Predef), + Prelude, + ResRomance, + DiffFre, + 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' "à"). + + Preposition : Type ; + + accusative : Preposition ; + genitive : Preposition ; + dative : Preposition ; + + mkPreposition : Str -> Preposition ; + + +--2 Nouns + +-- Worst case: give both two forms and the gender. + + mkN : (oeil,yeux : Str) -> Gender -> N ; + +-- The regular function takes the singular form and the gender, +-- and computes the plural by a heuristic. The heuristic currently +-- covers the cases "pas-pas", "prix-prix", "nez-nez", +-- "bijou-bijoux", "cheveu-cheveux", "plateau-plateaux", "cheval-chevaux". +-- If in doubt, use the $cc$ command to test! + + regN : 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. + + compN : N -> Str -> N ; + + +--3 Relational nouns +-- +-- Relational nouns ("fille de x") need a case and a preposition. + + mkN2 : N -> Preposition -> 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 -> Preposition -> Preposition -> N3 ; + + +--3 Relational common noun phrases +-- +-- In some cases, you may want to make a complex $CN$ into a +-- relational noun (e.g. "the old town hall of"). 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. + + mkPN : Str -> Gender -> PN ; -- Jean + +-- To form a noun phrase that can also be plural, +-- you can use the worst-case function. + + mkNP : Str -> Gender -> Number -> NP ; + +--2 Adjectives + +-- Non-comparison one-place adjectives need four forms in the worst +-- case (masc and fem singular, masc plural, adverbial). + + mkA : (banal,banale,banaux,banalement : Str) -> A ; + +-- For regular adjectives, all other forms are derived from the +-- masculine singular. The heuristic takes into account certain +-- deviant endings: "banal- -banaux", "chinois- -chinois", +-- "heureux-heureuse-heureux", "italien-italienne", "jeune-jeune", +-- "amer-amère", "carré- - -carrément", "joli- - -joliment". + + regA : Str -> A ; + +-- These functions create 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. + + prefA : A -> A ; + +--3 Two-place adjectives +-- +-- Two-place adjectives need a preposition for their second argument. + + mkA2 : A -> Preposition -> A2 ; + +--3 Comparison adjectives + +-- Comparison adjectives are in the worst case put up from two +-- adjectives: the positive ("bon"), and the comparative ("meilleure"). + + mkADeg : A -> A -> A ; + +-- If comparison is formed by "plus", as usual in French, +-- the following pattern is used: + + compADeg : A -> A ; + +-- From a given $A$, it is possible to get back to $A$. + + adegA : A -> A ; + +-- For prefixed adjectives, the following function is +-- provided. + + prefA : A -> A ; + +--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 $VerbsFre$. +-- 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 is the first conjugation recognizes +-- these endings, as well as the variations among +-- "aimer, céder, placer, peser, jeter, placer, manger, assiéger, payer". + + regV : Str -> V ; + +-- 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. + + reg3V : (jeter,jette,jettera : Str) -> V ; + +-- The function $regV$ gives all verbs the compound auxiliary "avoir". +-- To change it to "être", use the following function. + + etreV : V -> V ; + +--3 Two-place verbs +-- +-- Two-place verbs need a preposition, except the special case with direct object. +-- (transitive verbs). Notice that a particle comes from the $V$. + + mkV2 : V -> Preposition -> V2 ; + + dirV2 : V -> V2 ; + +-- You can reuse a $V2$ verb in $V$. + + v2V : V2 -> V ; + +--3 Three-place verbs +-- +-- Three-place (ditransitive) verbs need two prepositions, of which +-- the first one or both can be absent. + + mkV3 : V -> Preposition -> Preposition -> V3 ; -- parler, à, de + dirV3 : V -> Preposition -> V3 ; -- donner,_,à + dirdirV3 : V -> V3 ; -- donner,_,_ + +--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 -> Preposition -> V2S ; + mkVV : V -> VV ; -- plain infinitive: "je veux parler" + deVV : V -> VV ; -- "j'essaie de parler" + aVV : V -> VV ; -- "j'arrive à parler" + mkV2V : V -> Preposition -> Preposition -> V2V ; + mkVA : V -> VA ; + mkV2A : V -> Preposition -> V2A ; + mkVQ : V -> VQ ; + mkV2Q : V -> Preposition -> V2Q ; + + mkAS : A -> AS ; + subjAS : A -> AS ; + mkA2S : A -> Preposition -> A2S ; + mkAV : A -> Preposition -> AV ; + mkA2V : A -> Preposition -> Preposition -> A2V ; + +-- Notice: categories $V2S, V2V, V2A, V2Q$ are in v 1.0 treated +-- just as synonyms of $V2$, and the second argument is given +-- as an adverb. Likewise $AS, A2S, AV, A2V$ are just $A$. +-- $V0$ is just $V$. + + V0, V2S, V2V, V2A, V2Q : 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 ; + genitive = complGen ; + dative = complDat ; + mkPreposition p = {s = p ; c = Acc} ; + + mkN x y g = mkCNomIrreg x y g ** {lock_N = <>} ; + regN x g = mkNomReg x g ** {lock_N = <>} ; + compN x y = {s = \\n => x.s ! n ++ y ; g = x.g ; lock_N = <>} ; + + 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} ; + + mkPN x g = {s = x ; g = g} ** {lock_PN = <>} ; + + mkA 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 = <>} ; + + 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 = <>} ; + + + 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 ; aux = VHabere ; lock_V = <> ; isRefl = False} ; + reg3V x y z = let v = vvf (mkVerb3Reg x y z) in {s = v ; aux = VHabere ; lock_V = <> ; isRefl = False} ; + etreV v = {s = v.s ; aux = VEsse ; lock_V = <> ; isRefl = False} ; + + mkV2 v p = v ** {c2 = p ; lock_V2 = <>} ; + dirV2 v = mkV2 v accusative ; + v2V v = v ** {lock_V = <>} ; + + mkV3 v p q = v ** {c2 = p ; c3 = q ; lock_V3 = <>} ; + dirV3 v p = mkV3 v complAcc p ; + dirdirV3 v = dirV3 v complDat ; + + V0 : Type = V ; + V2S, V2V, V2Q, V2A : Type = V2 ; + AS, AV : Type = A ; + A2S, A2V : Type = A2 ; + + mkV0 v = v ** {lock_V0 = <>} ; + mkVS v = v ** {mn,mp = Indic ; lock_VS = <>} ; ---- more moods + mkV2S v p = mkV2 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 t = mkV2 v p ** {c3 = t.p1 ; s3 = p.p2 ; lock_V2V = <>} ; + mkVA v = v ** {lock_VA = <>} ; + mkV2A v p = mkV2 v p ** {lock_V2A = <>} ; + mkVQ v = v ** {lock_VQ = <>} ; + mkV2Q v p = mkV2 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 = <>} ; + +} ; diff --git a/lib/resource-1.0/french/PhonoFre.gf b/lib/resource-1.0/french/PhonoFre.gf new file mode 100644 index 000000000..d87817953 --- /dev/null +++ b/lib/resource-1.0/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-1.0/french/PhraseFre.gf b/lib/resource-1.0/french/PhraseFre.gf new file mode 100644 index 000000000..6a1ab70dc --- /dev/null +++ b/lib/resource-1.0/french/PhraseFre.gf @@ -0,0 +1,2 @@ +concrete PhraseFre of Phrase = CatFre, TenseX ** PhraseRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/QuestionFre.gf b/lib/resource-1.0/french/QuestionFre.gf new file mode 100644 index 000000000..715da09b3 --- /dev/null +++ b/lib/resource-1.0/french/QuestionFre.gf @@ -0,0 +1,2 @@ +concrete QuestionFre of Question = CatFre ** QuestionRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/RelativeFre.gf b/lib/resource-1.0/french/RelativeFre.gf new file mode 100644 index 000000000..94c7710ab --- /dev/null +++ b/lib/resource-1.0/french/RelativeFre.gf @@ -0,0 +1,2 @@ +concrete RelativeFre of Relative = CatFre ** RelativeRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/ResFre.gf b/lib/resource-1.0/french/ResFre.gf new file mode 100644 index 000000000..f9ebce7ed --- /dev/null +++ b/lib/resource-1.0/french/ResFre.gf @@ -0,0 +1,268 @@ +----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$. +-- +resource ResFre = ParamRomance, ResRomance, DiffFre ** open Prelude in { + + flags optimize=all ; + + oper + +-- For $Lex$. + +-- For each lexical category, here are the worst-case constructors. + + mkNoun : (_,_,_,_ : Str) -> Gender -> + {s : Number => Species => Case => Str ; g : Gender} = + \man,mannen,men,mennen,g -> { + s = nounForms man mannen men mennen ; + g = g + } ; + +-- mkAdjective : (_,_,_,_ : Str) -> {s : AForm => Str} = +-- \good,better,best,well -> { +-- s = table { +-- AAdj Posit => good ; +-- AAdj Compar => better ; +-- AAdj Superl => best ; +-- AAdv => well +-- } +-- } ; +-- +-- mkVerb : (_,_,_,_,_ : Str) -> {s : VForm => Str} = +-- \go,goes,went,gone,going -> { +-- s = table { +-- VInf => go ; +-- VPres => goes ; +-- VPast => went ; +-- VPPart => gone ; +-- VPresPart => going +-- } +-- } ; +-- +-- mkIP : (i,me,my : Str) -> Number -> {s : Case => Str ; n : Number} = +-- \i,me,my,n -> let who = mkNP i me my n P3 in {s = who.s ; n = n} ; +-- +-- mkNP : (i,me,my : Str) -> Number -> Person -> {s : Case => Str ; a : Agr} = +-- \i,me,my,n,p -> { +-- s = table { +-- Nom => i ; +-- Acc => me ; +-- Gen => my +-- } ; +-- a = { +-- n = n ; +-- p = p +-- } +-- } ; +-- +---- These functions cover many cases; full coverage inflectional patterns are +---- in $MorphoRomance$. +-- +-- regN : Str -> {s : Number => Case => Str} = \car -> +-- mkNoun car (car + "'s") (car + "s") (car + "s'") ; +-- +-- regA : Str -> {s : AForm => Str} = \warm -> +-- mkAdjective warm (warm + "er") (warm + "est") (warm + "ly") ; +-- +-- regV : Str -> {s : VForm => Str} = \walk -> +-- mkVerb walk (walk + "s") (walk + "ed") (walk + "ed") (walk + "ing") ; +-- +-- regNP : Str -> Number -> {s : Case => Str ; a : Agr} = \that,n -> +-- mkNP that that (that + "'s") n P3 ; +-- +---- We have just a heuristic definition of the indefinite article. +---- There are lots of exceptions: consonantic "e" ("euphemism"), consonantic +---- "o" ("one-sided"), vocalic "u" ("umbrella"). +-- +-- artIndef = pre { +-- "a" ; +-- "an" / strs {"a" ; "e" ; "i" ; "o" ; "A" ; "E" ; "I" ; "O" } +-- } ; +-- +-- artDef = "the" ; +-- +---- For $Verb$. +-- +-- Verb : Type = { +-- s : VForm => Str +-- } ; +-- +-- VerbForms : Type = +-- Tense => Anteriority => Polarity => Ord => Agr => {fin, inf : Str} ; +-- +-- VP : Type = { +-- s : VerbForms ; +-- s2 : Agr => Str +-- } ; +-- +-- predV : Verb -> VP = \verb -> { +-- s = \\t,ant,b,ord,agr => +-- let +-- inf = verb.s ! VInf ; +-- fin = presVerb verb agr ; +-- past = verb.s ! VPast ; +-- part = verb.s ! VPPart ; +-- vf : Str -> Str -> {fin, inf : Str} = \x,y -> +-- {fin = x ; inf = y} ; +-- in +-- case of { +-- => vf fin [] ; +-- => vf (does agr) inf ; +-- => vf (doesnt agr) inf ; +-- => vf (have agr) part ; +-- => vf (havent agr) part ; +-- => vf past [] ; +-- => vf "did" inf ; +-- => vf "didn't" inf ; +-- => vf "had" part ; +-- => vf "hadn't" part ; +-- => vf "will" inf ; +-- => vf "won't" inf ; +-- => vf "will" ("have" ++ part) ; +-- => vf "won't" ("have" ++ part) ; +-- => vf "would" inf ; +-- => vf "wouldn't" inf ; +-- => vf "would" ("have" ++ part) ; +-- => vf "wouldn't" ("have" ++ part) +-- } ; +-- s2 = \\_ => [] +-- } ; +-- +-- predAux : Aux -> VP = \verb -> { +-- s = \\t,ant,b,ord,agr => +-- let +-- inf = verb.inf ; +-- fin = verb.pres ! b ! agr ; +-- past = verb.past ! b ! agr ; +-- part = verb.ppart ; +-- vf : Str -> Str -> {fin, inf : Str} = \x,y -> +-- {fin = x ; inf = y} ; +-- in +-- case of { +-- => vf fin [] ; +-- => vf (have agr) part ; +-- => vf (havent agr) part ; +-- => vf past [] ; +-- => vf "had" part ; +-- => vf "hadn't" part ; +-- => vf "will" inf ; +-- => vf "won't" inf ; +-- => vf "will" ("have" ++ part) ; +-- => vf "won't" ("have" ++ part) ; +-- => vf "would" inf ; +-- => vf "wouldn't" inf ; +-- => vf "would" ("have" ++ part) ; +-- => vf "wouldn't" ("have" ++ part) +-- } ; +-- s2 = \\_ => [] +-- } ; +-- +-- insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> { +-- s = vp.s ; +-- s2 = \\a => vp.s2 ! a ++ obj ! a +-- } ; +-- +----- This is not functional. +-- +-- insertAdV : Str -> VP -> VP = \adv,vp -> { +-- s = vp.s ; +-- s2 = vp.s2 +-- } ; +-- +-- presVerb : {s : VForm => Str} -> Agr -> Str = \verb -> +-- agrVerb (verb.s ! VPres) (verb.s ! VInf) ; +-- +-- infVP : VP -> Agr -> Str = \vp,a -> +-- (vp.s ! Fut ! Simul ! Neg ! ODir ! a).inf ++ vp.s2 ! a ; +-- +-- agrVerb : Str -> Str -> Agr -> Str = \has,have,agr -> +-- case agr of { +-- {n = Sg ; p = P3} => has ; +-- _ => have +-- } ; +-- +-- have = agrVerb "has" "have" ; +-- havent = agrVerb "hasn't" "haven't" ; +-- does = agrVerb "does" "do" ; +-- doesnt = agrVerb "doesn't" "don't" ; +-- +-- Aux = {pres,past : Polarity => Agr => Str ; inf,ppart : Str} ; +-- +-- auxBe : Aux = { +-- pres = \\b,a => case of { +-- => "am" ; +-- => ["am not"] ; --- am not I +-- _ => agrVerb (posneg b "is") (posneg b "are") a +-- } ; +-- past = \\b,a => agrVerb (posneg b "was") (posneg b "were") a ; +-- inf = "be" ; +-- ppart = "been" +-- } ; +-- +-- posneg : Polarity -> Str -> Str = \p,s -> case p of { +-- Pos => s ; +-- Neg => s + "n't" +-- } ; +-- +-- conjThat : Str = "that" ; +-- +-- reflPron : Agr => Str = table { +-- {n = Sg ; p = P1} => "myself" ; +-- {n = Sg ; p = P2} => "yourself" ; +-- {n = Sg ; p = P3} => "itself" ; ---- +-- {n = Pl ; p = P1} => "ourselves" ; +-- {n = Pl ; p = P2} => "yourselves" ; +-- {n = Pl ; p = P3} => "themselves" +-- } ; +-- +---- For $Sentence$. +-- +-- Clause : Type = { +-- s : Tense => Anteriority => Polarity => Ord => Str +-- } ; +-- +-- mkS : Str -> Agr -> VerbForms -> (Agr => Str) -> Clause = +-- \subj,agr,verb,compl0 -> { +-- s = \\t,a,b,o => +-- let +-- verb = verb ! t ! a ! b ! o ! agr ; +-- compl = compl0 ! agr +-- in +-- case o of { +-- ODir => subj ++ verb.fin ++ verb.inf ++ compl ; +-- OQuest => verb.fin ++ subj ++ verb.inf ++ compl +-- } +-- } ; +-- +-- +---- For $Numeral$. +-- +-- mkNum : Str -> Str -> Str -> Str -> {s : DForm => CardOrd => Str} = +-- \two, twelve, twenty, second -> +-- {s = table { +-- unit => table {NCard => two ; NOrd => second} ; +-- teen => \\c => mkCard c twelve ; +-- ten => \\c => mkCard c twenty +-- } +-- } ; +-- +-- regNum : Str -> {s : DForm => CardOrd => Str} = +-- \six -> mkNum six (six + "teen") (six + "ty") (regOrd six) ; +-- +-- regCardOrd : Str -> {s : CardOrd => Str} = \ten -> +-- {s = table {NCard => ten ; NOrd => regOrd ten}} ; +-- +-- mkCard : CardOrd -> Str -> Str = \c,ten -> +-- (regCardOrd ten).s ! c ; +-- +-- regOrd : Str -> Str = \ten -> +-- case last ten of { +-- "y" => init ten + "ieth" ; +-- _ => ten + "th" +-- } ; +-- +} diff --git a/lib/resource-1.0/french/SentenceFre.gf b/lib/resource-1.0/french/SentenceFre.gf new file mode 100644 index 000000000..08674e823 --- /dev/null +++ b/lib/resource-1.0/french/SentenceFre.gf @@ -0,0 +1,2 @@ +concrete SentenceFre of Sentence = CatFre ** SentenceRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/StructuralFre.gf b/lib/resource-1.0/french/StructuralFre.gf new file mode 100644 index 000000000..ecfc13bfd --- /dev/null +++ b/lib/resource-1.0/french/StructuralFre.gf @@ -0,0 +1,115 @@ +concrete StructuralFre of Structural = CatFre ** + open MorphoFre, Prelude in { + + flags optimize=all ; + + lin + above_Prep = ss "ovanför" ; + after_Prep = ss "efter" ; + by8agent_Prep = ss "av" ; + all_Predet = {s = gennumForms "all" "allt" "alla"} ; + almost_AdA, almost_AdN = ss "nästan" ; + although_Subj = ss "fast" ; + always_AdV = ss "alltid" ; + and_Conj = ss "och" ** {n = Pl} ; + because_Subj = ss "eftersom" ; + before_Prep = ss "före" ; + behind_Prep = ss "bakom" ; + between_Prep = ss "mellan" ; + both7and_DConj = sd2 "både" "och" ** {n = Pl} ; + but_PConj = ss "men" ; + by8means_Prep = ss "med" ; + can8know_VV, can_VV = + mkVerb6 "kunna" "kan" "kunn" "kunde" "kunnat" "kunnen" ** + {c2 = [] ; lock_VV = <>} ; + during_Prep = ss "under" ; + either7or_DConj = sd2 "antingen" "eller" ** {n = Sg} ; + everybody_NP = regNP "alla" "allas" Plg ; + every_Det = {s = \\_,_ => "varje" ; n = Sg ; det = DDef Indef} ; + everything_NP = regNP "allting" "alltings" SgNeutr ; + everywhere_Adv = ss "överallt" ; + first_Ord = {s = "första" ; isDet = True} ; + from_Prep = ss "från" ; + he_Pron = mkNP "han" "honom" "hans" "hans" "hans" SgUtr P3 ; + here_Adv = ss "här" ; + here7to_Adv = ss "hit" ; + here7from_Adv = ss "härifrån" ; + how_IAdv = ss "hur" ; + how8many_IDet = {s = \\_ => ["hur många"] ; n = Pl ; det = DDef Indef} ; + if_Subj = ss "om" ; + in8front_Prep = ss "framför" ; + i_Pron = mkNP "jag" "mig" "min" "mitt" "mina" SgUtr P1 ; + in_Prep = ss "i" ; + it_Pron = regNP "det" "dess" SgNeutr ; + less_CAdv = ss "mindre" ; + many_Det = {s = \\_,_ => "många" ; n = Pl ; det = DDef Indef} ; + more_CAdv = ss "mer" ; + most_Predet = {s = gennumForms ["den mesta"] ["det mesta"] ["de flesta"]} ; + much_Det = {s = \\_,_ => "mycket" ; n = Pl ; det = DDef Indef} ; + must_VV = + mkVerb6 "få" "måste" "få" "fick" "måst" "måst" ** {c2 = [] ; lock_VV = <>} ; + no_Phr = ss ["Nej"] ; + on_Prep = ss "på" ; + one_Quant = {s = \\_ => genderForms ["en"] ["ett"] ; n = Sg ; det = DIndef} ; + only_Predet = {s = \\_ => "bara"} ; + or_Conj = ss "eller" ** {n = Sg} ; + otherwise_PConj = ss "annars" ; + part_Prep = ss "av" ; + please_Voc = ss "tack" ; --- + possess_Prep = ss "av" ; + quite_Adv = ss "ganska" ; + she_Pron = mkNP "hon" "henne" "hennes" "hennes" "hennes" SgUtr P3 ; + so_AdA = ss "så" ; + someSg_Det = {s = \\_ => genderForms "någon" "något" ; n = Sg ; det = DIndef} ; + somePl_Det = {s = \\_,_ => "några" ; n = Pl ; det = DIndef} ; + somebody_NP = regNP "någon" "någons" SgUtr ; + something_NP = regNP "något" "någots" SgNeutr ; + somewhere_Adv = ss "någonstans" ; + that_Quant = + {s = \\_ => genderForms ["den där"] ["det där"] ; n = Sg ; det = DDef Def} ; + that_NP = regNP ["det där"] ["det därs"] SgNeutr ; + there_Adv = ss "där" ; + there7to_Adv = ss "dit" ; + there7from_Adv = ss "därifrån" ; + therefore_PConj = ss "därför" ; + these_NP = regNP ["de här"] ["det härs"] Plg ; + these_Quant = {s = \\_,_ => ["de här"] ; n = Pl ; det = DDef Def} ; + they_Pron = mkNP "de" "dem" "deras" "deras" "deras" Plg P1 ; + this_Quant = + {s = \\_ => genderForms ["den här"] ["det här"] ; n = Sg ; det = DDef Def} ; + this_NP = regNP ["det här"] ["det härs"] SgNeutr ; + those_NP = regNP ["de där"] ["det därs"] Plg ; + those_Quant = {s = \\_,_ => ["de där"] ; n = Pl ; det = DDef Def} ; + thou_Pron = mkNP "du" "dig" "din" "ditt" "dina" SgUtr P2 ; + through_Prep = ss "genom" ; + too_AdA = ss "för" ; + to_Prep = ss "till" ; + under_Prep = ss "under" ; + very_AdA = ss "mycket" ; + want_VV = + mkVerb6 "vilja" "vill" "vilj" "ville" "velat" "velad" ** + {c2 = [] ; lock_VV = <>} ; + we_Pron = mkNP "vi" "oss" "vår" "vårt" "våra" Plg P1 ; + whatSg_IP = {s = \\_ => "vad" ; gn = SgUtr} ; ---- infl + whatPl_IP = {s = \\_ => "vad" ; gn = Plg} ; ---- infl + when_IAdv = ss "när" ; + when_Subj = ss "när" ; + where_IAdv = ss "var" ; + whichPl_IDet = {s = \\_ => "vilka" ; n = Pl ; det = DIndef} ; + whichSg_IDet = {s = genderForms "vilken" "vilket" ; n = Sg ; det = DIndef} ; + whoSg_IP = {s = vem.s ; gn = SgUtr} ; + whoPl_IP = {s = vem.s ; gn = Plg} ; + why_IAdv = ss "varför" ; + without_Prep = ss "utan" ; + with_Prep = ss "med" ; + ye_Pron = mkNP "ni" "er" "er" "ert" "era" Plg P2 ; + yes_Phr = ss ["ja"] ; + you_Pron = mkNP "ni" "er" "er" "ert" "era" SgUtr P2 ; --- wrong in refl + +-- Auxiliaries that are used repeatedly. + + oper + vem = mkNP "vem" "vem" "vems" "vems" "vems" SgUtr P3 ; + +} + diff --git a/lib/resource-1.0/french/TensedFre.gf b/lib/resource-1.0/french/TensedFre.gf new file mode 100644 index 000000000..7bf2c2730 --- /dev/null +++ b/lib/resource-1.0/french/TensedFre.gf @@ -0,0 +1,2 @@ +concrete TensedFre of Tensed = CatFre, TenseX ** TensedRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/TestFre.gf b/lib/resource-1.0/french/TestFre.gf new file mode 100644 index 000000000..dc0e6d337 --- /dev/null +++ b/lib/resource-1.0/french/TestFre.gf @@ -0,0 +1,21 @@ +--# -path=.:../romance:../abstract:../common:prelude + +concrete TestFre of Test = + NounFre, + VerbFre, + AdjectiveFre, + AdverbFre, +-- -- NumeralFre, + SentenceFre, + QuestionFre, + RelativeFre, + ConjunctionFre, + PhraseFre, + UntensedFre, +-- -- TensedFre, + LexFre + ** { + +flags startcat = Phr ; + +} ; diff --git a/lib/resource-1.0/french/UntensedFre.gf b/lib/resource-1.0/french/UntensedFre.gf new file mode 100644 index 000000000..fd2478fff --- /dev/null +++ b/lib/resource-1.0/french/UntensedFre.gf @@ -0,0 +1,2 @@ +concrete UntensedFre of Untensed = CatFre ** UntensedRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/VerbFre.gf b/lib/resource-1.0/french/VerbFre.gf new file mode 100644 index 000000000..225215452 --- /dev/null +++ b/lib/resource-1.0/french/VerbFre.gf @@ -0,0 +1,2 @@ +concrete VerbFre of Verb = CatFre ** VerbRomance with + (DiffRomance = DiffFre) ; diff --git a/lib/resource-1.0/french/VerbsFre.gf b/lib/resource-1.0/french/VerbsFre.gf new file mode 100644 index 000000000..366c899b9 --- /dev/null +++ b/lib/resource-1.0/french/VerbsFre.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 VerbsFre of VerbsFreAbs = 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" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + absoudre_V2 = v_besch72 "absoudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + abstenir_V = v_besch23 "abstenir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + abstraire_V2 = v_besch61 "abstraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + accourir_V = v_besch33 "accourir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + accroître_V2 = v_besch73 "accroître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + accueillir_V2 = v_besch28 "accueillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + acquérir_V2 = v_besch24 "acquérir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + adjoindre_V2 = v_besch58 "adjoindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + admettre_V2 = v_besch56 "admettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + advenir_V = v_besch23 "advenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + aller_V = v_besch22 "aller" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + apercevoir_V2 = v_besch38 "apercevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + apparaître_V = v_besch64 "apparaître" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + appartenir_V2 = v_besch23 "appartenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + appendre_V2 = v_besch53 "appendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + apprendre_V2 = v_besch54 "apprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + assaillir_V2 = v_besch29 "assaillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + asseoir_V2 = v_besch49 "asseoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + astreindre_V2 = v_besch57 "astreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + atteindre_V2 = v_besch57 "atteindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + attendre_V2 = v_besch53 "attendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + avoir_V2 = v_besch1 "avoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + battre_V2 = v_besch55 "battre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + boire_V2 = v_besch69 "boire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + bouillir_V2 = v_besch31 "bouillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + braire_V = v_besch61 "braire" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + ceindre_V2 = v_besch57 "ceindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + choir_V = v_besch52 "choir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + circonscrire_V2 = v_besch80 "circonscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + circonvenir_V2 = v_besch23 "circonvenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + clore_V2 = v_besch70 "clore" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + combattre_V2 = v_besch55 "combattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + commettre_V2 = v_besch56 "commettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + comparaître_V2 = v_besch64 "comparaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + complaire_V2 = v_besch63 "complaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + comprendre_V2 = v_besch54 "comprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + compromettre_V2 = v_besch56 "compromettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + concevoir_V2 = v_besch38 "concevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conclure_V2 = v_besch71 "conclure" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + concourir_V2 = v_besch33 "concourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + condescendre_V2 = v_besch53 "condescendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + conduire_V2 = v_besch82 "conduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + confire_V2 = v_besch81 "confire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + confondre_V2 = v_besch53 "confondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conjoindre_V2 = v_besch58 "conjoindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + connaître_V2 = v_besch64 "connaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + conquérir_V2 = v_besch24 "conquérir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + consentir_V2 = v_besch25 "consentir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + construire_V2 = v_besch82 "construire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contenir_V2 = v_besch23 "contenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contraindre_V2 = v_besch59 "contraindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrebattre_V2 = v_besch55 "contrebattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contredire_V2 = v_besch78 "contredire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrefaire_V2 = v_besch62 "contrefaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + contrevenir_V2 = v_besch23 "contrevenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + convaincre_V2 = v_besch60 "convaincre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + convenir_V2 = v_besch23 "convenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + correspondre_V2 = v_besch53 "correspondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + corrompre_V2 = v_besch53 "corrompre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + coudre_V2 = v_besch73 "coudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + courir_V2 = v_besch33 "courir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + couvrir_V2 = v_besch27 "couvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + craindre_V2 = v_besch59 "craindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + croire_V2 = v_besch68 "croire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + croître_V = v_besch67 "croître" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + cueillir_V2 = v_besch28 "cueillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + cuire_V2 = v_besch82 "cuire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + débattre_V2 = v_besch55 "débattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + débouillir_V2 = v_besch31 "débouillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décevoir_V2 = v_besch38 "décevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déchoir_V2 = v_besch52 "déchoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déclore_V2 = v_besch70 "déclore" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décommettre_V2 = v_besch56 "décommettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déconfire_V2 = v_besch81 "déconfire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + découdre_V2 = v_besch73 "découdre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + découvrir_V2 = v_besch27 "découvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décrire_V2 = v_besch80 "décrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décroître_V2 = v_besch67 "décroître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + décuire_V2 = v_besch82 "décuire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déduire_V2 = v_besch82 "déduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + défaillir_V = v_besch30 "défaillir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + défaire_V2 = v_besch62 "défaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + défendre_V2 = v_besch53 "défendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démentir_V2 = v_besch25 "démentir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démettre_V2 = v_besch56 "démettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + démordre_V = v_besch53 "démordre" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + départir_V2 = v_besch25 "départir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + dépeindre_V2 = v_besch57 "dépeindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dépendre_V2 = v_besch53 "dépendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + déplaire_V = v_besch63 "déplaire" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + dépourvoir_V2 = v_besch40 "dépourvoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déprendre_V2 = v_besch54 "déprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + désapprendre_V2 = v_besch54 "désapprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + descendre_V2 = v_besch53 "descendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + desservir_V2 = v_besch35 "desservir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + déteindre_V2 = v_besch57 "déteindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détendre_V2 = v_besch53 "détendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détenir_V2 = v_besch23 "détenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détordre_V2 = v_besch53 "détordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + détruire_V2 = v_besch82 "détruire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + devenir_V = v_besch23 "devenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + dévêtir_V2 = v_besch26 "dévêtir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + devoir_V2 = v_besch42 "devoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dire_V2 = v_besch78 "dire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + disconvenir_V2 = v_besch23 "disconvenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + discourir_V2 = v_besch33 "discourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + disjoindre_V2 = v_besch58 "disjoindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + disparaître_V2 = v_besch64 "disparaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dissoudre_V2 = v_besch72 "dissoudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distendre_V2 = v_besch53 "distendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distordre_V2 = v_besch53 "distordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + distraire_V2 = v_besch61 "distraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + dormir_V2 = v_besch32 "dormir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ébattre_V = v_besch55 "ébattre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + échoir_V2 = v_besch52 "échoir" ** {isRefl = False ; aux = VEsse ; lock_V2 = <> ; c2 = complDat} ; + éclore_V2 = v_besch70 "éclore" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + éconduire_V2 = v_besch82 "éconduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + écrire_V2 = v_besch80 "écrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + élire_V2 = v_besch77 "élire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + embatre_V2 = v_besch55 "embatre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + embattre_V2 = v_besch55 "embattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + emboire_V = v_besch69 "emboire" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + émettre_V2 = v_besch56 "émettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + émoudre_V2 = v_besch74 "émoudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + émouvoir_V2 = v_besch44 "émouvoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + empreindre_V2 = v_besch57 "empreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + enceindre_V2 = v_besch57 "enceindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enclore_V2 = v_besch70 "enclore" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + encourir_V2 = v_besch33 "encourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + endormir_V2 = v_besch32 "endormir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enduire_V2 = v_besch82 "enduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enfreindre_V2 = v_besch57 "enfreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enfuir_V = v_besch36 "enfuir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + enjoindre_V2 = v_besch58 "enjoindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + enquérir_V = v_besch24 "enquérir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entendre_V2 = v_besch53 "entendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entr'apercevoir_V = v_besch38 "entr'apercevoir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entrebattre_V = v_besch55 "entrebattre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_détruire_V = v_besch82 "entre-détruire" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_haïr_V = v_besch20 "entre-haïr" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entremettre_V = v_besch56 "entremettre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + entre_nuire_V = v_besch82 "entre-nuire" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + entreprendre_V2 = v_besch54 "entreprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entretenir_V2 = v_besch23 "entretenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entrevoir_V2 = v_besch39 "entrevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + entrouvrir_V2 = v_besch27 "entrouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + envoyer_V2 = v_besch18 "envoyer" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + épandre_V2 = v_besch53 "épandre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + éperdre_V = v_besch53 "éperdre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + éprendre_V = v_besch54 "éprendre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + équivaloir_V2 = v_besch47 "équivaloir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + éteindre_V2 = v_besch57 "éteindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + étendre_V2 = v_besch53 "étendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + étreindre_V2 = v_besch57 "étreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + être_V = v_besch2 "être" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + exclure_V2 = v_besch71 "exclure" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + extraire_V2 = v_besch61 "extraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + faillir_V2 = v_besch30 "faillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + faire_V2 = v_besch62 "faire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + falloir_V = v_besch46 "falloir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + feindre_V2 = v_besch57 "feindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fendre_V2 = v_besch53 "fendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fondre_V2 = v_besch53 "fondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + forfaire_V2 = v_besch62 "forfaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + foutre_V2 = v_besch53 "foutre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + frire_V2 = v_besch81 "frire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + fuir_V2 = v_besch36 "fuir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + geindre_V2 = v_besch57 "geindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + gésir_V2 = mkNV (conj3gésir "gésir") ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + haïr_V2 = v_besch20 "haïr" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + inclure_V2 = v_besch71 "inclure" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + induire_V2 = v_besch82 "induire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + inscrire_V2 = v_besch80 "inscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + instruire_V2 = v_besch82 "instruire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + interdire_V2 = v_besch78 "interdire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + interrompre_V2 = v_besch53 "interrompre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + intervenir_V = v_besch23 "intervenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + introduire_V2 = v_besch82 "introduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + joindre_V2 = v_besch58 "joindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + lire_V2 = v_besch77 "lire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + luire_V = v_besch82 "luire" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + mainmettre_V2 = v_besch56 "mainmettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + maintenir_V2 = v_besch23 "maintenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + méconnaître_V2 = v_besch64 "méconnaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mécroire_V2 = v_besch68 "mécroire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + médire_V2 = v_besch78 "médire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + mentir_V2 = v_besch25 "mentir" ** {isRefl = False ; aux = VEsse ; lock_V2 = <> ; c2 = complDat} ; + méprendre_V2 = v_besch54 "méprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + messeoir_V2 = v_besch50 "messeoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mettre_V2 = v_besch56 "mettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mévendre_V2 = v_besch53 "mévendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mordre_V2 = v_besch53 "mordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + morfondre_V = v_besch53 "morfondre" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + moudre_V2 = v_besch74 "moudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + mourir_V = v_besch34 "mourir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + mouvoir_V2 = v_besch44 "mouvoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + naître_V = v_besch65 "naître" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + nuire_V2 = v_besch82 "nuire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + obtenir_V2 = v_besch23 "obtenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + obvenir_V = v_besch23 "obvenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + occlure_V2 = v_besch71 "occlure" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + offrir_V2 = v_besch27 "offrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + oindre_V2 = v_besch58 "oindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + omettre_V2 = v_besch56 "omettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ouïr_V2 = v_besch37 "ouïr" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ouvrir_V2 = v_besch27 "ouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + paître_V2 = v_besch66 "paître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + paître_V = v_besch66 "paître" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + paraître_V = v_besch64 "paraître" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + parcourir_V2 = v_besch33 "parcourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + parfondre_V2 = v_besch53 "parfondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + partir_V = v_besch25 "partir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + parvenir_V = v_besch23 "parvenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + peindre_V2 = v_besch57 "peindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pendre_V2 = v_besch53 "pendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + percevoir_V2 = v_besch38 "percevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + perdre_V2 = v_besch53 "perdre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + permettre_V2 = v_besch56 "permettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + plaindre_V2 = v_besch59 "plaindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + plaire_V2 = v_besch63 "plaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + pleuvoir_V = v_besch45 "pleuvoir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + poindre_V2 = v_besch58 "poindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pondre_V2 = v_besch53 "pondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pourfendre_V2 = v_besch53 "pourfendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + poursuivre_V2 = v_besch75 "poursuivre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pourvoir_V2 = v_besch40 "pourvoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + pouvoir_V = v_besch43 "pouvoir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + prédire_V2 = v_besch78 "prédire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prendre_V2 = v_besch54 "prendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prescrire_V2 = v_besch80 "prescrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + pressentir_V2 = v_besch25 "pressentir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prétendre_V2 = v_besch53 "prétendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + prévaloir_V2 = v_besch47 "prévaloir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + prévenir_V2 = v_besch23 "prévenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + prévoir_V2 = v_besch39 "prévoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + produire_V2 = v_besch82 "produire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + promettre_V2 = v_besch56 "promettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + promouvoir_V2 = v_besch44 "promouvoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + proscrire_V2 = v_besch80 "proscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + provenir_V = v_besch23 "provenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + rabattre_V2 = v_besch55 "rabattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + raire_V2 = v_besch61 "raire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rapprendre_V2 = v_besch54 "rapprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rasseoir_V2 = v_besch49 "rasseoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réadmettre_V2 = v_besch56 "réadmettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réapparaître_V = v_besch64 "réapparaître" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + réapprendre_V2 = v_besch54 "réapprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rebattre_V2 = v_besch55 "rebattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recevoir_V2 = v_besch38 "recevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recomparaître_V2 = v_besch64 "recomparaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconduire_V2 = v_besch82 "reconduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconnaître_V2 = v_besch64 "reconnaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconquérir_V2 = v_besch24 "reconquérir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reconstruire_V2 = v_besch82 "reconstruire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recoudre_V2 = v_besch73 "recoudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recourir_V2 = v_besch33 "recourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + recouvrir_V2 = v_besch27 "recouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + récrire_V2 = v_besch80 "récrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recroître_V2 = v_besch67 "recroître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recueillir_V2 = v_besch28 "recueillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + recuire_V2 = v_besch82 "recuire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redécouvrir_V2 = v_besch27 "redécouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redéfaire_V2 = v_besch62 "redéfaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redescendre_V2 = v_besch53 "redescendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redevenir_V = v_besch23 "redevenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + redevoir_V2 = v_besch42 "redevoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + redire_V2 = v_besch78 "redire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réduire_V2 = v_besch82 "réduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + réécrire_V2 = v_besch80 "réécrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réélire_V2 = v_besch77 "réélire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réentendre_V2 = v_besch53 "réentendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refaire_V2 = v_besch62 "refaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refendre_V2 = v_besch53 "refendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + refondre_V2 = v_besch53 "refondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réinscrire_V2 = v_besch80 "réinscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + réintroduire_V2 = v_besch82 "réintroduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rejoindre_V2 = v_besch58 "rejoindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + relire_V2 = v_besch77 "relire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reluire_V2 = v_besch82 "reluire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remettre_V2 = v_besch56 "remettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remordre_V2 = v_besch53 "remordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + remoudre_V2 = v_besch74 "remoudre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + renaître_V2 = v_besch65 "renaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rendormir_V2 = v_besch32 "rendormir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rendre_V2 = v_besch53 "rendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rentraire_V2 = v_besch61 "rentraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rentrouvrir_V2 = v_besch27 "rentrouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + renvoyer_V2 = v_besch18 "renvoyer" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repaître_V2 = v_besch66 "repaître" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + répandre_V2 = v_besch53 "répandre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reparaître_V = v_besch64 "reparaître" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + repartir_V = v_besch25 "repartir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + repeindre_V2 = v_besch57 "repeindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rependre_V2 = v_besch53 "rependre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repentir_V = v_besch25 "repentir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + reperdre_V2 = v_besch53 "reperdre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + repleuvoir_V = v_besch45 "repleuvoir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + répondre_V2 = v_besch53 "répondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reprendre_V2 = v_besch54 "reprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reproduire_V2 = v_besch82 "reproduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + requérir_V2 = v_besch24 "requérir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + résoudre_V2 = mkNV (conj3résoudre "résoudre") ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ressentir_V2 = v_besch25 "ressentir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + resservir_V2 = v_besch35 "resservir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + ressortir_V = v_besch25 "ressortir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + ressouvenir_V = v_besch23 "ressouvenir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + restreindre_V2 = v_besch57 "restreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + reteindre_V2 = v_besch57 "reteindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retendre_V2 = v_besch53 "retendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retenir_V2 = v_besch23 "retenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retondre_V2 = v_besch53 "retondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retordre_V2 = v_besch53 "retordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retraduire_V2 = v_besch82 "retraduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retraire_V2 = v_besch61 "retraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retranscrire_V2 = v_besch80 "retranscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + retransmettre_V2 = v_besch56 "retransmettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rétreindre_V2 = v_besch57 "rétreindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revaloir_V2 = v_besch47 "revaloir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revendre_V2 = v_besch53 "revendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revenir_V = v_besch23 "revenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + revêtir_V2 = v_besch26 "revêtir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revivre_V2 = v_besch76 "revivre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revoir_V2 = v_besch39 "revoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + revouloir_V2 = v_besch48 "revouloir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rire_V2 = v_besch79 "rire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + rompre_V2 = v_besch53 "rompre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + rouvrir_V2 = v_besch27 "rouvrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + saillir_V2 = v_besch29 "saillir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + satisfaire_V2 = v_besch62 "satisfaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + savoir_V2 = v_besch41 "savoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + secourir_V2 = v_besch33 "secourir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + séduire_V2 = v_besch82 "séduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sentir_V2 = v_besch25 "sentir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + seoir_V = v_besch50 "seoir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + servir_V2 = v_besch35 "servir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sortir_V = v_besch25 "sortir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + soubattre_V2 = v_besch55 "soubattre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + souffrir_V2 = v_besch27 "souffrir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soumettre_V2 = v_besch56 "soumettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + sourire_V2 = v_besch79 "sourire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + souscrire_V2 = v_besch80 "souscrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + sous_entendre_V2 = v_besch53 "sous-entendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + sous_tendre_V2 = v_besch53 "sous-tendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soustraire_V2 = v_besch61 "soustraire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + soutenir_V2 = v_besch23 "soutenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + souvenir_V = v_besch23 "souvenir" ** {isRefl = False ; aux = VHabere ; lock_V = <> ; c2 = complAcc} ; + subvenir_V2 = v_besch23 "subvenir" ** {isRefl = False ; aux = VEsse ; lock_V2 = <> ; c2 = complDat} ; + suffire_V2 = v_besch81 "suffire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + suivre_V2 = v_besch75 "suivre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surfaire_V2 = v_besch62 "surfaire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surprendre_V2 = v_besch54 "surprendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surproduire_V2 = v_besch82 "surproduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + surseoir_V2 = v_besch51 "surseoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + surtondre_V2 = v_besch53 "surtondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + survenir_V = v_besch23 "survenir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + survivre_V2 = v_besch76 "survivre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + suspendre_V2 = v_besch53 "suspendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + taire_V2 = v_besch63 "taire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + teindre_V2 = v_besch57 "teindre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tendre_V2 = v_besch53 "tendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + tenir_V2 = v_besch23 "tenir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complDat} ; + tondre_V2 = v_besch53 "tondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tordre_V2 = v_besch53 "tordre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + traduire_V2 = v_besch82 "traduire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + traire_V2 = v_besch61 "traire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transcrire_V2 = v_besch80 "transcrire" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transmettre_V2 = v_besch56 "transmettre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + transparaître_V = v_besch64 "transparaître" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + tréfondre_V2 = v_besch53 "tréfondre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + tressaillir_V = v_besch29 "tressaillir" ** {isRefl = False ; aux = VHabere ; lock_V = <>} ; + vaincre_V2 = v_besch60 "vaincre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + valoir_V2 = v_besch47 "valoir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vendre_V2 = v_besch53 "vendre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + venir_V = v_besch23 "venir" ** {isRefl = False ; aux = VEsse ; lock_V = <>} ; + vêtir_V2 = v_besch26 "vêtir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vivre_V2 = v_besch76 "vivre" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + voir_V2 = v_besch39 "voir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complAcc} ; + vouloir_V2 = v_besch48 "vouloir" ** {isRefl = False ; aux = VHabere ; lock_V2 = <> ; c2 = complGen} ; + +} diff --git a/lib/resource-1.0/french/VerbsFreAbs.gf b/lib/resource-1.0/french/VerbsFreAbs.gf new file mode 100644 index 000000000..8bf242854 --- /dev/null +++ b/lib/resource-1.0/french/VerbsFreAbs.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 VerbsFreAbs = 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-1.0/romance/AdjectiveRomance.gf b/lib/resource-1.0/romance/AdjectiveRomance.gf new file mode 100644 index 000000000..148212ae5 --- /dev/null +++ b/lib/resource-1.0/romance/AdjectiveRomance.gf @@ -0,0 +1,40 @@ +incomplete concrete AdjectiveRomance of Adjective = + CatRomance ** open DiffRomance, ResRomance, Prelude in { + + lin + + PositA a = { + s = \\ap => a.s ! AF (APosit ap) Nom ; + isPre = True + } ; + ComparA a np = { + s = \\_ => a.s ! AF ACompar Nom ++ conjThan ++ np.s ! nominative ; + isPre = False + } ; + +-- $SuperlA$ belongs to determiner syntax in $Noun$. + + ComplA2 a np = { + s = \\ap => a.s ! AF (APosit ap) Nom ++ a.c2 ++ np.s ! accusative ; + isPre = False + } ; + + ReflA2 a = { + s = \\ap => a.s ! AF (APosit ap) Nom ++ a.c2 ++ + reflPron (agrP3 Utr Sg) ; ---- + isPre = False + } ; + + SentAP ap sc = { + s = \\a => ap.s ! a ++ sc.s ; + isPre = False + } ; + + AdAP ada ap = { + s = \\a => ada.s ++ ap.s ! a ; + isPre = ap.isPre + } ; + + UseA2 a = a ; + +} diff --git a/lib/resource-1.0/romance/AdverbRomance.gf b/lib/resource-1.0/romance/AdverbRomance.gf new file mode 100644 index 000000000..f80b82d09 --- /dev/null +++ b/lib/resource-1.0/romance/AdverbRomance.gf @@ -0,0 +1,28 @@ +incomplete concrete AdverbRomance of Adverb = CatRomance ** open DiffRomance, ResRomance, Prelude in { + + lin + PositAdvAdj a = { + s = a.s ! adverbForm + } ; + ComparAdvAdj cadv a np = { + s = cadv.s ++ a.s ! adverbForm ++ conjThan ++ np.s ! nominative + } ; + ComparAdvAdjS cadv a s = { + s = cadv.s ++ a.s ! adverbForm ++ conjThan ++ s.s ! Sub + } ; + + PrepNP prep np = {s = prep.s ++ np.s ! accusative} ; + + AdAdv = cc2 ; + + SubjS subj s = { + s = subj.s ++ s.s ! Sub + } ; + AdvSC s = s ; + + AdnCAdv cadv = {s = cadv.s ++ conjThan} ; + + oper + adverbForm : AForm = AF (APosit (Strong SgNeutr)) Nom ; + +} diff --git a/lib/resource-1.0/romance/CatRomance.gf b/lib/resource-1.0/romance/CatRomance.gf new file mode 100644 index 000000000..de20cf24e --- /dev/null +++ b/lib/resource-1.0/romance/CatRomance.gf @@ -0,0 +1,104 @@ +incomplete concrete CatRomance of Cat = + open ResRomance, Prelude, DiffRomance, (R = ParamX) in { + + flags optimize=all_subs ; + + lincat + +-- Phrase + + Text, Phr, Utt, Voc = {s : Str} ; + +-- Tensed/Untensed + + S = {s : Mood => Str} ; + QS = {s : QForm => Str} ; + RS = {s : Mood => Agr => Str} ; + +-- Sentence + + Cl = {s : Tense => Anteriority => Polarity => Mood => Str} ; + Slash = {s : Tense => Anteriority => Polarity => Mood => Str} ** {c2 : Compl} ; + Imp = {s : Polarity => AAgr => Str} ; + +-- Question + + QCl = {s : Tense => Anteriority => Polarity => QForm => Str} ; + IP = {s : Case => Str ; a : AAgr} ; + IAdv = {s : Str} ; + IDet = {s : Gender => Str ; n : Number} ; + +-- Relative + + RCl = {s : Tense => Anteriority => Polarity => Mood => Agr => Str} ; +---- RP = {s : AAgr => RelForm => Str ; a : RAgr} ; + +-- Verb + + VP = { + s : Anteriority => VF => { + fin : Str ; -- ai + inf : Str -- dit + } ; + a1 : Polarity => Str ; -- ne-pas + c1 : Str ; -- le + c2 : Str ; -- lui + n2 : Agr => Str ; -- content(e) ; à ma mère + a2 : Str ; -- hier + ext : Str ; -- que je dors + } ; + Comp = {s : Agr => Str} ; + SC = {s : Str} ; + + +-- Adjective + + AP = {s : AForm => Str ; isPre : Bool} ; + +-- Noun + + CN = {s : Number => Str ; g : Gender} ; + NP,Pron = {s : NPForm => Str ; a : Agr ; c : ClitType} ; + Det = {s : Gender => Case => Str ; n : Number} ; + QuantSg = {s : Gender => Case => Str} ; + QuantPl = {s : Gender => Case => Str} ; + Predet = {s : AAgr => Str} ; + Num = {s : Gender => Str} ; + Ord = {s : AAgr => Str} ; + +-- Adverb + + Adv, AdV, AdA, AdS, AdN = {s : Str} ; + +-- Numeral + +---- Numeral = {s : CardOrd => Str ; n : Number} ; + +-- Structural + + Conj = {s : Str ; n : Number} ; + DConj = {s1,s2 : Str ; n : Number} ; + PConj = {s : Str} ; + CAdv = {s : Str} ; + Subj = {s : Str ; m : Mood} ; + Prep = {s : Str} ; + +-- Open lexical classes, e.g. Basic + + V, VS, VQ, VA = Verb ; + V2, VV, V2A = Verb ** {c2 : Compl} ; + V3 = Verb ** {c2,c3 : Compl} ; + + 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} ; + + oper + Noun = {s : Number => Str ; g : Gender} ; + Verb = {s : VF => Str ; aux : VAux ; isRefl : Bool} ; + +} diff --git a/lib/resource-1.0/romance/ConjunctionRomance.gf b/lib/resource-1.0/romance/ConjunctionRomance.gf new file mode 100644 index 000000000..612161928 --- /dev/null +++ b/lib/resource-1.0/romance/ConjunctionRomance.gf @@ -0,0 +1,45 @@ +incomplete concrete ConjunctionRomance of Conjunction = + CatRomance ** open ResRomance, Coordination, Prelude in { + + flags optimize=all_subs ; + + lin + + ConjS conj ss = conjunctTable Order conj ss ; + DConjS conj ss = conjunctDistrTable Order conj ss ; + + ConjAdv conj ss = conjunctSS conj ss ; + DConjAdv conj ss = conjunctDistrSS conj ss ; + + ConjNP conj ss = conjunctTable NPForm conj ss ** { + a = {gn = conjGenNum (gennum utrum conj.n) ss.a.gn ; p = ss.a.p} + } ; + DConjNP conj ss = conjunctDistrTable NPForm conj ss ** { + a = {gn = conjGenNum (gennum utrum conj.n) ss.a.gn ; p = ss.a.p} + } ; + + ConjAP conj ss = conjunctTable AFormPos conj ss ** { + isPre = ss.isPre + } ; + DConjAP conj ss = conjunctDistrTable AFormPos conj ss ** { + isPre = ss.isPre + } ; + +-- These fun's are generated from the list cat's. + + BaseS = twoTable Order ; + ConsS = consrTable Order comma ; + BaseAdv = twoSS ; + ConsAdv = consrSS comma ; + BaseNP x y = twoTable NPForm x y ** {a = conjAgr x.a y.a} ; + ConsNP xs x = consrTable NPForm comma xs x ** {a = conjAgr xs.a x.a} ; + BaseAP x y = twoTable AFormPos x y ** {isPre = andB x.isPre y.isPre} ; + ConsAP xs x = consrTable AFormPos comma xs x ** {isPre = andB xs.isPre x.isPre} ; + + lincat + [S] = {s1,s2 : Order => Str} ; + [Adv] = {s1,s2 : Str} ; + [NP] = {s1,s2 : NPForm => Str ; a : Agr} ; + [AP] = {s1,s2 : AFormPos => Str ; isPre : Bool} ; + +} diff --git a/lib/resource-1.0/romance/DiffRomance.gf b/lib/resource-1.0/romance/DiffRomance.gf new file mode 100644 index 000000000..d3455153d --- /dev/null +++ b/lib/resource-1.0/romance/DiffRomance.gf @@ -0,0 +1,55 @@ +interface DiffRomance = open ResRomance, Prelude in { + +--2 Parameters. + +-- Prepositions that fuse with the article vary. + +param + + Prep ; + + Case = Nom | Acc | CPrep Prep ; + + NPForm = Ton Case | Aton Case | Poss AAgr ; + + RelForm = RSimple Case | RComplex Gender Number Case ; + + VAux ; + +oper + + Compl : Type = {s : Str ; c : Case} ; + + dative : Case ; + genitive : Case ; + + prepCase : Case -> Str ; + + npform2case : NPForm -> Case = \p -> case p of { + Ton x => x ; + Aton x => x ; + Poss _ => genitive + } ; + + case2npform : Case -> NPForm = \c -> case c of { + Nom => Aton Nom ; + Acc => Aton Acc ; + _ => Ton c + } ; + + npRelForm : NPForm -> RelForm = \np -> case np of { + Ton c => RSimple c ; + Aton c => RSimple c ; + Poss _ => RSimple genitive + } ; + + appCompl : Compl -> (NPForm => Str) -> Str = \comp,np -> + comp.s ++ np ! Ton comp.c ; + + artDef : Gender -> Number -> Case -> Str ; + artIndef : Gender -> Number -> Case -> Str ; + + partitive : Gender -> Case -> Str ; + +} + diff --git a/lib/resource-1.0/romance/ExtEngAbs.gf b/lib/resource-1.0/romance/ExtEngAbs.gf new file mode 100644 index 000000000..85c117e47 --- /dev/null +++ b/lib/resource-1.0/romance/ExtEngAbs.gf @@ -0,0 +1,15 @@ +abstract ExtEngAbs = Cat ** { + + cat + Aux ; -- auxiliary verbs: "can", "must", etc + +-- Notice that $Aux$ cannot form $VP$ with infinitive, imperative, etc. + + fun + PredAux : NP -> Aux -> VP -> Cl ; + QuestAux : IP -> Aux -> VP -> QCl ; + + can_Aux : Aux ; + must_Aux : Aux ; + +} diff --git a/lib/resource-1.0/romance/ExtRomance.gf b/lib/resource-1.0/romance/ExtRomance.gf new file mode 100644 index 000000000..a5586d715 --- /dev/null +++ b/lib/resource-1.0/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-1.0/romance/ExtScandAbs.gf b/lib/resource-1.0/romance/ExtScandAbs.gf new file mode 100644 index 000000000..b76a3d4a8 --- /dev/null +++ b/lib/resource-1.0/romance/ExtScandAbs.gf @@ -0,0 +1,9 @@ +abstract ExtRomanceAbs = Cat ** { + + fun + +-- Definite form of simple nouns without article; neither $Num$ nor $Ord$ allowed. + + DefSgN, DefPlN : Predef -> N -> NP ; + +} diff --git a/lib/resource-1.0/romance/MathRomance.gf b/lib/resource-1.0/romance/MathRomance.gf new file mode 100644 index 000000000..73ad4221e --- /dev/null +++ b/lib/resource-1.0/romance/MathRomance.gf @@ -0,0 +1,27 @@ +incomplete concrete MathRomance of Math = + CatRomance ** open Prelude, ResRomance, DiffRomance in { + +lin + SymbPN i = {s = \\c => i.s ; g = Neutr} ; --- c + IntPN i = {s = \\c => i.s ; g = Neutr} ; --- c + CNIntNP cn i = { + s = \\c => (cn.s ! Sg ! DIndef ! Nom ++ i.s) ; + a = agrP3 cn.g Sg + } ; + CNSymbNP det cn xs = let g = cn.g in { + s = \\c => det.s ! g ++ cn.s ! det.n ! det.det ! caseNP c ++ xs.s ; + a = agrP3 g det.n + } ; + +lincat + + Symb, SymbList = SS ; + +lin + + MkSymb s = s ; + + BaseSymb = infixSS conjAnd ; + ConsSymb = infixSS "," ; + +} diff --git a/lib/resource-1.0/romance/NounRomance.gf b/lib/resource-1.0/romance/NounRomance.gf new file mode 100644 index 000000000..c922f663a --- /dev/null +++ b/lib/resource-1.0/romance/NounRomance.gf @@ -0,0 +1,124 @@ +incomplete concrete NounRomance of Noun = + CatRomance ** open DiffRomance, ResRomance, Prelude in { + + flags optimize=all_subs ; + + lin + DetCN det cn = + let + g = cn.g ; + n = det.n + in { + s = \\c => det.s ! g ! npform2case c ++ cn.s ! n ; + a = agrP3 g n ; + c = Clit0 + } ; + + UsePN pn = { + s = \\c => prepCase (npform2case c) ++ pn.s ; + a = agrP3 pn.g Sg ; + c = Clit0 + } ; + + UsePron p = p ; + + PredetNP pred np = { + s = \\c => prepCase (npform2case c) ++ pred.s ! np.a ++ np.s ! Ton Acc ; + a = np.a ; + c = Clit0 + } ; + + DetSg quant ord = { + s = \\g,c => quant.s ! g ! c ++ ord.s ! aagr g Sg ; + n = Sg + } ; + DetPl quant num ord = { + s = \\g,c => quant.s ! g ! c ++ num.s ! g ++ ord.s ! aagr g Sg ; + n = Pl + } ; + + PossSg p = { + s = \\g,c => prepCase c ++ p.s ! Poss (aagr g Sg) ; + n = Sg + } ; + PossPl p = { + s = \\g,c => prepCase c ++ p.s ! Poss (aagr g Pl) ; + n = Pl + } ; + + NoNum = {s = \\_ => []} ; + NoOrd = {s = \\_ => []} ; + + NumInt n = {s = \\_ => n.s} ; + OrdInt n = {s = \\_ => n.s ++ "ème"} ; --- + +---- NumNumeral numeral = {s = \\g => numeral.s ! NCard g ; isDet = True} ; +---- OrdNumeral numeral = {s = numeral.s ! NOrd SupWeak ; isDet = True} ; + + AdNum adn num = {s = \\a => adn.s ++ num.s ! a} ; + +---- OrdSuperl a = {s = a.s ! AF (ASuperl SupWeak) Nom ; isDet = True} ; + + DefSg = { + s = \\g,c => artDef g Sg c ; + n = Sg + } ; + DefPl = { + s = \\g,c => artDef g Sg c ; + n = Pl + } ; + + IndefSg = { + s = \\g,c => artIndef g Sg c ; + n = Sg + } ; + IndefPl = { + s = \\g,c => artIndef g Pl c ; + n = Pl + } ; + + MassDet = { + s = \\g,c => partitive g c ; + n = Sg + } ; + +-- 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,d,c => cn.s ! n ! d ! c ++ rs.s ! agrP3 g n ; + g = g ; + isMod = cn.isMod + } ; + SentCN cn sc = let g = cn.g in { + s = \\n,d,c => cn.s ! n ! d ! c ++ sc.s ; + g = g ; + isMod = cn.isMod + } ; + AdvCN cn sc = let g = cn.g in { + s = \\n,d,c => cn.s ! n ! d ! c ++ sc.s ; + g = g ; + isMod = cn.isMod + } ; +-} +} diff --git a/lib/resource-1.0/romance/ParamRomance.gf b/lib/resource-1.0/romance/ParamRomance.gf new file mode 100644 index 000000000..f169a085b --- /dev/null +++ b/lib/resource-1.0/romance/ParamRomance.gf @@ -0,0 +1,126 @@ +--1 Romance Word Classes and Morphological Parameters +-- + +resource ParamRomance = ParamX ** open Prelude in { + +-- This is a resource module for Romance grammars, currently instantiated for +-- French, Italian, and Spanish. It defines the +-- morphological parameters that are common to all Romance languages. +-- The guiding principle has been +-- to share as much as possible, which has two advantages: it saves work in +-- encoding, and it shows how the languages are related. +-- Those parameters that differ are defined in [DiffRomance DiffRomance.html]. +-- Some parameters are shared even more widely, such as $Number$ and $Person$. +-- They are defined in [ParamX ParamX.html]. + + +--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 ; + +-- There are different types of clicic pronouns (as for position). +-- Examples of each: "Giovanni" ; "io" ; "lui" ; "noi". + + ClitType = Clit0 | Clit1 | Clit2 | Clit3 ; + +-- 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 ; + +-- 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" + } ; + +--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. + +param + VF = + VInfin + | VFin TMood Number Person + | VImper NumPersI + | VPart Gender Number + | VGer + ; + + TMood = + VPres Mood + | VImperf Mood + | VPasse + | VFut + | VCondit + ; + + NumPersI = SgP2 | PlP1 | PlP2 ; + +-- Agreement of adjectives, verb phrases, and relative pronouns. + +oper + AAgr : Type = {g : Gender ; n : Number} ; + Agr : Type = AAgr ** {p : Person} ; + +param + RAgr = RAg AAgr | RNoAg ; + +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 + } ; + +} diff --git a/lib/resource-1.0/romance/PhraseRomance.gf b/lib/resource-1.0/romance/PhraseRomance.gf new file mode 100644 index 000000000..69652ec67 --- /dev/null +++ b/lib/resource-1.0/romance/PhraseRomance.gf @@ -0,0 +1,24 @@ +incomplete concrete PhraseRomance of Phrase = + CatRomance, TenseX ** open DiffRomance, ResRomance, Prelude in { + + lin + PhrUtt pconj utt voc = {s = pconj.s ++ utt.s ++ voc.s} ; + + UttS s = {s = s.s ! Main} ; + UttQS qs = {s = qs.s ! QDir} ; + UttImpSg pol imp = {s = pol.s ++ imp.s ! pol.p ! Sg} ; + UttImpPl pol imp = {s = pol.s ++ imp.s ! pol.p ! Pl} ; + + UttIP ip = {s = ip.s ! nominative} ; --- Acc also + UttIAdv iadv = iadv ; + UttNP np = {s = np.s ! accusative} ; + UttVP vp = {s = infMark ++ infVP vp (agrP3 Utr Sg)} ; + UttAdv adv = adv ; + + NoPConj = {s = []} ; + PConjConj conj = conj ; + + NoVoc = {s = []} ; + VocNP np = {s = "," ++ np.s ! nominative} ; + +} diff --git a/lib/resource-1.0/romance/QuestionRomance.gf b/lib/resource-1.0/romance/QuestionRomance.gf new file mode 100644 index 000000000..08a114259 --- /dev/null +++ b/lib/resource-1.0/romance/QuestionRomance.gf @@ -0,0 +1,66 @@ +incomplete concrete QuestionRomance of Question = + CatRomance ** open DiffRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + + QuestCl cl = { + s = \\t,a,p => + let cls = cl.s ! t ! a ! p + in table { + QDir => cls ! Inv ; + QIndir => subjIf ++ cls ! Sub + } + } ; + + QuestVP qp vp = { + s = \\t,a,b,q => + let + somo = case q of { + QIndir => <"som",Sub> ; + _ => <[], Main> + } ; + cl = mkClause (qp.s ! nominative ++ somo.p1) {gn = qp.gn ; p = P3} vp + in + cl.s ! t ! a ! b ! somo.p2 + } ; + + QuestSlash ip slash = { + s = \\t,a,p => + let + cls = slash.s ! t ! a ! p ; + who = slash.c2 ++ ip.s ! accusative --- stranding in ExtRomance + in table { + QDir => who ++ cls ! Inv ; + QIndir => who ++ cls ! Sub + } + } ; + + QuestIAdv iadv cl = { + s = \\t,a,p => + let + cls = cl.s ! t ! a ! p ; + why = iadv.s + in table { + QDir => why ++ cls ! Inv ; + QIndir => why ++ cls ! Sub + } + } ; + + PrepIP p ip = { + s = p.s ++ ip.s ! accusative + } ; + + AdvIP ip adv = { + s = \\c => ip.s ! c ++ adv.s ; + gn = ip.gn + } ; + + IDetCN idet num ord cn = let g = cn.g in { + s = \\c => + idet.s ! g ++ num.s ! g ++ ord.s ++ cn.s ! idet.n ! idet.det ! caseNP c ; + gn = gennum g idet.n + } ; + +} diff --git a/lib/resource-1.0/romance/RelativeRomance.gf b/lib/resource-1.0/romance/RelativeRomance.gf new file mode 100644 index 000000000..e8d249025 --- /dev/null +++ b/lib/resource-1.0/romance/RelativeRomance.gf @@ -0,0 +1,44 @@ +incomplete concrete RelativeRomance of Relative = + CatRomance ** open DiffRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + + RelCl cl = { + s = \\t,a,p,ag => pronSuch ! ag.gn ++ conjThat ++ cl.s ! t ! a ! p ! Sub + } ; + + RelVP rp vp = { + s = \\t,ant,b,ag => + let + agr = case rp.a of { + RNoAg => ag ; + RAg a => a + } ; + cl = mkClause (rp.s ! ag.gn ! RNom) agr vp + in + cl.s ! t ! ant ! b ! Sub + } ; + +--- We make this easy by using "som" and preposition stranding. It would be +--- a proble to determine whether $slash$ takes a direct object, since +--- $slash.c2$ is defined to be just a string. +-- +-- The empty relative is left to $ExtRomance$. + + RelSlash rp slash = { + s = \\t,a,p,ag => + rp.s ! ag.gn ! RNom ++ slash.s ! t ! a ! p ! Sub ++ slash.c2 + } ; + +--- The case here could be genitive. + + FunRP p np rp = { + s = \\gn,c => np.s ! nominative ++ p.s ++ rp.s ! gn ! RPrep ; + a = RAg np.a + } ; + + IdRP = {s = relPron ; a = RNoAg} ; + +} diff --git a/lib/resource-1.0/romance/ResRomance.gf b/lib/resource-1.0/romance/ResRomance.gf new file mode 100644 index 000000000..079c487b7 --- /dev/null +++ b/lib/resource-1.0/romance/ResRomance.gf @@ -0,0 +1,205 @@ +----1 Romance 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$. +-- +resource ResRomance = ParamRomance ** open Prelude in { + + flags optimize=all ; + + oper + genForms : Str -> Str -> Gender => Str = \bon,bonne -> + table { + Masc => bon ; + Fem => bonne + } ; + + +} + +{- + oper + +-- For $Lex$. + +-- For each lexical category, here are the worst-case constructors. +-- +-- But $mkNoun$ is fully defined only for each language, since +-- $Gender$ varies. + + nounForms : (x1,_,_,x4 : Str) -> (Number => Species => Case => Str) = + \man,mannen,men,mennen -> \\n,d,c => case of { + => mkCase c man ; + => mkCase c mannen ; + => mkCase c men ; + => mkCase c mennen + } ; + + Adjective : Type = {s : AForm => Str} ; + + mkAdjective : (x1,_,_,_,_,_,x7 : Str) -> {s : AForm => Str} = + \liten, litet, lilla, sma, mindre, minst, minsta -> { + s = table { + AF (APosit a) c => mkCase c (mkAdjPos a liten litet lilla sma) ; + AF ACompar c => mkCase c mindre ; + AF (ASuperl SupStrong) c => mkCase c minst ; + AF (ASuperl SupWeak) c => mkCase c minsta + } + } ; + + mkVerb : (x1,_,_,_,_,_,_,x8 : Str) -> {s : VForm => Str ; vtype : VType} = + \finna,finner,finn,fann,funnit,funnen,funnet,funna -> { + s = table { + VF (VPres Act) => finner ; + VF (VPres Pass) => mkVoice Pass finn ; + VF (VPret v) => mkVoice v fann ; + VF (VImper v) => mkVoice v finn ; + VI (VInfin v) => mkVoice v finna ; + VI (VSupin v) => mkVoice v funnit ; + VI (VPtPret a c)=> mkCase c (mkAdjPos a funnen funnet funna funna) + } ; + vtype = VAct + } ; + +-- These are useful auxiliaries. + + mkCase : Case -> Str -> Str = \c,f -> case c of { + Nom => f ; + Gen => f + case last f of { + "s" | "x" => [] ; + _ => "s" + } + } ; + + mkAdjPos : AFormPos -> (s1,_,_,s4 : Str) -> Str = + \a, liten, litet, lilla, sma -> + case a of { + Strong gn => case gn of { + SgUtr => liten ; + SgNeutr => litet ; + Plg => sma + } ; + Weak Sg => lilla ; + Weak Pl => sma + } ; + + mkVoice : Voice -> Str -> Str = \v,s -> case v of { + Act => s ; + Pass => s + case last s of { + "s" => "es" ; + _ => "s" + } + } ; + + +-- For $Noun$. + + artDef : GenNum -> Str = \gn -> gennumForms "den" "det" "de" ! gn ; + + mkNP : (x1,_,_,_,x5 : Str) -> GenNum -> Person -> + {s : NPForm => Str ; a : Agr} = \du,dig,din,ditt,dina,gn,p -> { + s = table { + NPNom => du ; + NPAcc => dig ; + NPPoss g => gennumForms din ditt dina ! g + } ; + a = { + gn = gn ; + p = p + } + } ; + + gennumForms : (x1,x2,x3 : Str) -> GenNum => Str = \den,det,de -> + table { + SgUtr => den ; + SgNeutr => det ; + _ => de + } ; + + regNP : Str -> Str -> GenNum -> {s : NPForm => Str ; a : Agr} = + \det,dess,gn -> + mkNP det det dess dess dess gn P3 ; + + +-- For $Verb$. + + Verb : Type = { + s : VForm => Str ; + vtype : VType + } ; + + VP = { + s : VPForm => { + fin : Str ; -- V1 har ---s1 + inf : Str -- V2 sagt ---s4 + } ; + a1 : Polarity => Str ; -- A1 inte ---s3 + n2 : Agr => Str ; -- N2 dig ---s5 + a2 : Str ; -- A2 idag ---s6 + ext : Str ; -- S-Ext att hon går ---s7 + --- ea1,ev2, --- these depend on params of v and a1 + en2,ea2,eext : Bool -- indicate if the field exists + } ; + + + insertObj : (Agr => Str) -> VP -> VP = \obj,vp -> { + s = vp.s ; + a1 = vp.a1 ; + n2 = \\a => vp.n2 ! a ++ obj ! a ; + a2 = vp.a2 ; + ext = vp.ext ; + en2 = True ; + ea2 = vp.ea2 ; + eext = vp.eext + } ; + + insertAdv : Str -> VP -> VP = \adv,vp -> { + s = vp.s ; + a1 = vp.a1 ; + n2 = vp.n2 ; + a2 = vp.a2 ++ adv ; + ext = vp.ext ; + en2 = vp.en2 ; + ea2 = True ; + eext = vp.eext + } ; + + insertAdV : Str -> VP -> VP = \adv,vp -> { + s = vp.s ; + a1 = \\b => vp.a1 ! b ++ adv ; + n2 = vp.n2 ; + a2 = vp.a2 ; + ext = vp.ext ; + en2 = vp.en2 ; + ea2 = vp.ea2 ; + eext = vp.eext + } ; + + infVP : VP -> Agr -> Str = \vp,a -> + (vp.s ! VPInfinit Simul).inf ++ vp.n2 ! a ++ vp.a2 ++ vp.ext ; --- a1 + + +-- For $Sentence$. + + Clause : Type = { + s : Tense => Anteriority => Polarity => Order => Str + } ; + + mkClause : Str -> Agr -> VP -> Clause = \subj,agr,vp -> { + s = \\t,a,b,o => + let + verb = vp.s ! VPFinite t a ; + neg = vp.a1 ! b ; + compl = vp.n2 ! agr ++ vp.a2 ++ vp.ext + in + case o of { + Main => subj ++ verb.fin ++ neg ++ verb.inf ++ compl ; + Inv => verb.fin ++ subj ++ neg ++ verb.inf ++ compl ; + Sub => subj ++ neg ++ verb.fin ++ verb.inf ++ compl + } + } ; + +} +-} \ No newline at end of file diff --git a/lib/resource-1.0/romance/SentenceRomance.gf b/lib/resource-1.0/romance/SentenceRomance.gf new file mode 100644 index 000000000..d81acc4b5 --- /dev/null +++ b/lib/resource-1.0/romance/SentenceRomance.gf @@ -0,0 +1,43 @@ +incomplete concrete SentenceRomance of Sentence = + CatRomance ** open DiffRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + PredVP np vp = mkClause (np.s ! nominative) np.a vp ; + + PredSCVP sc vp = mkClause sc.s (agrP3 neutrum Sg) vp ; + + ImpVP vp = { + s = \\pol,n => + let + agr = {gn = gennum utrum n ; p = P2} ; + verb = vp.s ! VPImperat ; + in + verb.fin ++ vp.a1 ! pol ++ verb.inf ++ vp.n2 ! agr ++ vp.a2 ++ vp.ext + } ; + + SlashV2 np v2 = + mkClause + (np.s ! nominative) np.a + (predV v2) ** + {c2 = v2.c2} ; + + SlashVVV2 np vv v2 = + mkClause + (np.s ! nominative) np.a + (insertObj (\\_ => vv.c2 ++ infVP (predV v2) np.a) (predV vv)) ** + {c2 = v2.c2} ; + + AdvSlash slash adv = { + s = \\t,a,b,o => slash.s ! t ! a ! b ! o ++ adv.s ; + c2 = slash.c2 + } ; + + SlashPrep cl prep = cl ** {c2 = prep.s} ; + + EmbedS s = {s = conjThat ++ s.s ! Sub} ; + EmbedQS qs = {s = qs.s ! QIndir} ; + EmbedVP vp = {s = infVP vp (agrP3 utrum Sg)} ; --- agr + +} diff --git a/lib/resource-1.0/romance/SeqConjunctionRomance.gf b/lib/resource-1.0/romance/SeqConjunctionRomance.gf new file mode 100644 index 000000000..8433f087e --- /dev/null +++ b/lib/resource-1.0/romance/SeqConjunctionRomance.gf @@ -0,0 +1,41 @@ +--concrete SeqConjunctionRomance of Conjunction = +-- CatRomance ** open ResRomance, Coordination, Prelude in { +-- +-- lin +-- +-- ConjS conj ss = {s = conjunctX conj ss} ; +-- DConjS conj ss = {s = conjunctDistrX conj ss} ; +-- +-- ConjAdv conj ss = {s = conjunctX conj ss} ; +-- DConjAdv conj ss = {s = conjunctDistrX conj ss} ; +-- +-- ConjNP conj ss = conjunctTable Case conj ss ** { +-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p} +-- } ; +-- DConjNP conj ss = conjunctDistrTable Case conj ss ** { +-- a = {n = conjNumber conj.n ss.a.n ; p = ss.a.p} +-- } ; +-- +-- ConjAP conj ss = conjunctTable Agr conj ss ** { +-- isPre = ss.isPre +-- } ; +-- DConjAP conj ss = conjunctDistrTable Agr conj ss ** { +-- isPre = ss.isPre +-- } ; +-- +-- TwoS = twoSS ; +-- AddS = consSS comma ; +-- TwoAdv = twoSS ; +-- AddAdv = consSS comma ; +-- TwoNP x y = twoTable Case x y ** {a = conjAgr x.a y.a} ; +-- AddNP xs x = consTable Case comma xs x ** {a = conjAgr xs.a x.a} ; +-- TwoAP x y = twoTable Agr x y ** {isPre = andB x.isPre y.isPre} ; +-- AddAP xs x = consTable Agr comma xs x ** {isPre = andB xs.isPre x.isPre} ; +-- +-- lincat +-- SeqS = {s1,s2 : Str} ; +-- SeqAdv = {s1,s2 : Str} ; +-- SeqNP = {s1,s2 : Case => Str ; a : Agr} ; +-- SeqAP = {s1,s2 : Agr => Str ; isPre : Bool} ; +-- +--} diff --git a/lib/resource-1.0/romance/TensedRomance.gf b/lib/resource-1.0/romance/TensedRomance.gf new file mode 100644 index 000000000..a1398ccca --- /dev/null +++ b/lib/resource-1.0/romance/TensedRomance.gf @@ -0,0 +1,11 @@ +incomplete concrete TensedRomance of Tensed = CatRomance, TenseX ** + open ResRomance in { + + flags optimize=all_subs ; + + lin + UseCl t a p cl = {s = \\o => t.s ++ a.s ++ p.s ++ cl.s ! 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 => t.s ++ a.s ++ p.s ++ cl.s ! t.t ! a.a ! p.p ! r} ; + +} diff --git a/lib/resource-1.0/romance/UntensedRomance.gf b/lib/resource-1.0/romance/UntensedRomance.gf new file mode 100644 index 000000000..f874ca4e7 --- /dev/null +++ b/lib/resource-1.0/romance/UntensedRomance.gf @@ -0,0 +1,15 @@ +incomplete concrete UntensedRomance of Untensed = CatRomance ** open ResRomance in { + + flags optimize=all_subs ; + + lin + PosCl cl = {s = cl.s ! Pres ! Simul ! Pos} ; + NegCl cl = {s = cl.s ! Pres ! Simul ! Neg} ; + + PosQCl cl = {s = cl.s ! Pres ! Simul ! Pos} ; + NegQCl cl = {s = cl.s ! Pres ! Simul ! Neg} ; + + PosRCl cl = {s = cl.s ! Pres ! Simul ! Pos} ; + NegRCl cl = {s = cl.s ! Pres ! Simul ! Neg} ; + +} diff --git a/lib/resource-1.0/romance/VerbRomance.gf b/lib/resource-1.0/romance/VerbRomance.gf new file mode 100644 index 000000000..c82c66c2e --- /dev/null +++ b/lib/resource-1.0/romance/VerbRomance.gf @@ -0,0 +1,43 @@ +incomplete concrete VerbRomance of Verb = CatRomance ** open DiffRomance, ResRomance in { + + flags optimize=all_subs ; + + lin + UseV = predV ; + ComplV2 v np = insertObj (\\_ => v.c2 ++ np.s ! accusative) (predV v) ; + ComplV3 v np np2 = + insertObj + (\\_ => v.c2 ++ np.s ! accusative ++ v.c3 ++ np2.s ! accusative) + (predV v) ; + + ComplVV v vp = insertObj (\\a => v.c2 ++ infVP vp a) (predV v) ; + ComplVS v s = insertObj (\\_ => conjThat ++ s.s ! Sub) (predV v) ; + ComplVQ v q = insertObj (\\_ => q.s ! QIndir) (predV v) ; + + ComplVA v ap = + insertObj (\\a => ap.s ! agrAdj a.gn DIndef) (predV v) ; + ComplV2A v np ap = + insertAdv + (ap.s ! agrAdj np.a.gn DIndef) + (insertObj (\\_ => v.c2 ++ np.s ! accusative) (predV v)) ; + + UseComp comp = insertObj (\\a => comp.s ! agrAdj a.gn DIndef) (predV verbBe) ; + + CompAP ap = ap ; + CompNP np = {s = \\_ => np.s ! accusative} ; + CompAdv a = {s = \\_ => a.s} ; + + AdvVP vp adv = insertAdv adv.s vp ; + AdVVP adv vp = insertAdV adv.s vp ; + + + ReflV2 v = insertObj (\\a => v.c2 ++ reflPron a) (predV v) ; + + PassV2 v = + insertObj + (\\a => v.s ! VI (VPtPret (agrAdj a.gn DIndef) Nom)) + (predV verbBecome) ; + + UseVS, UseVQ = \vv -> {s = vv.s ; c2 = [] ; vtype = vv.vtype} ; + +}