Module:arabe

Bonjour, vous êtes venu ici pour chercher la signification du mot Module:arabe. Dans DICTIOUS, vous trouverez non seulement toutes les significations du dictionnaire pour le mot Module:arabe, mais vous apprendrez également son étymologie, ses caractéristiques et comment dire Module:arabe au singulier et au pluriel. Tout ce que vous devez savoir sur le mot Module:arabe est ici. La définition du mot Module:arabe vous aidera à être plus précis et correct lorsque vous parlerez ou écrirez vos textes. Connaître la définition deModule:arabe, ainsi que celles d'autres mots, enrichit votre vocabulaire et vous fournit des ressources linguistiques plus nombreuses et de meilleure qualité.
Procédures générales
  • appliquer Application d'un schème à une racine, résultat en alphabet latin :
{{ar-appliquer | ar-ma**û*ũ | ar-ktb}}
{{#invoke:arabe| appliquer | scheme = {{{1}}} | racine = {{{2}}} }}

Remplacement des "jokers" du schème par les lettres radicales. Voir {{ar-appliquer}}.

  • arabiser Réécriture dans l'alphabet arabe d'un texte translittéré (obtenu par ar-appliquer ou pas) :
{{ar-abiser | texte }}
{{#invoke:arabe| arabiser | texte = {{{1}}}}}
Utilitaires de vérification

À partir de {{ar-racine/liste}}

  • verifier : utilitaire utilisé dans la documentation des pages "modèle de racine" pour vérifier si les schèmes mentionnés sont connus du système : retourne la liste des schèmes inconnus. Appelé sous forme de #invoke par Modèle:ar-racine/doc (donc, sur tous les modèles de racine) pour vérifier que les modèles de type ar-ktb n'évoquent que des schèmes connus, et donne la liste des inconnus sinon.
Note : Les suffixes en -@ũ puis ceux en -iy²ũ sont réduits en -ũ. Il n'est donc pas nécessaire d'initialiser les formes correspondantes.
{{#invoke:arabe| verifier | racine={{pagename}}}}
  • scheme_connu : utilitaire utilisé dans la documentation des pages "modèle de schème" pour vérifier si le schème est connu du système, à partir de la liste de schèmes. Retourne "oui" si c'est le cas, rien sinon.
Note : Les suffixes en -@ũ puis ceux en -iy²ũ sont réduits en -ũ. Il n'est donc pas nécessaire d'initialiser les formes correspondantes.
{{#invoke:arabe| scheme_connu | scheme={{pagename}}}}
Utilitaires d'affichage
  • ligne : utilitaire d'affichage des mots relevant d'une racine, à partir de la liste de schèmes, appelé par la page de la racine (version simple).
  • ligne2 : utilitaire d'affichage des mots relevant d'une racine, à partir de la liste de schèmes, appelé par la page de documentation du modèle de racine (version tableau).
  • ligne3 : utilitaire d'affichage des formes potentielles d'une racine, à partir de la liste de schèmes, dans la page Modèle:ar-racine/tableau2.
  • ligne4 : utilitaire d'affichage des schèmes connus, à partir de la liste de schèmes, dans la page Annexe:Schèmes arabes.
  • liste_scheme : utilitaire d'affichage des schèmes associés à un shcème, à partir de la liste de schèmes, appelé par la page de documentation du modèle de schème.

local p = {}

local scheme , racine, contexte, modele_racine  = "", "", "", "" -- variables communes aux procédures

-- Translittérations de API / romain / ... vers arabe
local U = mw.ustring.char
local EnArabe = {
      = " ", -- blancs entre mots
      = "(", -- parenthèse
      = ")", -- parenthèse
      = "", -- underscore ignoré pour décontextualisation éventuelle
 = U(0x61B), -- point virgule arabe
      = U(0x61B),
 = U(0x60C), -- virgule inversée
      = U(0x60C),
 = U(0x61E), -- trois points
 = U(0x61F), -- point d'interrogation
      = U(0x61F),
      = "!", -- exclamation
 = U(0x621), -- Hamza
      = U(0x654), --Hamza suscrite
      = U(0x621),
      = U(0x621),
      = U(0x621),
      = U(0x621),
      = U(0x621),
      = U(0x621),
      = U(0x621),
 = U(0x671), -- Alif wasla
      = U(0x671),
 = U(0x622), -- Alif madda
      = U(0x622),
 = U(0x623), -- Alif hamza
      = U(0x623),
 = U(0x624), -- Waw hamza
      = U(0x624),
 = U(0x625), -- Alif hamza souscrite
      = U(0x625),
 = U(0x626), -- Ya hamza
      = U(0x626),
 = U(0x627), -- Alif
      = U(0x627),
      = U(0x64E)..U(0x627), -- diacritique intégré
      = U(0x64E)..U(0x627), -- diacritique intégré
      = U(0x627), -- permet d'écrire "el-"
 = U(0x628), -- Ba
      = U(0x628),
 = U(0x629), -- Ta marbouta
      = U(0x629),
 = U(0x62A), -- Té
      = U(0x62A),
 = U(0x62B), -- Thé
      = U(0x62B),
      = U(0x62B),
      = U(0x62B),
 = U(0x62C), -- Djim
      = U(0x62C),
      = U(0x62C),
      = U(0x62C),
      = U(0x62C),
 = U(0x62D), -- Ha
      = U(0x62D),
      = U(0x62D),
      = U(0x62D),
      = U(0x62D),
 = U(0x62E), -- Kha
      = U(0x62E),
      = U(0x62E),
      = U(0x62E),
      = U(0x62E),
      = U(0x62E),
      = U(0x62E),
 = U(0x62F), -- Dal
      = U(0x62F),
 = U(0x630), -- Dhal
      = U(0x630),
      = U(0x630),
      = U(0x630),
 = U(0x631), -- Ra
      = U(0x631),
 = U(0x632), -- Zain
      = U(0x632),
 = U(0x633), -- Sîn
      = U(0x633),
 = U(0x634), -- Chîn
      = U(0x634),
      = U(0x634),
      = U(0x634),
      = U(0x634),
 = U(0x635), -- Çad
      = U(0x635),
      = U(0x635),
      = U(0x635),
      = U(0x635),
      = U(0x635),
 = U(0x636), -- Dad
      = U(0x636),
      = U(0x636),
      = U(0x636),
 = U(0x637), -- Ta
      = U(0x637),
      = U(0x637),
      = U(0x637),
 = U(0x638), -- Zza
      = U(0x638),
      = U(0x638),
 = U(0x639), -- Rain
      = U(0x639),
      = U(0x639),
      = U(0x639),
      = U(0x639),
 = U(0x63A), -- Ghain
      = U(0x63A),
      = U(0x63A),
      = U(0x63A),
      = U(0x63A),
      = U(0x63A),
      = U(0x63A),
 = U(0x640), -- tiret
      = U(0x640),
 = U(0x641), -- Fa
      = U(0x641),
 = U(0x642), -- Qaf
      = U(0x642),
 = U(0x643), -- Kaf
      = U(0x643),
 = U(0x644), -- Lam
      = U(0x644),
 = U(0x645), -- Mîm
      = U(0x645),
 = U(0x646), -- Noun
      = U(0x646),
 = U(0x647), -- Hé
      = U(0x647),
 = U(0x648), -- Waw
      = U(0x648),
      = U(0x648),
      = U(0x648),
      = U(0x64F)..U(0x648), -- préfixage du diacritique
      = U(0x64F)..U(0x648), -- préfixage du diacritique
 = U(0x649), -- Alif maksoura
      = U(0x649),
      = U(0x649),
 = U(0x64A), -- Waw
      = U(0x64A),
      = U(0x64A),
      = U(0x64A),
      = U(0x650)..U(0x64A),
      = U(0x650)..U(0x64A),
 = U(0x64B), -- Fathatan
      = U(0x64B),
 = U(0x64C), -- Dammatan
      = U(0x64C),
      = U(0x64C),
 = U(0x64D), -- Kasratan
      = U(0x64D),
      = U(0x64D),
 = U(0x64E), -- Fatha
      = U(0x64E),
 = U(0x64F), -- Damma
      = U(0x64F),
 = U(0x650), -- Damma
      = U(0x650),
 = U(0x651), -- Chadda
      = U(0x651),
 = U(0x652), -- Soukoun
      = U(0x652),
 = U(0x66D), -- *
      = U(0x66D),
 = U(0x670), -- Alif suscrit
      = U(0x670),
-- Lettres additionnelles diverses
      = U(0x67E), -- pa
      = U(0x06A4), -- ve
      = U(0x06A5), -- ve algérien
      = U(0x0686), -- tch perse
      = U(0x06E4), -- Petit madda arabe en chef
}

function p.arabiser (frame)
    -- translittération en arabe du paramètre, suivant l'assoc-liste EnArabe.
    local texte = frame.args.texte
    return arabiser_interne(texte)
    end
function arabiser_interne (p1)
    local texte = " " .. p1 .. " "
    -- on rajoute un blanc devant et derrière pour uniformiser les tests de début et fin de mot
    local transcription = ""
    local a_traiter
    -- à faire un jour : transformer tous les ² en redoublements explicites avant traitement
    -- à faire un jour : reporter sur la lettre attendue toutes les lettres équivalentes admissibles
    local diacritiques =( (mw.ustring.find(texte,"a")~=nil) or (mw.ustring.find(texte,"i")~=nil) or (mw.ustring.find(texte,"u")~=nil) or
                                   (mw.ustring.find(texte,"â")~=nil) or (mw.ustring.find(texte,"î")~=nil) or (mw.ustring.find(texte,"û")~=nil) or
                                   (mw.ustring.find(texte,"ã")~=nil) or (mw.ustring.find(texte,"ĩ")~=nil) or (mw.ustring.find(texte,"ũ")~=nil) or
                                   (mw.ustring.find(texte,"°")~=nil) )

    for curseur = 2, mw.ustring.len( texte )-1 do
        a_traiter = mw.ustring.sub( texte, curseur, curseur )

        -- orthographe différente suivant qu'on est en "début" ou en milieu de mot.

        -- début de mot
        if (mw.ustring.sub( texte, curseur-1, curseur-1 ) == " ") -- précédé d'un blanc = début de mot
         -- derrière el- il faut écrire comme en début de mot malgré la liaison :
         -- idem derrière particules inséparables
        or ( (curseur > 2) and (a_traiter ~= "'") and (
           -- Pb de la hamza dans des mots comme bi'r, ne pas traiter comme un préfixe
           -- On regarde ce qu'il y avait trois caractères avant
            (mw.ustring.sub( texte, curseur-2, curseur-1 ) == "el") -- normalement le "e" n'apparaît que pour le "el" préfixe
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " ^l") -- alif Wasla, marque de liaison
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " bi")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " fa")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " ka")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " la")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " li")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == " wa")
           ))
        -- idem si plusieurs particules séparées par un blanc souligné
        or ( (curseur > 2) and (
           (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_el") 
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_^l")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_bi")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_fa")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_ka")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_la")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_li")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "_wa")
           ))
        -- un blanc souligné permet de couper le mot s'il faut forcer un fa'tu en fa_'tu par exemple
        or ( (curseur > 2) and (
           (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "el_") 
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "^l_") -- alif Wasla, marque de liaison
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "bi_")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "fa_")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "ka_")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "la_")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "li_")
           or (mw.ustring.sub( texte, curseur-3, curseur-1 ) == "wa_")
           ))

        then -- le curseur est en début de mot, indépendamment du préfixe

            -- Si le début du mot est une voyelle il faut insérer en amont une hamza préfixe
            -- Mais il faut intercepter en amont les cas du alif madda,
            -- Mais c'est plus facile à traiter si on traite d'abord normalement les cas de type a & hamza & voyelle :
            -- Pour ça, on regarde les trois premiers caractères à partir du courant :
            local debut = mw.ustring.sub( texte, curseur, curseur+2 ) 
            if (debut=="a'i") or (debut=="a'î") or (debut=="a'u") or (debut=="a'û") or (debut=="a'a") or (debut=="a'â")
            then
                -- il y aura superposition d'une hamza instable et d'une hamza structurelle portant voyelle
                transcription = transcription .. U(0x623) .. U(0x64E) -- alif hamza + fatha
                -- ... et la hamza suivante sera traitée par le cas général.

            -- Traitement à présent des cas où il faut un alif madda
            -- débuts de la forme a & hamza (donc sans voyelle, puisque interceptées précédemment), ou hamza & â, ou â :
            elseif (mw.ustring.sub( texte, curseur, curseur+1 ) == "a'") or (mw.ustring.sub( texte, curseur, curseur+1 ) == "'â") or (a_traiter == "â")
            then
                transcription = transcription .. U(0x622) -- alif madda

            -- Traitement de la hamza explicite en début de mot
            elseif a_traiter == "'"
            then -- hamza explicite en début de mot
                local suivant = mw.ustring.sub( texte, curseur+1, curseur+1 )
                if (suivant == "â")
                then transcription = transcription .. U(0x622) -- alif madda
                elseif (suivant == "a") or (suivant == "u") or (suivant == "û")
                then transcription = transcription .. U(0x623) -- support en haut
                elseif (suivant == "i") or (suivant == "î")
                then transcription = transcription .. U(0x625) -- support en bas
                else transcription = transcription .. U(0x627) -- par défaut, alif
                end --
                -- hamza explicite en début de mot, la hamza préfixe a été insérée, la voyelle suivante sera transcrite ensuite
 
           else -- Il faut rajouter la lettre courante à la transcription.

                -- Mais d'abord si c'est une voyelle, on met une hamza préfixe
                if (a_traiter == "a") or (a_traiter == "u") or (a_traiter == "û") -- le â est un cas à part traité précédemment
                then transcription = transcription .. U(0x623) -- support en haut
                elseif (a_traiter == "i") or (a_traiter == "î")
                then transcription = transcription .. U(0x625) -- support en bas
                end -- la hamza préfixe a été insérée, le reste suit.

                -- Ensuite si on est sur le "e" d'une structure de type "liel" en début de mot,
                -- elle s'écrit sans alif donc il faut sauter le "e" et passer à la lettre suivante :
                if (mw.ustring.sub( texte, curseur-2, curseur+1) ~= "liel")
                then transcription = transcription .. EnArabe
                   end
            end -- cas hamza préfixe à insérer.

        -- post-traitement : si la consonne est derrière el (ou ^l) il faut rajouter un chadda aux lettres solaires
        -- il faut que le "el" soit collé au mot, donc une forme comme el_sadatu supprime le chadda. Faut pas pousser.
        if ((mw.ustring.sub( texte, curseur-1, curseur-1 ) == "l")
        and (mw.ustring.sub( texte, curseur-2, curseur-2 ) == "e" or mw.ustring.sub( texte, curseur-2, curseur-2 ) == "^"))
        then -- faire le test solaire
            if ((a_traiter=="t") or (a_traiter=="F") or (a_traiter=="d") or (a_traiter=="V")
            or (a_traiter=="r") or (a_traiter=="z") or (a_traiter=="s") or (a_traiter=="C")
            or (a_traiter=="S") or (a_traiter=="D") or (a_traiter=="T") or (a_traiter=="Z")
            or (a_traiter=="l") or (a_traiter=="n")) and diacritiques
            then transcription = transcription .. EnArabe end
        end -- faire le test solaire

        else -- on n'est pas en début de mot

            -- Ne présentent jamais de redoublement :
            
            if (a_traiter == "a") or (a_traiter == "i") or (a_traiter == "u") or (a_traiter == "e") or (a_traiter == "^")
            or (a_traiter == "î")
            or (a_traiter == "A") or (a_traiter == "I") or (a_traiter == "U") or (a_traiter == "E") or (a_traiter == "É") -- voyelles longues forcées sans diacritique
            or (a_traiter == "ĩ") or (a_traiter == "ũ") or (a_traiter == "õ") or (a_traiter == "_")
            then transcription =  transcription .. EnArabe

            elseif (a_traiter == "é")-- 
            then 
                if (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "ã")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "_")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "E")
                and diacritiques
                then transcription =  transcription .. EnArabe
                end
                transcription =  transcription .. EnArabe

            elseif (a_traiter == "û")-- cas particulier d'un u final : alif muet
            then -- plus simple de ne pas le mettre.
                transcription =  transcription .. EnArabe
                -- if (mw.ustring.sub( texte, curseur+1, curseur+1 ) == " ")
                -- then transcription = transcription .. EnArabe end

            elseif (a_traiter == "~") then
                if diacritiques then transcription =  transcription .. EnArabe end
                transcription =  transcription .. EnArabe
            
            -- Traitement des différents cas particuliers dépendants du contexte
            
            elseif (a_traiter == "ã")
            then -- le ã est suivi d'un alif muet, mais pas derrière ât et @ :
                transcription = transcription .. EnArabe
                if  (mw.ustring.sub( texte, curseur-1, curseur-1 ) == "@")
                or  (mw.ustring.sub( texte, curseur-2, curseur-1 ) == "ât")
                -- ni devant un alif é
                or  (mw.ustring.sub( texte, curseur+1, curseur+1 ) == "é")
                -- ni devant une hamza précédé d'une voyelle longue
                or  (mw.ustring.sub( texte, curseur-2, curseur-1 ) == "â'")
                or  (mw.ustring.sub( texte, curseur-2, curseur-1 ) == "î'")
                or  (mw.ustring.sub( texte, curseur-2, curseur-1 ) == "û'")
                then
                else transcription = transcription ..EnArabe 
                end
            
            elseif (a_traiter == "â")
            then -- pas de nouvel alif derrière une hammza portée par alif
                if mw.ustring.sub( texte, curseur-1, curseur-1) == "'"
                then
                    local avant = mw.ustring.sub( texte, curseur-2, curseur-2)
                    if avant == "'" then avant = mw.ustring.sub( texte, curseur-3, curseur-3) end
                    if (avant == "i") or (avant == "î") or (avant == "I") or (avant == "y")
                    or (avant == "u") or (avant == "û") or (avant == "w") or (avant == "â")
                    then transcription =  transcription .. EnArabe
                    end -- sinon : la hamza a déjà inséré un alif madda et on ne fait rien
                else transcription =  transcription .. EnArabe
                end
            
            elseif (a_traiter == "@")
            then -- ta arbouta : précédé de 'a' implicite, sauf quand derrière une voyelle longue
                if  (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "â")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "î")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "û")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "_")
                and diacritiques 
                then transcription = transcription .. EnArabe
                end
                transcription = transcription .. EnArabe

            elseif (a_traiter == "é")
            then -- alif maksoura : précédé de 'a' implicite, sauf quand devant un 'ã' ou quand on efface les voyelles
                if  (mw.ustring.sub( texte, curseur+1, curseur+1 ) ~= "ã")
                and (mw.ustring.sub( texte, curseur-1, curseur-1 ) ~= "_")
                then transcription = transcription .. EnArabe
                end
                transcription = transcription .. EnArabe
            
            -- Quelques cas où on ne veut pas examiner la présence d'un ²
            elseif (a_traiter == "°") -- Sukun explicite
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "*") or (a_traiter == ".")
            then transcription = transcription .. EnArabe
            
            -- Lettre redoublée de la précédente :
            elseif (a_traiter == mw.ustring.sub( texte, curseur-1, curseur-1 )) and (a_traiter ~= "-") and diacritiques
            -- pas de gemmination sur les tirets
            -- Pas de gemmination si on est derrière un el- préfixe (el-lah)
            -- mais dans ce cas le second l est traité comme début de mot : pas cette branche.
            then transcription = transcription .. EnArabe
            
            elseif (a_traiter == "'") -- hamza
            then -- Hamza : problème du support
                local avant = mw.ustring.sub( texte, curseur-1, curseur-1 )
                local apres = mw.ustring.sub( texte, curseur+1, curseur+1 )

                -- insertion d'un sukun si nécessaire
                if (avant ~= "a") and (avant ~= "e") and (avant ~= "i") and (avant ~= "u")
                and (avant ~= "â") and (avant ~= "î") and (avant ~= "û") and (avant ~= "é")
                and (avant ~= "ã") and (avant ~= "ĩ") and (avant ~= "ñ") and (avant ~= "É")
                and (avant ~= "A") and (avant ~= "I") and (avant ~= "U") and (avant ~= "E")
                and (avant ~= "ñ") and (avant ~= "õ") and (avant ~= "-") and (avant ~= "~") and (avant ~= ",")
                and (avant ~= "é") and (avant ~= "_") and (avant ~= "°")  and (avant ~= "^")
                and (avant ~= "(") and (avant ~= ")") and (avant ~= "!")
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= " el") -- pas de sukun après el- en début de mot
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= " ^l") -- cas du alif wasla
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= "_el") -- pas de sukun après el- en début de mot
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= "_^l") -- cas du alif wasla
                and diacritiques
                then transcription = transcription .. EnArabe end

                -- Traitement différent suivant qu'on est en fin de mot ou en milieu :
                if (curseur > mw.ustring.len( texte )-2) or (apres == " ")
                or (
                (mw.ustring.sub( texte, curseur+2, curseur+2 ) == " ")
                -- il ne faut pas de lettre de prolongation non plus
                and (apres~= "â") and (apres~= "î") and (apres~= "û") and (apres~= "é")
                and (apres~= "A") and (apres~= "I") and (apres~= "U") and (apres~= "E")
                -- et piège, après un a̋ le alif orthographique compte comme lettre, donc ce n'est pas une fin de mot...
                and (apres~= "ã")
                )
                then -- hamza en fin de mot
                    if (avant== "i") then transcription = transcription .. EnArabe
                    elseif (avant == "u") then transcription = transcription .. EnArabe
                    elseif (avant == "a") then transcription = transcription .. EnArabe
                    else transcription = transcription .. EnArabe
                    end -- fin de mot
                else -- hamza en milieu de mot
                    if (apres == "'") or (apres == "²") then apres = mw.ustring.sub( texte, curseur+2, curseur+2 ) end

                    -- derrière un i, support ya sans point
                    if (avant== "i") or (avant == "î") or (avant == "I") or (avant == "y")
                    then transcription = transcription .. EnArabe
                    -- derrière un waw, hamza en ligne
                    elseif (avant == "û") or (avant == "w")
                    then transcription = transcription .. EnArabe
                    -- derrière un u faut voir après
                    elseif (avant == "u")
                    then
                        if (apres == "i") or (apres == "î")
                        then transcription = transcription .. EnArabe
                        else transcription = transcription .. EnArabe
                        end
                    -- derrière un a faut voir après
                    elseif (avant == "a")
                    then
                        if (apres == "i") or (apres == "î")
                        then transcription = transcription .. EnArabe
                        elseif (apres == "û") or (apres == "u")
                        then transcription = transcription .. EnArabe
                        elseif (apres == "â")
                        then transcription = transcription .. EnArabe -- madda, et â sera omis
                        -- dans les autres cas, support alif, sauf le cas a' initial déjà traité avec le a initial
                        elseif ( mw.ustring.sub( texte, curseur-2, curseur-2 ) ~= " ")
                        then transcription = transcription .. EnArabe
                        end
                    -- derrière un â, on risque de trouver une hamza en ligne pour ā’a, ū’a & aw’a 
                    elseif (avant == "â")
                    then -- il y a nécessairement une consonne après
                        if (apres == "i") or (apres == "î")
                        then transcription = transcription .. EnArabe
                        elseif (apres == "u")
                        then transcription = transcription .. EnArabe
                        else transcription = transcription .. EnArabe -- en ligne
                        end
                    else -- pas de voyelle avant, donc sukun
                        if (apres == "i") or (apres == "î")
                        then transcription = transcription ..  EnArabe
                        elseif (apres == "û") or (apres == "u")
                        then transcription = transcription .. EnArabe
                        elseif (apres == "â")
                        then transcription = transcription .. EnArabe
                        else transcription = transcription ..  EnArabe
                        end
                    end -- traitement milieu de mot
                end -- fin ou pas
                -- fin du cas de la hamza

            -- Ici il faut isoler le traitement des caractères sur lesquels il n'y aura jamais de sukkun            
            elseif (a_traiter == ",")
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "-")
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "²")
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "^")
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "?")
            then transcription = transcription .. EnArabe
            elseif (a_traiter == "!")
            then transcription = transcription .. EnArabe
            else -- dans les autres cas, translittération de la consonne, mais avec sukun éventuel

                local avant = mw.ustring.sub( texte, curseur-1, curseur-1 )
                -- on ne met pas de sukun après...
                if (avant ~= "a") and (avant ~= "e") and (avant ~= "i") and (avant ~= "u")
                and (avant ~= "â") and (avant ~= "î") and (avant ~= "û") and (avant ~= "é")
                and (avant ~= "ã") and (avant ~= "ĩ") and (avant ~= "ñ") and (avant ~= "É")
                and (avant ~= "A") and (avant ~= "I") and (avant ~= "U") and (avant ~= "E")
                and (avant ~= "ñ") and (avant ~= "õ") and (avant ~= "-") and (avant ~= "~")
                and (avant ~= "_") and (avant ~= "°") and (a_traiter~= " ") and (avant~= "^") and (avant~= "?")
                and (avant ~= "(") and (avant ~= ")")
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= " el") -- pas de sukun après el- en début de mot
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= " ^l") -- pas de sukun sur un alof wasla
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= "_el") -- pas de sukun après el- en début de mot
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= "_^l") -- pas de sukun sur un alof wasla
                and (mw.ustring.sub( texte, curseur-3, curseur-1 ) ~= " a'") -- pas de sukun sur un alif madda
                and diacritiques
                then transcription = transcription .. EnArabe end

                if EnArabe~=nil then transcription = transcription .. EnArabe end
                -- cas d'une consonne en fin de mot - rajouter un sukun final
                if (mw.ustring.sub( texte, curseur+1, curseur+1 ) == " ") and diacritiques
                then transcription = transcription .. EnArabe end
            end

        end
    end -- for - boucle de traitement
    return transcription
