Module:fr-flexion/bac à sable
Ce module est une copie de travail [1] de Module:fr-flexion destinée à tester les modifications ou nouveautés de ce dernier sans perturber les articles.
- Raison d’être de cette page
Module:fr-flexion est utilisé sur des centaines de milliers de pages :
- toute bêtise impacte toutes ces pages,
- même si vous ne faites pas de bêtise, les serveurs sont obligés d’invalider le cache de toutes les pages (càd recalculer le rendu de toutes les pages) qui l’utilisent à chaque modification, ce qui est très couteux.
Au contraire, Module:fr-flexion/bac à sable n’est jamais invoqué dans les modèles utilisés sur les articles, le modifier est donc sans danger.
- Mode d’emploi
Si vous voulez y faire un test :
- assurez-vous que personne d’autre n’y a de test en cours [2],
- récupérez le code de Module:fr-flexion et copiez-le ici avec un commentaire de modif du genre « copie de Module:fr-flexion dans la version actuelle » afin de rendre l’historique clair (c’est important),
- faites vos modifs, testez-les via un
{{#invoke|fr-flexion/bac à sable|…}}dans une page de test [3], - lorsque vous en êtes content, et seulement alors, copiez le nouveau code dans Module:fr-flexion [4].
- Notes
- [1] À un instant donné, il contient sans doute un code un peu différent de l’original, selon ce qu’y a fait le dernier contributeur.
- [2] Sinon contactez le contributeur sur sa page de discussion pour vous coordonner, nous sommes sur un site collaboratif.
- [3] En fait un couple de pages de test, une pour simuler le modèle, une pour simuler l’article. Voir par exemple Utilisateur:ArséniureDeGallium/modl-eau et Utilisateur:ArséniureDeGallium/mot-eau.
- [4] Ce serait sans doute bien de l’annoncer à la communauté si ce n’est pas une modification triviale ou une correction de bug.
La documentation de ce module est générée par le modèle {{Documentation module}}.
Elle est incluse depuis la page Module:fr-flexion/bac à sable/Documentation. Veuillez placer les catégories sur cette page-là.
Les éditeurs peuvent travailler dans le bac à sable (créer).
Voir les statistiques d'appel depuis le wikicode sur l'outil wstat et les appels depuis d'autres modules.
--========================================================================================
-- Module:fr-flexion : génération des tableaux de flexions des mots en français
------------------------------------------------------------------------------------------
-- auteurs principaux : ArséniureDeGallium
-- licence : CC-BY-SA 3.0
--========================================================================================
lib_pron = require('Module:prononciation')
local p={}
------------------------------------------------------
-- raccourci pour prononciation en français
-- NB : nil est géré par lua_pron()
function pron(api,pref)
return '<br>'..(pref or '')..lib_pron.lua_pron(api,'fr')
end
------------------------------------------------------
-- raccourci pour prononciation additionnelle en français
-- si nil répond '', sinon préfixe par saut de ligne et le mot "ou" en small
function ou_pron(api,pref)
if api then
return '<br><small>ou</small> '..(pref or '')..lib_pron.lua_pron(api,'fr')
end
return ''
end
------------------------------------------------------
-- ajout du caractère adéquat devant la 2e partie invariable d'une prononciation
-- (espace, point, liaison)
-- "." et "‿" inchangés ; nbsp transformé en espace ; sinon espace ajouté
function fin_invar_pron(api)
-- si rien, alors rien
if (api==nil) or (api=='') then return '' end
local PremCar = mw.ustring.sub(api,1,1)
-- point
if PremCar=='.' then return api end
-- liaison
if PremCar=='‿' then return api end
-- espace normal 0x20
if PremCar==' ' then return api end
-- espace insécable en UTF8 0xC2 0xA0
if PremCar=='\194\160' then return ' '..mw.ustring.sub(api,2) end
-- espace insécable en html, non parsé avant d'envoyer la chaine au lua
if mw.ustring.sub(api,1,6)==' ' then return ' '..mw.ustring.sub(api,7) end
-- dans tous les autres cas ajouter un espace
return ' '..api
end
------------------------------------------------------
-- calcul des 4 préfpron avec valeurs par défaut, priorité au plus détaillé
-- inspiré du comportement de Modèle:fr-accord-mixte
function prefpron_4(mfsp,msp,fsp,ms,mp,fs,fp)
return ms or msp or mfsp, mp or msp or mfsp, fs or fsp or mfsp, fp or fsp or mfsp
end
------------------------------------------------------
-- Détection du radical parmi 1 à 4 possibilités, et de l'éventuelle partie invariable
-- Algo : première occurrence d'une des formes suivie d'un espace ou d'un tiret ou de la fin de la chaine,
-- à gauche c'est le radical, à droite c'est le suffixe invar
-- Note 1 : %- est nécessaire pour le tiret, voir http://www.lua.org/manual/5.1/manual.html
-- Note 2 : l'ordre des tests est important si plusieurs peuvent être vrais simultanémént !!
function cherche_radic(TitrePage, p1, p2, p3, p4)
local Radic
local Separ = ''
local Fin = ''
local TitrePage1 = TitrePage..' ' -- pour que %s détecte aussi les fins de chaines.
local n1, n2 = mw.ustring.find( TitrePage1, p1..'[%s%-]' )
if (not n1) and p2 then n1, n2 = mw.ustring.find( TitrePage1, p2..'[%s%-]' ) end
if (not n1) and p3 then n1, n2 = mw.ustring.find( TitrePage1, p3..'[%s%-]' ) end
if (not n1) and p4 then n1, n2 = mw.ustring.find( TitrePage1, p4..'[%s%-]' ) end
if n1 then
Radic = mw.ustring.sub(TitrePage, 1, n1-1)
if n2 <= mw.ustring.len(TitrePage) then
Fin = mw.ustring.sub(TitrePage, n2) -- comprend le séparateur
Separ = mw.ustring.sub(Fin,1,1)
end
return Radic, Separ, Fin
end
-- sinon return nil, nil, nil
end
------------------------------------------------------
-- Message d'erreur quand le radical n'a pas été trouvé
function pas_trouve_radic(modele)
local txt = "usage erroné de [[Modèle:fr-"..modele.."|{{fr-"..modele.."}}]].<br>"
txt = txt.."Le titre de la page ne comporte pas<br>une des terminaisons attendues."
return tableau_erreur(txt).."[[Catégorie:Appels de modèles incorrects/fr-flexion-lua]]"
end
----------------------------------------------------------------------------------------
-- récupération prononciation en param 2 ou 1 selon syntaxe ancienne/nouvelle
-- retourne PronRadic, PronFinInvar
-- fonction à usage transitoire, en attendant l'abandon définitif de l'ancienne syntaxe
----------------------------------------------------------------------------------------
-- tableau des cas possibles, hors cas particuliers :
-- entrées : sorties
-- radical arg1 arg2 : radical PronRad PronInv
-- (1) R - - : R - - (nouvelle)
-- (2) R R - : R - - (ancienne)
-- (3) R P - : R P - (nouvelle)
-- (4) R R P : R P - (ancienne)
-- (5) R P I : R P I (nouvelle)
function nouvelle_ancienne_syntaxe_radic4(radic, args)
if (not args[1]) or (args[1]=='') then
--(1) syntaxe nouvelle, sans prononciation ou avec param nommés
--(c’était une erreur dans l’ancienne syntaxe)
return args["pron"] or '', fin_invar_pron(args["pinv"])
elseif (radic ~= args[1]) then
--(3,5) syntaxe nouvelle, cas général : le param 1 n’est pas le radical, donc c’est la prononciation
--(sinon c’est une erreur à corriger à la main)
return args[1], fin_invar_pron(args[2] or args["pinv"])
elseif (radic=='b') then
--cas particuliers des radicaux monosyllabes identiques à leur API où le test précédent échoue (comme pour "beau")
-- liste des radicaux potentiellement concernés (WT:QT/décembre 2014#Problème métaphysique avec Modèle:fr-accord-eau + Module:fr-flexion) :
-- b, bl, d, f, (k), (kl), l, m, n, p, pl, ps, s, t, ts, v, w, z.
if args[2] and (args[2] ~= radic) then
--(5) nouvelle syntaxe avec "prononciation partie invar" en args[2]
return radic, fin_invar_pron(args[2])
else
--(2,4) ancienne syntaxe sans ou avec pron en args[2] (de tte façon dévinée comme égale à radic)
--(3) nouvelle sans "prononciation partie invar" en args[2]
return radic, fin_invar_pron(args["pinv"])
end
else
--(2,4) syntaxe ancienne sans ou avec pron en args[2]
return args[2] or '', fin_invar_pron(args["pinv"])
end
end
------------------------------------------------------
-- tableau en erreur
function tableau_erreur(msg, nocat)
local txt =
'{|class="flextable"\n'..
'|+<span style="color:red"><b>Erreur !</b></span>\n'..
'|-\n'..
'!scope="col"| Singulier\n'..
'!scope="col"| Pluriel\n'..
'|-\n'..
'|scope="row" colspan="2" |<span style="color:red">'..(msg or "erreur inconnue")..'</span>\n'..
'|}'
local ns = mw.title.getCurrentTitle().namespace
if (ns~=2) and (not nocat) then -- cf [[Aide:Espace de noms]]
txt = txt..'[[Catégorie:Appels de modèles incorrects]]'
end
return txt
end
------------------------------------------------------
-- tableau de flexions générique à 2 formes (habituellement singulier/pluriel)
function tableau_generique_2(prm)
-- génération tableau
local txt = '{|class="flextable flextable-fr-mfsp"\n'
if prm.titre then
txt = txt..'|+'..prm.titre..'\n'
end
txt = txt..
'|-\n'..
'|class="invisible"|\n'..
'!scope="col"| Singulier\n'..
'!scope="col"| Pluriel\n'..
'|-\n'..
'!scope="row"| Masculin\n'..
'|[['..prm.MS1..']]'..pron(prm.MS1pron1,prm.MS1pref1)..ou_pron(prm.MS1pron2,prm.MS1pref2)..ou_pron(prm.MS1pron3,prm.MS1pref3)..'\n'..
'|[['..prm.MP1..']]'..pron(prm.MP1pron1,prm.MP1pref1)..ou_pron(prm.MP1pron2,prm.MP1pref2)..ou_pron(prm.MP1pron3,prm.MP1pref3)..'\n'..
'|-\n'..
'|}'
return txt
end
------------------------------------------------------
-- tableau de flexions générique à 4 formes (habituellement ms/mp/fs/fp)
function tableau_generique_4(prm)
-- génération tableau
local txt = '{|class="flextable flextable-fr-mfsp"\n'
if prm.titre then
txt = txt..'|+'..prm.titre..'\n'
end
txt = txt..
'|-\n'..
'|class="invisible"|\n'..
'!scope="col"| Singulier\n'..
'!scope="col"| Pluriel\n'..
'|-\n'..
'!scope="row"| Masculin\n'..
'|[['..prm.MS1..']]'..pron(prm.MS1pron1,prm.MS1pref1)..ou_pron(prm.MS1pron2,prm.MS1pref2)..ou_pron(prm.MS1pron3,prm.MS1pref3)..'\n'..
'|[['..prm.MP1..']]'..pron(prm.MP1pron1,prm.MP1pref1)..ou_pron(prm.MP1pron2,prm.MP1pref2)..ou_pron(prm.MP1pron3,prm.MP1pref3)..'\n'..
'|-\n'..
'!scope="row"| Féminin\n'..
'|[['..prm.FS1..']]'..pron(prm.FS1pron1,prm.FS1pref1)..ou_pron(prm.FS1pron2,prm.FS1pref2)..ou_pron(prm.FS1pron3,prm.FS1pref3)..'\n'..
'|[['..prm.FP1..']]'..pron(prm.FP1pron1,prm.FP1pref1)..ou_pron(prm.FP1pron2,prm.FP1pref2)..ou_pron(prm.FP1pron3,prm.FP1pref3)..'\n'..
'|}'
return txt
end
--=====================================================================================================
function p.boite_erreur(frame) -- message d'erreur pour tableau de flexion appelable depuis le wikicode
--=====================================================================================================
-- accepte un appel direct ou un appel via modèle
-----------------------------------------------------------------------------------------
local msg = frame.args[1] or frame:getParent().args[1] or "erreur inconnue"
local nocat = frame.args["nocat"] or frame:getParent().args["nocat"]
return tableau_erreur(msg,nocat)
end
--=======================================================================================
function p.boite_ain_ains_aine_aines(frame) -- pour Modèle:fr-accord-ain
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2014-12-02 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'ain','ains','aine','aines')
if not Radic then return pas_trouve_radic("accord-ain") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'ain'..FinInvar
params.MP1 = Radic..'ains'..FinInvar
params.FS1 = Radic..'aine'..FinInvar
params.FP1 = Radic..'aines'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɛ̃̃'..PronFinInvar
params.MP1pron1 = PronRadic..'ɛ̃'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛn'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛn'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛn'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛn'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛn'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛn'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=====================================================================================================
function p.boite_al_aux_ale_ales(frame) -- pour Modèle:fr-accord-al
--=====================================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2014-11-23 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'al','ale','ales','aux')
if not Radic then return pas_trouve_radic("accord-al") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 ou 2 selon syntaxe ancienne/nouvelle
local PronRadic, PronFinInvar = nouvelle_ancienne_syntaxe_radic4(Radic, args)
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'al'..FinInvar
params.MP1 = Radic..'aux'..FinInvar
params.FS1 = Radic..'ale'..FinInvar
params.FP1 = Radic..'ales'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'al'..PronFinInvar
params.MP1pron1 = PronRadic..'o'..PronFinInvar
params.FS1pron1 = PronRadic..'al'..PronFinInvar
params.FP1pron1 = PronRadic..'al'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'al'..PronFinInvar
params.MP1pron2 = args["pron2"]..'o'..PronFinInvar
params.FS1pron2 = args["pron2"]..'al'..PronFinInvar
params.FP1pron2 = args["pron2"]..'al'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'al'..PronFinInvar
params.MP1pron3 = args["pron3"]..'o'..PronFinInvar
params.FS1pron3 = args["pron3"]..'al'..PronFinInvar
params.FP1pron3 = args["pron3"]..'al'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_an_ans_ane_anes(frame) -- pour Modèle:fr-accord-an
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-01-22 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
-- suffixe féminin avec un ou deux "n" selon le param
local SufFemS, SufFemP
if args["nn"] then
SufFemS='anne'
SufFemP='annes'
else
SufFemS='ane'
SufFemP='anes'
end
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'an','ans',SufFemS,SufFemP)
if not Radic then return pas_trouve_radic("accord-an") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'an'..FinInvar
params.MP1 = Radic..'ans'..FinInvar
params.FS1 = Radic..SufFemS..FinInvar
params.FP1 = Radic..SufFemP..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɑ̃'..PronFinInvar
params.MP1pron1 = PronRadic..'ɑ̃'..PronFinInvar
params.FS1pron1 = PronRadic..'an'..PronFinInvar
params.FP1pron1 = PronRadic..'an'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɑ̃'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɑ̃'..PronFinInvar
params.FS1pron2 = args["pron2"]..'an'..PronFinInvar
params.FP1pron2 = args["pron2"]..'an'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɑ̃'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɑ̃'..PronFinInvar
params.FS1pron3 = args["pron3"]..'an'..PronFinInvar
params.FP1pron3 = args["pron3"]..'an'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_eau_eaux_elle_elles(frame) -- pour Modèle:fr-accord-eau
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2014-12-07 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'eau','eaux','elle','elles')
if not Radic then return pas_trouve_radic("accord-eau") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 ou 2 selon syntaxe ancienne/nouvelle
local PronRadic, PronFinInvar = nouvelle_ancienne_syntaxe_radic4(Radic, args)
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'eau'..FinInvar
params.MP1 = Radic..'eaux'..FinInvar
params.FS1 = Radic..'elle'..FinInvar
params.FP1 = Radic..'elles'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'o'..PronFinInvar
params.MP1pron1 = PronRadic..'o'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛl'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛl'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'o'..PronFinInvar
params.MP1pron2 = args["pron2"]..'o'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'o'..PronFinInvar
params.MP1pron3 = args["pron3"]..'o'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_el_els_elle_elles(frame) -- pour Modèle:fr-accord-el
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-01-26 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'el','els','elle','elles')
if not Radic then return pas_trouve_radic("accord-el") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'el'..FinInvar
params.MP1 = Radic..'els'..FinInvar
params.FS1 = Radic..'elle'..FinInvar
params.FP1 = Radic..'elles'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɛl'..PronFinInvar
params.MP1pron1 = PronRadic..'ɛl'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛl'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛl'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛl'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛl'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_en_ens_enne_ennes(frame) -- pour Modèle:fr-accord-en
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-02-16 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'en','ens','enne','ennes')
if not Radic then return pas_trouve_radic("accord-en") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'en'..FinInvar
params.MP1 = Radic..'ens'..FinInvar
params.FS1 = Radic..'enne'..FinInvar
params.FP1 = Radic..'ennes'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɛ̃'..PronFinInvar
params.MP1pron1 = PronRadic..'ɛ̃'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛn'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛn'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛn'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛn'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛn'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛn'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_er_ers_ere_eres(frame) -- pour Modèle:fr-accord-er
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-01-26 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'er','ers','ère','ères')
if not Radic then return pas_trouve_radic("accord-er") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 ou 2 selon syntaxe ancienne/nouvelle
local PronRadic, PronFinInvar = nouvelle_ancienne_syntaxe_radic4(Radic, args)
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'er'..FinInvar
params.MP1 = Radic..'ers'..FinInvar
params.FS1 = Radic..'ère'..FinInvar
params.FP1 = Radic..'ères'..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'e'..PronFinInvar
params.MP1pron1 = PronRadic..'e'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛʁ'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛʁ'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'e'..PronFinInvar
params.MP1pron2 = args["pron2"]..'e'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛʁ'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛʁ'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'e'..PronFinInvar
params.MP1pron3 = args["pron3"]..'e'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛʁ'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛʁ'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_et_ets_ette_ettes(frame) -- pour Modèle:fr-accord-et
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-01-27 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
-- suffixe féminin "ète" ou "ette" selon le param
local SufFemS, SufFemP
if args["è"] then
SufFemS='ète'
SufFemP='ètes'
else
SufFemS='ette'
SufFemP='ettes'
end
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'et','ets',SufFemS,SufFemP)
if not Radic then return pas_trouve_radic("accord-et") end -- si pas trouvé dans le titre, on ne va pas plus loin
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'et'..FinInvar
params.MP1 = Radic..'ets'..FinInvar
params.FS1 = Radic..SufFemS..FinInvar
params.FP1 = Radic..SufFemP..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɛ'..PronFinInvar
params.MP1pron1 = PronRadic..'ɛ'..PronFinInvar
params.FS1pron1 = PronRadic..'ɛt'..PronFinInvar
params.FP1pron1 = PronRadic..'ɛt'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɛ'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɛ'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɛt'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɛt'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɛ'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɛ'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɛt'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɛt'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_at_ats_atte_attes(frame) -- pour Modèle:fr-accord-at
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-03-14 JackPotte : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
-- suffixe féminin "atte"
local SufMS, SufMP
SufMS='at'
SufMP='ats'
SufFS='atte'
SufFP='attes'
SufPMS='a'
SufPMP='a'
SufPFS='at'
SufPFP='at'
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, SufMS,SufMP,SufFS,SufFP)
if not Radic then return pas_trouve_radic("accord-at") end -- si pas trouvé dans le titre, on ne va pas plus loin
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..SufMS..FinInvar
params.MP1 = Radic..SufMP..FinInvar
params.FS1 = Radic..SufFS..FinInvar
params.FP1 = Radic..SufFP..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..SufPMS..PronFinInvar
params.MP1pron1 = PronRadic..SufPMP..PronFinInvar
params.FS1pron1 = PronRadic..SufFS..PronFinInvar
params.FP1pron1 = PronRadic..SufFP..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..SufPMS..PronFinInvar
params.MP1pron2 = args["pron2"]..SufPMP..PronFinInvar
params.FS1pron2 = args["pron2"]..SufPFS..PronFinInvar
params.FP1pron2 = args["pron2"]..SufPFP..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..SufPMS..PronFinInvar
params.MP1pron3 = args["pron3"]..SufPMP..PronFinInvar
params.FS1pron3 = args["pron3"]..SufPFS..PronFinInvar
params.FP1pron3 = args["pron3"]..SufPFP..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_in_ins_ine_ines(frame) -- pour Modèle:fr-accord-in
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2015-02-27 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
-- suffixe féminin avec un ou deux "n" selon le param
local SufFemS, SufFemP
if args["deux_n"] then
SufFemS='inne'
SufFemP='innes'
else
SufFemS='ine'
SufFemP='ines'
end
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'in','ins',SufFemS,SufFemP)
if not Radic then return pas_trouve_radic("accord-in") end -- si pas trouvé dans le titre, on ne va pas plus loin
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'in'..FinInvar
params.MP1 = Radic..'ins'..FinInvar
params.FS1 = Radic..SufFemS..FinInvar
params.FP1 = Radic..SufFemP..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɛ̃'..PronFinInvar
params.MP1pron1 = PronRadic..'ɛ̃'..PronFinInvar
params.FS1pron1 = PronRadic..'in'..PronFinInvar
params.FP1pron1 = PronRadic..'in'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɛ̃'..PronFinInvar
params.FS1pron2 = args["pron2"]..'in'..PronFinInvar
params.FP1pron2 = args["pron2"]..'in'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɛ̃'..PronFinInvar
params.FS1pron3 = args["pron3"]..'in'..PronFinInvar
params.FP1pron3 = args["pron3"]..'in'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
--=======================================================================================
function p.boite_on_ons_onne_onnes(frame) -- pour Modèle:fr-accord-on
--=======================================================================================
-- pour les paramètres, voir la documentation du modèle
-- utilise les paramètres frame:getParent() et donc ne peut être appelé que depuis un modèle
-- 2014-11-24 GaAs : version initiale
-----------------------------------------------------------------------------------------
-- récupération des paramètres passés au modèle
local args = frame:getParent().args
-- suffixe féminin avec un ou deux "n" selon le param
local SufFemS, SufFemP
if args["un_n"] then
SufFemS='one'
SufFemP='ones'
else
SufFemS='onne'
SufFemP='onnes'
end
----------------------------------------------------------------------------------------------
-- Détection du radical et de l'éventuelle partie invariable à partir du titre de la page
-- s'il existe un paramètre "mot", le prendre en priorité (utile pour les pages de doc)
local TitrePage = args["mot"] or mw.title.getCurrentTitle().text
local Radic, Separ, FinInvar = cherche_radic(TitrePage, 'on','ons',SufFemS,SufFemP)
if not Radic then return pas_trouve_radic("accord-on") end -- si pas trouvé dans le titre, erreur
----------------------------------------------------------------------------------------------
-- prononciation en param 1 (la syntaxe nouvelle est la même que l'ancienne)
local PronRadic = args[1] or args["pron"] or ''
local PronFinInvar = fin_invar_pron(args[2] or args["pinv"])
----------------------------------------------------------------------------------------------
-- construction de la structure de paramètres pour tableau_generique_4
local params={}
params.titre = args["titre"]
params.MS1 = Radic..'on'..FinInvar
params.MP1 = Radic..'ons'..FinInvar
params.FS1 = Radic..SufFemS..FinInvar
params.FP1 = Radic..SufFemP..FinInvar
if PronRadic and (PronRadic~='') then
params.MS1pron1 = PronRadic..'ɔ̃'..PronFinInvar
params.MP1pron1 = PronRadic..'ɔ̃'..PronFinInvar
params.FS1pron1 = PronRadic..'ɔn'..PronFinInvar
params.FP1pron1 = PronRadic..'ɔn'..PronFinInvar
params.MS1pref1, params.MP1pref1, params.FS1pref1, params.FP1pref1 = prefpron_4(args["préfpron"])
if args["pron2"] then
params.MS1pron2 = args["pron2"]..'ɔ̃'..PronFinInvar
params.MP1pron2 = args["pron2"]..'ɔ̃'..PronFinInvar
params.FS1pron2 = args["pron2"]..'ɔn'..PronFinInvar
params.FP1pron2 = args["pron2"]..'ɔn'..PronFinInvar
params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args["préfpron2"])
if args["pron3"] then
params.MS1pron3 = args["pron3"]..'ɔ̃'..PronFinInvar
params.MP1pron3 = args["pron3"]..'ɔ̃'..PronFinInvar
params.FS1pron3 = args["pron3"]..'ɔn'..PronFinInvar
params.FP1pron3 = args["pron3"]..'ɔn'..PronFinInvar
params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args["préfpron3"])
end
end
end
----------------------------------------------------------------------------------------------
-- génération du tableau
return tableau_generique_4(params)
end
-- publication des fonctions publiques (pléonasme inside)
return p