Module:arabe

Définition, traduction, prononciation, anagramme et synonyme sur le dictionnaire libre Wiktionnaire.
Sauter à la navigation Sauter à la recherche
  • appliquer Application d'un schème à une racine :
{{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}}.


local p = {}

local scheme , racine, contexte = "", "", ""

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.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)
20        "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)[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)[2] } 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)[2] } 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)[2] } end ; 
            end -- consonne
            do return {"?", "?"} end ;
         end
    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
    scheme , racine = mw.ustring.sub(frame.args.scheme,4) , mw.ustring.sub(frame.args.racine, 4)

    -- 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 ;

    -- remplacement des étoiles par le rang d'ordre des lettres radicales (pour homogénéiser le traitement des verbes irréguliers) :
    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 ;
    -- sauf pour 3, parce que sinon, on a des problèmes si "3" est present comme lettre radicale...
    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...
    scheme = mw.ustring.gsub( scheme, "3", "*") ;

    -- verbe sourd, on supprime la voyelle intercalaire entre 2 et 3 si c'est possible
    if  (mw.ustring.sub(racine, 2, 2) == mw.ustring.sub(racine, 3, 3))
    then
        local position2 = mw.ustring.find  ( scheme, "2")  ;
        local nature2= nature (position2) ;
        if (nature2[1]..nature2[2] == "io")
        and mw.ustring.find("ãĩũñõ" , mw.ustring.sub(scheme, position2+3, position2+3) )==nil -- pas de contraction sur noms et adjectifs
        then
            local position3 = mw.ustring.find  ( scheme, "*")  ;
            if est_voyelle(position2-1)
            then scheme = mw.ustring.sub( scheme, 1, position3-2) .. mw.ustring.sub( scheme, position3)
            else scheme = mw.ustring.sub( scheme, 1, position2-1) ..
                mw.ustring.sub( scheme, position3-1, position3-1) ..
                mw.ustring.sub( scheme, position2, position2) ..
                mw.ustring.sub( scheme, position3)
                end
            end
        end

    -- troisième radicale
    scheme = mw.ustring.gsub( scheme, "*", mw.ustring.sub(racine, 3, 3)) ;

    -- quatrième radicale éventuelle
    scheme = mw.ustring.gsub ( scheme, "4", mw.ustring.sub(racine, 4, 4)) ;

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

    -- deuxième radicale
    if mw.ustring.sub(racine, 2, 2) == "w"
        then
            do -- verbe creux en W, ch Schier p. 71
                -- NB : ne traite pas correctement la forme ix qui devrait être régulière.
                local position = mw.ustring.find  ( scheme, "2")

                -- contexte de la radicale
                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)[1] == "f")
                        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
                elseif contexte == "a2a" and position~=3
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2)[1] == "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

                -- awi remplacé par â ou a
                elseif contexte == "a2i"
                then -- la lettre en position +2 est-elle une finale de syllable ?
                        if (nature (position+2)[1] == "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

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

                -- âwi : remplacé par â'i dans le nom d'agent première forme, mais reste yufâwilu dans les autres formes 
                elseif (contexte == "â2i") and (position == 3)
                    and (mw.ustring.sub( scheme, position+3, position+3)~="")
                    and (mw.ustring.find("ãĩũ@ñõ" , mw.ustring.sub( scheme, position+3, position+3) ) ~= nil)
                then  scheme=mw.ustring.sub( scheme, 1, position-2) .. "â'i" .. mw.ustring.sub( scheme, position+2)

                -- iw° 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)

                -- °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[1] == "f") and (suite[2] == "f" )
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "a" .. mw.ustring.sub( scheme, position+2)
                        elseif suite[1] == "f"
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "a" .. mw.ustring.sub( scheme, position+2)
                        elseif suite[1] == "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â")
                then -- distinction entre le nom verbal de la forme (iv) **â*ñ et le pluriel irrégulier a**â*ñ
                    if position==2 
                    then scheme=mw.ustring.sub( scheme, 1, position-1) .. "â" .. mw.ustring.sub( scheme, position+2)
                    else scheme=mw.ustring.sub( scheme, 1, position-1) .. "wâ" .. mw.ustring.sub( scheme, position+2)
                    end

                 -- °2i : î si la syllable longue est possible, i sinon
                elseif (contexte == "°2i")
                then
                        if (nature (position+2)[1] == "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

                 -- °wu : û si la syllable longue est possible, u sinon
                elseif (mw.ustring.sub( scheme, position+1, position+1) == "u")  and  ( mw.ustring.find("aiuâîûãĩũ@ñõ" , mw.ustring.sub( scheme, position-1, position-1) ) == nil )
                then
                        if (mw.ustring.sub( scheme, position+3, position+3)== nil) or mw.ustring.find("aiuâîûãĩũ@ñõ" , mw.ustring.sub( scheme, position+3, position+3) )
                        then scheme=mw.ustring.sub( scheme, 1, position-1) .. "û" .. mw.ustring.sub( scheme, position+2)
                        else scheme=mw.ustring.sub( scheme, 1, position-1) .. "u" .. mw.ustring.sub( scheme, position+2)
                        end
                elseif (mw.ustring.sub( scheme, position+1, position+1) == "û")
                    -- °wû : participe passif
                then scheme=mw.ustring.sub( scheme, 1, position-2) .. "û" .. mw.ustring.sub( scheme, position+2)
                else
                    scheme = mw.ustring.gsub( scheme, "2", mw.ustring.sub(racine, 2, 2))
                end -- if
            end -- do verbe creux en W
        else scheme = mw.ustring.gsub( scheme, "2", mw.ustring.sub(racine, 2, 2))
        end ;

    -- ajout en finale 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 ;

    return scheme
    end

function p.verifier ( frame )
    -- paramètre = nom de page d'un modèle racine de la forme ar-ktb
    local racine = frame.args.racine
    -- récupération du texte brut du modèle
    local moncode = mw.title.makeTitle( "template", racine):getContent()

    -- décomposition du modèle racine

    -- positionnement au début du "#switch:"
    local index =  mw.ustring.find(moncode, "#switch:") ;
    moncode=mw.ustring.sub(moncode, index+14) ;
    local resultat = "" ;

    repeat
        -- positionnement sur le prochain item
        index = mw.ustring.find(moncode, "|") ;
        if index == nil then do return resultat end end ;
        moncode=mw.ustring.sub(moncode, index+1) ;
        -- positionnement sur le prochain "="
        index = mw.ustring.find(moncode, "=") ;
        if index == nil then do return resultat end end ;
        racine=mw.ustring.sub(moncode, 1, index-1)
        racine = string.gsub(racine, " ", "")
        if mw.ustring.sub(racine, 1, 3) == "ar-"
        then
            resultat = resultat .. "{{" .. racine .. "}}"
            end
        until mw.ustring.find(moncode, "=") == nil ;
    return resultat
    end

return p