end

function est_voyelle (position)
    -- détecte la presence d'une voyelle à cette position.
    -- La voyelle peut être tout ce qui permet à une consonne d'être une initiale de syllabe : courte ou longue, tanwîn, ou ta marbuta
    return (mw.ustring.len(scheme) >= position) and (mw.ustring.find("aeiuâîûãĩũ@ñõ" , mw.ustring.sub( scheme, position, position) )~=nil)
    end
function est_voyelle_courte (position)
    -- détecte la presence d'une voyelle courte à cette position.
    -- comme ci-dessus mais sans les voyelles longues
    return (mw.ustring.len(scheme) >= position) and (mw.ustring.find("aeiuãĩũ@ñõ" , mw.ustring.sub( scheme, position, position) )~=nil)
    end

function nature (position)
    --[[    Renvoit la nature de la lettre  du schème=scheme située à la position=position.
            Ce peut être :
                    (voyelles)
            "vo" = voyelle courte dans une syllable ouverte ;
            "vf" = voyelle courte dans une syllable fermée ;
            "vl" = voyelle longue (dans une syllable longue) ;
                    (consonnes initiales)
            "io" = consonne initiale d'une syllable ouverte ;
            "if" = consonne initiale d'une syllable fermée ;
            "il" = consonne initiale d'une syllable longue ;
                    (consonnes doubles)
            "do" = consonne double, fermant une syllable et debutant une syllable ouverte ;
            "df" = consonne double debutant une syllable fermée ;
            "dl" = consonne double, debutant une syllable longue ;
                    (consonnes de fermeture)
            "fo" = fin de syllable fermée suivie d'une autre consonne ;
            "ff" = fin de syllable fermée et fin de mot (imperatif).
        ]]
        if est_voyelle (position)
        then -- cas voyelle
            if mw.ustring.find("âîû" , mw.ustring.sub( scheme, position, position) )~=nil
            then do return {"v", "l"} end ; -- voyelle longue
            elseif mw.ustring.find("ãĩũ@ñõ", mw.ustring.sub( scheme, position, position)) ~= nil
            then do return {"v", "o"} end ;-- par convention; une consonne précédente sera toujours "ouverte"
            elseif mw.ustring.sub( scheme, position+1, position+1) == ""
            then do return {"v", "o"} end ;                      -- voyelle courte finale donc ouverte
            elseif mw.ustring.sub( scheme, position+2, position+2) == ""
            then do return {"v", "f"} end ;                       -- voyelle courte + consonne finale donc fermée
            elseif est_voyelle (position+2)
            then do return {"v", "o"} end ;                      -- voyelle courte + consonne + voyelle donc ouverte
            else do return {"v", "f"} end ;
            end -- cas voyelle
        else -- cas consonne
            if mw.ustring.sub( scheme, position+1, position+1)=="" then return {"f", "f"} end                                       -- la consonne est la dernière lettre, donc finale fermée
            if (mw.ustring.sub( scheme, position+1, position+1)=="²") or (mw.ustring.sub( scheme, position+1, position+1)==mw.ustring.sub( scheme, position, position))
            then do return {"d" , nature(position+2) } end ;                                 -- consonne double, voir la nature de la voyelle nécessairement présente à pos+2
            elseif  (mw.ustring.sub( scheme, position-1, position-1)==mw.ustring.sub( scheme, position, position))
            then do return {"d" , nature(position+1) } end ;                                  -- 2ème de double, voir la nature de la voyelle nécessairement présente à pos+1
            elseif not(est_voyelle(position-1))
            then do return  {"i" , nature(position+1) } end ;                                  -- 2ème de deux consonnes, idem
            elseif not(est_voyelle(position+1))
            then do return {"f", "o"} end ;                                                                 -- precede de voyelle et suivie de consonne
            else do return {"i", nature(position+1) } end ; 
            end -- consonne
            do return {"?", "?"} end ;
         end
    end

