Module:fr-flexion/bac à sable

Bonjour, vous êtes venu ici pour chercher la signification du mot Module:fr-flexion/bac à sable. Dans DICTIOUS, vous trouverez non seulement toutes les significations du dictionnaire pour le mot Module:fr-flexion/bac à sable, mais vous apprendrez également son étymologie, ses caractéristiques et comment dire Module:fr-flexion/bac à sable au singulier et au pluriel. Tout ce que vous devez savoir sur le mot Module:fr-flexion/bac à sable est ici. La définition du mot Module:fr-flexion/bac à sable vous aidera à être plus précis et correct lorsque vous parlerez ou écrirez vos textes. Connaître la définition deModule:fr-flexion/bac à sable, ainsi que celles d'autres mots, enrichit votre vocabulaire et vous fournit des ressources linguistiques plus nombreuses et de meilleure qualité.

 Documentation[voir] [modifier] [historique] [purger]

Ce module est une copie de travail 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 :

  1. 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),
  3. faites vos modifs, testez-les via un {{#invoke|fr-flexion/bac à sable|…}} dans une page de test,
  4. lorsque vous en êtes content, et seulement alors, copiez le nouveau code dans Module:fr-flexion.
Notes

  • À 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.
  • Sinon contactez le contributeur sur sa page de discussion pour vous coordonner, nous sommes sur un site collaboratif.
  • 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.
  • Ce serait sans doute bien de l’annoncer à la communauté si ce n’est pas une modification triviale ou une correction de bug.


--========================================================================================
-- 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 chaîne 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 chaîne,
--        à 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 chaînes.
    local n1, n2 = mw.ustring.find( TitrePage1, p1..'' )
    if (not n1) and p2 then n1, n2 = mw.ustring.find( TitrePage1, p2..'' ) end
    if (not n1) and p3 then n1, n2 = mw.ustring.find( TitrePage1, p3..'' ) end
    if (not n1) and p4 then n1, n2 = mw.ustring.find( TitrePage1, p4..'' ) 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 ].<br>"
    txt = txt.."Le titre de la page ne comporte pas<br>une des terminaisons attendues."
    return tableau_erreur(txt).."]"
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) or (args=='') then
        --(1) syntaxe nouvelle, sans prononciation ou avec param nommés
	    --(c’était une erreur dans l’ancienne syntaxe)
	    return args or '', fin_invar_pron(args)
		
    elseif (radic ~= args) 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, fin_invar_pron(args or args)
		
    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 and (args ~= radic) then
            --(5) nouvelle syntaxe avec "prononciation partie invar" en args
            return radic, fin_invar_pron(args)

        else
            --(2,4) ancienne syntaxe sans ou avec pron en args (de tte façon dévinée comme égale à radic)
            --(3) nouvelle sans "prononciation partie invar" en args
            return radic, fin_invar_pron(args)
 
        end			
    else
        --(2,4) syntaxe ancienne sans ou avec pron en args
        return args or '', fin_invar_pron(args)
		
    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 ]
        txt = txt..']'
    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'..
        '|]'..pron(prm.MS1pron1,prm.MS1pref1)..ou_pron(prm.MS1pron2,prm.MS1pref2)..ou_pron(prm.MS1pron3,prm.MS1pref3)..'\n'..
        '|]'..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'..
        '|]'..pron(prm.MS1pron1,prm.MS1pref1)..ou_pron(prm.MS1pron2,prm.MS1pref2)..ou_pron(prm.MS1pron3,prm.MS1pref3)..'\n'..
        '|]'..pron(prm.MP1pron1,prm.MP1pref1)..ou_pron(prm.MP1pron2,prm.MP1pref2)..ou_pron(prm.MP1pron3,prm.MP1pref3)..'\n'..
        '|-\n'..
        '!scope="row"| Féminin\n'..
        '|]'..pron(prm.FS1pron1,prm.FS1pref1)..ou_pron(prm.FS1pron2,prm.FS1pref2)..ou_pron(prm.FS1pron3,prm.FS1pref3)..'\n'..
        '|]'..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 or frame:getParent().args or "erreur inconnue"
    local nocat = frame.args or frame:getParent().args
    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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɛ̃'..PronFinInvar
            params.MP1pron2 = args..'ɛ̃'..PronFinInvar
            params.FS1pron2 = args..'ɛn'..PronFinInvar
            params.FP1pron2 = args..'ɛn'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɛ̃'..PronFinInvar
                params.MP1pron3 = args..'ɛ̃'..PronFinInvar
                params.FS1pron3 = args..'ɛn'..PronFinInvar
                params.FP1pron3 = args..'ɛn'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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
    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)
        if args then
            params.MS1pron2 = args..'al'..PronFinInvar
            params.MP1pron2 = args..'o'..PronFinInvar
            params.FS1pron2 = args..'al'..PronFinInvar
            params.FP1pron2 = args..'al'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'al'..PronFinInvar
                params.MP1pron3 = args..'o'..PronFinInvar
                params.FS1pron3 = args..'al'..PronFinInvar
                params.FP1pron3 = args..'al'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɑ̃'..PronFinInvar
            params.MP1pron2 = args..'ɑ̃'..PronFinInvar
            params.FS1pron2 = args..'an'..PronFinInvar
            params.FP1pron2 = args..'an'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɑ̃'..PronFinInvar
                params.MP1pron3 = args..'ɑ̃'..PronFinInvar
                params.FS1pron3 = args..'an'..PronFinInvar
                params.FP1pron3 = args..'an'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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
    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)
        if args then
            params.MS1pron2 = args..'o'..PronFinInvar
            params.MP1pron2 = args..'o'..PronFinInvar
            params.FS1pron2 = args..'ɛl'..PronFinInvar
            params.FP1pron2 = args..'ɛl'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'o'..PronFinInvar
                params.MP1pron3 = args..'o'..PronFinInvar
                params.FS1pron3 = args..'ɛl'..PronFinInvar
                params.FP1pron3 = args..'ɛl'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɛl'..PronFinInvar
            params.MP1pron2 = args..'ɛl'..PronFinInvar
            params.FS1pron2 = args..'ɛl'..PronFinInvar
            params.FP1pron2 = args..'ɛl'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɛl'..PronFinInvar
                params.MP1pron3 = args..'ɛl'..PronFinInvar
                params.FS1pron3 = args..'ɛl'..PronFinInvar
                params.FP1pron3 = args..'ɛl'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɛ̃'..PronFinInvar
            params.MP1pron2 = args..'ɛ̃'..PronFinInvar
            params.FS1pron2 = args..'ɛn'..PronFinInvar
            params.FP1pron2 = args..'ɛn'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɛ̃'..PronFinInvar
                params.MP1pron3 = args..'ɛ̃'..PronFinInvar
                params.FS1pron3 = args..'ɛn'..PronFinInvar
                params.FP1pron3 = args..'ɛn'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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
    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)
        if args then
            params.MS1pron2 = args..'e'..PronFinInvar
            params.MP1pron2 = args..'e'..PronFinInvar
            params.FS1pron2 = args..'ɛʁ'..PronFinInvar
            params.FP1pron2 = args..'ɛʁ'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'e'..PronFinInvar
                params.MP1pron3 = args..'e'..PronFinInvar
                params.FS1pron3 = args..'ɛʁ'..PronFinInvar
                params.FP1pron3 = args..'ɛʁ'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɛ'..PronFinInvar
            params.MP1pron2 = args..'ɛ'..PronFinInvar
            params.FS1pron2 = args..'ɛt'..PronFinInvar
            params.FP1pron2 = args..'ɛt'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɛ'..PronFinInvar
                params.MP1pron3 = args..'ɛ'..PronFinInvar
                params.FS1pron3 = args..'ɛt'..PronFinInvar
                params.FP1pron3 = args..'ɛt'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..SufPMS..PronFinInvar
            params.MP1pron2 = args..SufPMP..PronFinInvar
            params.FS1pron2 = args..SufPFS..PronFinInvar
            params.FP1pron2 = args..SufPFP..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..SufPMS..PronFinInvar
                params.MP1pron3 = args..SufPMP..PronFinInvar
                params.FS1pron3 = args..SufPFS..PronFinInvar
                params.FP1pron3 = args..SufPFP..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɛ̃'..PronFinInvar
            params.MP1pron2 = args..'ɛ̃'..PronFinInvar
            params.FS1pron2 = args..'in'..PronFinInvar
            params.FP1pron2 = args..'in'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɛ̃'..PronFinInvar
                params.MP1pron3 = args..'ɛ̃'..PronFinInvar
                params.FS1pron3 = args..'in'..PronFinInvar
                params.FP1pron3 = args..'in'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            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 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 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 or args or ''
    local PronFinInvar = fin_invar_pron(args or args)

    ----------------------------------------------------------------------------------------------
    -- construction de la structure de paramètres pour tableau_generique_4
    local params={}
    params.titre = args
    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)
        if args then
            params.MS1pron2 = args..'ɔ̃'..PronFinInvar
            params.MP1pron2 = args..'ɔ̃'..PronFinInvar
            params.FS1pron2 = args..'ɔn'..PronFinInvar
            params.FP1pron2 = args..'ɔn'..PronFinInvar
            params.MS1pref2, params.MP1pref2, params.FS1pref2, params.FP1pref2 = prefpron_4(args)
            if args then
                params.MS1pron3 = args..'ɔ̃'..PronFinInvar
                params.MP1pron3 = args..'ɔ̃'..PronFinInvar
                params.FS1pron3 = args..'ɔn'..PronFinInvar
                params.FP1pron3 = args..'ɔn'..PronFinInvar
                params.MS1pref3, params.MP1pref3, params.FS1pref3, params.FP1pref3 = prefpron_4(args)
            end
        end
    end
    
    ----------------------------------------------------------------------------------------------
    -- génération du tableau
    return tableau_generique_4(params)
end

-- publication des fonctions publiques (pléonasme inside)
return p