forked from GitHub/gf-core
resource = resource-1.0
This commit is contained in:
aarne
233
lib/resource-0.9/french/BasicFre.gf
Normal file
233
lib/resource-0.9/french/BasicFre.gf
Normal file
@@ -0,0 +1,233 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
--# -val
|
||||
|
||||
concrete BasicFre of Basic = CategoriesFre ** open ParadigmsFre, VerbsFre in {
|
||||
|
||||
flags
|
||||
startcat=Phr ; lexer=textlit ; unlexer=text ;
|
||||
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_ADeg = prefADeg (mkADeg (regA "mauvais") (regA "pire")) ;
|
||||
bank_N = regN "banque" feminine ;
|
||||
beautiful_ADeg = prefADeg (regADeg "joli") ; ---- beau
|
||||
become_VA = mkVA devenir_V ;
|
||||
beer_N = regN "bière" feminine ;
|
||||
beg_V2V = mkV2V (regV "demander") accusative dative ;
|
||||
big_ADeg = prefADeg (regADeg "grand") ;
|
||||
bike_N = regN "vélo" masculine ;
|
||||
bird_N = regN "oiseau" masculine ;
|
||||
black_ADeg = regADeg "noir" ;
|
||||
blue_ADeg = regADeg "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_ADeg = regADeg "large" ;
|
||||
brother_N2 = deN2 (regN "frère" masculine) ;
|
||||
brown_ADeg = regADeg "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_ADeg = regADeg "propre" ;
|
||||
clever_ADeg = regADeg "sage" ; ----
|
||||
close_V2 = dirV2 (regV "fermer") ;
|
||||
coat_N = regN "manteau" masculine ;
|
||||
cold_ADeg = regADeg "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_ADeg = regADeg "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_ADeg = regADeg "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_ADeg = prefADeg (mkADeg (mkA "bon" "bonne" "bons" "bien")
|
||||
(mkA "meilleur" "meilleure" "meilleurs" "mieux")) ;
|
||||
go_V = aller_V ;
|
||||
green_ADeg = regADeg "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_ADeg = regADeg "chaud" ;
|
||||
house_N = regN "maison" feminine ;
|
||||
important_ADeg = regADeg "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_ADeg = 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_ADeg = regADeg "étroit" ;
|
||||
new_ADeg = prefADeg (compADeg (mkA "nouveau" "nouvelle" "nouveaux" "nouvellement")) ;
|
||||
newspaper_N = regN "journal" masculine ;
|
||||
oil_N = regN "huile" feminine ;
|
||||
old_ADeg =
|
||||
prefADeg (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_ADeg = regADeg "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_ADeg = regADeg "court" ; ---- bref
|
||||
silver_N = regN "argent" masculine ;
|
||||
sister_N = regN "soeur" feminine ;
|
||||
sleep_V = v2V dormir_V2 ;
|
||||
small_ADeg = prefADeg (regADeg "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_ADeg = regADeg "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_ADeg = compADeg (mkA "épais" "épaisse" "épais" "épaissement") ;
|
||||
thin_ADeg = regADeg "fin" ;
|
||||
train_N = regN "train" masculine ;
|
||||
travel_V = regV "voyager" ;
|
||||
tree_N = regN "arbre" masculine ;
|
||||
---- trousers_N = regN "pantalon" masculine ;
|
||||
ugly_ADeg = regADeg "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_ADeg = regADeg "chaud" ;
|
||||
war_N = regN "guerre" masculine ;
|
||||
watch_V2 = dirV2 (regV "regarder") ;
|
||||
water_N = regN "eau" feminine ;
|
||||
white_ADeg = 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_ADeg = regADeg "jaune" ;
|
||||
young_ADeg = prefADeg (regADeg "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
|
||||
} ;
|
||||
100
lib/resource-0.9/french/BeschFre.gf
Normal file
100
lib/resource-0.9/french/BeschFre.gf
Normal file
@@ -0,0 +1,100 @@
|
||||
resource BeschFre = open Prelude, TypesFre, 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
|
||||
}
|
||||
4
lib/resource-0.9/french/CategoriesFre.gf
Normal file
4
lib/resource-0.9/french/CategoriesFre.gf
Normal file
@@ -0,0 +1,4 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete CategoriesFre of Categories =
|
||||
CategoriesRomance with (SyntaxRomance=SyntaxFre) ;
|
||||
4
lib/resource-0.9/french/ClauseFre.gf
Normal file
4
lib/resource-0.9/french/ClauseFre.gf
Normal file
@@ -0,0 +1,4 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete ClauseFre of Clause = CategoriesFre **
|
||||
ClauseRomance with (SyntaxRomance=SyntaxFre) ;
|
||||
101
lib/resource-0.9/french/ConjugNancy.gf
Normal file
101
lib/resource-0.9/french/ConjugNancy.gf
Normal file
@@ -0,0 +1,101 @@
|
||||
resource ConjugNancy = open Prelude, TypesFre, MorphoFre in {
|
||||
|
||||
oper VerbeN = {s : VForm => Str} ;
|
||||
oper mkNV : Verbe -> VerbeN = \ve ->
|
||||
{s = ve} ;
|
||||
|
||||
oper conj : Str -> Verbe = conj1aimer ; --- temp. default
|
||||
|
||||
oper v_nancy100inf : Str -> VerbeN = \ve -> {s = table {
|
||||
Inf => ve ;
|
||||
_ => nonExist
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
oper v_nancy1 : Str -> VerbeN = \s -> mkNV (conjAvoir s) ;
|
||||
oper v_nancy2 : Str -> VerbeN = \s -> mkNV (conjÊtre s) ;
|
||||
-- 3-5 not used
|
||||
oper v_nancy6 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ;
|
||||
oper v_nancy7 : Str -> VerbeN = \s -> mkNV (conj1placer s) ;
|
||||
oper v_nancy8 : Str -> VerbeN = \s -> mkNV (conj1manger s) ;
|
||||
oper v_nancy9 : Str -> VerbeN = \s -> mkNV (conj1peser s) ;
|
||||
oper v_nancy10 : Str -> VerbeN = \s -> mkNV (conj1céder s) ;
|
||||
oper v_nancy11 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ;
|
||||
oper v_nancy12 : Str -> VerbeN = \s -> mkNV (conj1jeter s) ;
|
||||
oper v_nancy13 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ;
|
||||
oper v_nancy14 : Str -> VerbeN = \s -> mkNV (conj1assiéger s) ;
|
||||
oper v_nancy15 : Str -> VerbeN = \s -> mkNV (conj1aimer s) ; --- ?
|
||||
oper v_nancy16 : Str -> VerbeN = \s -> mkNV (conj1payer s) ;
|
||||
oper v_nancy17 : Str -> VerbeN = \s -> mkNV (conj1payer s) ;
|
||||
oper v_nancy18 : Str -> VerbeN = \s -> mkNV (conj1envoyer s) ;
|
||||
oper v_nancy19 : Str -> VerbeN = \s -> mkNV (conj2finir s) ;
|
||||
oper v_nancy20 : Str -> VerbeN = \s -> mkNV (conj2haïr s) ;
|
||||
-- oper v_nancy21 : Str -> VerbeN = \s -> mkNV (conj s) ; -- not used
|
||||
oper v_nancy22 : Str -> VerbeN = \s -> mkNV (conj3aller s) ;
|
||||
oper v_nancy23 : Str -> VerbeN = \s -> mkNV (conj3tenir s) ;
|
||||
oper v_nancy24 : Str -> VerbeN = \s -> mkNV (conj3quérir s) ;
|
||||
oper v_nancy25 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ;
|
||||
oper v_nancy26 : Str -> VerbeN = \s -> mkNV (conj3vêtir s) ;
|
||||
oper v_nancy27 : Str -> VerbeN = \s -> mkNV (conj3couvrir s) ;
|
||||
oper v_nancy28 : Str -> VerbeN = \s -> mkNV (conj3cueillir s) ;
|
||||
oper v_nancy29 : Str -> VerbeN = \s -> mkNV (conj3assaillir s) ;
|
||||
oper v_nancy30 : Str -> VerbeN = \s -> mkNV (conj3faillir s) ;
|
||||
oper v_nancy31 : Str -> VerbeN = \s -> mkNV (conj3bouillir s) ;
|
||||
oper v_nancy32 : Str -> VerbeN = \s -> mkNV (conj3dormir s) ;
|
||||
oper v_nancy33 : Str -> VerbeN = \s -> mkNV (conj3courir s) ;
|
||||
oper v_nancy34 : Str -> VerbeN = \s -> mkNV (conj3mourir s) ;
|
||||
oper v_nancy35 : Str -> VerbeN = \s -> mkNV (conj3sentir s) ;
|
||||
oper v_nancy36 : Str -> VerbeN = \s -> mkNV (conj3fuir s) ;
|
||||
oper v_nancy37 : Str -> VerbeN = \s -> mkNV (conj3ouïr s) ;
|
||||
oper v_nancy38 : Str -> VerbeN = \s -> mkNV (conj3cevoir s) ;
|
||||
oper v_nancy39 : Str -> VerbeN = \s -> mkNV (conj3voir s) ;
|
||||
oper v_nancy40 : Str -> VerbeN = \s -> mkNV (conj3pourvoir s) ;
|
||||
oper v_nancy41 : Str -> VerbeN = \s -> mkNV (conj3savoir s) ;
|
||||
oper v_nancy42 : Str -> VerbeN = \s -> mkNV (conj3devoir s) ;
|
||||
oper v_nancy43 : Str -> VerbeN = \s -> mkNV (conj3pouvoir s) ;
|
||||
oper v_nancy44 : Str -> VerbeN = \s -> mkNV (conj3mouvoir s) ;
|
||||
oper v_nancy45 : Str -> VerbeN = \s -> mkNV (conj3pleuvoir s) ;
|
||||
oper v_nancy46 : Str -> VerbeN = \s -> mkNV (conj3falloir s) ;
|
||||
oper v_nancy47 : Str -> VerbeN = \s -> mkNV (conj3valoir s) ;
|
||||
oper v_nancy48 : Str -> VerbeN = \s -> mkNV (conj3vouloir s) ;
|
||||
oper v_nancy49 : Str -> VerbeN = \s -> mkNV (conj3asseoir s) ;
|
||||
oper v_nancy50 : Str -> VerbeN = \s -> mkNV (conj3messeoir s) ; --- ?
|
||||
oper v_nancy51 : Str -> VerbeN = \s -> mkNV (conj3surseoir s) ;
|
||||
oper v_nancy52 : Str -> VerbeN = \s -> mkNV (conj3choir s) ;
|
||||
oper v_nancy53 : Str -> VerbeN = \s -> mkNV (conj3rendre s) ;
|
||||
oper v_nancy54 : Str -> VerbeN = \s -> mkNV (conj3prendre s) ;
|
||||
oper v_nancy55 : Str -> VerbeN = \s -> mkNV (conj3battre s) ;
|
||||
oper v_nancy56 : Str -> VerbeN = \s -> mkNV (conj3mettre s) ;
|
||||
oper v_nancy57 : Str -> VerbeN = \s -> mkNV (conj3peindre s) ;
|
||||
oper v_nancy58 : Str -> VerbeN = \s -> mkNV (conj3joindre s) ;
|
||||
oper v_nancy59 : Str -> VerbeN = \s -> mkNV (conj3craindre s) ;
|
||||
oper v_nancy60 : Str -> VerbeN = \s -> mkNV (conj3vaincre s) ;
|
||||
oper v_nancy61 : Str -> VerbeN = \s -> mkNV (conj3traire s) ;
|
||||
oper v_nancy62 : Str -> VerbeN = \s -> mkNV (conj3faire s) ;
|
||||
oper v_nancy63 : Str -> VerbeN = \s -> mkNV (conj3plaire s) ;
|
||||
oper v_nancy64 : Str -> VerbeN = \s -> mkNV (conj3connaître s) ;
|
||||
oper v_nancy65 : Str -> VerbeN = \s -> mkNV (conj3naître s) ;
|
||||
oper v_nancy66 : Str -> VerbeN = \s -> mkNV (conj3paître s) ;
|
||||
oper v_nancy67 : Str -> VerbeN = \s -> mkNV (conj3croître s) ;
|
||||
oper v_nancy68 : Str -> VerbeN = \s -> mkNV (conj3croire s) ;
|
||||
oper v_nancy69 : Str -> VerbeN = \s -> mkNV (conj3boire s) ;
|
||||
oper v_nancy70 : Str -> VerbeN = \s -> mkNV (conj3clore s) ;
|
||||
oper v_nancy71 : Str -> VerbeN = \s -> mkNV (conj3conclure s) ;
|
||||
oper v_nancy72 : Str -> VerbeN = \s -> mkNV (conj3absoudre s) ;
|
||||
oper v_nancy73 : Str -> VerbeN = \s -> mkNV (conj3coudre s) ;
|
||||
oper v_nancy74 : Str -> VerbeN = \s -> mkNV (conj3moudre s) ;
|
||||
oper v_nancy75 : Str -> VerbeN = \s -> mkNV (conj3suivre s) ;
|
||||
oper v_nancy76 : Str -> VerbeN = \s -> mkNV (conj3vivre s) ;
|
||||
oper v_nancy77 : Str -> VerbeN = \s -> mkNV (conj3lire s) ;
|
||||
oper v_nancy78 : Str -> VerbeN = \s -> mkNV (conj3dire s) ;
|
||||
oper v_nancy79 : Str -> VerbeN = \s -> mkNV (conj3rire s) ;
|
||||
oper v_nancy80 : Str -> VerbeN = \s -> mkNV (conj3écrire s) ;
|
||||
oper v_nancy81 : Str -> VerbeN = \s -> mkNV (conj3confire s) ;
|
||||
oper v_nancy82 : Str -> VerbeN = \s -> mkNV (conj3cuire s) ;
|
||||
|
||||
-- 83-99 not used
|
||||
|
||||
oper v_nancy100 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do
|
||||
oper v_nancy101 : Str -> VerbeN = \s -> mkNV (conj s) ; --- to do
|
||||
}
|
||||
27
lib/resource-0.9/french/CountryFre.gf
Normal file
27
lib/resource-0.9/french/CountryFre.gf
Normal file
@@ -0,0 +1,27 @@
|
||||
concrete CountryFre of Country = open CategoriesFre, ParadigmsFre in {
|
||||
|
||||
lincat
|
||||
Country = PN ;
|
||||
Nationality = A ;
|
||||
Language = N ;
|
||||
|
||||
lin
|
||||
Denmark = mkPN "Danemark" masculine ;
|
||||
England = mkPN "Angleterre" feminine ;
|
||||
Finland = mkPN "Finlande" feminine ;
|
||||
France = mkPN "France" feminine ;
|
||||
Germany = mkPN "Allemagne" feminine ;
|
||||
Italy = mkPN "Italie" feminine ;
|
||||
Norway = mkPN "Norvège" feminine ;
|
||||
Russia = mkPN "Russie" feminine ;
|
||||
Spain = mkPN "Espagne" feminine ;
|
||||
Sweden = mkPN "Suède" feminine ;
|
||||
|
||||
Danish = regA "danois" ;
|
||||
English = regA "anglais" ;
|
||||
|
||||
DanishLang = regN "danois" masculine ;
|
||||
EnglishLang = regN "anglais" masculine ;
|
||||
|
||||
|
||||
} ;
|
||||
9
lib/resource-0.9/french/DemResFre.gf
Normal file
9
lib/resource-0.9/french/DemResFre.gf
Normal file
@@ -0,0 +1,9 @@
|
||||
instance DemResFre of DemRes = open Prelude, ResourceFre, SyntaxFre in {
|
||||
|
||||
oper
|
||||
msS : S -> Str = \x -> x.s ! Ind ;
|
||||
msQS : QS -> Str = \x -> x.s ! DirQ ;
|
||||
msImp : Imp -> Str = \x -> x.s ! Masc ! Sg ;
|
||||
|
||||
|
||||
} ;
|
||||
7
lib/resource-0.9/french/DemonstrativeFre.gf
Normal file
7
lib/resource-0.9/french/DemonstrativeFre.gf
Normal file
@@ -0,0 +1,7 @@
|
||||
--# -path=.:../abstract:../romance:../../prelude
|
||||
|
||||
concrete DemonstrativeFre of Demonstrative =
|
||||
CategoriesFre ** DemonstrativeI with
|
||||
(Resource = ResourceFre),
|
||||
(Basic = BasicFre),
|
||||
(DemRes = DemResFre) ;
|
||||
23
lib/resource-0.9/french/LangFre.gf
Normal file
23
lib/resource-0.9/french/LangFre.gf
Normal file
@@ -0,0 +1,23 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete LangFre of Lang =
|
||||
RulesFre,
|
||||
ClauseFre,
|
||||
StructuralFre,
|
||||
BasicFre,
|
||||
TimeFre,
|
||||
CountryFre,
|
||||
MathFre
|
||||
|
||||
** open Prelude, ParadigmsFre in {
|
||||
|
||||
lin
|
||||
AdvDate d = prefixSS "le" d ;
|
||||
AdvTime t = prefixSS "à" t ;
|
||||
NWeekday w = w ;
|
||||
PNWeekday w = mkPN (w.s ! singular) w.g ;
|
||||
|
||||
PNCountry x = x ;
|
||||
ANationality x = x ;
|
||||
NLanguage x = x ;
|
||||
}
|
||||
4
lib/resource-0.9/french/MathFre.gf
Normal file
4
lib/resource-0.9/french/MathFre.gf
Normal file
@@ -0,0 +1,4 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete MathFre of Math = CategoriesFre **
|
||||
MathRomance with (SyntaxRomance=SyntaxFre) ;
|
||||
46
lib/resource-0.9/french/MkVerbs.hs
Normal file
46
lib/resource-0.9/french/MkVerbs.hs
Normal file
@@ -0,0 +1,46 @@
|
||||
main :: IO ()
|
||||
main = do
|
||||
|
||||
s <- readFile "verbs"
|
||||
mapM_ putRule $ combine $ map words $ lines s -- to create fun/lin
|
||||
-- mapM_ putConjug [1..100] -- to create oper
|
||||
|
||||
putRule = appendFile "verbs.gf" . mkRule
|
||||
|
||||
mkRule s = case s of
|
||||
n:v:cs ->
|
||||
"fun " ++ fv ++ cat ++ " : " ++ cat ++ " ;\n" ++
|
||||
"lin " ++ fv ++ cat ++
|
||||
" = v_nancy" ++ n ++ " \"" ++ v ++ "\"" ++ ext ++ " ;\n"
|
||||
where
|
||||
(cat,ext) = case cs of
|
||||
_ | elem "T" cs -> ("VN2", " ** {aux = AHabere ; c = Acc}")
|
||||
"a":au -> ("VN2", " ** {aux = " ++ aux au ++ " ; c = Dat}")
|
||||
"de":au -> ("VN2", " ** {aux = " ++ aux au ++ " ; c = Gen}")
|
||||
"P":_ -> ("VNR", "")
|
||||
au -> ("VN", " ** {aux = " ++ aux au ++ "}")
|
||||
|
||||
fv = map unhyph v
|
||||
|
||||
unhyph c = case c of
|
||||
'-' -> '_'
|
||||
_ -> c
|
||||
|
||||
aux au = case au of
|
||||
"etre":_ -> "AEsse"
|
||||
_ -> "AHabere"
|
||||
|
||||
combine ls = case ls of
|
||||
l@(n:v:_:c:_):vs ->
|
||||
let (vv,rest) = span ((==v) . (!!1)) vs in
|
||||
([n,v,c] ++ map (!!3) vs) : combine rest
|
||||
_ -> ls
|
||||
|
||||
|
||||
---
|
||||
|
||||
putConjug = appendFile "nancy_conjugs.gf" . mkConjug
|
||||
|
||||
mkConjug :: Integer -> String
|
||||
mkConjug i = "oper v_nancy" ++ show i ++
|
||||
" : Str -> V = \\s -> conj v ++ {lock_V = <>} ;\n"
|
||||
1359
lib/resource-0.9/french/MorphoFre.gf
Normal file
1359
lib/resource-0.9/french/MorphoFre.gf
Normal file
File diff suppressed because it is too large
Load Diff
8
lib/resource-0.9/french/MultimodalFre.gf
Normal file
8
lib/resource-0.9/french/MultimodalFre.gf
Normal file
@@ -0,0 +1,8 @@
|
||||
--# -path=.:../abstract:../romance:../../prelude
|
||||
|
||||
concrete MultimodalFre of Multimodal =
|
||||
RulesFre, StructuralFre, BasicFre, TimeFre, DemonstrativeFre ** MultimodalI with
|
||||
(Resource = ResourceFre),
|
||||
(Basic = BasicFre),
|
||||
(Lang = LangFre),
|
||||
(DemRes = DemResFre) ;
|
||||
81
lib/resource-0.9/french/NumeralsFre.gf
Normal file
81
lib/resource-0.9/french/NumeralsFre.gf
Normal file
@@ -0,0 +1,81 @@
|
||||
concrete NumeralsFre of Numerals = open TypesFre, MorphoFre in {
|
||||
|
||||
lincat Numeral = {s : Gender => Str ; n : Number} ;
|
||||
lincat Digit = {inh : DForm ; inh1 : Number ; s : Gender => DForm => Str ; n : Number} ;
|
||||
lincat Sub10 = {inh : Number ; s : Gender => {p1 : DForm ; p2 : Place} => Str ; n : Number} ;
|
||||
lincat Sub100 = {s : Gender => Place => Str ; n : Number} ;
|
||||
lincat Sub1000 = {s : Gender => Place => Str ; n : Number} ;
|
||||
lincat Sub1000000 = {s : Gender => Str ; n : Number} ;
|
||||
|
||||
lin num x0 = x0 ;
|
||||
|
||||
lin n2 =
|
||||
digitPl {inh = unit ; inh1 = Sg ; s = table {unit => "deux" ; teen => "douze" ; jten => "vingt" ; ten => "vingt" ; tenplus => "vingt"}} ;
|
||||
lin n3 =
|
||||
digitPl {inh = unit ; inh1 = Sg ; s = table {unit => "trois" ; teen => "treize" ; jten => "trente" ; ten => "trente" ; tenplus => "trente"}} ;
|
||||
lin n4 =
|
||||
digitPl {inh = unit ; inh1 = Sg ; s = table {unit => "quatre" ; teen => "quatorze" ; jten => "quarante" ; ten => "quarante" ; tenplus => "quarante"}} ;
|
||||
lin n5 =
|
||||
digitPl {inh = unit ; inh1 = Sg ; s = table {unit => "cinq" ; teen => "quinze" ; jten => "cinquante" ; ten => "cinquante" ; tenplus => "cinquante"}} ;
|
||||
lin n6 =
|
||||
digitPl {inh = unit ; inh1 = Sg ; s = table {unit => "six" ; teen => "seize" ; jten => "soixante" ; ten => "soixante" ; tenplus => "soixante"}} ;
|
||||
lin n7 =
|
||||
digitPl {inh = teen ; inh1 = Sg ; s = table {unit => "sept" ; teen => "dix" ++ "-" ++ "sept" ; jten => "soixante" ++ "-" ++ "dix" ; ten => "soixante" ++ "-" ++ "dix" ; tenplus => "soixante"}} ;
|
||||
lin n8 =
|
||||
digitPl {inh = unit ; inh1 = Pl ; s = table {unit => "huit" ; teen => "dix" ++ "-" ++ "huit" ; jten => "quatre" ++ "-" ++ "vingts" ; ten => "quatre" ++ "-" ++ "vingt" ; tenplus => "quatre" ++ "-" ++ "vingt"}} ;
|
||||
lin n9 =
|
||||
digitPl {inh = teen ; inh1 = Pl ; s = table {unit => "neuf" ; teen => "dix" ++ "-" ++ "neuf" ; jten => "quatre" ++ "-" ++ "vingt" ++ "-" ++ "dix" ; ten => "quatre" ++ "-" ++ "vingt" ++ "-" ++ "dix" ; tenplus => "quatre" ++ "-" ++ "vingt"}} ;
|
||||
lin pot01 =
|
||||
{inh = Sg ; s = \\g => table {{p1 = unit ; p2 = indep} => case g of {Masc =>
|
||||
"un" ; Fem => "une"} ; {p1 = unit ; p2 = attr} => [] ; {p1 = teen ;
|
||||
p2 = indep} => "onze" ; {p1 = teen ; p2 = attr} => [] ; {p1 = jten ;
|
||||
p2 = indep} => "dix" ; {p1 = jten ; p2 = attr} => [] ; {p1 = ten ;
|
||||
p2 = indep} => "dix" ; {p1 = ten ; p2 = attr} => [] ; {p1 = tenplus
|
||||
; p2 = indep} => "dix" ; {p1 = tenplus ; p2 = attr} => []} ; n = Sg} ;
|
||||
lin pot0 d =
|
||||
{inh = Pl ; s = \\g => table {{p1 = unit ; p2 = indep} => d.s ! g ! unit
|
||||
; {p1 = unit ; p2 = attr} => d.s ! g ! unit ; {p1 = teen ; p2 = indep}
|
||||
=> d.s ! g ! teen ; {p1 = teen ; p2 = attr} => d.s ! g ! teen ; {p1 = jten ;
|
||||
p2 = indep} => d.s ! g ! jten ; {p1 = jten ; p2 = attr} => d.s ! g ! jten ;
|
||||
{p1 = ten ; p2 = indep} => d.s ! g ! ten ; {p1 = ten ; p2 = attr} => d.s
|
||||
! g ! ten ; {p1 = tenplus ; p2 = indep} => d.s ! g ! tenplus ; {p1 = tenplus
|
||||
; p2 = attr} => d.s ! g ! tenplus} ; n = Pl} ;
|
||||
lin pot110 =
|
||||
{s = \\_ => table {indep => "dix" ; attr => "dix"} ; n = Pl} ;
|
||||
lin pot111 =
|
||||
{s = \\_ => table {indep => "onze" ; attr => "onze"} ; n = Pl} ;
|
||||
lin pot1to19 d =
|
||||
{s = \\g => table {indep => d.s ! g ! teen ; attr => d.s ! g ! teen} ; n = Pl} ;
|
||||
lin pot0as1 n =
|
||||
{s = \\g => table {indep => n.s ! g ! {p1 = unit ; p2 = indep} ;
|
||||
attr => n.s ! g ! {p1 = unit ; p2 = attr}} ; n = n.n} ;
|
||||
lin pot1 d =
|
||||
{s = \\g => table {indep => d.s ! g ! jten ; attr => d.s ! g ! ten}
|
||||
; n = Pl} ;
|
||||
lin pot1plus d e =
|
||||
{s = \\g => table {indep => (d.s ! g ! tenplus) ++ (table {{p1 = Sg
|
||||
; p2 = Sg} => "et" ; {p1 = Sg ; p2 = pl} => "-" ; {p1 = Pl ; p2 =
|
||||
Sg} => "-" ; {p1 = Pl ; p2 = pl} => "-"} ! {p1 = d.inh1 ; p2 =
|
||||
e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 = indep} ; attr => (d.s ! g !
|
||||
tenplus) ++ (table {{p1 = Sg ; p2 = Sg} => "et" ; {p1 = Sg ; p2 =
|
||||
pl} => "-" ; {p1 = Pl ; p2 = Sg} => "-" ; {p1 = Pl ; p2 = pl} =>
|
||||
"-"} ! {p1 = d.inh1 ; p2 = e.inh}) ++ e.s ! g ! {p1 = d.inh ; p2 =
|
||||
indep}} ; n = Pl} ;
|
||||
lin pot1as2 n = n ;
|
||||
---- {s = \\g,d => n.s ! indep ; attr => n.s ! attr}} ;
|
||||
lin pot2 d =
|
||||
{s = \\g => table {indep => (d.s ! Masc ! {p1 = unit ; p2 = attr})
|
||||
++ table {Sg => "cent" ; Pl => "cents"} ! (d.inh) ; attr => (d.s !
|
||||
Masc ! {p1 = unit ; p2 = attr}) ++ "cent"} ; n = Pl} ;
|
||||
lin pot2plus d e =
|
||||
{s = \\g => table {indep => (d.s ! Masc ! {p1 = unit ; p2 = attr})
|
||||
++ "cent" ++ e.s ! g ! indep ; attr => (d.s ! Masc ! {p1 = unit ; p2
|
||||
= attr}) ++ "cent" ++ e.s ! g ! indep} ; n = Pl} ;
|
||||
lin pot2as3 n =
|
||||
{s = \\g => n.s ! g ! indep ; n = n.n} ;
|
||||
lin pot3 n =
|
||||
{s = \\_ => (n.s ! Masc ! attr) ++ "mille" ; n = Pl} ;
|
||||
lin pot3plus n m =
|
||||
{s = \\g => (n.s ! Masc ! attr) ++ "mille" ++ m.s ! g ! indep ; n =
|
||||
Pl} ;
|
||||
}
|
||||
6543
lib/resource-0.9/french/OldVerbesFre.gf
Normal file
6543
lib/resource-0.9/french/OldVerbesFre.gf
Normal file
File diff suppressed because it is too large
Load Diff
346
lib/resource-0.9/french/ParadigmsFre.gf
Normal file
346
lib/resource-0.9/french/ParadigmsFre.gf
Normal file
@@ -0,0 +1,346 @@
|
||||
--# -path=.:../romance:../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.
|
||||
--
|
||||
-- The following modules are presupposed:
|
||||
|
||||
resource ParadigmsFre =
|
||||
open (Predef=Predef), Prelude, TypesFre, MorphoFre, SyntaxFre, RulesFre in {
|
||||
|
||||
--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 -> ADeg ;
|
||||
|
||||
-- If comparison is formed by "plus", as usual in French,
|
||||
-- the following pattern is used:
|
||||
|
||||
compADeg : A -> ADeg ;
|
||||
|
||||
-- The regular pattern is the same as $regA$ for plain adjectives,
|
||||
-- with comparison by "plus".
|
||||
|
||||
regADeg : Str -> ADeg ;
|
||||
|
||||
-- From a given $ADeg$, it is possible to get back to $A$.
|
||||
|
||||
adegA : ADeg -> A ;
|
||||
|
||||
-- For prefixed adjectives, the following function is
|
||||
-- provided.
|
||||
|
||||
prefADeg : ADeg -> ADeg ;
|
||||
|
||||
--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 ;
|
||||
|
||||
|
||||
--2 Definitions of the paradigms
|
||||
--
|
||||
-- The definitions should not bother the user of the API. So they are
|
||||
-- hidden from the document.
|
||||
--.
|
||||
|
||||
Gender = SyntaxFre.Gender ;
|
||||
Number = TypesFre.Number ;
|
||||
masculine = Masc ;
|
||||
feminine = Fem ;
|
||||
singular = Sg ;
|
||||
plural = Pl ;
|
||||
|
||||
Preposition = Case * Str ;
|
||||
accusative = <Acc,[]> ;
|
||||
genitive = <Gen,[]> ;
|
||||
dative = <Dat,[]> ;
|
||||
mkPreposition p = <Acc,p> ;
|
||||
|
||||
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 = <> ; c = p.p1 ; s2 = p.p2} ;
|
||||
deN2 n = mkN2 n genitive ;
|
||||
aN2 n = mkN2 n dative ;
|
||||
mkN3 = \n,p,q -> n ** {lock_N3 = <> ; c = p.p1 ; s2 = p.p2 ; c3 = q.p1 ; s3 = q.p2} ;
|
||||
|
||||
mkPN x g = {s = x ; g = g} ** {lock_PN = <>} ;
|
||||
mkNP x g n = let np = mkNameNounPhrase x g in
|
||||
{s = np.s ; g = np.g ; p = np.p ; c = np.c ; n = n ; lock_NP = <>} ;
|
||||
|
||||
mkA a b c d = mkAdj a c b d ** {p = False ; lock_A = <>} ;
|
||||
regA a = mkAdjReg a ** {p = False ; lock_A = <>} ;
|
||||
prefA a = {s = a.s ; p = True ; lock_A = <>} ;
|
||||
|
||||
mkA2 a p = a ** {c = p.p1 ; s2 = p.p2 ; lock_A2 = <>} ;
|
||||
|
||||
mkADeg a b = {s = table {Pos => a.s ; _ => b.s} ; p = a.p ; lock_ADeg = <>} ;
|
||||
compADeg a = {s = table {Pos => a.s ; _ => \\f => "plus" ++ a.s ! f} ; p = a.p ;
|
||||
lock_ADeg = <>} ;
|
||||
regADeg a = compADeg (regA a) ;
|
||||
prefADeg a = {s = a.s ; p = True ; lock_ADeg = <>} ;
|
||||
|
||||
adegA a = {s = a.s ! Pos ; p = a.p ; lock_A = <>} ;
|
||||
|
||||
mkAdv x = ss x ** {lock_Adv = <>} ;
|
||||
mkAdV x = ss x ** {lock_AdV = <>} ;
|
||||
mkAdA x = ss x ** {lock_AdA = <>} ;
|
||||
|
||||
regV x = let v = (mkVerbReg x) in verbPres v AHabere ** {aux = AHabere ; lock_V = <>} ;
|
||||
reg3V x y z = let v = (mkVerb3Reg x y z) in verbPres v AHabere ** {aux = AHabere ; lock_V = <>} ;
|
||||
etreV v = {s = v.s ; aux = AEsse ; lock_V = <>} ;
|
||||
|
||||
mkV2 v p = {s = v.s ; aux = v.aux ; s2 = p.p2 ; c = p.p1 ; lock_V2 = <>} ;
|
||||
dirV2 v = mkV2 v accusative ;
|
||||
v2V v = v ** {lock_V = <>} ;
|
||||
|
||||
mkV3 v p q = {s = v.s ; aux = v.aux ;
|
||||
s2 = p.p2 ; s3 = q.p2 ; c = p.p1 ; c3 = q.p1 ; lock_V3 = <>} ;
|
||||
dirV3 v p = mkV3 v accusative p ;
|
||||
dirdirV3 v = dirV3 v dative ;
|
||||
|
||||
mkV0 v = v ** {lock_V0 = <>} ;
|
||||
mkVS v = v ** {mn,mp = Ind ; lock_VS = <>} ; ---- more moods
|
||||
mkV2S v p = mkV2 v p ** {mn,mp = Ind ; lock_V2S = <>} ;
|
||||
mkVV v = v ** {c = accusative.p1 ; lock_VV = <>} ;
|
||||
deVV v = v ** {c = genitive.p1 ; lock_VV = <>} ;
|
||||
aVV v = v ** {c = dative.p1 ; 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 ** {mn,mp = Ind ; lock_AS = <>} ; ---- more moods
|
||||
mkA2S v p = mkA2 v p ** {mn,mp = Ind ; 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 = <>} ;
|
||||
|
||||
} ;
|
||||
38
lib/resource-0.9/french/README
Normal file
38
lib/resource-0.9/french/README
Normal file
@@ -0,0 +1,38 @@
|
||||
The French resource API implementation, based on romance.
|
||||
|
||||
The Verbes* modules were translated from an XML resource created
|
||||
by Sylvain Pogodalla.
|
||||
|
||||
WARNING: The subcategorization information is not very reliable
|
||||
(the extraction method is the main thing to blame).
|
||||
|
||||
The biggest test grammar is TestVerbesFre.
|
||||
|
||||
We recommend using GF with extra stack and heap:
|
||||
|
||||
gf +RTS -K10M -H200M
|
||||
|
||||
We recommend reading grammars from source and not emitting gfc code,
|
||||
since, the size of gfc files becomes enormous. Thus:
|
||||
|
||||
i -noemit -src -cflexer TestVerbesFre.gf
|
||||
|
||||
So it seems we'll have to work on effectivizing GF!
|
||||
|
||||
Useful tests:
|
||||
|
||||
l -table choirVN -- create infl table
|
||||
|
||||
ma "cours cherra" -- analyse a couple of forms
|
||||
|
||||
gr -cat=Cl | l -table -- generate random sentence
|
||||
|
||||
gr PredVG HeNP (PredV2 (UseVN2 ?) SheNP) | l -table -- idem, of form "il la X"
|
||||
|
||||
rf labible.txt | ma | wf labible.tagged -- tag the bible (first get it!)
|
||||
|
||||
mq -cat=VN2 -- run a morphology quiz
|
||||
|
||||
Aarne Ranta 30/11/2004
|
||||
|
||||
|
||||
5
lib/resource-0.9/french/ResourceFre.gf
Normal file
5
lib/resource-0.9/french/ResourceFre.gf
Normal file
@@ -0,0 +1,5 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete ResourceFre of Resource = RulesFre, ClauseFre, StructuralFre ** {} ;
|
||||
|
||||
|
||||
4
lib/resource-0.9/french/RulesFre.gf
Normal file
4
lib/resource-0.9/french/RulesFre.gf
Normal file
@@ -0,0 +1,4 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete RulesFre of Rules = CategoriesFre **
|
||||
RulesRomance with (SyntaxRomance=SyntaxFre) ;
|
||||
8
lib/resource-0.9/french/SimpleFre.gf
Normal file
8
lib/resource-0.9/french/SimpleFre.gf
Normal file
@@ -0,0 +1,8 @@
|
||||
--# -path=.:../romancs:../abstract:../../prelude
|
||||
|
||||
concrete SimpleFre of Simple = CategoriesFre ** SimpleI with
|
||||
(Categories = CategoriesFre),
|
||||
(Rules = RulesFre),
|
||||
(Structural = StructuralFre),
|
||||
(Verbphrase = VerbphraseFre)
|
||||
;
|
||||
21
lib/resource-0.9/french/SimpleLangFre.gf
Normal file
21
lib/resource-0.9/french/SimpleLangFre.gf
Normal file
@@ -0,0 +1,21 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete SimpleLangFre of SimpleLang =
|
||||
SimpleFre,
|
||||
StructuralFre,
|
||||
BasicFre,
|
||||
TimeFre,
|
||||
CountryFre
|
||||
|
||||
** open Prelude, ParadigmsFre in {
|
||||
|
||||
lin
|
||||
AdvDate d = prefixSS "le" d ;
|
||||
AdvTime t = prefixSS "à" t ;
|
||||
NWeekday w = w ;
|
||||
PNWeekday w = mkPN (w.s ! singular) w.g ;
|
||||
|
||||
PNCountry x = x ;
|
||||
ANationality x = x ;
|
||||
NLanguage x = x ;
|
||||
}
|
||||
95
lib/resource-0.9/french/StructuralFre.gf
Normal file
95
lib/resource-0.9/french/StructuralFre.gf
Normal file
@@ -0,0 +1,95 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
|
||||
concrete StructuralFre of Structural =
|
||||
CategoriesFre, NumeralsFre **
|
||||
open SyntaxFre, MorphoFre, Prelude in {
|
||||
|
||||
lin
|
||||
|
||||
UseNumeral n = {s = \\g => n.s !g ; n = n.n ; isNo = False} ;
|
||||
|
||||
above_Prep = {s = ["au dessus"] ; c = genitive} ;
|
||||
after_Prep = justPrep "après" ;
|
||||
all8mass_Det = toutDet ;
|
||||
all_NDet = mkDeterminerNum ["tous les"] ["toutes les"] ;
|
||||
almost_Adv = ss "presque" ;
|
||||
although_Subj = ss ("bien" ++ elisQue) ** {m = Con} ;
|
||||
and_Conj = etConj ;
|
||||
because_Subj = ss ("parce" ++ elisQue) ** {m = Ind} ;
|
||||
before_Prep = justPrep "avant" ;
|
||||
behind_Prep = justPrep "derrière" ;
|
||||
between_Prep = justPrep "entre" ;
|
||||
both_AndConjD = etetConj ;
|
||||
by8agent_Prep = justPrep "par" ;
|
||||
by8means_Prep = justPrep "par" ;
|
||||
can8know_VV = mkVerbVerbDir (verbPres (conj3savoir "savoir") AHabere) ;
|
||||
can_VV = mkVerbVerbDir (verbPres (conj3pouvoir "pouvoir") AHabere) ;
|
||||
during_Prep = justPrep "pendant" ;
|
||||
either8or_ConjD = ououConj ;
|
||||
everybody_NP = mkNameNounPhrase ["tout le monde"] Masc ;
|
||||
every_Det = chaqueDet ;
|
||||
everything_NP = mkNameNounPhrase ["tout"] Masc ;
|
||||
everywhere_Adv = ss "partout" ;
|
||||
from_Prep = justCase genitive ; ---
|
||||
he_NP = pronNounPhrase pronIl ;
|
||||
how_IAdv = commentAdv ;
|
||||
how8many_IDet = {s = \\_ => "combien" ++ elisDe ; n = Pl} ;
|
||||
if_Subj = siSubj ;
|
||||
in8front_Prep = justPrep "devant" ;
|
||||
i_NP = pronNounPhrase pronJe ;
|
||||
in_Prep = justPrep "dans" ;
|
||||
it_NP = pronNounPhrase pronIl ;
|
||||
many_Det = mkDeterminer1 plural "plusieurs" ;
|
||||
most8many_Det = plupartDet ;
|
||||
most_Det = mkDeterminer1 singular (["la plupart"] ++ elisDe) ; --- de
|
||||
much_Det = mkDeterminer1 singular ("beaucoup" ++ elisDe) ; --- de
|
||||
must_VV = mkVerbVerbDir (verbPres (conj3devoir "devoir") AHabere) ;
|
||||
no_Phr = nonPhr ; --- and also Si!
|
||||
on_Prep = justPrep "sur" ;
|
||||
or_Conj = ouConj ;
|
||||
otherwise_Adv = ss "autrement" ;
|
||||
part_Prep = justCase genitive ; ---
|
||||
possess_Prep = justCase genitive ;
|
||||
quite_Adv = ss "assez" ;
|
||||
she_NP = pronNounPhrase pronElle ;
|
||||
so_Adv = ss "si" ;
|
||||
somebody_NP = mkNameNounPhrase ["quelqu'un"] Masc ;
|
||||
some_Det = mkDeterminer1 singular "quelque" ;
|
||||
some_NDet = mkDeterminerNum "quelques" "quelques" ;
|
||||
something_NP = mkNameNounPhrase ["quelque chose"] Masc ;
|
||||
somewhere_Adv = ss ["quelque part"] ; --- ne - pas
|
||||
that_Det = mkDeterminer singular (pre {"ce" ; "cet" / voyelle}) "cette" ; --- là
|
||||
that_NP = mkNameNounPhrase ["ça"] Masc ;
|
||||
therefore_Adv = ss "donc" ;
|
||||
these_NDet = mkDeterminerNum "ces" "ces" ; --- ci
|
||||
they_NP = pronNounPhrase pronIls ;
|
||||
they8fem_NP = pronNounPhrase pronElles ;
|
||||
this_Det = mkDeterminer singular (pre {"ce" ; "cet" / voyelle}) "cette" ; --- ci
|
||||
this_NP = mkNameNounPhrase ["ceci"] Masc ;
|
||||
those_NDet = mkDeterminerNum "ces" "ces" ; --- là
|
||||
thou_NP = pronNounPhrase pronTu ;
|
||||
through_Prep = justPrep "par" ;
|
||||
too_Adv = ss "trop" ;
|
||||
to_Prep = justCase dative ; ---
|
||||
under_Prep = justPrep "sous" ;
|
||||
very_Adv = ss "très" ;
|
||||
want_VV = mkVerbVerbDir (verbPres (conj3vouloir "vouloir") AHabere) ;
|
||||
we_NP = pronNounPhrase pronNous ;
|
||||
what8one_IP = intPronWhat singular ;
|
||||
what8many_IP = intPronWhat plural ;
|
||||
when_IAdv = quandAdv ;
|
||||
when_Subj = quandSubj ;
|
||||
where_IAdv = ouAdv ;
|
||||
which8many_IDet = mkDeterminerNum "quels" "quelles" ** {n = Pl} ;
|
||||
which8one_IDet = quelDet ;
|
||||
who8one_IP = intPronWho singular ;
|
||||
who8many_IP = intPronWho plural ;
|
||||
why_IAdv = pourquoiAdv ;
|
||||
without_Prep = justPrep "sans" ;
|
||||
with_Prep = justPrep "avec" ;
|
||||
ye_NP = pronNounPhrase pronVous ;
|
||||
yes_Phr = ouiPhr ;
|
||||
you_NP = pronNounPhrase pronVous ;
|
||||
|
||||
|
||||
}
|
||||
246
lib/resource-0.9/french/SwadeshLexFre.gf
Normal file
246
lib/resource-0.9/french/SwadeshLexFre.gf
Normal file
@@ -0,0 +1,246 @@
|
||||
--# -path=.:../abstract:../../prelude:../romance
|
||||
|
||||
concrete SwadeshLexFre of SwadeshLex = CategoriesFre
|
||||
** open StructuralFre, RulesFre, SyntaxFre, ParadigmsFre, VerbsFre,
|
||||
BasicFre, Prelude in {
|
||||
|
||||
lin
|
||||
|
||||
-- Pronouns
|
||||
|
||||
i_NP = i_NP ;
|
||||
thou_NP = thou_NP ;
|
||||
he_NP = he_NP ;
|
||||
we_NP = we_NP ;
|
||||
you_NP = you_NP ;
|
||||
they_NP = they_NP ;
|
||||
who8many_IP = who8many_IP ;
|
||||
who8one_IP = who8one_IP ;
|
||||
what8many_IP = what8many_IP ;
|
||||
what8one_IP = what8one_IP ;
|
||||
|
||||
-- Determiners
|
||||
|
||||
this_Det = this_Det ;
|
||||
that_Det = that_Det ;
|
||||
all_NDet = all_NDet ;
|
||||
many_Det = many_Det ;
|
||||
some_Det = some_Det ;
|
||||
few_Det = mkDeterminer1 Pl ("peu" ++ elisDe) ;
|
||||
other_Det = mkDeterminer1 Pl ["d'autres"] ;
|
||||
|
||||
|
||||
-- Adverbs
|
||||
|
||||
here_Adv = here_Adv;
|
||||
there_Adv = there_Adv;
|
||||
where_IAdv = where_IAdv;
|
||||
when_IAdv = when_IAdv;
|
||||
how_IAdv = how_IAdv;
|
||||
|
||||
-- not : Adv ; -- ?
|
||||
|
||||
-- Conjunctions
|
||||
|
||||
and_Conj = and_Conj ;
|
||||
|
||||
-- Prepositions
|
||||
|
||||
at_Prep = justCase dative.p1 ;
|
||||
in_Prep = StructuralFre.in_Prep ;
|
||||
with_Prep = StructuralFre.with_Prep ;
|
||||
|
||||
-- Numerals
|
||||
|
||||
one_Num = UseNumeral (num (pot2as3 (pot1as2 (pot0as1 pot01)))) ;
|
||||
two_Num = UseNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n2))))) ;
|
||||
three_Num = UseNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n3))))) ;
|
||||
four_Num = UseNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n4))))) ;
|
||||
five_Num = UseNumeral (num (pot2as3 (pot1as2 (pot0as1 (pot0 n5))))) ;
|
||||
|
||||
-- Adjectives
|
||||
|
||||
bad_ADeg = bad_ADeg ;
|
||||
big_ADeg = big_ADeg ;
|
||||
black_ADeg = black_ADeg ;
|
||||
cold_ADeg = cold_ADeg ;
|
||||
correct_ADeg = regADeg "correct" ;
|
||||
dirty_ADeg = dirty_ADeg ;
|
||||
dry_ADeg = compADeg (mkA "sec" "sèche" "secs" "sèches") ;
|
||||
dull_ADeg = regADeg "émoussé" ;
|
||||
far_ADeg = regADeg "lointain" ;
|
||||
full_ADeg = regADeg "plein" ;
|
||||
good_ADeg = good_ADeg ;
|
||||
green_ADeg = green_ADeg ;
|
||||
heavy_ADeg = regADeg "lourd" ;
|
||||
long_ADeg = long_ADeg ;
|
||||
narrow_ADeg = narrow_ADeg ;
|
||||
near_ADeg = regADeg "proche" ;
|
||||
new_ADeg = new_ADeg ;
|
||||
old_ADeg = old_ADeg ;
|
||||
red_ADeg = red_ADeg ;
|
||||
rotten_ADeg = regADeg "pourri" ;
|
||||
round_ADeg = regADeg "rond" ;
|
||||
sharp_ADeg = regADeg "tranchant" ;
|
||||
short_ADeg = short_ADeg ;
|
||||
small_ADeg = small_ADeg ;
|
||||
smooth_ADeg = regADeg "lisse" ;
|
||||
straight_ADeg = regADeg "droite" ;
|
||||
thick_ADeg = thick_ADeg ;
|
||||
thin_ADeg = thin_ADeg ;
|
||||
warm_ADeg = warm_ADeg ;
|
||||
wet_ADeg = regADeg "mouillé" ;
|
||||
white_ADeg = white_ADeg ;
|
||||
wide_ADeg = regADeg "large" ;
|
||||
yellow_ADeg = yellow_ADeg ;
|
||||
|
||||
left_A = regA "gauche" ;
|
||||
right_A = regA "droite" ;
|
||||
|
||||
-- Nouns
|
||||
|
||||
animal_N = regN "animal" masculine ;
|
||||
ashes_N = regN "cendre" masculine ;
|
||||
back_N = regN "dos" masculine ;
|
||||
bark_N = regN "écorce" feminine ;
|
||||
belly_N = regN "ventre" masculine ;
|
||||
bird_N = bird_N;
|
||||
blood_N = regN "sang" masculine ;
|
||||
bone_N = regN "os" masculine ;
|
||||
breast_N = regN "sein" masculine ; --- poitrine
|
||||
child_N = child_N ;
|
||||
cloud_N = regN "nuage" masculine ;
|
||||
day_N = regN "jour" masculine ;
|
||||
dog_N = dog_N ;
|
||||
dust_N = regN "poussière" feminine ;
|
||||
ear_N = regN "oreille" feminine ;
|
||||
earth_N = regN "terre" feminine ;
|
||||
egg_N = regN "oeuf" masculine ;
|
||||
eye_N = mkN "oeil" "yeux" masculine ;
|
||||
fat_N = regN "graisse" feminine ;
|
||||
father_N = UseN2 father_N2 ;
|
||||
feather_N = regN "plume" feminine ;
|
||||
fingernail_N = regN "ongle" masculine ;
|
||||
fire_N = regN "feu" masculine ;
|
||||
fish_N = fish_N ;
|
||||
flower_N = regN "fleur" feminine ;
|
||||
fog_N = regN "brouillard" masculine ;
|
||||
foot_N = regN "pied" masculine ;
|
||||
forest_N = regN "forêt" feminine ;
|
||||
fruit_N = fruit_N ;
|
||||
grass_N = regN "herbe" feminine ;
|
||||
guts_N = regN "entraille" feminine ;
|
||||
hair_N = regN "cheveu" masculine ;
|
||||
hand_N = regN "main" feminine ;
|
||||
head_N = regN "tête" feminine ;
|
||||
heart_N = regN "coeur" masculine ;
|
||||
horn_N = regN "corne" masculine ;
|
||||
husband_N = regN "mari" masculine ;
|
||||
ice_N = regN "glace" feminine ;
|
||||
knee_N = regN "genou" masculine ;
|
||||
lake_N = lake_N ;
|
||||
leaf_N = regN "feuille" feminine ;
|
||||
leg_N = regN "jambe" feminine ;
|
||||
liver_N = regN "foie" masculine ;
|
||||
louse_N = regN "pou" masculine ;
|
||||
man_N = man_N ;
|
||||
meat_N = meat_N ;
|
||||
moon_N = moon_N ;
|
||||
mother_N = UseN2 mother_N2 ;
|
||||
mountain_N = mountain_N ;
|
||||
mouth_N = regN "bouche" feminine ;
|
||||
name_N = regN "nom" masculine ;
|
||||
neck_N = mkN "cou" "cous" masculine ;
|
||||
night_N = regN "nuit" feminine ;
|
||||
nose_N = regN "nez" masculine ;
|
||||
person_N = regN "personne" feminine ;
|
||||
rain_N = regN "pluie" feminine ;
|
||||
river_N = river_N ;
|
||||
road_N = regN "route" feminine ;
|
||||
root_N = regN "racine" feminine ;
|
||||
rope_N = regN "corde" feminine ;
|
||||
salt_N = regN "sel" masculine ;
|
||||
sand_N = regN "sable" masculine ;
|
||||
sea_N = sea_N ;
|
||||
seed_N = regN "graine" feminine ;
|
||||
skin_N = regN "peau" masculine ;
|
||||
sky_N = mkN "ciel" "cieux" masculine ;
|
||||
smoke_N = regN "fumée" feminine ;
|
||||
snake_N = snake_N ;
|
||||
snow_N = regN "neige" feminine ;
|
||||
star_N = star_N ;
|
||||
stick_N = regN "bâton" masculine ;
|
||||
stone_N = stone_N ;
|
||||
sun_N = sun_N ;
|
||||
tail_N = regN "queue" feminine ;
|
||||
tongue_N = regN "langue" feminine ;
|
||||
tooth_N = regN "dent" feminine ;
|
||||
tree_N = tree_N ;
|
||||
water_N = water_N ;
|
||||
wife_N = regN "femme" feminine ;
|
||||
wind_N = regN "vent" masculine ;
|
||||
wing_N = regN "aile" feminine ;
|
||||
woman_N = woman_N ;
|
||||
worm_N = regN "ver" masculine ;
|
||||
year_N = regN "an" masculine ; --- année
|
||||
|
||||
-- Verbs
|
||||
|
||||
bite_V = UseV2 mordre_V2 ;
|
||||
blow_V = regV "souffler" ;
|
||||
breathe_V = regV "respirer" ;
|
||||
burn_V = regV "brûler" ;
|
||||
come_V = venir_V ;
|
||||
count_V = regV "conter" ;
|
||||
cut_V = regV "tailler" ;
|
||||
die_V = mourir_V ;
|
||||
dig_V = regV "creuser" ;
|
||||
drink_V = UseV2 boire_V2 ;
|
||||
eat_V = regV "manger" ;
|
||||
fall_V = regV "tomber" ;
|
||||
fear_V = UseV2 craindre_V2 ;
|
||||
fight_V = regV "lutter" ;
|
||||
float_V = regV "flotter" ;
|
||||
flow_V = regV "couler" ;
|
||||
fly_V = regV "voler" ;
|
||||
freeze_V = reg3V "geler" "gèle" "gèlera" ;
|
||||
give_V = regV "donner" ;
|
||||
hear_V = UseV2 entendre_V2 ;
|
||||
hit_V = regV "frapper" ;
|
||||
hold_V = UseV2 tenir_V2 ;
|
||||
hunt_V = regV "chasser" ;
|
||||
kill_V = regV "tuer" ;
|
||||
know_V = UseV2 savoir_V2 ; --- connaître
|
||||
laugh_V = UseV2 rire_V2 ;
|
||||
lie_V = UseV2 étendre_V2 ; ---- reflexive
|
||||
live_V = UseV2 vivre_V2 ;
|
||||
play_V = regV "jouer" ;
|
||||
pull_V = regV "tirer" ;
|
||||
push_V = regV "pousser" ;
|
||||
rub_V = regV "frotter" ;
|
||||
say_V = UseV2 dire_V2 ;
|
||||
scratch_V = regV "gratter" ;
|
||||
see_V = UseV2 voir_V2 ;
|
||||
sew_V = UseV2 coudre_V2 ;
|
||||
sing_V = regV "chanter" ;
|
||||
sit_V = UseV2 asseoir_V2 ; --- refl
|
||||
sleep_V = UseV2 dormir_V2 ;
|
||||
smell_V = UseV2 sentir_V2 ;
|
||||
spit_V = regV "cracher" ;
|
||||
split_V = UseV2 fendre_V2 ;
|
||||
squeeze_V = regV "serrer" ;
|
||||
stab_V = regV "poignarder" ;
|
||||
stand_V = reg3V "lever" "lève" "lèvera" ; ---- refl ----
|
||||
suck_V = regV "sucer" ;
|
||||
swell_V = regV "gonfler" ;
|
||||
swim_V = regV "nager" ;
|
||||
think_V = regV "penser" ;
|
||||
throw_V = regV "jeter" ;
|
||||
tie_V = regV "lier" ;
|
||||
turn_V = regV "tourner" ;
|
||||
vomit_V = regV "vomir" ;
|
||||
walk_V = regV "marcher" ;
|
||||
wash_V = regV "laver" ;
|
||||
wipe_V = regV "essuyer" ;
|
||||
|
||||
}
|
||||
340
lib/resource-0.9/french/SyntaxFre.gf
Normal file
340
lib/resource-0.9/french/SyntaxFre.gf
Normal file
@@ -0,0 +1,340 @@
|
||||
--# -path=.:../romance:../../prelude
|
||||
|
||||
instance SyntaxFre of SyntaxRomance = TypesFre **
|
||||
open Prelude, (CO=Coordination), MorphoFre in {
|
||||
|
||||
flags optimize=parametrize ;
|
||||
|
||||
oper
|
||||
nameNounPhrase = \jean ->
|
||||
normalNounPhrase
|
||||
(\\c => prepCase c ++ jean.s)
|
||||
jean.g
|
||||
Sg ;
|
||||
|
||||
nounPhraseOn = mkNameNounPhrase "on" Masc ;
|
||||
|
||||
pronImpers : NounPhrase = pronNounPhrase pronIl ;
|
||||
|
||||
partitiveNounPhrase = \n,vin ->
|
||||
normalNounPhrase
|
||||
(table {
|
||||
Gen => elisDe ++ vin.s ! n ;
|
||||
c => prepCase c ++ artDef vin.g n Gen ++ vin.s ! n
|
||||
}
|
||||
)
|
||||
vin.g
|
||||
n ;
|
||||
|
||||
chaqueDet = mkDeterminer1 Sg "chaque" ;
|
||||
|
||||
toutDet : Determiner =
|
||||
{s = \\g => genForms "tout" "toute" ! g ++ artDef g Sg nominative ;
|
||||
n = Sg
|
||||
} ;
|
||||
tousDet : Numeral -> Determiner = \nu ->
|
||||
{s = \\g => genForms "tous" "toutes" ! g ++ artDef g Pl nominative ++ nu.s ! g ;
|
||||
n = Pl
|
||||
} ;
|
||||
|
||||
plupartDet = mkDeterminer1 Pl ["la plupart des"] ;
|
||||
unDet = mkDeterminer Sg "un" "une" ;
|
||||
plDet = mkDeterminer1 Pl "des" ; ---
|
||||
|
||||
quelDet = mkDeterminer Sg "quel" "quelle" ;
|
||||
quelsDet = mkDeterminer Pl "quels" "quelles" ;
|
||||
|
||||
npGenPoss = \n,ton,mec ->
|
||||
\\c => prepCase c ++ ton.s ! Poss n mec.g ++ mec.s ! n ;
|
||||
|
||||
npGenPossNum = \nu,ton,mec ->
|
||||
\\c => prepCase c ++ ton.s ! Poss Pl mec.g ++ nu.s ! mec.g ++ mec.s ! Pl ;
|
||||
|
||||
existNounPhrase = \unemaison ->
|
||||
sats2clause (
|
||||
insertObject (mkSatsObject pronImpers (mkTransVerbCas verbAvoir dative) pronY)
|
||||
accusative [] unemaison) ;
|
||||
|
||||
reflPron : Number => Person => NPFormA => Str = \\n,p =>
|
||||
case p of {
|
||||
P3 => table {
|
||||
Ton x => prepCase x ++ "soi" ;
|
||||
Aton _ => elision "s" ;
|
||||
Poss Sg Masc => "son" ;
|
||||
Poss Sg Fem => "sa" ;
|
||||
Poss Pl _ => "ses"
|
||||
} ;
|
||||
_ => (personPron Masc n p).s
|
||||
} ;
|
||||
|
||||
comparConj = elisQue ;
|
||||
|
||||
mkAdjDegrReg : Str -> Bool -> AdjDegr = \adj,p ->
|
||||
mkAdjDegrLong (adjGrand adj) p ;
|
||||
|
||||
-- The commonest case for functions is common noun + "de".
|
||||
|
||||
funDe : CommNounPhrase -> Function = \mere ->
|
||||
mere ** complementCas genitive ;
|
||||
|
||||
-- Chains of "dont" - "dont" do not arise.
|
||||
|
||||
funRelPron : Function -> RelPron -> RelPron = \mere,lequel ->
|
||||
{s = table {
|
||||
RComplex g n c => variants {
|
||||
case mere.c of { ---
|
||||
Gen => lequel.s ! RSimple Gen ++
|
||||
artDef mere.g n c ++ mere.s ! n ;
|
||||
_ => nonExist} ;
|
||||
artDef mere.g n c ++ mere.s ! n ++
|
||||
mere.s2 ++ lequel.s ! RComplex g n mere.c
|
||||
} ;
|
||||
_ => nonExist
|
||||
} ;
|
||||
g = RG mere.g
|
||||
} ;
|
||||
|
||||
|
||||
-- Verbs
|
||||
|
||||
negVerb = \va -> elisNe ++ va ++ "pas" ;
|
||||
|
||||
-- copula = \b,w -> let etre = (predVerb verbEtre).s in etre ! b ! Masc ! w ;
|
||||
copula = verbEtre ;
|
||||
|
||||
|
||||
isClitCase = \c -> case c of {
|
||||
Acc => True ;
|
||||
Dat => True ;
|
||||
_ => False --- this is not quite correct
|
||||
} ;
|
||||
|
||||
auxVerb ve = case ve.aux of {
|
||||
AHabere => verbAvoir ;
|
||||
AEsse => verbEtre
|
||||
} ;
|
||||
|
||||
{- ---G
|
||||
progressiveVerbPhrase : VerbPhrase -> VerbGroup = \vp ->
|
||||
predClauseBeGroup
|
||||
(complCopula (\\g,n,p =>
|
||||
"en" ++ "train" ++ elisDe ++ vp.s ! VIInfinit ! g ! n ! p)) ;
|
||||
-}
|
||||
|
||||
-- The "ne - pas" negation.
|
||||
|
||||
posNeg = \b,v,c ->
|
||||
if_then_else Str b
|
||||
(v ++ c)
|
||||
(elisNe ++ v ++ "pas" ++ c) ; --- exception: infinitive!
|
||||
|
||||
-- Exampe: 'to be or not to be'.
|
||||
|
||||
etreNetre : Bool -> Verb = \b ->
|
||||
{s = \\w => posNeg b (verbEtre.s ! w) [] ; aux = AHabere} ; ---- v reveals a BUG in refresh
|
||||
|
||||
embedConj = elisQue ;
|
||||
|
||||
-- Relative pronouns
|
||||
|
||||
identRelPron = {
|
||||
s = table {
|
||||
RSimple c => relPronForms ! c ;
|
||||
RComplex g n c => composRelPron g n c
|
||||
} ;
|
||||
g = RNoGen
|
||||
} ;
|
||||
|
||||
suchPron = telPron ;
|
||||
|
||||
composRelPron = lequelPron ;
|
||||
|
||||
allRelForms = \lequel,g,n,c ->
|
||||
variants {
|
||||
lequel.s ! RSimple c ;
|
||||
lequel.s ! RComplex g n c
|
||||
} ;
|
||||
|
||||
-- Interrogative pronouns
|
||||
|
||||
nounIntPron = \n, mec ->
|
||||
{s = \\c => prepCase c ++ quelPron mec.g n ++ mec.s ! n ;
|
||||
g = mec.g ;
|
||||
n = n
|
||||
} ;
|
||||
|
||||
intPronWho = \num -> {
|
||||
s = \\c => prepCase c ++ "qui" ;
|
||||
g = Masc ; --- can we decide this?
|
||||
n = num
|
||||
} ;
|
||||
|
||||
intPronWhat = \num -> {
|
||||
s = table {
|
||||
Gen => ["de quoi"] ;
|
||||
Acc => ["à quoi"] ;
|
||||
c => elisQue
|
||||
} ;
|
||||
g = Masc ; --- can we decide this?
|
||||
n = num
|
||||
} ;
|
||||
|
||||
-- Questions
|
||||
|
||||
intSlash = \Qui, Tuvois ->
|
||||
{s = \\b,cl =>
|
||||
let
|
||||
qui = Tuvois.s2 ++ Qui.s ! Tuvois.c ;
|
||||
tuvois = Tuvois.s ! b ! cl
|
||||
in
|
||||
table {
|
||||
DirQ => qui ++ optStr (estCeQue Acc) ++ tuvois ;
|
||||
IndirQ => ifCe Tuvois.c ++ qui ++ tuvois
|
||||
}
|
||||
} ;
|
||||
|
||||
-- An auxiliary to distinguish between
|
||||
-- "je ne sais pas" ("ce qui dort" / "ce que tu veux" / "à qui tu penses").
|
||||
|
||||
ifCe : Case -> Str = \c -> case c of {
|
||||
Nom => "ce" ;
|
||||
Acc => "ce" ;
|
||||
_ => []
|
||||
} ;
|
||||
|
||||
----- moved from Morpho
|
||||
|
||||
--2 Articles
|
||||
--
|
||||
-- A macro for defining gender-dependent tables will be useful.
|
||||
-- Its first application is in the indefinite article.
|
||||
--
|
||||
-- Notice that the plural genitive is special: "de femmes".
|
||||
|
||||
genForms : Str -> Str -> Gender => Str = \bon,bonne ->
|
||||
table {Masc => bon ; Fem => bonne} ;
|
||||
|
||||
artIndef = \g,n,c -> case <n,c> of {
|
||||
<Sg,_> => prepCase c ++ genForms "un" "une" ! g ;
|
||||
<Pl,Gen> => elisDe ;
|
||||
_ => prepCase c ++ "des"
|
||||
} ;
|
||||
|
||||
artDef = \g,n,c -> artDefTable ! g ! n ! c ;
|
||||
|
||||
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 ;
|
||||
|
||||
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 ;
|
||||
|
||||
-- moved from ResFra
|
||||
|
||||
commentAdv = ss "comment" ;
|
||||
quandAdv = ss "quand" ;
|
||||
ouAdv = ss "où" ;
|
||||
pourquoiAdv = ss "pourquoi" ;
|
||||
|
||||
etConj = ss "et" ** {n = Pl} ;
|
||||
ouConj = ss "ou" ** {n = Sg} ;
|
||||
etetConj = sd2 "et" "et" ** {n = Pl} ;
|
||||
ououConj = sd2 "ou" "ou" ** {n = Sg} ;
|
||||
niniConj = sd2 "ni" "ni" ** {n = Sg} ; --- requires ne !
|
||||
siSubj = ss elisSi ** {m = Ind} ;
|
||||
quandSubj = ss "quand" ** {m = Ind} ;
|
||||
|
||||
ouiPhr = ss ["Oui ."] ;
|
||||
nonPhr = ss ["Non ."] ; --- and also Si!
|
||||
|
||||
negNe = elisNe ; negPas = "pas" ;
|
||||
|
||||
progressiveSats subj vp =
|
||||
mkSatsCopula subj
|
||||
(["en train"] ++ elisDe ++
|
||||
vp.s ! VIInfinit ! (pgen2gen subj.g) ! subj.n ! subj.p) ;
|
||||
|
||||
conjunctCase : CaseA -> CaseA = \c -> c ;
|
||||
|
||||
}
|
||||
34
lib/resource-0.9/french/TimeFre.gf
Normal file
34
lib/resource-0.9/french/TimeFre.gf
Normal file
@@ -0,0 +1,34 @@
|
||||
concrete TimeFre of Time = NumeralsFre **
|
||||
open Prelude, MorphoFre, CategoriesFre, ParadigmsFre in {
|
||||
|
||||
lincat
|
||||
Date = SS ;
|
||||
Weekday = N ;
|
||||
Hour = SS ;
|
||||
Minute = SS ;
|
||||
Time = SS ;
|
||||
|
||||
lin
|
||||
DayDate day = ss (day.s ! singular) ;
|
||||
DayTimeDate day time = ss (day.s ! singular ++ "à" ++ time.s) ;
|
||||
|
||||
FormalTime = infixSS "heures" ;
|
||||
PastTime h m = ss (h.s ++ "et" ++ m.s) ;
|
||||
ToTime h m = ss (h.s ++ "moins" ++ m.s) ;
|
||||
ExactTime h = ss (h.s ++ "exactement") ;
|
||||
|
||||
NumHour n = ss (n.s ! feminine ! indep) ;
|
||||
NumMinute n = ss (n.s ! feminine ! indep) ;
|
||||
|
||||
monday = regN "lundi" masculine ;
|
||||
tuesday = regN "mardi" masculine ;
|
||||
wednesday = regN "mercredi" masculine ;
|
||||
thursday = regN "jeudi" masculine ;
|
||||
friday = regN "vendredi" masculine ;
|
||||
saturday = regN "samedi" masculine ;
|
||||
sunday = regN "dimanche" masculine ;
|
||||
|
||||
|
||||
|
||||
|
||||
} ;
|
||||
185
lib/resource-0.9/french/TypesFre.gf
Normal file
185
lib/resource-0.9/french/TypesFre.gf
Normal file
@@ -0,0 +1,185 @@
|
||||
--1 French Word Classes and Morphological Parameters
|
||||
--
|
||||
-- This is a resource module for Italian morphology, defining the
|
||||
-- morphological parameters and word classes of Italian.
|
||||
-- The morphology is so far only
|
||||
-- complete w.r.t. the syntax part of the resource grammar.
|
||||
-- It does not include those parameters that are not needed for
|
||||
-- analysing individual words: such parameters are defined in syntax modules.
|
||||
|
||||
instance TypesFre of TypesRomance = {
|
||||
|
||||
-- Now we can give values to the abstract types.
|
||||
|
||||
param
|
||||
Case = Nom | Acc | Gen | Dat ; -- corresp. to prepositions de and à
|
||||
|
||||
NPForm = Ton Case | Aton Case | Poss Number Gender ;
|
||||
|
||||
oper
|
||||
CaseA = Case ;
|
||||
NPFormA = NPForm ;
|
||||
|
||||
nominative = Nom ;
|
||||
accusative = Acc ;
|
||||
genitive = Gen ;
|
||||
dative = Dat ;
|
||||
prepositional = accusative ;
|
||||
|
||||
stressed = Ton ;
|
||||
unstressed = Aton ;
|
||||
|
||||
------------------------- move this somewhere else!
|
||||
--2 Some phonology
|
||||
--
|
||||
--3 Elision
|
||||
--
|
||||
-- The phonological rule of *elision* can be defined as follows in GF.
|
||||
-- There is one thing that is not treated properly: the "h aspiré",
|
||||
-- which is not separated orthographically from the "h muet".
|
||||
-- Our definition works correctly only for the "h muet".
|
||||
|
||||
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"}} ;
|
||||
|
||||
|
||||
--2 Prepositions
|
||||
--
|
||||
-- The type $Cas$ in $types.Fra.gf$ has the dative and genitive
|
||||
-- cases, which are relevant for pronouns and the definite article,
|
||||
-- but which are otherwise expressed by prepositions.
|
||||
|
||||
prepCase = \c -> case c of {
|
||||
Nom => [] ;
|
||||
Acc => [] ;
|
||||
Gen => elisDe ;
|
||||
Dat => "à"
|
||||
} ;
|
||||
|
||||
--2 Relative pronouns
|
||||
--
|
||||
-- The simple (atonic) relative pronoun shows genuine variation in all of the
|
||||
-- cases.
|
||||
|
||||
relPronForms = table {
|
||||
Nom => "qui" ; Gen => "dont" ; Dat => ["à qui"] ; Acc => elisQue
|
||||
} ;
|
||||
|
||||
-- Usually the comparison forms are built by prefixing the word
|
||||
-- "plus". The definite article needed in the superlative is provided in
|
||||
-- $syntax.Fra.gf$.
|
||||
|
||||
adjCompLong : Adj -> AdjComp = \cher ->
|
||||
mkAdjComp
|
||||
cher.s
|
||||
(\\a => "plus" ++ cher.s ! a) ;
|
||||
|
||||
-- Comparative adjectives are only sometimes formed morphologically
|
||||
-- (actually: by different morphemes).
|
||||
|
||||
mkAdjComp : (_,_ : AForm => Str) -> AdjComp =
|
||||
\bon, meilleur ->
|
||||
{s = table {Pos => bon ; _ => meilleur}} ;
|
||||
|
||||
------------------------------
|
||||
|
||||
-- Their inflection tables has tonic and atonic forms, as well as
|
||||
-- the possessive forms, which are inflected like determiners.
|
||||
--
|
||||
-- Example: "lui, de lui, à lui" - "il,le,lui" - "son,sa,ses".
|
||||
|
||||
--
|
||||
-- Examples of each: "Jean" ; "je"/"te" ; "il"/"elle"/"ils"/"elles" ; "nous"/"vous".
|
||||
|
||||
-- The following coercions are useful:
|
||||
|
||||
oper
|
||||
pform2case = \p -> case p of {
|
||||
Ton x => x ;
|
||||
Aton x => x ;
|
||||
Poss _ _ => Gen
|
||||
} ;
|
||||
|
||||
case2pform = \c -> case c of {
|
||||
Nom => Aton Nom ;
|
||||
Acc => Aton Acc ;
|
||||
_ => Ton c
|
||||
} ;
|
||||
|
||||
case2pformClit = \c -> case c of {
|
||||
Nom => Aton Nom ;
|
||||
Acc => Aton Acc ;
|
||||
Dat => Aton Dat ;
|
||||
_ => Ton c
|
||||
} ;
|
||||
|
||||
-- Relative pronouns: the case-dependent parameter type.
|
||||
|
||||
param RelForm = RSimple Case | RComplex Gender Number Case ;
|
||||
|
||||
oper RelFormA = RelForm ;
|
||||
npRelForm : NPFormA -> RelFormA = \np -> case np of {
|
||||
Ton c => RSimple c ;
|
||||
Aton c => RSimple c ;
|
||||
Poss _ _ => RSimple genitive
|
||||
} ;
|
||||
|
||||
|
||||
oper RelFormA = RelForm ;
|
||||
|
||||
-- Verbs: conversion from full verbs to present-tense verbs.
|
||||
|
||||
verbPres = \aller,a -> {s = vvf aller ; aux = a} ;
|
||||
|
||||
vvf : (VForm => Str) -> (VF => Str) = \aller -> table {
|
||||
VInfin => aller ! Inf ;
|
||||
VFin (VPres Ind) n p => aller ! Indic Pres n p ;
|
||||
VFin (VPres Sub) n p => aller ! Subjo SPres n p ;
|
||||
VFin (VImperf Ind) n p => aller ! Indic Imparf n p ;
|
||||
VFin (VImperf Sub) n p => aller ! Subjo SImparf n p ;
|
||||
VFin VPasse n p => aller ! Indic Passe n p ;
|
||||
VFin VFut n p => aller ! Indic Futur n p ;
|
||||
VFin VCondit n p => aller ! Cond n p ;
|
||||
VImper np => aller ! Imper np ;
|
||||
VPart g n => aller ! Part (PPasse g n) ;
|
||||
VGer => aller ! Part PPres -- *en* allant
|
||||
} ;
|
||||
|
||||
-- The full conjunction is a table on $VForm$:
|
||||
|
||||
param
|
||||
Temps = Pres | Imparf | Passe | Futur ;
|
||||
TSubj = SPres | SImparf ;
|
||||
TPart = PPres | PPasse Gender Number ;
|
||||
VForm = Inf
|
||||
| Indic Temps Number Person
|
||||
| Cond Number Person
|
||||
| Subjo TSubj Number Person
|
||||
| Imper NumPersI
|
||||
| Part TPart ;
|
||||
|
||||
-- This is the full verb type.
|
||||
|
||||
oper
|
||||
Verbum : Type = VForm => Str ;
|
||||
}
|
||||
6531
lib/resource-0.9/french/VerbesAbs.gf
Normal file
6531
lib/resource-0.9/french/VerbesAbs.gf
Normal file
File diff suppressed because it is too large
Load Diff
6634
lib/resource-0.9/french/VerbesFre.gf
Normal file
6634
lib/resource-0.9/french/VerbesFre.gf
Normal file
File diff suppressed because it is too large
Load Diff
3
lib/resource-0.9/french/VerbphraseFre.gf
Normal file
3
lib/resource-0.9/french/VerbphraseFre.gf
Normal file
@@ -0,0 +1,3 @@
|
||||
--# -path=.:../romance:../abstract:../../prelude
|
||||
concrete VerbphraseFre of Verbphrase = CategoriesFre **
|
||||
VerbphraseRomance with (SyntaxRomanceVP=SyntaxFreVP) ;
|
||||
399
lib/resource-0.9/french/VerbsFre.gf
Normal file
399
lib/resource-0.9/french/VerbsFre.gf
Normal file
@@ -0,0 +1,399 @@
|
||||
--# -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
|
||||
|
||||
concrete VerbsFre of VerbsFreAbs =
|
||||
open TypesFre, MorphoFre, CategoriesFre, BeschFre in {
|
||||
|
||||
flags optimize=values ;
|
||||
|
||||
lincat
|
||||
V = CategoriesFre.V ;
|
||||
V2 = CategoriesFre.V2 ;
|
||||
|
||||
-- all verbs in classes with "er" and "finir" are omitted
|
||||
|
||||
lin
|
||||
abattre_V2 = v_besch55 "abattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
absoudre_V2 = v_besch72 "absoudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
abstenir_V = v_besch23 "abstenir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
abstraire_V2 = v_besch61 "abstraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
accourir_V = v_besch33 "accourir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
accroître_V2 = v_besch73 "accroître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
accueillir_V2 = v_besch28 "accueillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
acquérir_V2 = v_besch24 "acquérir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
adjoindre_V2 = v_besch58 "adjoindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
admettre_V2 = v_besch56 "admettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
advenir_V = v_besch23 "advenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
aller_V = v_besch22 "aller" ** {aux = AEsse ; lock_V = <>} ;
|
||||
apercevoir_V2 = v_besch38 "apercevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
apparaître_V = v_besch64 "apparaître" ** {aux = AHabere ; lock_V = <>} ;
|
||||
appartenir_V2 = v_besch23 "appartenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
appendre_V2 = v_besch53 "appendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
apprendre_V2 = v_besch54 "apprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
assaillir_V2 = v_besch29 "assaillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
asseoir_V2 = v_besch49 "asseoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
astreindre_V2 = v_besch57 "astreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
atteindre_V2 = v_besch57 "atteindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
attendre_V2 = v_besch53 "attendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
avoir_V2 = v_besch1 "avoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
battre_V2 = v_besch55 "battre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
boire_V2 = v_besch69 "boire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
bouillir_V2 = v_besch31 "bouillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
braire_V = v_besch61 "braire" ** {aux = AHabere ; lock_V = <>} ;
|
||||
ceindre_V2 = v_besch57 "ceindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
choir_V = v_besch52 "choir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
circonscrire_V2 = v_besch80 "circonscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
circonvenir_V2 = v_besch23 "circonvenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
clore_V2 = v_besch70 "clore" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
combattre_V2 = v_besch55 "combattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
commettre_V2 = v_besch56 "commettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
comparaître_V2 = v_besch64 "comparaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
complaire_V2 = v_besch63 "complaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
comprendre_V2 = v_besch54 "comprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
compromettre_V2 = v_besch56 "compromettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
concevoir_V2 = v_besch38 "concevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
conclure_V2 = v_besch71 "conclure" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
concourir_V2 = v_besch33 "concourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
condescendre_V2 = v_besch53 "condescendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
conduire_V2 = v_besch82 "conduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
confire_V2 = v_besch81 "confire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
confondre_V2 = v_besch53 "confondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
conjoindre_V2 = v_besch58 "conjoindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
connaître_V2 = v_besch64 "connaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
conquérir_V2 = v_besch24 "conquérir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
consentir_V2 = v_besch25 "consentir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
construire_V2 = v_besch82 "construire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contenir_V2 = v_besch23 "contenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contraindre_V2 = v_besch59 "contraindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contrebattre_V2 = v_besch55 "contrebattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contredire_V2 = v_besch78 "contredire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contrefaire_V2 = v_besch62 "contrefaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
contrevenir_V2 = v_besch23 "contrevenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
convaincre_V2 = v_besch60 "convaincre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
convenir_V2 = v_besch23 "convenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
correspondre_V2 = v_besch53 "correspondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
corrompre_V2 = v_besch53 "corrompre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
coudre_V2 = v_besch73 "coudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
courir_V2 = v_besch33 "courir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
couvrir_V2 = v_besch27 "couvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
craindre_V2 = v_besch59 "craindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
croire_V2 = v_besch68 "croire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
croître_V = v_besch67 "croître" ** {aux = AEsse ; lock_V = <>} ;
|
||||
cueillir_V2 = v_besch28 "cueillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
cuire_V2 = v_besch82 "cuire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
débattre_V2 = v_besch55 "débattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
débouillir_V2 = v_besch31 "débouillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
décevoir_V2 = v_besch38 "décevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déchoir_V2 = v_besch52 "déchoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déclore_V2 = v_besch70 "déclore" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
décommettre_V2 = v_besch56 "décommettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déconfire_V2 = v_besch81 "déconfire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
découdre_V2 = v_besch73 "découdre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
découvrir_V2 = v_besch27 "découvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
décrire_V2 = v_besch80 "décrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
décroître_V2 = v_besch67 "décroître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
décuire_V2 = v_besch82 "décuire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déduire_V2 = v_besch82 "déduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
défaillir_V = v_besch30 "défaillir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
défaire_V2 = v_besch62 "défaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
défendre_V2 = v_besch53 "défendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
démentir_V2 = v_besch25 "démentir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
démettre_V2 = v_besch56 "démettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
démordre_V = v_besch53 "démordre" ** {aux = AHabere ; lock_V = <>} ;
|
||||
départir_V2 = v_besch25 "départir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
dépeindre_V2 = v_besch57 "dépeindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
dépendre_V2 = v_besch53 "dépendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
déplaire_V = v_besch63 "déplaire" ** {aux = AHabere ; lock_V = <>} ;
|
||||
dépourvoir_V2 = v_besch40 "dépourvoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déprendre_V2 = v_besch54 "déprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
désapprendre_V2 = v_besch54 "désapprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
descendre_V2 = v_besch53 "descendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
desservir_V2 = v_besch35 "desservir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
déteindre_V2 = v_besch57 "déteindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
détendre_V2 = v_besch53 "détendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
détenir_V2 = v_besch23 "détenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
détordre_V2 = v_besch53 "détordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
détruire_V2 = v_besch82 "détruire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
devenir_V = v_besch23 "devenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
dévêtir_V2 = v_besch26 "dévêtir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
devoir_V2 = v_besch42 "devoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
dire_V2 = v_besch78 "dire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
disconvenir_V2 = v_besch23 "disconvenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
discourir_V2 = v_besch33 "discourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
disjoindre_V2 = v_besch58 "disjoindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
disparaître_V2 = v_besch64 "disparaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
dissoudre_V2 = v_besch72 "dissoudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
distendre_V2 = v_besch53 "distendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
distordre_V2 = v_besch53 "distordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
distraire_V2 = v_besch61 "distraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
dormir_V2 = v_besch32 "dormir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
ébattre_V = v_besch55 "ébattre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
échoir_V2 = v_besch52 "échoir" ** {aux = AEsse ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
éclore_V2 = v_besch70 "éclore" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
éconduire_V2 = v_besch82 "éconduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
écrire_V2 = v_besch80 "écrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
élire_V2 = v_besch77 "élire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
embatre_V2 = v_besch55 "embatre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
embattre_V2 = v_besch55 "embattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
emboire_V = v_besch69 "emboire" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
émettre_V2 = v_besch56 "émettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
émoudre_V2 = v_besch74 "émoudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
émouvoir_V2 = v_besch44 "émouvoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
empreindre_V2 = v_besch57 "empreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
enceindre_V2 = v_besch57 "enceindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
enclore_V2 = v_besch70 "enclore" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
encourir_V2 = v_besch33 "encourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
endormir_V2 = v_besch32 "endormir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
enduire_V2 = v_besch82 "enduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
enfreindre_V2 = v_besch57 "enfreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
enfuir_V = v_besch36 "enfuir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
enjoindre_V2 = v_besch58 "enjoindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
enquérir_V = v_besch24 "enquérir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entendre_V2 = v_besch53 "entendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
entr'apercevoir_V = v_besch38 "entr'apercevoir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entrebattre_V = v_besch55 "entrebattre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entre_détruire_V = v_besch82 "entre-détruire" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entre_haïr_V = v_besch20 "entre-haïr" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entremettre_V = v_besch56 "entremettre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
entre_nuire_V = v_besch82 "entre-nuire" ** {aux = AHabere ; lock_V = <>} ;
|
||||
entreprendre_V2 = v_besch54 "entreprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
entretenir_V2 = v_besch23 "entretenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
entrevoir_V2 = v_besch39 "entrevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
entrouvrir_V2 = v_besch27 "entrouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
envoyer_V2 = v_besch18 "envoyer" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
épandre_V2 = v_besch53 "épandre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
éperdre_V = v_besch53 "éperdre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
éprendre_V = v_besch54 "éprendre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
équivaloir_V2 = v_besch47 "équivaloir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
éteindre_V2 = v_besch57 "éteindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
étendre_V2 = v_besch53 "étendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
étreindre_V2 = v_besch57 "étreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
être_V = v_besch2 "être" ** {aux = AHabere ; lock_V = <>} ;
|
||||
exclure_V2 = v_besch71 "exclure" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
extraire_V2 = v_besch61 "extraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
faillir_V2 = v_besch30 "faillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
faire_V2 = v_besch62 "faire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
falloir_V = v_besch46 "falloir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
feindre_V2 = v_besch57 "feindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
fendre_V2 = v_besch53 "fendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
fondre_V2 = v_besch53 "fondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
forfaire_V2 = v_besch62 "forfaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
foutre_V2 = v_besch53 "foutre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
frire_V2 = v_besch81 "frire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
fuir_V2 = v_besch36 "fuir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
geindre_V2 = v_besch57 "geindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
gésir_V2 = mkNV (conj3gésir "gésir") ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
haïr_V2 = v_besch20 "haïr" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
inclure_V2 = v_besch71 "inclure" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
induire_V2 = v_besch82 "induire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
inscrire_V2 = v_besch80 "inscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
instruire_V2 = v_besch82 "instruire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
interdire_V2 = v_besch78 "interdire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
interrompre_V2 = v_besch53 "interrompre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
intervenir_V = v_besch23 "intervenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
introduire_V2 = v_besch82 "introduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
joindre_V2 = v_besch58 "joindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
lire_V2 = v_besch77 "lire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
luire_V = v_besch82 "luire" ** {aux = AHabere ; lock_V = <>} ;
|
||||
mainmettre_V2 = v_besch56 "mainmettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
maintenir_V2 = v_besch23 "maintenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
méconnaître_V2 = v_besch64 "méconnaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
mécroire_V2 = v_besch68 "mécroire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
médire_V2 = v_besch78 "médire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
mentir_V2 = v_besch25 "mentir" ** {aux = AEsse ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
méprendre_V2 = v_besch54 "méprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
messeoir_V2 = v_besch50 "messeoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
mettre_V2 = v_besch56 "mettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
mévendre_V2 = v_besch53 "mévendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
mordre_V2 = v_besch53 "mordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
morfondre_V = v_besch53 "morfondre" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
moudre_V2 = v_besch74 "moudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
mourir_V = v_besch34 "mourir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
mouvoir_V2 = v_besch44 "mouvoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
naître_V = v_besch65 "naître" ** {aux = AEsse ; lock_V = <>} ;
|
||||
nuire_V2 = v_besch82 "nuire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
obtenir_V2 = v_besch23 "obtenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
obvenir_V = v_besch23 "obvenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
occlure_V2 = v_besch71 "occlure" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
offrir_V2 = v_besch27 "offrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
oindre_V2 = v_besch58 "oindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
omettre_V2 = v_besch56 "omettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
ouïr_V2 = v_besch37 "ouïr" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
ouvrir_V2 = v_besch27 "ouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
paître_V2 = v_besch66 "paître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
paître_V = v_besch66 "paître" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
paraître_V = v_besch64 "paraître" ** {aux = AHabere ; lock_V = <>} ;
|
||||
parcourir_V2 = v_besch33 "parcourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
parfondre_V2 = v_besch53 "parfondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
partir_V = v_besch25 "partir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
parvenir_V = v_besch23 "parvenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
peindre_V2 = v_besch57 "peindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
pendre_V2 = v_besch53 "pendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
percevoir_V2 = v_besch38 "percevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
perdre_V2 = v_besch53 "perdre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
permettre_V2 = v_besch56 "permettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
plaindre_V2 = v_besch59 "plaindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
plaire_V2 = v_besch63 "plaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
pleuvoir_V = v_besch45 "pleuvoir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
poindre_V2 = v_besch58 "poindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
pondre_V2 = v_besch53 "pondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
pourfendre_V2 = v_besch53 "pourfendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
poursuivre_V2 = v_besch75 "poursuivre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
pourvoir_V2 = v_besch40 "pourvoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
pouvoir_V = v_besch43 "pouvoir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
prédire_V2 = v_besch78 "prédire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
prendre_V2 = v_besch54 "prendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
prescrire_V2 = v_besch80 "prescrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
pressentir_V2 = v_besch25 "pressentir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
prétendre_V2 = v_besch53 "prétendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
prévaloir_V2 = v_besch47 "prévaloir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
prévenir_V2 = v_besch23 "prévenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
prévoir_V2 = v_besch39 "prévoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
produire_V2 = v_besch82 "produire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
promettre_V2 = v_besch56 "promettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
promouvoir_V2 = v_besch44 "promouvoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
proscrire_V2 = v_besch80 "proscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
provenir_V = v_besch23 "provenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
rabattre_V2 = v_besch55 "rabattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
raire_V2 = v_besch61 "raire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rapprendre_V2 = v_besch54 "rapprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rasseoir_V2 = v_besch49 "rasseoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réadmettre_V2 = v_besch56 "réadmettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réapparaître_V = v_besch64 "réapparaître" ** {aux = AHabere ; lock_V = <>} ;
|
||||
réapprendre_V2 = v_besch54 "réapprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rebattre_V2 = v_besch55 "rebattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recevoir_V2 = v_besch38 "recevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recomparaître_V2 = v_besch64 "recomparaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reconduire_V2 = v_besch82 "reconduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reconnaître_V2 = v_besch64 "reconnaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reconquérir_V2 = v_besch24 "reconquérir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reconstruire_V2 = v_besch82 "reconstruire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recoudre_V2 = v_besch73 "recoudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recourir_V2 = v_besch33 "recourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
recouvrir_V2 = v_besch27 "recouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
récrire_V2 = v_besch80 "récrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recroître_V2 = v_besch67 "recroître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recueillir_V2 = v_besch28 "recueillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
recuire_V2 = v_besch82 "recuire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
redécouvrir_V2 = v_besch27 "redécouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
redéfaire_V2 = v_besch62 "redéfaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
redescendre_V2 = v_besch53 "redescendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
redevenir_V = v_besch23 "redevenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
redevoir_V2 = v_besch42 "redevoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
redire_V2 = v_besch78 "redire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réduire_V2 = v_besch82 "réduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
réécrire_V2 = v_besch80 "réécrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réélire_V2 = v_besch77 "réélire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réentendre_V2 = v_besch53 "réentendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
refaire_V2 = v_besch62 "refaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
refendre_V2 = v_besch53 "refendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
refondre_V2 = v_besch53 "refondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réinscrire_V2 = v_besch80 "réinscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
réintroduire_V2 = v_besch82 "réintroduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rejoindre_V2 = v_besch58 "rejoindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
relire_V2 = v_besch77 "relire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reluire_V2 = v_besch82 "reluire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
remettre_V2 = v_besch56 "remettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
remordre_V2 = v_besch53 "remordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
remoudre_V2 = v_besch74 "remoudre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
renaître_V2 = v_besch65 "renaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rendormir_V2 = v_besch32 "rendormir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rendre_V2 = v_besch53 "rendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rentraire_V2 = v_besch61 "rentraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rentrouvrir_V2 = v_besch27 "rentrouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
renvoyer_V2 = v_besch18 "renvoyer" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
repaître_V2 = v_besch66 "repaître" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
répandre_V2 = v_besch53 "répandre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reparaître_V = v_besch64 "reparaître" ** {aux = AEsse ; lock_V = <>} ;
|
||||
repartir_V = v_besch25 "repartir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
repeindre_V2 = v_besch57 "repeindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rependre_V2 = v_besch53 "rependre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
repentir_V = v_besch25 "repentir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
reperdre_V2 = v_besch53 "reperdre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
repleuvoir_V = v_besch45 "repleuvoir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
répondre_V2 = v_besch53 "répondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reprendre_V2 = v_besch54 "reprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reproduire_V2 = v_besch82 "reproduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
requérir_V2 = v_besch24 "requérir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
résoudre_V2 = mkNV (conj3résoudre "résoudre") ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
ressentir_V2 = v_besch25 "ressentir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
resservir_V2 = v_besch35 "resservir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
ressortir_V = v_besch25 "ressortir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
ressouvenir_V = v_besch23 "ressouvenir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
restreindre_V2 = v_besch57 "restreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
reteindre_V2 = v_besch57 "reteindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retendre_V2 = v_besch53 "retendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retenir_V2 = v_besch23 "retenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retondre_V2 = v_besch53 "retondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retordre_V2 = v_besch53 "retordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retraduire_V2 = v_besch82 "retraduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retraire_V2 = v_besch61 "retraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retranscrire_V2 = v_besch80 "retranscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
retransmettre_V2 = v_besch56 "retransmettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rétreindre_V2 = v_besch57 "rétreindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revaloir_V2 = v_besch47 "revaloir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revendre_V2 = v_besch53 "revendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revenir_V = v_besch23 "revenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
revêtir_V2 = v_besch26 "revêtir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revivre_V2 = v_besch76 "revivre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revoir_V2 = v_besch39 "revoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
revouloir_V2 = v_besch48 "revouloir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rire_V2 = v_besch79 "rire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
rompre_V2 = v_besch53 "rompre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
rouvrir_V2 = v_besch27 "rouvrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
saillir_V2 = v_besch29 "saillir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
satisfaire_V2 = v_besch62 "satisfaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
savoir_V2 = v_besch41 "savoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
secourir_V2 = v_besch33 "secourir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
séduire_V2 = v_besch82 "séduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
sentir_V2 = v_besch25 "sentir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
seoir_V = v_besch50 "seoir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
servir_V2 = v_besch35 "servir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
sortir_V = v_besch25 "sortir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
soubattre_V2 = v_besch55 "soubattre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
souffrir_V2 = v_besch27 "souffrir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
soumettre_V2 = v_besch56 "soumettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
sourire_V2 = v_besch79 "sourire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
souscrire_V2 = v_besch80 "souscrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
sous_entendre_V2 = v_besch53 "sous-entendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
sous_tendre_V2 = v_besch53 "sous-tendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
soustraire_V2 = v_besch61 "soustraire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
soutenir_V2 = v_besch23 "soutenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
souvenir_V = v_besch23 "souvenir" ** {aux = AHabere ; s2 = [] ; lock_V = <> ; c = Acc} ;
|
||||
subvenir_V2 = v_besch23 "subvenir" ** {aux = AEsse ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
suffire_V2 = v_besch81 "suffire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
suivre_V2 = v_besch75 "suivre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
surfaire_V2 = v_besch62 "surfaire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
surprendre_V2 = v_besch54 "surprendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
surproduire_V2 = v_besch82 "surproduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
surseoir_V2 = v_besch51 "surseoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
surtondre_V2 = v_besch53 "surtondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
survenir_V = v_besch23 "survenir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
survivre_V2 = v_besch76 "survivre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
suspendre_V2 = v_besch53 "suspendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
taire_V2 = v_besch63 "taire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
teindre_V2 = v_besch57 "teindre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
tendre_V2 = v_besch53 "tendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
tenir_V2 = v_besch23 "tenir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Dat} ;
|
||||
tondre_V2 = v_besch53 "tondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
tordre_V2 = v_besch53 "tordre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
traduire_V2 = v_besch82 "traduire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
traire_V2 = v_besch61 "traire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
transcrire_V2 = v_besch80 "transcrire" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
transmettre_V2 = v_besch56 "transmettre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
transparaître_V = v_besch64 "transparaître" ** {aux = AHabere ; lock_V = <>} ;
|
||||
tréfondre_V2 = v_besch53 "tréfondre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
tressaillir_V = v_besch29 "tressaillir" ** {aux = AHabere ; lock_V = <>} ;
|
||||
vaincre_V2 = v_besch60 "vaincre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
valoir_V2 = v_besch47 "valoir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
vendre_V2 = v_besch53 "vendre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
venir_V = v_besch23 "venir" ** {aux = AEsse ; lock_V = <>} ;
|
||||
vêtir_V2 = v_besch26 "vêtir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
vivre_V2 = v_besch76 "vivre" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
voir_V2 = v_besch39 "voir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Acc} ;
|
||||
vouloir_V2 = v_besch48 "vouloir" ** {aux = AHabere ; s2 = [] ; lock_V2 = <> ; c = Gen} ;
|
||||
|
||||
}
|
||||
395
lib/resource-0.9/french/VerbsFreAbs.gf
Normal file
395
lib/resource-0.9/french/VerbsFreAbs.gf
Normal file
@@ -0,0 +1,395 @@
|
||||
--# -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
|
||||
V ;
|
||||
V2 ;
|
||||
|
||||
-- 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 ;
|
||||
}
|
||||
Reference in New Issue
Block a user