function ProtectedExpandTemplate(frame, scheme, forme)
    -- ExpandTemplate déclenche une erreur si le schème appelé est vide.
    -- permet d'encapsuler cette erreur par le test de pcall.
    local bidon = frame:expandTemplate{ title = "ar-"..scheme, args = {"forme"} }
    end

function p.appliquer( frame ) -- à partir de la librairie standard
    -- les deux paramètres sont aussi des noms de modèles : scheme de la forme ar-ma**u* ; racine de la forme ar-Hmr
    -- le paramètre "var" indique une option, eg la forme du verbe
    scheme , racine, var = mw.ustring.sub(frame.args.scheme,4) , mw.ustring.sub(frame.args.racine, 4), frame.args.var
    return appliquer_interne(scheme, racine, var, frame)
    end
function appliquer_interne(p1, p2, p3, p4) -- Il faut passer par des variables pour que scheme &Cie restent des variables globales au module...
    scheme=p1 ; racine=p2 ; var=p3 ; frame=p4

    if (var == "") -- ne dit rien
    and pcall(ProtectedExpandTemplate, frame, scheme, forme) -- modèle existe?
    then -- essai de récupérer le n° de la forme par le modèle?
        var = frame:expandTemplate{ title = "ar-"..scheme, args = {"forme"} }
        end
    -- Dans les modèles de la forme ar-*a*a*a-i, les deux dernières lettres indiquent conventionnellement la voyelle de l'inaccompli
    -- et doivent être supprimées dans un affichage normal
    if mw.ustring.sub(scheme, -2, -2) == "-"  -- avant-dernière lettre = "-" ?
    then
        scheme = mw.ustring.sub(scheme, 1, -3) -- supprimer les deux dernières, donc limiter au rang -3.
        end
    -- voyelle préfixe mobile éventuelle
    local mobile
    if (mw.ustring.sub(scheme, 3, 3)=="u") or (mw.ustring.sub(scheme, 3, 3)=="û") then mobile= "u" else mobile= "i" end ;
    -- Variables auxilliaires
    local position, contexte ;

    -- Dans le schème, les lettres radicales sont symbolisées par des *, sauf si elles sont répétées, auquel cas elles sont symbolisées par leur numéro d'ordre.
    -- remplacement des étoiles successives par le rang d'ordre des lettres radicales (pour homogénéiser le traitement des verbes irréguliers) si le n° correspondant est absent :
    if mw.ustring.find ( scheme, "1") == nil then scheme = mw.ustring.gsub( scheme, "*", "1", 1) end ;
    if mw.ustring.find ( scheme, "2") == nil then scheme = mw.ustring.gsub( scheme, "*", "2", 1) end ;
    if mw.ustring.find ( scheme, "3") == nil then scheme = mw.ustring.gsub( scheme, "*", "3", 1) end ;
    if mw.ustring.find ( scheme, "4") == nil then scheme = mw.ustring.gsub( scheme, "*", "4", 1) end ;
    -- sauf pour 3, parce que sinon, on a des problèmes si "3" est present comme lettre radicale... donc on remet un caractère jocker.
    scheme = mw.ustring.gsub( scheme, "3", "µ") ;
    -- NB : on présume que les chiffres sont dans l'ordre ; avec ce système, un "schème" de type ar-3a2a1a réalise en fait une inversion des lettres - pas malin, mais bon.
    -- De même, on peut forcer une lettre faible à une autre valeur par exemple ar-mi**â*ũ peut être forcé sur ar-mi*yâ3ũ quand le W doit se transformer en Y.
    -- Les radicales faibles sont w et y. Pour "régulariser" sinon, mettre la radicale faible en majuscule.
    local shemeinit = scheme -- sauvegarde de la valeur primitive

    -- deuxième radicale = creuse?
    if ((var=="(2)") or (var=="(3)") or (var=="(5)") or (var=="(6)") or (var=="(9)")) and (mw.ustring.sub(racine, 2, 2) == "w")  -- ces formes sont régulières, cf Schier p.64. cf Ryding p. 580.
    then racine = mw.ustring.sub(racine,1,1).."W"..mw.ustring.sub(racine,3,3) end ;
    if ((var=="(2)") or (var=="(3)") or (var=="(5)") or (var=="(6)") or (var=="(9)")) and (mw.ustring.sub(racine, 2, 2) == "y")  -- ces formes sont régulières, cf Schier p.64. cf Ryding p. 580.
    then racine = mw.ustring.sub(racine,1,1).."Y"..mw.ustring.sub(racine,3,3) end ;

    -- Sinon, traitement des formes creuses après neutralisation des formes verbales invariables :
    if ((mw.ustring.sub(racine, 2, 2) == "w") or (mw.ustring.sub(racine, 2, 2) == "y"))
    and (scheme ~= "a12aµu") -- invariant, cf Ryding p. 246.
        then
            do -- verbe creux en W, cf Schier p. 71

                position = mw.ustring.find  ( scheme, "2")
                -- La 2ème radicale a pu être forcée à autre chose.
                if position  ~= nil then
                -- contexte de la radicale : quelles sont les voyelles (courtes ou longues) avant et après la consonne 2 :
                if est_voyelle(position-1) then contexte = mw.ustring.sub( scheme, position-1, position-1) .. "2" else contexte = "°2" end ;
                if  (mw.ustring.sub( scheme, position+1, position+1) == "²")
                or (mw.ustring.sub( scheme, position+1, position+1) == mw.ustring.sub( scheme, position, position))
                then
                    contexte = contexte .. "²" ;
                    if est_voyelle(position+2)
                    then contexte = contexte .. mw.ustring.sub( scheme, position+2, position+2)
                    else contexte = contexte .."°"
                    end ;
                else if est_voyelle(position+1)
                then contexte = contexte .. mw.ustring.sub( scheme, position+1, position+1)
                else contexte = contexte .."°" end ;
                end ;

                if contexte == "a2a" and position==3
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2) == "f") or (nature (position+2) == "d")
                        then if (mw.ustring.sub(racine, 2, 2) == "w")
                                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+2)
                                else scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)
                                end
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "â" .. mw.ustring.sub( scheme, position+2)
                        end
                elseif contexte == "a2a" and position~=3
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2) == "f")
                        then scheme=mw.ustring.sub( scheme, 1, position-2) .. "a" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "â" .. mw.ustring.sub( scheme, position+2)
                        end

                -- a2i remplacé par â ou i
                elseif contexte == "a2i"
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2) == "f") or (nature (position+2) == "d")
                        then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "â" .. mw.ustring.sub( scheme, position+2)
                        end

                -- a2u remplacé par â ou u
                elseif contexte == "a2u"
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2) == "f") or (nature (position+2) == "d")
                        then scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "â" .. mw.ustring.sub( scheme, position+2)
                        end

                -- a2î remplacé par âyi dans ar-*a*î*ũ
                elseif contexte == "a2î"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "âyi" .. mw.ustring.sub( scheme, position+2)

                -- a2²i remplacé par ay²i mais pas dans ar-mu*a2²i*ũ (forme 2 invariable)
                elseif  (contexte == "a2²i") and (scheme ~= "mu1a2²iµũ")
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay²i" .. mw.ustring.sub( scheme, position+3)

                -- âwi : remplacé par â'i sauf formes verbales 2, 3, 5 et 6 
                elseif (contexte == "â2i")
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'i" .. mw.ustring.sub( scheme, position+2)

                -- i2° remplacé par î
                elseif (contexte == "i2°")
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+1)

                -- iwâ remplacé par iyâ
                elseif (contexte == "i2â")
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "iyâ" .. mw.ustring.sub( scheme, position+2)
                elseif (contexte == "î2â")
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "iyâ" .. mw.ustring.sub( scheme, position+2)

                -- uwi (passif) remplacé par î ou i
                elseif (contexte == "u2i") -- and (mw.ustring.sub(racine, 2, 2) == "w")
                then if (nature (position+2) == "f") or (nature (position+2) == "d")
                        then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)
                        end
                -- uyi (passif) remplacé par î ou u (?) sembler être une erreur
                -- elseif (contexte == "u2i") and (mw.ustring.sub(racine, 2, 2) == "y")
                -- then if (nature (position+2) == "f") or (nature (position+2) == "d")
                --         then scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+2)
                --         else scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)
                ---        end

                -- °2a : problème à l'impératif pour toutes ces formes : quand l'impératif se termine par la troisième radicale, celle-ci doit fermer la syllabe, et non ouvrir sur une terminaison.
                elseif (contexte == "°2a" )
                then -- °wa : â si la syllable longue est possible, a sinon
                        local suite = nature (position+2)
                        if (suite == "f") and (suite == "f" )
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "a" .. mw.ustring.sub( scheme, position+2)
                        elseif suite == "f"
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "a" .. mw.ustring.sub( scheme, position+2)
                        elseif (suite == "d")
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "a" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "â" .. mw.ustring.sub( scheme, position+2)
                        end

                 -- °2â : â, et w supprimé
                elseif (contexte == "°2â") and (mw.ustring.sub(racine, 2, 2) == "w") -- pas de transformation pour "y"
                then -- distinction entre le nom verbal de la forme (iv) **â*ũ et le pluriel irrégulier a**â*ũ (régulier) & mi**â*ũ régulier
                    if (mw.ustring.sub( scheme, 1, 1) == "a") or (mw.ustring.sub( scheme, 1, 2) == "mi") 
                    then scheme=mw.ustring.sub( scheme, 1, position-1) .. "wâ" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-1) .. "â" .. mw.ustring.sub( scheme, position+2)
                    end

                 -- °2i : î si la syllable longue est possible, i sinon
                elseif (contexte == "°2i")
                then
                        if (nature (position+2) == "f")
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "i" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "î" .. mw.ustring.sub( scheme, position+2)
                        end

                 -- °2u : û si la syllable longue est possible, u sinon
                elseif (contexte=="°2u") 
                then
                        if (nature (position+2) == "f") or (nature (position+2) == "d")
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "u" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
                        end

                -- °2û remplacé par û ou î (participe passif)
                elseif contexte == "°2û"
                then if (mw.ustring.sub(racine, 2, 2) == "w")
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "î" .. mw.ustring.sub( scheme, position+2)
                        end

                elseif (contexte=="°û")
                then scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
                end -- if ... elseif ... else
                -- voiture balai : on remplace tous les "2" par la lettre radicale :
                scheme = mw.ustring.gsub( scheme, "2", mw.ustring.sub(racine, 2, 2))
            end end -- do verbe creux en W

        end ;

    -- première radicale en W
    if (mw.ustring.sub(racine, 1, 1) == "w")    then
        position = mw.ustring.find  ( scheme, "1")
        -- La 1ère radicale a pu être forcée à autre chose.
        if (position  ~= nil) then
            -- première forme, suppression du w dans les formes w2i3, sauf dans les verbes sourds (2=3)
            if (mw.ustring.sub(scheme, position+2, position+2) == "i")  and ( var == "(1)")
            and (mw.ustring.sub(racine, 2, 2) ~= mw.ustring.sub(racine, 3, 3))
            then scheme=mw.ustring.sub( scheme, 1, position-1) .. mw.ustring.sub( scheme, position+1)
            -- huitième forme : iwta2a3 => it²a2a3 : à faire à la main, la forme i*ta*a*a est une "exception régulière"
            end
        end end -- fin verbes assimilés en W

    -- verbe sourd, on supprime la voyelle intercalaire entre 2 et 3 si c'est possible (forme contractée préférentielle) =
    -- * Si la 3 porte un sukkun (la 2 est alors une initiale de syllabe fermée), pas de suppression (forme déployée).
    -- * Si la 3 porte une voyelle courte, la 2 peut porter un sukkun (forme contractée), dans ce cas :
    --    * Si la 1 porte une voyelle on peut supprimer la voyelle (courte et éventuelle) de la 2 ;
    --    * Si la 1 ne porte pas de voyelle on doit y transférer la voyelle courte de la 2.
    --  because of a phonological rule that prevents two identical consonants from being
    -- in sequence with a short vowel between them when they are directly followed by a vowel,
    -- However, if the second identical stem consonant is followed by another consonant,
    -- the identical consonants remain separated
    local position3 = mw.ustring.find  ( scheme, "µ")  ;
    if  (mw.ustring.sub(racine, 2, 2) == mw.ustring.sub(racine, 3, 3)) -- deux consonnes identiques
    and (mw.ustring.sub(racine, 2, 2)~="*") and (mw.ustring.sub(racine, 2, 2)~=".") and (mw.ustring.sub(racine, 2, 2)~="?") -- "lettres" bidon dans les modèles
    and ( position3 ~= nil) -- si un petit malin propose un schème sans position 3 en redoublant la 2...
    then -- on est dans un cas "sourd"
        local position2 = mw.ustring.find  ( scheme, "2")  ;
