Grammalecte  Check-in [101d54de7e]

    sCode = sCode.replace("__also__", "bCondMemo")
    sCode = sCode.replace("__else__", "not bCondMemo")
    sCode = sCode.replace("sContext", "_sAppContext")
    sCode = re.sub(r"\b(morph0?|morphVC|value|tag|meta|info)[(]\\(\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(morph0?|morphVC|value|tag|meta|info)[(]\\-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(select|define|definefrom|rewrite|addmorph|setmeta)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2]', sCode)
    sCode = re.sub(r"\b(select|define|definefrom|rewrite|addmorph|setmeta)[(][\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\](\d+), *[\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2], lToken[nTokenOffset+\\3]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\](\d+), *[\\]-(\d+)", 'g_\\1(lToken[nTokenOffset+\\2], lToken[nLastToken-\\3+1]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\]-(\d+), *[\\](\d+)", 'g_\\1(lToken[nLastToken-\\2+1], lToken[nTokenOffset+\\3]', sCode)
    sCode = re.sub(r"\b(agreement|suggAgree)[(][\\]-(\d+), *[\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1], lToken[nLastToken-\\3+1]', sCode)
    sCode = re.sub(r"\b(tagbefore|tagafter)[(][\\](\d+)", 'g_\\1(lToken[nTokenOffset+\\2], dTags', sCode)
    sCode = re.sub(r"\b(tagbefore|tagafter)[(][\\]-(\d+)", 'g_\\1(lToken[nLastToken-\\2+1], dTags', sCode)
    sCode = re.sub(r"\bspace[(][\\](\d+)", 'g_space(lToken[nTokenOffset+\\1], lToken[nTokenOffset+\\1+1]', sCode)
    sCode = re.sub(r"\bspace[(][\\]-(\d+)", 'g_space(lToken[nLastToken-\\1+1], lToken[nLastToken-\\1+2]', sCode)
    sCode = re.sub(r"\bmorph2[(][\\](\d+)", 'g_morph2(lToken[nTokenOffset+\\1], lToken[nTokenOffset+\\1+1]', sCode)
    sCode = re.sub(r"\bmorph2[(][\\]-(\d+)", 'g_morph2(lToken[nLastToken-\\1+1], lToken[nLastToken-\\1+2]', sCode)
    sCode = re.sub(r"\b(morph0?|tag|meta|value|info)\(>1", 'g_\\1(lToken[nLastToken+1]', sCode)                      # next token
    sCode = re.sub(r"\b(morph0?|tag|meta|value|info)\(<1", 'g_\\1(lToken[nTokenOffset]', sCode)                      # previous token
    sCode = re.sub(r"\b(morph0?|tag|meta|value|info)\(>(\d+)", 'g_\\1(g_token(lToken, nLastToken+\\2)', sCode)       # next token
    sCode = re.sub(r"\b(morph0?|tag|meta|value|info)\(<(\d+)", 'g_\\1(g_token(lToken, nTokenOffset+1-\\2)', sCode)   # previous token
    sCode = re.sub(r"\bspace[(](>1)", 'g_space(lToken[nLastToken+1], g_token(lToken, nLastToken+2)', sCode)     # next token
    sCode = re.sub(r"\bspace[(](<1)", 'g_space(lToken[nTokenOffset], lToken[nTokenOffset+1]', sCode)            # previous token
    sCode = re.sub(r"\bspell *[(]", '_oSpellChecker.isValid(', sCode)
    sCode = re.sub(r"\bbefore\(\s*", 'look(sSentence[:lToken[1+nTokenOffset]["nStart"]], ', sCode)          # before(sCode)
    sCode = re.sub(r"\bafter\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', sCode)                 # after(sCode)
    sCode = re.sub(r"\bbefore0\(\s*", 'look(sSentence0[:lToken[1+nTokenOffset]["nStart"]], ', sCode)        # before0(sCode)
    sCode = re.sub(r"\bafter0\(\s*", 'look(sSentence0[lToken[nLastToken]["nEnd"]:], ', sCode)               # after0(sCode)


    sCode = re.sub(r"[\\](\d+)", 'lToken[nTokenOffset+\\1]["sValue"]', sCode)
    sCode = re.sub(r"[\\]-(\d+)", 'lToken[nLastToken-\\1+1]["sValue"]', sCode)
    sCode = re.sub(r">1", 'lToken[nLastToken+1]["sValue"]', sCode)
    sCode = re.sub(r"<1", 'lToken[nTokenOffset]["sValue"]', sCode)
    return sCode

// Grammalecte - Compiled regular expressions

/* jshint esversion:6 */
/* jslint esversion:6 */


var cregex = {
    ///// Lemme
    _zLemma: new RegExp(">([a-zà-öø-ÿ0-9Ā-ʯ][a-zà-öø-ÿ0-9Ā-ʯ-]+)"),

    ///// Masculin / féminin / singulier / pluriel
    _zGender: new RegExp(":[mfe]"),
    _zNumber: new RegExp(":[spi]"),
    _zGenderNumber: new RegExp(":[mfe]:[spi]"),

    ///// Nom et adjectif
    _zNA: new RegExp(":[NA]"),

    //// nombre
    _zNAs: new RegExp(":[NA].*:s"),
    _zNAp: new RegExp(":[NA].*:p"),

        return sGender;
    },

    getNumber: function (lMorph) {
        // returns number of word (':s', ':p', ':i' or empty string).
        let sNumber = "";
        for (let sMorph of lMorph) {
            let m = this._zNumber.exec(sMorph);
            if (m) {
                if (!sNumber) {
                    sNumber = m[0];
                } else if (sNumber != m[0]) {
                    return ":i";
                }
            }
        }
        return sNumber;
    },

    getGenderNumber: function (lMorph) {
        // returns tuple (gender, number) of word: (':m', ':f', ':e' or empty string) and (':s', ':p', ':i' or empty string)
        let sGender = "";
        let sNumber = "";
        for (let sMorph of lMorph) {
            let m = this._zGenderNumber.exec(sMorph);
            if (m) {
                let sGenderx = m[0].slice(0,2);
                let sNumberx = m[0].slice(2,4);
                if (!sGender) {
                    sGender = sGenderx;
                }
                else if (sGender != sGenderx) {
                    sGenderx = ":e";
                }
                if (!sNumber) {
                    sNumber = sNumberx;
                }
                else if (sNumber != sNumberx) {
                    sNumberx = ":i";
                }
            }
        }
        return [sGender, sNumber];
    },


    // NOTE :  isWhat (lMorph)    returns true   if lMorph contains nothing else than What
    //         mbWhat (lMorph)    returns true   if lMorph contains What at least once

    //// isXXX = it’s certain

    isNom: function (lMorph) {

    }
    aSugg.delete("");
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

function g_suggAgree (dTokenDst, dTokenSrc) {
    // returns suggestions for <dTokenDst> that matches agreement with <dTokenSrc>
    let lMorphSrc = oTokenSrc.hasOwnProperty("lMorph") ? oTokenSrc["lMorph"] : gc_engine.oSpellChecker.getMorph(oTokenSrc["sValue"]);
    if (lMorphSrc.length === 0) {
        return "";
    }
    let [sGender, sNumber] = cregex.getGenderNumber(lMorphSrc);
    if (sGender == ":m") {
        if (sNumber == ":s") {
            return suggMasSing(dTokenDst["sValue"]);
        }
        else if (sNumber == ":p") {
            return suggMasPlur(dTokenDst["sValue"]);
        }
        return suggMasSing(dTokenDst["sValue"]);
    }
    else if (sGender == ":f") {
        if (sNumber == ":s") {
            return suggFemSing(dTokenDst["sValue"]);
        }
        else if (sNumber == ":p") {
            return suggFemPlur(dTokenDst["sValue"]);
        }
        return suggFemSing(dTokenDst["sValue"]);
    }
    else if (sGender == ":e") {
        if (sNumber == ":s") {
            return suggSing(dTokenDst["sValue"]);
        }
        else if (sNumber == ":p") {
            return suggPlur(dTokenDst["sValue"]);
        }
        return dTokenDst["sValue"];
    }
    return "";
}

function hasFemForm (sFlex) {
    for (let sStem of gc_engine.oSpellChecker.getLemma(sFlex)) {
        if (mfsp.isMasForm(sStem) || conj.hasConj(sStem, ":PQ", ":Q3")) {
            return true;
        }
    }

"""
Grammalecte - Compiled regular expressions
"""

import re

#### Lemme
Lemma = re.compile(r"^>(\w[\w-]*)")

#### Analyses
Gender = re.compile(":[mfe]")
Number = re.compile(":[spi]")
GenderNumber = re.compile(":[mfe]:[spi]")

#### Nom et adjectif
NA = re.compile(":[NA]")

## nombre
NAs = re.compile(":[NA].*:s")
NAp = re.compile(":[NA].*:p")

        m = Number.search(sMorph)
        if m:
            if not sNumber:
                sNumber = m.group(0)
            elif sNumber != m.group(0):
                return ":i"
    return sNumber

def getGenderNumber (lMorph):
    "returns tuple (gender, number) of word: (':m', ':f', ':e' or empty string) and (':s', ':p', ':i' or empty string)"
    sGender = ""
    sNumber = ""
    for sMorph in lMorph:
        m = GenderNumber.search(sMorph)
        if m:
            sGenderx = m.group(0)[0:2]
            sNumberx = m.group(0)[2:4]
            if not sGender:
                sGender = sGenderx
            elif sGender != sGenderx:
                sGender = ":e"
            if not sNumber:
                sNumber = sNumberx
            elif sNumber != sNumberx:
                sNumber = ":i"
    return sGender, sNumber


# NOTE :  isWhat (lMorph)    returns True   if lMorph contains nothing else than What
#         mbWhat (lMorph)    returns True   if lMorph contains What at least once

## isXXX = it’s certain

def isNom (lMorph):

        for e in phonet.selectSimil(sFlex, ":f:[pi]"):
            aSugg.add(e)
    aSugg.discard("")
    if aSugg:
        return "|".join(aSugg)
    return ""


def g_suggAgree (dTokenDst, dTokenSrc):
    "returns suggestions for <dTokenDst> that matches agreement with <dTokenSrc>"
    lMorphSrc = dTokenSrc["lMorph"]  if "lMorph" in dTokenSrc  else  _oSpellChecker.getMorph(dTokenSrc["sValue"])
    if not lMorphSrc:
        return ""
    sGender, sNumber = cr.getGenderNumber(lMorphSrc)
    if sGender == ":m":
        if sNumber == ":s":
            return suggMasSing(dTokenDst["sValue"])
        elif sNumber == ":p":
            return suggMasPlur(dTokenDst["sValue"])
        return suggMasSing(dTokenDst["sValue"])
    elif sGender == ":f":
        if sNumber == ":s":
            return suggFemSing(dTokenDst["sValue"])
        elif sNumber == ":p":
            return suggFemPlur(dTokenDst["sValue"])
        return suggFemSing(dTokenDst["sValue"])
    elif sGender == ":e":
        if sNumber == ":s":
            return suggSing(dTokenDst["sValue"])
        elif sNumber == ":p":
            return suggPlur(dTokenDst["sValue"])
        return dTokenDst["sValue"]
    return ""


def hasFemForm (sFlex):
    "return True if there is a feminine form of <sFlex>"
    for sStem in _oSpellChecker.getLemma(sFlex):
        if mfsp.isMasForm(sStem) or conj.hasConj(sStem, ":PQ", ":Q3"):
            return True
    if phonet.hasSimil(sFlex, ":f"):

TEST: Le mari répète à l’envi qu’il a découvert la France à travers les mots de sa femme.
TEST: Il reste de nombreux militants sincères à la FI.


__conf_de_vconj__
    [de|d’]  @:[123][sp]¬:[GNA]
        <<- /conf/ not \2.istitle() and not \2.isupper() and not value(\2, "|jure|") and not tag(\2, "eg1mot")
        -2>> =suggSimil(\2, ":[NA]", True)+"|"+suggVerbInfi(\2)                                     && Incohérence avec « \1 » : “\2” est une forme verbale conjuguée.

TEST: il s’agit de {{mette}} en évidence.
TEST: sa façon de {{nettoyez}} était inefficace.                                            ->> nettoyer|nettoyant


    [de|d’]  [l’|leur]  @:[123][sp]¬:[GNAQ]
        <<- /conf/ not \3.istitle() and not \3.isupper() -3>> =suggSimil(\3, ":[NA]:.:[si]", True)  && Incohérence avec « \1 \2 » : “\3” est une forme verbale conjuguée.

TEST: de l’{{arrivait}}
TEST: la production d’électricité par des énergies renouvelables aurait encore augmenté de 7 %, selon les calculs de l’AIE

    autour [de|d’] [ce|mon|ton|son|notre|votre|leur] [coup|coût|cout]
    la bride au [coup|coût|cout]
    la bride autour du [coup|coût|cout]
    la bride sur le [coup|coût|cout]
        <<- /conf/ --1>> cou            && Confusion probable. Le coût est le prix d’une chose. Le coup est ce qui frappe. Le cou est la partie joignant le tronc à la tête.|https://fr.wiktionary.org/wiki/cou

    [>cou|>coût|>cout] [au-dessous|en-dessous] [de|d’] la ceinture
    [>cou|>coût|>cout] [de|d’] [>baguette|>barre|>bâton|>bec|>bélier|blues|>botte|>boule|>boutoir|>bol|>bite|>cœur|>chaud|>coude|>couteau|>crayon|>dé|>dent|>déprime|>éponge|>feu|>froid|fil|>filet|>folie|>foudre|>genou|>grâce|>griffe|>grisou|>gueule|>hache|>hachette|>hanche|Jarnac|jus|>jeune|>klaxon|>main|maître|maitre|>massue|>marteau|>menton|monté+s|>nostalgie|>pied|>poing|>poignard|>pouce|>pute|>queue|>rein|>rabot|>savate|>sang|>sabot|>sabre|>semonce|>sonnette|>sifflet|>soleil|>sonde|>sort|>surin|>tête|>théâtre|>tonnerre|>torchon|>trique|>vent|vieux]
    [>cou|>coût|>cout] d’ [>arrêt|>éclat|>épée|>état|>épaule|œil|oeil|>estoc]
    [>cou|>coût|>cout] du sort
    [>cou|>coût|>cout] [dur+s]
    >cou d’ envoi
        <<- /conf/ -1>> coup|coups      && Confusion probable. Le coût est le prix d’une chose. Le cou est la partie joignant le tronc à la tête. Pour ce qui frappe, écrivez “coup”.

    violence du [>cou|>coût|>cout]

    ci-dessus
    chaque chose en son temps
    chose promise ?,¿ chose due
    comme [de|d’] juste
    comme bon [me|te|lui|leur|nous|vous] semble
    comme ci ?,¿ comme ça
    comme cul et chemise
    comme des fétus [de|d’] paille
    comme [frappé+ses] par la foudre
    comme gage [de|d’] bonne foi
    comme n’importe où ?ailleurs¿
    comme par [enchantement|magie]
    comme par un fait exprès
    comme pas deux
    comme peau [de|d’] chagrin
    comme prévu
    comme promis
    comme qui dirait
    comme si [de|d’] rien n’ était
    comme sur des roulettes
    comme un lion en cage
    comme un fétu [de|d’] paille
    comme une lettre à la poste
    contrairement aux apparences
    contre mauvaise fortune ?,¿ bon cœur
    contre nature
    contre toute [attente|vraisemblance]
    contre vents et marées
    contre [mon|ton|son|notre|votre|leur] gré

    pour ça [vaut|valait]
    pourtant
    presque
    primo
    quand bien même
    quand bon [me|te|lui|nous|vous|leur] [semble|semblera|semblait]
    quant à [ça|cela|ceci]
    qu’ à cela ne tienne
    [que|qu’] [ça|ceci|cela] [me|te|lui|leur|nous|vous] plaise ou non
    ##
    [que|qu’] je [le|l’] veuille ou non
    [que|qu’] tu [le|l’] veuilles ou non
    qu’ [il|elle|on|iel] [le|l’] veuille ou non
    [que|qu’] vous [le|l’] vouliez ou non
    [que|qu’] nous [le|l’] voulions ou non
    qu’ [ils|elles|iels] [le|l’] veuillent ou non
    ##
    [que|qu’] [je|j’] m’ en réjouisse ou que [je|j’] le déplore
    [que|qu’] tu t’ en réjouisses ou que tu le déplores
    qu’ [il|elle|iel|on] s’ en réjouisse ou qu’ [il|elle|iel|on] le déplore
    [que|qu’] nous nous en réjouissions ou que nous le déplorions
    [que|qu’] vous vous en réjouissez ou que vous le déploriez
    qu’ [ils|elles|iels] s’ en réjouissent ou qu’ [ils|elles|iels] le déplorent
    ##
    quel qu’ en soit [le|l’] [moyen|prix|danger]
    quel qu’ en soit [le|l’] risque ?[économique|financier|légal|juridique|militaire]¿
    quelle qu’ en soit la [cause|raison]
    quelque peu
    ?[de|d’]¿ quelque part
    qui plus est
    quoi qu’ il [arrive|arrivât|advienne|advînt]

    >résidence d’ [été|hiver]
    >responsable qualité
    [>resto|>restau] u
    >retour à la case départ
    >retour à la normale
    >retour [de|d’] [bâton|flamme]
    >retour en arrière
    revers [de|d’] fortune
    >revue [de|d’] presse
    >rivière à sec
    >robe [de|d’] [chambre|soirée]
    >robe du soir
    >robe sans >manche
    >roi [de|d’] [carreau|cœur|pique|trèfle]
    >roman à [>sensation|suspense]

    complètement
        <<- not morph(<1, ":D.*:m") ~>> *

    ~.ment$  ?[parlant|pas]¿
        <<- morph(\1, ":W", ":(?:3p|N)") ~>> *

    , *WORD et $:W¬* ,
        <<- morph(\2, ":W", "*") ~>> *


@@@@
@@@@
@@@@
@@@@
@@@@GRAPH: intergraphe12a|ig12a                                                                    _

!!
!!
!!!! Groupe nominal (sans déterminant)                                                            !!
!!
!!


__gn_start_prn_1m__
    <start>  $:M1 ?,¿  @:[NA]¬:([ISKYPEGW]|e:[si])
        <<- /gn/ morph(\2, ":M1.*:m", ":[fe]") and morph(\-1, ":[NA]", ":[me]:[si]")
        --1>> =suggMasSing(\-1)                                                                     && Cet adjectif n’est pas accordé avec le prénom masculin “\2”.
        <<- /gn/ __else__ and morph(\2, ":M1.*:f", ":[me]") and morph(\-1, ":[NA]", ":[fe]:[si]")
        --1>> =suggFemSing(\-1)                                                                     && Cet adjectif n’est pas accordé avec le prénom féminin “\2”.

TEST: Patrick {{partie}} à la boulangerie depuis une heure.                         ->> parti
TEST: Antonina, {{oublié}} par ses parents chez leur grand-mère                     ->> oubliée
TEST: Pauline, {{surnuméraires}} parmi les employés de cette boîte                  ->> surnuméraire
TEST: Ahmed, {{psychologues}} à l’hôpital de Strasbourg                             ->> psychologue
TEST: il fronça les sourcils, inquiet pour son avenir
TEST: elles préservaient ce secret, conscientes du danger.


__gn_start_2m__
    <start>  @:[NA]¬*  @:[NA]¬*
        <<- /gn/ ((morph(\2, ":m", "*") and morph(\3, ":f", "*")) or (morph(\2, ":f", "*") and morph(\3, ":m", "*"))) and not apposition(\2, \3)
        -3>> =switchGender(\3)                                                                      && Accord de genre erroné avec « \2 ».
        <<- /gn/ __also__ and hasFemForm(\2) -2>> =switchGender(\2)                                 && Accord de genre erroné avec « \3 ».
        <<- /gn/ ((morph(\2, ":s", "*") and morph(\3, ":p", "*")) or (morph(\2, ":p", "*") and morph(\3, ":s", "*"))) and not apposition(\2, \3)
        -3>> =switchPlural(\3)                                                                      && Accord de nombre erroné avec « \2 ».
        <<- /gn/ __also__ -2>> =switchPlural(\2)                                                    && Accord de nombre erroné avec « \3 ».

TEST: {{serrurière}} {{intelligent}}.                                               ->> serrurier|||intelligente
TEST: {{serrurier}} {{intelligente}}.                                               ->> serrurière|||intelligent
TEST: {{Femmes}} {{mariée}}                                                         ->> Femme|||mariées
TEST: {{hommes}} {{marié}}                                                          ->> homme|||mariés


__gn_start_3m__
    <start>  @:[NA]¬*  @:[NA]¬*  @:[NA]¬*
        <<- /gn/ morph(\2, ":p") and morph(\3, ":[pi]") and morph(\4, ":s", ":[pi]") and \4.islower() -4>> =switchPlural(\4)  && Accord de nombre erroné avec « \2 \3 » : « \4 » devrait être au pluriel.
        <<- /gn/ morph(\2, ":i") and morph(\3, ":p")    and morph(\4, ":s", ":[pi]") and \4.islower() -4>> =switchPlural(\4)  && Accord de nombre erroné avec « \2 \3 » : « \4 » devrait être au pluriel.
        <<- /gn/ morph(\2, ":s") and morph(\3, ":[si]") and morph(\4, ":p", ":[si]") and \4.islower() -4>> =switchPlural(\4)  && Accord de nombre erroné avec « \2 \3 » : « \4 » devrait être au singulier.

TEST: {{petite}} et {{grande}} homme                            ->> petit|||grand
TEST: {{bel}} et {{grand}} nation                               ->> belle|||grande
TEST: {{stupides}} et {{intellectuels}} psychologue             ->> stupide|||intellectuel
TEST: {{petite}} et {{grande}} hommes                           ->> petits|||grands
TEST: {{bel}} et {{grand}} nations                              ->> belles|||grandes
TEST: {{stupide}} et {{intellectuel}} psychologues              ->> stupides|||intellectuels


__gn_2m_et__
    [<start>|,|(]  *WORD  et  @:A¬:[ISKYPEGW]|;C  [<end>|,|)]
        <<- /gn/ morph(\2, ":A", ":[ISKYPEGW]|;C") and not agreement(\2, \4, False) -2>> =suggAgree(\2, \4)     && Cet adjectif n’est pas accordé avec l’adjectif “\4”.
        <<- /gn/ __also__ -4>> =suggAgree(\4, \2)                                                               && Cet adjectif n’est pas accordé avec l’adjectif “\4”.

TEST: cette femme, {{grande}} et {{intelligent}}                ->> grand|||intelligente
TEST: cet homme, {{curieuse}} et {{affligé}}                    ->> curieux|||affligée
TEST: ces personnes, {{étrangères}} et {{passionnée}}           ->> étrangère|||passionnées
TEST: des portes, {{grands}} et {{folles}}                      ->> grandes|||fous
TEST: ils marchaient ensemble, ingénieurs et patron, vers leur dernière heure, ignorants du danger.
TEST: nous roulions lentement vers cette maison, inquiets et apeurés.


## Prépositions
__gn_pfx_en_2m__
    en  @:[NA]¬*  @:[NA]¬*
        <<- /gn/ ( (morph(\2, ":m", "*") and morph(\3, ":f", "*")) or (morph(\2, ":f", "*") and morph(\3, ":m", "*")) ) and not apposition(\2, \3)
        -3>> =switchGender(\3)                                                                      && Accord de genre erroné avec « \2 ».
        <<- /gn/ __also__ and hasFemForm(\2) -2>> =switchGender(\2)                                 && Accord de genre erroné avec « \3 ».

__infi_commencer_finir_par__
    [>commencer|>finir]  par  ?[le|l’|la|leur|les]¿  @:V¬:[NGMY]
    [>commencer|>finir]  par  [nous|vous|lui]        @:V¬:[GMY]
        <<- /infi/ not \-1[0:1].isupper() --1>> =suggVerbInfi(\3)                       && Après « commencer/finir par », le verbe devrait être à l’infinitif.

TEST: commence par {{mangé}} le poulet.                                         ->> manger
TEST: enfin la petite finit par {{pleuré}} à chaudes larmes.                    ->> pleurer
TEST: sa tournée, elle la finit par Rodez.


#### Infinitif après “de”

__infi_de_verbe__
    [un|une] [de|d’] [perdu+ses] ?,¿ dix [de|d’] [retrouvé+ses]

    [de|d’] [me|m’|te|t’|se|s’]  [le|la|l’|les|en|y]                             @:V¬:Y
    [de|d’] [nous|vous]          [le|la|l’|les|en|y]                             @:V¬:[YP]
    [de|d’] [le|la|l’|les]       [lui|leur|en|y]                                 @:V¬:Y
    [de|d’] leur                 en                                              @:V¬:Y
    [de|d’] lui                  en                                              @:V¬:[YP]
        <<- /infi/ --1>> =suggVerbInfi(\-1)                                             && Après “de”, le verbe devrait être à l’infinitif.

    [de|d’]  @:V1.*:Q¬:N
        <<- /infi/ not \2[0:1].isupper() and not morph(<1, ">(?:en|passer|qualifier)/") and not morph(\2, ">(?:fieffer|sacrer)/") and not tag(<1, "_rien_")
            and not before("(?i)(?:quelqu(?:e chose|’une?)|qu’y a-t-il |\\b(?:l(?:es?|a)|nous|vous|me|te|se) trait|personne|points? +$|autant +$|ça +|rien d(?:e |’)|rien(?: +[a-zéèêâîûù]+|) +$)")
            and not tagbefore(\1, "_ceque_")
        -2>> =suggVerbInfi(\2)                                                          && Le verbe devrait être à l’infinitif.

TEST: d’en {{parlé}} sans cesse                                                             ->> parler
TEST: cela suffit de les {{aimait}}                                                         ->> aimer
TEST: de ne leur en {{avancé}} que le nécessaire.                                           ->> avancer
TEST: de l’y {{poussé}}                                                                     ->> pousser
TEST: je suis certain d’en {{choque}} plusieurs.                                            ->> choquer
TEST: elle était capable de la {{trouvait}} où qu’elle soit.                                ->> trouver
TEST: de me le {{facturez}}                                                                 ->> facturer
TEST: suffit de {{la}} {{finit}}                                                            ->> là|||finir
TEST: Il s’agit de me {{donnait}} tout ça.                                                  ->> donner
TEST: j’étais incapable de m’{{orientait}} dans la bonne direction.                         ->> orienter
TEST: ils étaient susceptibles de m’y {{trouvaient}}                                        ->> trouver

TEST: elle a délibérément omis de les {{inclurent}}.                                        ->> inclure
TEST: d’{{mangé}} je ne suis pas capable                                                    ->> manger
TEST: elles n’ont rien touché de souillé
TEST: elle s’engage de ne les lui donner qu’en dernier recours.
TEST: l’idée consiste de la lui donner sans contrepartie et voir ce qu’il en fera.
TEST: de leur plus grand fils, ils attendent beaucoup.
TEST: de n’importe quelle manière

__infi_que_faire_sinon__
    que faire ?,¿ sinon  ?[ne|n’]¿  ?[le|la|l’|les|en|me|m’|te|t’|se|s’|nous|vous|lui|leur|y]¿ ~..(?:ée?s?|ez|ai[ts]?)$
    que faire ?,¿ sinon  ?[ne|n’]¿  [me|m’|te|t’|se|s’|nous|vous]   [le|la|l’|les|en|y]        ~..(?:ée?s?|ez|ai[ts]?)$
    que faire ?,¿ sinon  ?[ne|n’]¿  [le|la|l’|les]                  [lui|leur|en|y]            ~..(?:ée?s?|ez|ai[ts]?)$
    que faire ?,¿ sinon  ?[ne|n’]¿  [lui|leur|y]                    en                         ~..(?:ée?s?|ez|ai[ts]?)$
        <<- /infi/ morph(\-1, ":V", ":M") --1>> =suggVerbInfi(\-1)                                  && Après “que faire”, mettez le verbe à l’infinitif.

TEST: que faire, sinon s’{{adonnait}} à sa passion                                          ->> adonner
TEST: que croire sinon la pensée qu’il y a toujours une solution


__infi_rien_à_faire_que_sinon__
    rien à faire [que|qu’|sinon]          ?[ne|n’]¿  ?[le|la|l’|les|en|me|m’|te|t’|se|s’|nous|vous|lui|leur|y]¿ ~..(?:ée?s?|ez|ai[ts]?)$
    rien à faire [que|qu’|sinon]          ?[ne|n’]¿  [me|m’|te|t’|se|s’|nous|vous]   [le|la|l’|les|en|y]        ~..(?:ée?s?|ez|ai[ts]?)$
    rien à faire [que|qu’|sinon]          ?[ne|n’]¿  [le|la|l’|les]                  [lui|leur|en|y]            ~..(?:ée?s?|ez|ai[ts]?)$
    rien à faire [que|qu’|sinon]          ?[ne|n’]¿  [lui|leur|y]                    en                         ~..(?:ée?s?|ez|ai[ts]?)$
    rien d’ autre à faire [que|qu’|sinon] ?[ne|n’]¿  ?[le|la|l’|les|en|me|m’|te|t’|se|s’|nous|vous|lui|leur|y]¿ ~..(?:ée?s?|ez|ai[ts]?)$
    rien d’ autre à faire [que|qu’|sinon] ?[ne|n’]¿  [me|m’|te|t’|se|s’|nous|vous]   [le|la|l’|les|en|y]        ~..(?:ée?s?|ez|ai[ts]?)$
    rien d’ autre à faire [que|qu’|sinon] ?[ne|n’]¿  [le|la|l’|les]                  [lui|leur|en|y]            ~..(?:ée?s?|ez|ai[ts]?)$
    rien d’ autre à faire [que|qu’|sinon] ?[ne|n’]¿  [lui|leur|y]                    en                         ~..(?:ée?s?|ez|ai[ts]?)$
        <<- /infi/ morph(\-1, ":V", ":M") --1>> =suggVerbInfi(\-1)                                  && Après “rien à faire que”, mettez le verbe à l’infinitif.

TEST: rien à faire sinon {{expliqué}} ce qu’il faisait là           ->> expliquer
TEST: rien d’autre à faire que lui {{donnait}} à manger             ->> donner


__infi_nous_vous_verbe!3__
    nous  ~ée?s?$
        <<- /infi/ space(\1, 1, 3) and morph(\2, ":Q") and not morph(<1, "V0.*:1p")
        -2>> =suggVerbInfi(\2)                                                                      && Après “\1”, le verbe ne devrait pas être un participe passé.

    vous  ~ée?s?$
        <<- /infi/ space(\1, 1, 3) and morph(\2, ":Q") and not morph(<1, "V0.*:2p")
        -2>> =suggVerbInfi(\2)+"|"+suggVerbTense(\2, ":Ip", ":2p")                                  && Après “\1”, le verbe ne devrait pas être un participe passé.

TEST: oui, pourquoi pas, puisque nous {{intéressé}} à la question ne suffit pas à faire de nous des experts.   ->> intéresser
TEST: il faut croire que vous {{mangé}} ne nous nourrirait guère                                               ->> manger|mangez
TEST: Sommes-nous désespérés à ce point ?
TEST: Vous d’habitude si réservée.


__infi_y_verbe!3__
    y ~ée?s?$
        <<- /infi/ \1.islower() and morph(\2, ":V", ":[123][sp]") -2>> =suggVerbInfi(\2)            && Le verbe ne devrait pas être un participe passé.

TEST: y {{mangée}} était un supplice                                ->> manger
TEST: j’y crée une nouvelle maison.



#### Infinitif directement après verbe

__infi_devoir!5__

TEST: En outre, les grosses institutions comme l’Éducation Nationale ne développent pas forcément en interne
TEST: Le mieux serait de le faire glisser


__tag_locutions_verbales_d_état__
    ## verbes d’état

    [>être|>sembler|>devenir|>rester|>demeurer|>redevenir|>paraître|>paraitre|>apparaître|>apparaitre]
        <<- /1>> _VE_

    /_VCint_
        <<- morph(\1, ":V[0-3]e") /1>> _VEI_


    ## locutions verbales d’état

    >avoir [été|semblé|paru]
    >avoir [cru|imaginé|pensé|pu|su|voulu]                      [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    >avoir [besoin|crainte|envie|horreur|peur]                  [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    >avoir l’ [envie|exigence|illusion|impression|intention]    [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    >avoir le [désir|sentiment]                                 [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    >avoir la ?ferme¿ [intention|volonté]                       [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    [>être|>sembler|>demeurer|>paraître|>apparaître|>apparaitre] [loin|près]  [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|apparaître|apparaitre]
    [>être|>sembler] [devenu+ses|redevenu+ses|resté+ses|demeuré+ses]
    [>aller|>adorer|>affirmer|>aimer|>croire|>déclarer|>désirer|>détester|>devoir|>dire|>estimer|>imaginer|>paraître|>paraitre|>penser|>pouvoir|>préférer|>risquer|>savoir|>sembler|>souhaiter|>vouloir]
        || ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
    [>adorer|>affirmer|>aimer|>croire|>déclarer|>désirer|>détester|>devoir|>dire|>estimer|>imaginer|>paraître|>paraitre|>penser|>pouvoir|>préférer|>risquer|>savoir|>sembler|>souhaiter|>vouloir]
        || ?[en|y]¿ être [devenu+ses|redevenu+ses|resté+ses|demeuré+ses|apparu+ses]
    [>adorer|>affirmer|>aimer|>croire|>déclarer|>désirer|>détester|>devoir|>dire|>estimer|>imaginer|>paraître|>paraitre|>penser|>pouvoir|>préférer|>risquer|>savoir|>sembler|>souhaiter|>vouloir]
        || ?[en|y]¿ avoir [été|semblé|paru]
    [>arriver|>continuer|>commencer|>parvenir|>renoncer|>réussir|>travailler]                   à ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
    [>cesser|>continuer|>craindre|>demander|>exiger|>redouter|>rêver|>refuser|>risquer|>venir]  [de|d’] ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
    [>être|>sembler|>devenir|>rester|>demeurer|>redevenir|>paraître|>paraitre|>apparaître|>apparaitre]  [>content|>conscient|>heureux|>inquiet|>malheureux|>susceptible]
        || [de|d’] ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
        <<- /1>> _LVED_
        <<- />> _LVE_
        <<- /-1>> _LVEF_

    /_VCint_  [été|semblé|paru]
    /_VCint_  [cru|imaginé|pensé|pu|su|voulu]                       [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
    /_VCint_  [besoin|crainte|envie|horreur|peur]                   [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
    /_VCint_  l’ [envie|exigence|illusion|impression|intention]     [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
    /_VCint_  le [désir|sentiment]                                  [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
    /_VCint_  la ?ferme¿ [intention|volonté]                        [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ">avoir/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  [loin|près]  [de|d’] [être|sembler|devenir|rester|demeurer|redevenir|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ">(?:être|sembler|demeurer|para[��i]tre|appara[��i]tre)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  [devenu+ses|redevenu+ses|resté+ses|demeuré+ses]
        <<- morphVC(\1, ">(?:être|sembler)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ">(?:aller|adorer|affirmer|aimer|croire|déclarer|désirer|détester|devoir|dire|estimer|imaginer|para[îi]tre|penser|pouvoir|préférer|risquer|savoir|sembler|souhaiter|vouloir)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  ?[en|y]¿ être [devenu+ses|redevenu+ses|resté+ses|demeuré+ses]
    /_VCint_  ?[en|y]¿ avoir [été|semblé|paru]
        <<- morphVC(\1, ">(?:adorer|affirmer|aimer|croire|déclarer|désirer|détester|devoir|dire|estimer|imaginer|para[îi]tre|penser|pouvoir|préférer|risquer|savoir|sembler|souhaiter|vouloir)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  à ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ">(?:arriver|commencer|continuer|parvenir|renoncer|réussir|travailler)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  [de|d’] ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ">(?:cesser|continuer|craindre|demander|exiger|redouter|rêver|refuser|risquer|venir)/") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_

    /_VCint_  [>content|>conscient|>heureux|>inquiet|>malheureux|>susceptible] [de|d’] ?[ne|n’]¿ ?[en|y]¿ [être|sembler|devenir|redevenir|rester|demeurer|paraître|paraitre|apparaître|apparaitre]
        <<- morphVC(\1, ":V[0-3]e") >>>
        <<- /1>> _LVEID_
        <<- />> _LVEI_
        <<- /-1>> _LVEIF_


    ## locutions verbales d’état pronominales

TEST: iel semble être {{ignore}}
TEST: ouais, on adore avoir été {{persécute}} par ces enfoirés
TEST: nous préférions être restés {{chagrinait}} par cette perte
TEST: on déclare avoir été {{choque}} par ces nouvelles
TEST: ils semblent être redevenus {{élut}}
TEST: elles aiment avoir paru {{murent}}


__ppas_fin_loc_verb_état_adj_et_adj__
    [/_VE_|/_VEI_|/_LVEF_|/_LVEIF_|/_VEP_|/_LVEPF_|/_LVEPIF_] *WORD et @:A¬:[ISKYPEGW]|;C
        <<- /ppas/ morph(\2, ":[AQ]", ":G|;C") and not agreement(\2, \-1, False)
        --1>> =suggAgree(\-1, \2)                                                                   && Cet adjectif n’est pas accordé avec l’adjectif “\2”.

TEST: il est furieux et {{curieuse}}                                                    ->> curieux
TEST: tu es sot et {{ignorants}}                                                        ->> ignorant
TEST: elle est belle et {{intelligent}}                                                 ->> intelligente
TEST: elle sut apparaître grande et {{humbles}} à la fois                               ->> humble
TEST: ils devenaient forts et {{humble}}                                                ->> humbles
TEST: ils crurent avoir été trompés et {{volé}}                                         ->> volés
TEST: elles déclareront être restées calmes et {{attentive}}                            ->> attentives
TEST: nous imaginons devenir riches et {{connu}}                                        ->> connus


__ppas_être_confusion__
    ne [pas|jamais] être @:(?:V(?:1.*:Y|2.*:Ip.*:3s|3.*:Is.*:3s)|2p)
        <<- /ppas/ --1>> =suggVerbPpas(\-1)                                                         && Après “ne \2 être”, il faut un participe passé.

    avoir [pu|cru|pensé|imaginé] être @:(?:V(?:1.*:Y|2.*:Ip.*:3s|3.*:Is.*:3s)|2p)
        <<- /ppas/ not value(<1, "|l’|") and not tagbefore(\1, "_que_") --1>> =suggVerbPpas(\-1)    && Après le verbe “être”, il faut un participe passé.