Ouvrir le menu principal
Ce module regroupe les fonctions pour afficher les infoboites de flexion en français.
IL EST EN COURS DE DÉVELOPPEMENT, NE PAS UTILISER LES FONCTIONS QUI NE SONT PAS LISTÉES COMME PRÊTES !
Fonctions activées sur les modèles
Fonctions appelables depuis d’autres modules lua
  • (aucune qui soit intéressante actuellement)
Fonctions appelables depuis le wikicode 
  • boite_erreur(frame) : pour afficher un message d’erreur qui ressemble à une boite de flexions.
Faire des modifications et des ajouts
Merci de le faire en passant par Module:fr-flexion/bac à sable (voir la doc qui explique pourquoi).

info Documentation du Module:fr-flexion : v · d · m · h.


--========================================================================================
-- 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)=='&nbsp;' 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'..
        '|- class="flextable-fr-m"\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'..
        '|- class="flextable-fr-f"\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..SufPFS..PronFinInvar
        params.FP1pron1 = PronRadic..SufPFP..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