if position2~=nil then -- sécurité : exclusion du cas des modèles d'exception imposant la deuxième radicale
        local nature2= nature (position2) -- Quelle est la nature de la seconde radicale?

        if (nature2..nature2 == "io") -- initiale d'une syllabe ouverte, donc 2 porte une voyelle courte et 3 une voyelle.
        -- contraction sur les verbes (var~=""), formes verbales, ou sur les noms (var=="") dont l'infixe n'est pas de la forme *v*v* (voyelle courte avant la deuxième radicale).
        -- le cas des noms n'est pas très clair, mais on constate que les **v* sont contractés, et certains *v*v* ne le sont pas, on suppose que ce qui apparaissent contractés sont des *v** d'origine (?)
        and (var~="" or (var=="" and mw.ustring.find("aiu" , mw.ustring.sub(scheme, position2-1, position2-1) )==nil ))
        then -- 
            if est_voyelle(position2-1) -- ie, la première radicale est vocalisée
            -- alors on peut supprimer la voyelle de la deuxième radicale
            -- La surdité n'est normalement réalisée que si la voyelle de la première radicale est courte.
            -- On ne peut normalement pas faire suivre une voyelle longue par une consonne avec tchechid (ce qui formerait une super-longue).
            -- Mais c'est une variante d'orthographe. Au besoin, créer un modèle de type ar-*â**a pour imposer la configuration.
            then if est_voyelle_courte (position2-1) then scheme = mw.ustring.sub( scheme, 1, position3-2) .. mw.ustring.sub( scheme, position3) end
            -- sinon on transfère la voyelle de la deuxième radicale sur la première
            else scheme = mw.ustring.sub( scheme, 1, position2-1) .. -- début jusqu'à la deuxième radicale
                mw.ustring.sub( scheme, position3-1, position3-1) .. -- insertion de la voyelle de la seconde radicale
                mw.ustring.sub( scheme, position2, position2) .. -- deuxième radicale
                mw.ustring.sub( scheme, position3) -- et directement la troisième (le signe de redoublement sera inséré lors de la translittération en arabe).
                end
            end
end -- fin exclusion de sécurité.
        end
    -- Cas des formes sourdes à quatre radicales = idem sur 3 et 4
    local position4 = mw.ustring.find  ( scheme, "4")  ;
    if  (mw.ustring.sub(racine, 4, 4) == mw.ustring.sub(racine, 3, 3)) -- deux consonnes identiques
    and (mw.ustring.sub(racine, 4, 4)~="*") and (mw.ustring.sub(racine, 4, 4)~=".") and (mw.ustring.sub(racine, 4, 4)~="?") -- "lettres" bidon dans les modèles
    and ( position4 ~= nil) -- si un petit malin propose un schème sans position 3 en redoublant la 2...
    then -- on est dans un cas "sourd"
        local position3 = mw.ustring.find  ( scheme, "µ")  ;
        local nature3= nature (position3) ;
        if (nature3..nature3 == "io") -- initiale d'une syllabe ouverte, donc 3 porte une voyelle courte et 4 une voyelle.
        then -- 
            if est_voyelle(position3-1) -- ie, la deuxième radicale est vocalisée
            -- alors on peut supprimer la troisième radicale
            then if est_voyelle_courte (position2-1) then scheme = mw.ustring.sub( scheme, 1, position4-2) .. mw.ustring.sub( scheme, position4) end
            -- sinon on transfère la voyelle de la troisième radicale sur la deuxième
            else scheme = mw.ustring.sub( scheme, 1, position3-1) .. -- début jusqu'à la troisième radicale
                mw.ustring.sub( scheme, position4-1, position4-1) .. -- insertion de la voyelle de la troisième radicale
                mw.ustring.sub( scheme, position3, position3) .. -- troisième radicale
                mw.ustring.sub( scheme, position4) -- et directement la troisième (le signe de redoublement sera inséré lors de la translittération en arabe).
                end
            end
        end

    -- Inversement, les verbes où la troisième radicale est redoublée dans le schème doivent se conjuguer comme des sourds
    -- ie, si le schème contient un µµ ou un µ² devant une consonne il faut séparer les deux, et boucher le trou avec un "a" pour ne pas avoir trois consonnes d'affilée.
    if (mw.ustring.find ( scheme, "µµ") ~= nil) or  (mw.ustring.find ( scheme, "µ²") ~= nil)
    then
        scheme = mw.ustring.gsub( scheme, "µ²", "µµ", 1) -- homogénéisation des cas
        local position3 = mw.ustring.find  ( scheme, "µµ", 0, true)  ;
        if not (est_voyelle(position3+2)) or (mw.ustring.sub(scheme, position3+2)=="")
        then
            scheme =  mw.ustring.sub( scheme, 1, position3) .. "a" .. mw.ustring.sub( scheme, position3+1)
        end -- est_voyelle.
    end
    scheme = mw.ustring.gsub( scheme, "2", mw.ustring.sub(racine, 2, 2))

    -- Toisième radicale : cas des verbes défectifs
    if (mw.ustring.sub(racine, 3, 3) == "w")
    or (mw.ustring.sub(racine, 3, 3) == "y")
    then -- préparation du contexte
        position = mw.ustring.find  ( scheme, "µ")
        if position  ~= nil -- La 3ème radicale a pu être forcée à autre chose.
        then
            -- contexte de la radicale : quelles sont les voyelles (courtes ou longues) avant et après la consonne 3 :
            if est_voyelle(position-1) then contexte = mw.ustring.sub( scheme, position-1, position-1) .. "3" else contexte = "°3" end ;
            if  (mw.ustring.len(scheme) == position)
            then contexte = contexte -- fin de schème
            elseif  (mw.ustring.sub( scheme, position+1, position+1) == "²")
            or (mw.ustring.sub( scheme, position+1, position+1) == mw.ustring.sub( scheme, position, position))
            then
                contexte = contexte .. "²" ;
                if est_voyelle(position+2)
                then contexte = contexte .. mw.ustring.sub( scheme, position+2, position+2)
                else contexte = contexte .."°"
                end ;
            elseif est_voyelle(position+1)
            then contexte = contexte .. mw.ustring.sub( scheme, position+1, position+1)
            else contexte = contexte .."°"
            end ;

            -- troisième radicale défective en w
            if (mw.ustring.sub(racine, 3, 3) == "w") and ( var == "(1)" or var=="" )
            then -- verbe défectif en W, cf Schier p. 74

                if contexte == "a3a"
                then -- awa final devient â au prétérit de la première forme, é sinon
                    if (position == mw.ustring.len( scheme )-1)
                    then -- position finale
                        if (position ==5) and (mw.ustring.sub( scheme, 2, 2) == "a") -- première forme
                        then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-2) .. "é" .. mw.ustring.sub( scheme, position+2)
                        end
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "a" .. mw.ustring.sub( scheme, position+2)
                    end -- test sur première forme

                elseif contexte == "a3â"
                then -- awâ final devient ayâ au passif devant a3âni final
                    if (position == mw.ustring.len( scheme )-3) and (mw.ustring.sub( scheme, position+2, position+3)=="ni")
                    and (var~="") -- les duels ne sont pas concernés.
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ayâ" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-1) .. mw.ustring.sub(racine, 3, 3) .. mw.ustring.sub( scheme, position+1)
                    end

                elseif contexte == "a3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3î"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3u"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "é" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3û"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "aw" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "a3ũ")
                -- Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                then
                    if (shemeinit =="1a2aµũ") or (shemeinit =="1i2aµũ") or (shemeinit =="1u2aµũ")
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ã"
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "ãé"
                    end
                elseif (contexte == "a3ã")
                -- Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                then
                    if (shemeinit =="1a2aµã") or (shemeinit =="1i2aµã") or (shemeinit =="1u2aµã")
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ã"
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "ãé"
                    end
                elseif (contexte == "a3ĩ")
                -- Pb ici, "ã" pour *a*a*ũ, *i*a*ũ et *u*a*ũ, "ãé" sinon. Cf. Palmer §50 p100
                then
                    if (shemeinit =="1a2aµĩ") or (shemeinit =="1i2aµĩ") or (shemeinit =="1u2aµĩ")
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ã"
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "ãé"
                    end

                elseif contexte == "â3i"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'i".. mw.ustring.sub( scheme, position+2)
                -- typiquement -*i*â*iy²ũ doit conserver la hamza de -*i*â*ũ -- en fait, non, dico dixit. -- en fait on peut neutraliser via un W fort.

                elseif contexte == "â3ũ" -- seul cas pratique derrière un â long?
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'u" -- diptote dans ce cas

                elseif contexte == "a3°"
                then
                    -- inaccompli passif (2FP, 3FP) en ay
                    -- versus accompli actif en voyelle de l'inaccompli (?) :
                    if (mw.ustring.sub( scheme,  position-3, position-3) == "a") -- on est à l'inaccompli
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "aw" .. mw.ustring.sub( scheme, position+1)
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay" .. mw.ustring.sub( scheme, position+1)
                    end

                elseif contexte == "i3a"
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "iya" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iy@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3i"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3â"
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "iyâ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3î"
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "i3ĩ")
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3u"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iy" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3û"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "i3ũ")
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3°"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+1)

                elseif contexte == "u3i"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "u3î"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "u3u" -- dépend si c'est en fin de mot
                then
                    if (position == mw.ustring.len( scheme )-1)
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+2)
                    end

                elseif contexte == "u3û"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "u3ũ"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "u3" -- en fin de mot
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+1)
                elseif contexte == "u3°"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+1)

                elseif mw.ustring.sub( scheme, position-1, position-1) == "y" -- cas du diminutif en *u*ay*ũ ou *u*ay*@ũ
                then scheme=mw.ustring.sub( scheme, 1, position-1) .. "y" .. mw.ustring.sub( scheme, position+1)

                elseif contexte == "û3ũ" -- Pb d'écriture
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "uw²ũ" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "°3ũ") and (mw.ustring.sub( scheme, position-2, position-2)=="a")
                -- traitement différent de *a*wũ et *u*wũ - bon, enfin, du moins ça marche :-/
                then scheme=mw.ustring.sub( scheme, 1, position-1) .. "wũ" .. mw.ustring.sub( scheme, position+2)
                elseif (contexte == "°3ũ") or (contexte == "°3ĩ")
                then scheme=mw.ustring.sub( scheme, 1, position-1) .. "ã" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "°3ã") and (mw.ustring.sub( scheme, position+2)~="é")
                then scheme=mw.ustring.sub( scheme, 1, position-1) .. "ã" .. mw.ustring.sub( scheme, position+2)

                -- la radicale faible disparaît parfois devant @, mais il faut dans ce cas la supprimer à la main.
                end -- fin traitement des cas particuliers en w
          
            else -- verbe défectif en Y, cf Schier p. 74
            -- ou formes dérivées d'un verbe défectif, traité comme un "y"

                if contexte == "a3a"
                then
                    if (position == mw.ustring.len( scheme )-1) -- position finale
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "é" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "a" .. mw.ustring.sub( scheme, position+2)
                    end

                elseif contexte == "a3â" -- 
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ayâ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "â3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ây@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3î"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "a3u"
                then -- dépend si c'est en fin de mot
                    if (position == mw.ustring.len( scheme )-1)
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "é".. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay".. mw.ustring.sub( scheme, position+2)
                    end

                elseif contexte == "a3û"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "aw" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "a3ũ") or (contexte == "a3ã") or (contexte == "a3ĩ")
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ãé"

                elseif contexte == "â3i"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'i".. mw.ustring.sub( scheme, position+2)
                -- typiquement -*i*â*iy²ũ doit conserver la hamza de -*i*â*ũ

                elseif contexte == "â3ũ"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'u" -- diptote dans ce cas

                elseif contexte == "a3°" -- ay devant consonne, é en finale
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ay".. mw.ustring.sub( scheme, position+1)

                elseif contexte == "a3"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i"

                elseif contexte == "i3a"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iya" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iy@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "î3@"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "îy@" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3â"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iyâ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3i"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3î" -- î
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3ĩ"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3u" -- dépend si c'est en fin de mot
                then
                    if (position == mw.ustring.len( scheme )-1)
                    then scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-2) .. "u" .. mw.ustring.sub( scheme, position+2)
                    end

                elseif contexte == "i3û"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+2)

                elseif contexte == "i3ũ"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ"

                elseif contexte == "i3°"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "î" .. mw.ustring.sub( scheme, position+1)

                elseif contexte == "i3" -- en fin de mot
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "i" .. mw.ustring.sub( scheme, position+1)

                elseif contexte == "u3ũ"
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "ĩ" .. mw.ustring.sub( scheme, position+2)

                elseif (contexte == "û3ũ") and (mw.ustring.sub( scheme, 1, 3)=="ma1")
                -- contamination du y sur le û dans la forme ma**û*ũ, cf Wright 1874 §170,
                -- mais la 2 est déjà remplacée dans le schème donc on ne peut pas tester le schème d'origine
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "iy²ũ" .. mw.ustring.sub( scheme, position+2)

                end -- fin traitement des cas particuliers en y
            end -- verbe défectifs

        end -- 3ème radicale présente
    end ; -- verbes défectifs
    --voiture balai :
    scheme = mw.ustring.gsub( scheme, "µ", mw.ustring.sub(racine, 3, 3)) ;

    -- quatrième radicale éventuelle
    if mw.ustring.sub(racine, 4, 4)== ""
    -- si on applique un schème quadrilittère à une racine à trois consonnes, on redouble simplement la dernière
    then scheme = mw.ustring.gsub ( scheme, "4", mw.ustring.sub(racine, 3, 3)) ;
    else scheme = mw.ustring.gsub ( scheme, "4", mw.ustring.sub(racine, 4, 4)) ;
    end ;

    -- première radicale
    scheme = mw.ustring.gsub( scheme, "1", mw.ustring.sub(racine, 1, 1)) ;

    -- pb : si le schème est en "1°" le "i" prosthétique est virtuel à ce stade :
    -- le cas général "de prolongation" ne marche pas, il faut forcer à la main :
    if (mw.ustring.sub( scheme, 1, 1)== "w") and not(est_voyelle(2))
    then scheme="î" .. mw.ustring.sub( scheme, 2)
    end

    -- Accord des w et y de prolongation en fonction du contexte vocalique (ne concerne pas les W et Y, invariables par principe) :
    while mw.ustring.find( scheme, "iw", 0, true)~= nil do
        position = mw.ustring.find( scheme, "iw", 0, true)
        if est_voyelle(position+2)
        then  scheme=mw.ustring.sub( scheme, 1, position-1) .. "iW" .. mw.ustring.sub( scheme, position+2) -- éviter une boucle infinie
        elseif (mw.ustring.sub( scheme, position+2, position+2)=="²") -- Pb sinon avec les -iw²- qu'il ne faut pas transformer en î², ce qui n'aurait aucun sens...
        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "iY" .. mw.ustring.sub( scheme, position+2)
        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "î" .. mw.ustring.sub( scheme, position+2)
        end
    end
    while mw.ustring.find( scheme, "uy", 0, true)~= nil do
        position = mw.ustring.find( scheme, "uy", 0, true)
        if est_voyelle(position+2)
        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "uY" .. mw.ustring.sub( scheme, position+2)
        else  scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
        end
    end
    while mw.ustring.find( scheme, "wî", 0, true)~= nil do
        position = mw.ustring.find( scheme, "wî", 0, true)
        scheme=mw.ustring.sub( scheme, 1, position-1) .. "yi" .. mw.ustring.sub( scheme, position+2)
    end

    -- nettoyage éventuel : Y et W des verbes réguliers
    scheme = mw.ustring.gsub( scheme, "Y", "y") ;
    scheme = mw.ustring.gsub( scheme, "W", "w") ;

    -- écriture des lettres de prolongations
    while mw.ustring.find( scheme, "ûw", 0, true)~= nil do
        position = mw.ustring.find( scheme, "ûw", 0, true)
        scheme=mw.ustring.sub( scheme, 1, position-1) .. "uw²" .. mw.ustring.sub( scheme, position+2)
    end
    while mw.ustring.find( scheme, "uw", 0, true)~= nil do
        position = mw.ustring.find( scheme, "uw", 0, true)
        if est_voyelle(position+2)
        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "uW" .. mw.ustring.sub( scheme, position+2)
        else  scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
        end
    end
    while mw.ustring.find( scheme, "iy", 0, true)~= nil do
        position = mw.ustring.find( scheme, "iy", 0, true)
        if est_voyelle(position+2) or (mw.ustring.sub( scheme, position+2, position+2)=="²") -- Pb sinon avec les -iy²-
        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "iY" .. mw.ustring.sub( scheme, position+2)
        else  scheme=mw.ustring.sub( scheme, 1, position-1) .. "î" .. mw.ustring.sub( scheme, position+2)
        end
    end
    while mw.ustring.find( scheme, "îy", 0, true)~= nil do
        position = mw.ustring.find( scheme, "îy", 0, true)
        scheme=mw.ustring.sub( scheme, 1, position-1) .. "iy²" .. mw.ustring.sub( scheme, position+2)
    end
    while mw.ustring.find( scheme, "yî", 0, true)~= nil do
        position = mw.ustring.find( scheme, "yî", 0, true)
        if est_voyelle_courte(position-1) -- intercepter des cas comme taXyîTũ => taXYîTũ et pas taXy²iTũ ;
        -- d'autre part des séquences de type âyî restent invariables (pas de redoublement possible après une voyelle longue).
        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "y²i" .. mw.ustring.sub( scheme, position+2)
        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "Yî" .. mw.ustring.sub( scheme, position+2)
        end
    end
    while mw.ustring.find( scheme, "û²", 0, true)~= nil do
        position = mw.ustring.find( scheme, "û²", 0, true)
        scheme=mw.ustring.sub( scheme, 1, position-1) .. "uw²" .. mw.ustring.sub( scheme, position+2)
    end

    -- nettoyage éventuel : Y et W des verbes réguliers
    scheme = mw.ustring.gsub( scheme, "Y", "y") ;
    scheme = mw.ustring.gsub( scheme, "W", "w") ;

    -- ajout d'une voyelle mutable, si le mot commence par deux consonnes :
    if (not ( est_voyelle(1))) and (not ( est_voyelle(2))) 
    -- Consonne en première position et pas de voyelle en deuxième position = il faut rajouter une voyelle préfixe.
    then  scheme = mobile..scheme end ;

    -- ajustement de l'initiale pour les verbes hamzés en 1 : i' se transforme en î et u' en û (une même syllabe ne peut pas être à la fois ouverte et fermée par une hamza)
    if mw.ustring.sub( scheme, 1, 2) == "i'" then
    if est_voyelle(3) then scheme = "iy" .. mw.ustring.sub( scheme, 3) else scheme = "î" .. mw.ustring.sub( scheme, 3) end end
    if mw.ustring.sub( scheme, 1, 2) == "u'" then
    if est_voyelle(3) then scheme = "uw" .. mw.ustring.sub( scheme, 3) else scheme = "û" .. mw.ustring.sub( scheme, 3) end end
    if mw.ustring.sub( scheme, 1, 2) == "a'" then
    if est_voyelle(3) then scheme = "aw" .. mw.ustring.sub( scheme, 3) else scheme = "â" .. mw.ustring.sub( scheme, 3) end end

    -- ajustement pour les verbes assimilés en y
    if mw.ustring.find(scheme, "uy") then
       local position = mw.ustring.find  ( scheme, "uy")
       if not est_voyelle(position+2) then
            scheme = mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
            end
       end

    return scheme
    end

function p.squelette( frame )
    -- les deux paramètres sont aussi des noms de modèles : scheme de la forme ar-ma**u* ; racine de la forme ar-Hmr
    -- le paramètre "var" indique une option, eg la forme du verbe
    texte=frame.args.texte ;
    return squelette_interne(texte)
    end
function squelette_interne(texte)
    resultat = "" ;
    index=1 ;
    local alphabet = mw.ustring.char( 0x627, 0x628, 0x629, 0x62A, 0x62B, 0x62C, 0x62D, 0x62E, 0x62F ) ;
    alphabet = alphabet .. mw.ustring.char( 0x630, 0x631, 0x632, 0x633, 0x634, 0x635, 0x636, 0x637 ) ;
    alphabet = alphabet .. mw.ustring.char( 0x638, 0x639, 0x63A, 0x63B, 0x63C, 0x63D, 0x63E, 0x63F ) ;
    alphabet = alphabet .. mw.ustring.char( 0x640, 0x641, 0x642, 0x643, 0x644, 0x645, 0x646, 0x647 ) ;
    alphabet = alphabet .. mw.ustring.char( 0x648, 0x649, 0x64A, 0x20, 0x621 ) ;
    alphabet = alphabet .. mw.ustring.char( 0x67E, 0x06A4, 0x06A5) ; -- quelques lettres additionnelles.
    repeat
        lettre = mw.ustring.sub(texte, index, index) ;
        if (mw.ustring.find(alphabet, lettre)~=nil) then resultat = resultat .. lettre end ;
        -- supports de hamza
        if (lettre == U(0x622)) or (lettre == U(0x623)) or (lettre == U(0x625)) then resultat = resultat .. U(0x627) end ; -- alif
        if (lettre == U(0x624)) then resultat = resultat .. U(0x648) end ; -- waw
        if (lettre == U(0x626)) then resultat = resultat .. U(0x649) end ; -- ya
        index = index+1 ;
        until  index==mw.ustring.len(texte) +1
    return resultat;
    end

-- Ci-dessous  : Fonctions agissant sur la liste des schèmes :
-- Par mesure d'économie, les préfixes en el- et suffixes en -u, -@, -ã, -ĩ, -ât, -iy²@, -iy²ât, -âtiy² sont automatiquement déduits des suffixes en -ũ,
-- ils doivent donc être reconstitués (ou réduits) par les fonctions itérant sur les listes.

function p.verifier ( frame )
    -- Un modèle de racine est essentiellement un p-list, donnant (entre autre) une valeur à un index de schème.
    -- La fonction vérifie que la liste de schèmes attachée à une racine ne comporte pas de schème inconnu :
    -- paramètre = nom de page d'un modèle racine de la forme ar-ktb
    -- Utilisée sur la page de documentation des modèles de racines.
    -- La fonction suppose qu'il n'y a qu'une clef par valeur, merci de ne pas faire des valeurs multi-clefs - qui ne seraient pas reconnues... Ha Ha Ha. Seules sont reconnues les clefs individualisées.

    local racine = frame.args.racine                                                                 -- Récupération du nom de la racine.
    local moncode = mw.title.makeTitle( "template", racine):getContent()            -- récupération du texte brut du modèle
    local maliste = mw.title.makeTitle( "template", "ar-racine/liste"):getContent() -- récupération de la liste des schèmes connus

    -- décomposition du modèle racine
    -- positionnement au début du "#switch:"
    local index =  mw.ustring.find(moncode, "#switch:") ;
    -- on saute les premiers items (? utile ?)
    moncode=mw.ustring.sub(moncode, index+14) ;
    local resultat = "" ;

    repeat -- boucle sur chaque item de la p-list
        -- positionnement sur le prochain item : débute par un |
        index = mw.ustring.find(moncode, "|") ;
        if index == nil then break end ; -- fin du modèle, on termine le "repeat".
        -- suppression du fragment jusqu'à | inclusivement (déjà traité) :
        moncode=mw.ustring.sub(moncode, index+1) ;
        -- Le schème est entre le début et le "=" ; positionnement sur le prochain "="
        index = mw.ustring.find(moncode, "=") ;
        if index == nil then break end ;
        scheme=mw.ustring.sub(moncode, 1, index-1)
        scheme= string.gsub(scheme, " ", "")
        if mw.ustring.sub(scheme, 1, 3) == "ar-" -- Si c'est autre chose qu'un "ar-" on ne va pas plus loin dans la p-list :
        then
            index =  mw.ustring.find(maliste, scheme.."}}", 1, true) ;
            if index == nil -- pas trouvé sous sa forme originale, on cherche un dérivé :
                then
                -- Nettoyage du schème : -@ũ, -iy²ũ (et -iy²@ũ) sont réduits à -ũ :
                if mw.ustring.sub(scheme, 0, 5) == "ar-el" then scheme="ar-"..mw.ustring.sub(scheme, 6, mw.ustring.len(scheme)) end ; -- forme définie avec el- préfixé
                if mw.ustring.sub(scheme, -1) == "u" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme définie
                if mw.ustring.sub(scheme, -1) == "ã" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme adverbiale
                if mw.ustring.sub(scheme, -1) == "ĩ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme adverbiale
                if mw.ustring.sub(scheme, -2) == "@ũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-2).."ũ" end ;
                if mw.ustring.sub(scheme, -3) == "âtũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-3).."ũ" end ;
                if mw.ustring.sub(scheme, -4) == "iy²ũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-4).."ũ" end ;
                if mw.ustring.sub(scheme, -3) == "âtũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-3).."ũ" end ; -- On peut avoir -âniy²ũ ou -iy²ânũ...
                -- on vérifie que le schème est bien dans la liste connue, encadré par "ar-" au début et "}}" à la fin :
                index =  mw.ustring.find(maliste, scheme.."}}", 1, true) ;
                -- Si pas trouvé, le schème inconnu est ajouté au "resultat" :
                if index == nil then resultat = resultat .. "{{" .. scheme.. "}}" end
                end -- recherche dérivé
            end -- schème en ar-
        until mw.ustring.find(moncode, "=") == nil ;
    return resultat
    end

function p.scheme_connu (frame)
    -- regarde si un schème (ou un de ses dérivés) figure dans la liste de référence. Utilisé sur la page de documentation associée aux modèles de schèmes.
    -- récupération du schème à tester :
    local scheme = frame.args.scheme
    scheme= string.gsub(scheme, " ", "")
    -- récupération de la liste des schèmes connus
    local maliste = mw.title.makeTitle( "template", "ar-racine/liste"):getContent()
    maliste= string.gsub(maliste, " ", "") -- suppression des espaces

    -- test si le schème est dans la liste sous sa propre forme :
    local index = mw.ustring.find(maliste, scheme.."}}", 0, true) ; -- NB : ", 0, true)" sont nécessaires ici pour que le schème ne soit pas interprété comme un "pattern".
    if index ~= nil then return "oui" end ;

    -- test s'il s'agit d'une forme dérivée dont la forme principale est dans la liste :
    if mw.ustring.sub(scheme, 0, 5) == "ar-el" then scheme="ar-"..mw.ustring.sub(scheme, 6, mw.ustring.len(scheme)) end ; -- forme définie avec el- préfixé
    if mw.ustring.sub(scheme, -1) == "u" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme définie
    if mw.ustring.sub(scheme, -1) == "ã" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme adverbiale
    if mw.ustring.sub(scheme, -1) == "ĩ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1).."ũ" end ; -- forme adverbiale
    if mw.ustring.sub(scheme, -2) == "@ũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-2).."ũ" end ; -- forme en -@
    if mw.ustring.sub(scheme, -3) == "âtũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-3).."ũ" end ; -- pluriel d'une forme en -@
    if mw.ustring.sub(scheme, -4) == "iy²ũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-4).."ũ" end ; -- adjectif relatif (les -iy²@ ont déjà été réduits en -iy²)
    if mw.ustring.sub(scheme, -3) == "âtũ" then scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-3).."ũ" end ; -- On peut avoir -âtiy²ũ ou -iy²âtũ...
    local index = mw.ustring.find(maliste, scheme.."}}", 0, true) ; -- NB : ", 0, true)" sont nécessaires ici pour que le schème ne soit pas interprété comme un "pattern".
    if index ~= nil then return "oui" end ;

    return ""
    end

function recup_racine (racine)
    -- Récupération et nettoyage des éléments associés à une racine
    modele_racine  = mw.title.makeTitle( "template", racine):getContent() -- récupération du modèle de racine pour avoir sa p-list
    -- Le modèle est une p-list bâtie sur un {{#switch: avec des lignes de la forme | ar-scheme = sens_à_mentionner
    -- Pb : éliminer les lignes vides qui ont quand même une clef
    -- suppression des commentaires :
    while mw.ustring.find(modele_racine, "<!--", 0, true)  do
        local index1 = mw.ustring.find(modele_racine, "<!--", 0, true)
        local index2 = mw.ustring.find(modele_racine, "-->", 0, true)
        modele_racine  = mw.ustring.sub(modele_racine, 0, index1-1) .. mw.ustring.sub(modele_racine, index2+3)
        end -- while
    -- suppression des retour à la ligne remplacés par des blancs (par prudence)
    modele_racine = string.gsub(modele_racine, string.char(10), " ")
    -- on veut pouvoir s'assurer que le schème se termine sur le "=" : suppression des blancs devant et derrière les délimiteurs :
    while mw.ustring.find(modele_racine, " =", 0, true)  do modele_racine = string.gsub(modele_racine, " =", "=") end
    while mw.ustring.find(modele_racine, "= ", 0, true)  do modele_racine = string.gsub(modele_racine, "= ", "=") end
    while mw.ustring.find(modele_racine, " |", 0, true)  do modele_racine = string.gsub(modele_racine, " |", "|") end
    while mw.ustring.find(modele_racine, "| ", 0, true)  do modele_racine = string.gsub(modele_racine, "| ", "|") end
    return modele_racine
    end

function p.ligne (frame)
    -- Appelée comme second paramètre sur l'itérateur ar-racine/liste, pour l'affichage des lignes d'une racine.
    -- La fonction reçoit de l'itérateur pour premier paramètre le modèle de la racine (ar-ktb) et pour second paramètre le nom du modèle de schème (de la forme ar-*a*a*a).
    --Si le schème est cité dans le modèle de racine, afficher la ligne, sinon ne rien afficher.
    -- récupération des arguments :
    local racine, scheme = frame.args, frame.args
    scheme= string.gsub(scheme, " ", "") -- suppression des blancs éventuels par sécurité
    racine= string.gsub(racine, " ", "") -- suppression des blancs éventuels par sécurité
    modele_racine = recup_racine(racine)
    local reponse=ligne_affichage(racine, scheme, frame)
    if mw.ustring.sub(scheme, -1) == "ũ" then -- cas nominal = rechercher les suffixes possibles
        scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1) -- supp du "ũ"
            reponse=reponse..ligne_affichage(racine, scheme.."u", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."u", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."ĩ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."@ũ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."@u", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."@u", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."@ĩ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."âtũ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."âtu", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."âtu", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."âtĩ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²ũ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²u", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²u", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²ĩ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²@ũ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²@u", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²@u", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²@ĩ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²âtũ", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²âtu", frame)
            reponse=reponse..ligne_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²âtu", frame)
            reponse=reponse..ligne_affichage(racine, scheme.."iy²âtĩ", frame)
        end -- cas nominal
        return reponse
    end
function ligne_affichage (racine, scheme, frame)
    -- Vérification que le schème est dans le modèle de racine :
    local reponse=""
    local index1 = mw.ustring.find(modele_racine, scheme.."=", 0, true) ; -- NB : ", 0, true)" sont nécessaires ici pour que le schème ne soit pas interprété comme un "pattern".
    if index1 ~= nil then -- on affiche
        sens =  mw.ustring.sub(modele_racine, index1) ; -- clipse du début
        index1 = mw.ustring.find(sens, "=", 0, true)
        sens =  mw.ustring.sub(sens, index1+1) ; -- clipse du schème
        index1 = mw.ustring.find(sens, "|", 0, true)
        if index1 ~= nil and index1 ~= 1 then sens =  mw.ustring.sub(sens, 0, index1-1) else sens="" end ; -- clipse de la fin (sans le pipe)
        translittere= appliquer_interne(mw.ustring.sub(scheme,4) , mw.ustring.sub(racine,4),"", frame)
        lexeme = arabiser_interne(translittere)
        if sens ~= "" then reponse =reponse
            -- nouvelle ligne de liste
            ..string.char(10).."* "
            -- lexème arabe mis en forme avec lien
            .."]"
            -- translittération (= translittere) mise en forme :
            .." (<small>'']''</small>)"
            -- sens donné par la racine
            .. " : " .. frame:preprocess(sens) -- preprocess nécessaire pour exécuter les modèles internes.
            end -- sens non vide
        end -- on affiche
    return reponse --pour ne pas avoir une valeur "nil"
    end -- function

function p.ligne2 (frame)
    -- Appelée comme second paramètre sur l'itérateur ar-racine/liste, pour l'affichage des lignes d'un modèle de racine.
    -- La fonction reçoit de l'itérateur pour premier paramètre le modèle de la racine (ar-ktb) et pour second paramètre le nom du modèle de schème (de la forme ar-*a*a*a).
    -- Conventionnellement, si le schème est ar-*a*?*a (premier schème de l'itérateur) il faut générer l'en-tête du tableau ;
    -- Conventionnellement, si le schème est ar-***ũ (dernier schème de l'itérateur) il faut générer la clôture du tableau ;
    --Si le schème est cité dans le modèle de racine, afficher la ligne, sinon ne rien afficher.
    -- récupération des arguments :
    local racine, scheme = frame.args, frame.args
    scheme= string.gsub(scheme, " ", "") -- suppression des blancs éventuels par sécurité
    racine= string.gsub(racine, " ", "") -- suppression des blancs éventuels par sécurité
    modele_racine = recup_racine(racine)
    if scheme=="ar-*a*?*a" then do return "{| class="..string.char(34).."wikitable sortable"..string.char(34)..string.char(10).."! Lexème !! Translitt. !! Squelette !! Sens !! Schème !! Nature" end
    elseif scheme=="ar-***ũ" then do return string.char(10).."|}" end
    else -- cas général
        local reponse=ligne2_affichage(racine, scheme, frame)
        if mw.ustring.sub(scheme, -1) == "ũ" then -- cas nominal = rechercher les suffixes possibles
            scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1) -- supp du "ũ"
            reponse=reponse..ligne2_affichage(racine, scheme.."u", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."u", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."ĩ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."@ũ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."@u", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."@u", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."@ĩ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."âtũ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."âtu", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."âtu", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."âtĩ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²ũ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²u", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²u", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²ĩ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²@ũ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²@u", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²@u", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²@ĩ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²âtũ", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²âtu", frame)
            reponse=reponse..ligne2_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²âtu", frame)
            reponse=reponse..ligne2_affichage(racine, scheme.."iy²âtĩ", frame)
            end -- cas nominal
        return reponse
        end -- cas général
    end
function get_nature(scheme, frame)
    local nature=frame:expandTemplate{title='modèle:'..scheme, args={'nature'}}
    return nature
    end
function ligne2_affichage (racine, scheme, frame)
    -- Vérification que le schème est dans le modèle de racine :
    local reponse=""
    local index1 = mw.ustring.find(modele_racine, scheme.."=", 0, true) ; -- NB : ", 0, true)" sont nécessaires ici pour que le schème ne soit pas interprété comme un "pattern".
    if index1 ~= nil then -- on affiche
        sens =  mw.ustring.sub(modele_racine, index1) ; -- clipse du début
        index1 = mw.ustring.find(sens, "=", 0, true)
        sens =  mw.ustring.sub(sens, index1+1) ; -- clipse du schème
        index1 = mw.ustring.find(sens, "|", 0, true)
        if index1 ~= nil and index1 ~= 1 then sens =  mw.ustring.sub(sens, 0, index1-1) else sens="" end ; -- clipse de la fin (sans le pipe)
        translittere= appliquer_interne(mw.ustring.sub(scheme,4) , mw.ustring.sub(racine,4),"", frame)
        lexeme = arabiser_interne(translittere)
        squelette = squelette_interne(lexeme)
        local existe, naturescheme = pcall(get_nature, scheme, frame)
        if not(existe) then naturescheme="]" end
        if (sens ~="") then reponse =reponse
            -- nouvelle ligne de tableau
            ..string.char(10).."|-"..string.char(10)
            -- lexème arabe mis en forme avec lien
            .."| align="..string.char(34).."right"..string.char(34).."| ] "
            -- translittération (= translittere) mise en forme :
            .." || .(<small>'']''</small>)."
            -- squelette mis en forme avec lien :
            .."|| align="..string.char(34).."right"..string.char(34).."| ] "
            -- sens donné par la racine
            .. " || " ..  frame:preprocess(sens) -- preprocess nécessaire pour exécuter les modèles internes.
            -- Schème associé
            .."|| "..frame:expandTemplate{title='modèle:ar-sch', args={scheme}}
            -- Nature
            .."|| ".. naturescheme
            end -- sens non vide
        end -- on affiche
    return reponse --pour ne pas avoir une valeur "nil"
    end -- function

function p.ligne3 (frame)
    -- Appelée comme second paramètre sur l'itérateur ar-racine/liste, pour l'affichage des formes possibles à partir d'une racine (donne donc la liste des schèmes connus).
    -- La fonction reçoit de l'itérateur pour premier paramètre le modèle de la racine (ar-ktb) et pour second paramètre le nom du modèle de schème (de la forme ar-*a*a*a).
    -- Conventionnellement, si le schème est ar-*a*?*a (premier schème de l'itérateur) il faut générer l'en-tête du tableau ;
    -- Conventionnellement, si le schème est ar-***ũ (dernier schème de l'itérateur) il faut générer la clôture du tableau ;
    --Si la catégorie du schème n'est pas vide, afficher la ligne, sinon ne rien afficher.
    -- récupération des arguments :
    local racine, scheme = frame.args, frame.args
    scheme= string.gsub(scheme, " ", "") -- suppression des blancs éventuels par sécurité
    racine= string.gsub(racine, " ", "") -- suppression des blancs éventuels par sécurité
    modele_racine = recup_racine(racine)
    if scheme=="ar-*a*?*a" then do return "{| class="..string.char(34).."wikitable sortable"..string.char(34)..string.char(10).."! Modèle !! # !! Forme !! Forme (trans) !! sens " end
    elseif scheme=="ar-***ũ" then do return string.char(10).."|}" end
    else -- cas général
        local reponse=ligne3_affichage(racine, scheme, frame)
        if mw.ustring.sub(scheme, -1) == "ũ" then -- cas nominal = rechercher les suffixes possibles
            scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1) -- supp du "ũ"
            reponse=reponse..ligne3_affichage(racine, scheme.."u", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."u", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."ĩ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."@ũ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."@u", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."@u", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."@ĩ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."âtũ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."âtu", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."âtu", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."âtĩ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²ũ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²u", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²u", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²ĩ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²@ũ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²@u", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²@u", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²@ĩ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²âtũ", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²âtu", frame)
            reponse=reponse..ligne3_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²âtu", frame)
            reponse=reponse..ligne3_affichage(racine, scheme.."iy²âtĩ", frame)
            end -- cas nominal
        return reponse
        end -- cas général
    end
function get_sens(scheme, frame)
    local sens =frame:expandTemplate{title=scheme, args={'sens'}}
    return sens
    end
function ligne3_affichage (racine, scheme, frame)
    -- Vérification que la catégorie du schème n'est pas vide :
    local reponse=""
    local existe, sens = pcall(get_sens, scheme, frame)
    if existe then -- on affiche (le "nombre" est une chaîne de caractères...)
        Nb = frame:callParserFunction{ name="PAGESINCATEGORY", args={scheme} }
        if Nb ~= "0" then
            terme = appliquer_interne(mw.ustring.sub(scheme,4) , mw.ustring.sub(racine,4),"", frame)
            lexeme = arabiser_interne(terme)
            reponse =reponse
            -- nouvelle ligne de tableau
            ..string.char(10).."|-" .. string.char(10)
            -- nom du modèle
            .. "| ]"
            -- pages dans la catégorie
            .. "||style="..string.char(34).."text-align: center;"..string.char(34).."| ".. Nb
            -- application du schème à la racine
 	        .. "||style="..string.char(34).."text-align: right;"..string.char(34).."| ".. "]"
            -- translittéré et délimité
            .. "|| ." .. terme
            -- sens du schème
            .. "|| " .. sens
            end -- cat non vide
        end -- on affiche
    return reponse --pour ne pas avoir une valeur "nil"
    end -- function

function p.ligne4 (frame)
    -- Appelée pour établir la liste des schèmes connus (pour lesquels il y a des exemples).
    -- paramètre 2 = schème à afficher.
    --Si la catégorie du schème n'est pas vide, afficher la ligne, sinon ne rien afficher.
    -- récupération des arguments :
    local racine, scheme = frame.args, frame.args
    scheme= string.gsub(scheme, " ", "") -- suppression des blancs éventuels par sécurité
    racine= string.gsub(racine, " ", "") -- suppression des blancs éventuels par sécurité
    if scheme=="ar-*a*?*a" then do return "{| class="..string.char(34).."wikitable sortable"..string.char(34)..string.char(10).."! # !! Modèle !! P !! I !! S !! Type !! sens " end
    elseif scheme=="ar-***ũ" then do return string.char(10).."|}" end
    else -- cas général
        local reponse=ligne4_affichage(racine, scheme, frame)
        if mw.ustring.sub(scheme, -1) == "ũ" then -- cas nominal = rechercher les suffixes possibles
            scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1) -- supp du "ũ"
            reponse=reponse..ligne4_affichage(racine, scheme.."u", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."u", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."ĩ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."@ũ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."@u", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."@u", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."@ĩ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."âtũ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."âtu", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."âtu", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."âtĩ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²ũ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²u", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²u", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²ĩ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²@ũ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²@u", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²@u", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²@ĩ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²âtũ", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²âtu", frame)
            reponse=reponse..ligne4_affichage(racine, "ar-el"..mw.ustring.sub(scheme, 4, mw.ustring.len(scheme)).."iy²âtu", frame)
            reponse=reponse..ligne4_affichage(racine, scheme.."iy²âtĩ", frame)
            end -- cas nominal
        return reponse
        end -- cas général
    end
function ligne4_affichage (racine, scheme, frame)
    -- Vérification que la catégorie du schème n'est pas vide :
    local reponse=""
    local existe, sens = pcall(get_sens, scheme, frame)
    if existe then -- on affiche (le "nombre" est une chaîne de caractères...)
    local type = frame:expandTemplate{title=scheme, args={'type'}}
        Nb = frame:callParserFunction{ name="PAGESINCATEGORY", args={scheme} }
        if Nb ~= "0" then
            local prefixe, infixe, suffixe = "", "", ""
            -- Récupération d'une image du scheme avec que des "*" pour caler les découpages
            scheme1=scheme
            while mw.ustring.find(scheme1, "1", 1, true)~= nil do scheme1 =  mw.ustring.gsub(scheme1, "1", "*") end
            while mw.ustring.find(scheme1, "2", 1, true)~= nil do scheme1 =  mw.ustring.gsub(scheme1, "2", "*") end
            while mw.ustring.find(scheme1, "3", 1, true)~= nil do scheme1 =  mw.ustring.gsub(scheme1, "3", "*") end
            while mw.ustring.find(scheme1, "4", 1, true)~= nil do scheme1 =  mw.ustring.gsub(scheme1, "4", "*") end
            while mw.ustring.find(scheme1, "t²", 1, true)~= nil do scheme1 =  mw.ustring.gsub(scheme1, "t²", "*²") end
            if mw.ustring.find(scheme1, "*", 1, true)~=nil then
                prefixe = mw.ustring.sub(scheme, 4,  mw.ustring.find(scheme1, "*", 1, true)-1)
                infixe=mw.ustring.sub(scheme, mw.ustring.find(scheme1, "*", 1, true), mw.ustring.len(scheme))
                suffixe=mw.ustring.sub(scheme, mw.ustring.find(scheme1, "*", 1, true), mw.ustring.len(scheme))
                suffixe1=mw.ustring.sub(scheme1, mw.ustring.find(scheme1, "*", 1, true), mw.ustring.len(scheme))
                -- suppression de l'infixe = tant qu'il y a des "*"
                while mw.ustring.find(suffixe1, "*", 1, true)~=nil do
                    suffixe = mw.ustring.sub(suffixe, mw.ustring.find(suffixe1, "*", 1, true)+1, mw.ustring.len(suffixe1))
                    suffixe1 = mw.ustring.sub(suffixe1, mw.ustring.find(suffixe1, "*", 1, true)+1, mw.ustring.len(suffixe1))
                    end
                -- recalage de l'infixe à la bonne longueur :
                infixe=mw.ustring.sub(infixe, 1, mw.ustring.len(infixe)-mw.ustring.len(suffixe))
                end
            reponse =reponse
            -- nouvelle ligne de tableau
            ..string.char(10).."|-" .. string.char(10)
            -- pages dans la catégorie
            .. "|style="..string.char(34).."text-align: center;"..string.char(34).."| ]"
            -- nom du modèle
            .. "|| ]"
            -- décomposition
            .. string.char(10).."|style="..string.char(34).."text-align: right;"..string.char(34).." | " .. prefixe
            .. string.char(10).."|style="..string.char(34).."text-align: center;"..string.char(34).." | " .. infixe
            .. string.char(10).."|style="..string.char(34).."text-align: left;"..string.char(34).." | " .. suffixe
            -- typedu schème
            .. "|| " .. type
            -- sens du schème
            .. "|| " .. sens
            end -- cat non vide
        end -- on affiche
    return reponse --pour ne pas avoir une valeur "nil"
    end -- function

function p.liste_scheme (frame)
    -- Appelée comme second paramètre sur l'itérateur ar-racine/liste, pour l'affichage des schèmes associés à un modèle de schème.
    -- La fonction reçoit de l'itérateur pour premier paramètre le modèle du modèle (ar-*a*u*a) et pour second paramètre le nom du modèle de schème (de la forme ar-*a*a*a).
    -- Si le schème est cité dans le modèle de racine, afficher la ligne, sinon ne rien afficher.
    -- récupération des arguments :
    local modele, scheme = frame.args, frame.args
    scheme= string.gsub(scheme, " ", "") -- suppression des blancs éventuels par sécurité
    modele_racine = recup_racine(modele) -- même problématique de nettoyage, en fait
    local reponse=liste_scheme_affichage (racine, scheme, frame)
    if mw.ustring.sub(scheme, -1) == "ũ" then -- cas nominal = rechercher les suffixes possibles
        scheme=mw.ustring.sub(scheme, 0, mw.ustring.len(scheme)-1) -- supp du "ũ"
            reponse=reponse..liste_scheme_affichage (racine, scheme.."u", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."u", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."ĩ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."@ũ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."@u", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."@u", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."@ĩ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."âtũ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."âtu", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."âtu", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."âtĩ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²ũ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²u", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."iy²u", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²ĩ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²@ũ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²@u", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."iy²@u", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²@ĩ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²âtũ", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²âtu", frame)
            reponse=reponse..liste_scheme_affichage (racine, "el"..scheme.."iy²âtu", frame)
            reponse=reponse..liste_scheme_affichage (racine, scheme.."iy²âtĩ", frame)
        end -- cas nominal
    return reponse
    end

function liste_scheme_affichage (racine, scheme, frame)
    -- Vérification que le schème est dans le modèle de racine :
    local reponse=""
    local index1 = mw.ustring.find(modele_racine, scheme.."=", 0, true) ; -- NB : ", 0, true)" sont nécessaires ici pour que le schème ne soit pas interprété comme un "pattern".
    if index1 ~= nil then -- on affiche
        sens =  mw.ustring.sub(modele_racine, index1) ; -- clipse du début
        index1 = mw.ustring.find(sens, "=", 0, true)
        sens =  mw.ustring.sub(sens, index1+1) ; -- clipse du schème
        index1 = mw.ustring.find(sens, "|", 0, true)
        if index1 ~= nil and index1 ~= 1 then sens =  mw.ustring.sub(sens, 0, index1-1) else sens="" end ; -- clipse de la fin (sans le pipe)
        if sens ~= "" then
            if mw.ustring.sub(sens, 0, 3)=="ar-" then sens = "{{modl|"..sens.."}}" end
            reponse =reponse
            ..string.char(10).."* "
            -- sens donné par la racine
            .. frame:preprocess(sens) -- preprocess nécessaire pour exécuter les modèles internes.
            -- Schème associé
            .." : "..frame:expandTemplate{title='modèle:modl', args={scheme}}
            end -- sens non vide
        end -- on affiche
    return reponse --pour ne pas avoir une valeur "nil"
    end -- function

return p