Grammalecte  Changes On Branch 2ac407c52f2c9d36

import re
import traceback
import json

import compile_rules_js_convert as jsconv
import compile_rules_graph as crg


dDEF = {}
lFUNCTIONS = []

aRULESET = set()     # set of rule-ids to check if there is several rules with the same id
nRULEWITHOUTNAME = 0

    s = re.sub(r"isRealStart *\(\)", 'before("^ *$")', s)
    s = re.sub(r"isStart0 *\(\)", 'before0("^ *$|, *$")', s)
    s = re.sub(r"isRealStart0 *\(\)", 'before0("^ *$")', s)
    s = re.sub(r"isEnd *\(\)", 'after("^ *$|^,")', s)
    s = re.sub(r"isRealEnd *\(\)", 'after("^ *$")', s)
    s = re.sub(r"isEnd0 *\(\)", 'after0("^ *$|^,")', s)
    s = re.sub(r"isRealEnd0 *\(\)", 'after0("^ *$")', s)
    s = re.sub(r"(select|exclude)[(][\\](\d+)", '\\1(dTokenPos, m.start(\\2), m.group(\\2)', s)
    s = re.sub(r"define[(][\\](\d+)", 'define(dTokenPos, m.start(\\1)', s)
    s = re.sub(r"(morph|morphex|displayInfo)[(][\\](\d+)", '\\1((m.start(\\2), m.group(\\2))', s)
    s = re.sub(r"(morph|morphex|displayInfo)[(]", '\\1(dTokenPos, ', s)
    s = re.sub(r"(sugg\w+|switch\w+)\(@", '\\1(m.group(i[4])', s)
    s = re.sub(r"word\(\s*1\b", 'nextword1(s, m.end()', s)                                  # word(1)
    s = re.sub(r"word\(\s*-1\b", 'prevword1(s, m.start()', s)                               # word(-1)
    s = re.sub(r"word\(\s*(\d)", 'nextword(s, m.end(), \\1', s)                             # word(n)
    s = re.sub(r"word\(\s*-(\d)", 'prevword(s, m.start(), \\1', s)                          # word(-n)
    s = re.sub(r"before\(\s*", 'look(s[:m.start()], ', s)                                   # before(s)
    s = re.sub(r"after\(\s*", 'look(s[m.end():], ', s)                                      # after(s)
    s = re.sub(r"textarea\(\s*", 'look(s, ', s)                                             # textarea(s)
    s = re.sub(r"before_chk1\(\s*", 'look_chk1(dTokenPos, s[:m.start()], 0, ', s)           # before_chk1(s)
    s = re.sub(r"after_chk1\(\s*", 'look_chk1(dTokenPos, s[m.end():], m.end(), ', s)        # after_chk1(s)
    s = re.sub(r"textarea_chk1\(\s*", 'look_chk1(dTokenPos, s, 0, ', s)                     # textarea_chk1(s)
    s = re.sub(r"/0", 'sx[m.start():m.end()]', s)                                           # /0
    s = re.sub(r"before0\(\s*", 'look(sx[:m.start()], ', s)                                 # before0(s)
    s = re.sub(r"after0\(\s*", 'look(sx[m.end():], ', s)                                    # after0(s)
    s = re.sub(r"textarea0\(\s*", 'look(sx, ', s)                                           # textarea0(s)
    s = re.sub(r"before0_chk1\(\s*", 'look_chk1(dTokenPos, sx[:m.start()], 0, ', s)         # before0_chk1(s)
    s = re.sub(r"after0_chk1\(\s*", 'look_chk1(dTokenPos, sx[m.end():], m.end(), ', s)      # after0_chk1(s)
    s = re.sub(r"textarea0_chk1\(\s*", 'look_chk1(dTokenPos, sx, 0, ', s)                   # textarea0_chk1(s)
    s = re.sub(r"isEndOfNG\(\s*\)", 'isEndOfNG(dTokenPos, s[m.end():], m.end())', s)        # isEndOfNG(s)
    s = re.sub(r"isNextNotCOD\(\s*\)", 'isNextNotCOD(dTokenPos, s[m.end():], m.end())', s)  # isNextNotCOD(s)
    s = re.sub(r"isNextVerb\(\s*\)", 'isNextVerb(dTokenPos, s[m.end():], m.end())', s)      # isNextVerb(s)
    s = re.sub(r"\bspell *[(]", '_oSpellChecker.isValid(', s)
    s = re.sub(r"[\\](\d+)", 'm.group(\\1)', s)
    return s


def uppercase (s, sLang):
    "(flag i is not enough): converts regex to uppercase regex: 'foo' becomes '[Ff][Oo][Oo]', but 'Bar' becomes 'B[Aa][Rr]'."

def createRule (s, nIdLine, sLang, bParagraph, dOptPriority):
    "returns rule as list [option name, regex, bCaseInsensitive, identifier, list of actions]"
    global dJSREGEXES
    global nRULEWITHOUTNAME


    sLineId = str(nIdLine) + ("p" if bParagraph else "s")
    sRuleId = sLineId

    #### GRAPH CALL
    if s.startswith("@@@@"):
        if bParagraph:
            print("Error. Graph call can’t be made only after the first pass (sentence by sentence)")
            exit()
        return ["@@@@", s[4:], sLineId]

    #### OPTIONS
    sOption = False         # False or [a-z0-9]+ name
    nPriority = 4           # Default is 4, value must be between 0 and 9
    tGroups = None          # code for groups positioning (only useful for JavaScript)
    cCaseMode = 'i'         # i: case insensitive,  s: case sensitive,  u: uppercasing allowed
    cWordLimitLeft = '['    # [: word limit, <: no specific limit
    cWordLimitRight = ']'   # ]: word limit, >: no specific limit
    m = re.match("^__(?P<borders_and_case>[[<]\\w[]>])(?P<option>/[a-zA-Z0-9]+|)(?P<ruleid>\\(\\w+\\)|)(?P<priority>![0-9]|)__ *", s)

        print("# Unknown action at line " + sIdAction)
        return None


def _calcRulesStats (lRules):
    d = {'=':0, '~': 0, '-': 0, '>': 0}
    for aRule in lRules:
        if aRule[0] != "@@@@":
            for aAction in aRule[6]:
                d[aAction[1]] = d[aAction[1]] + 1
    return (d, len(lRules))


def displayStats (lParagraphRules, lSentenceRules):
    print("  {:>18} {:>18} {:>18} {:>18}".format("DISAMBIGUATOR", "TEXT PROCESSOR", "GRAMMAR CHECKING", "REGEX"))
    d, nRule = _calcRulesStats(lParagraphRules)
    print("§ {:>10} actions {:>10} actions {:>10} actions  in {:>8} rules".format(d['='], d['~'], d['-'], nRule))

    except:
        print("Error. Rules file in project [" + sLang + "] not found.")
        exit()

    # removing comments, zeroing empty lines, creating definitions, storing tests, merging rule lines
    print("  parsing rules...")
    global dDEF

    lRuleLine = []
    lTest = []
    lOpt = []
    bGraph = False
    lGraphRule = []

    for i, sLine in enumerate(lRules, 1):
        if sLine.startswith('#END'):
            # arbitrary end
            printBookmark(0, "BREAK BY #END", i)
            break
        elif sLine.startswith("#"):
            # comment
            pass
        elif sLine.startswith("DEF:"):

            # definition



            m = re.match("DEF: +([a-zA-Z_][a-zA-Z_0-9]*) +(.+)$", sLine.strip())
            if m:
                dDEF["{"+m.group(1)+"}"] = m.group(2)
            else:
                print("Error in definition: ", end="")
                print(sLine.strip())
        elif sLine.startswith("TEST:"):
            # test
            lTest.append("{:<8}".format(i) + "  " + sLine[5:].strip())
        elif sLine.startswith("TODO:"):
            # todo
            pass
        elif sLine.startswith(("OPTGROUP/", "OPTSOFTWARE:", "OPT/", "OPTLANG/", "OPTDEFAULTUILANG:", "OPTLABEL/", "OPTPRIORITY/")):
            # options
            lOpt.append(sLine)


        elif sLine.startswith("!!"):
            # bookmark
            m = re.match("!!+", sLine)
            nExMk = len(m.group(0))
            if sLine[nExMk:].strip():
                printBookmark(nExMk-2, sLine[nExMk:].strip(), i)
        # Graph rules
        elif sLine.startswith("@@@@GRAPH:"):
            # rules graph call
            m = re.match(r"@@@@GRAPH: *(\w+)", sLine.strip())
            if m:
                printBookmark(1, "@GRAPH: " + m.group(1), i)
                lRuleLine.append([i, "@@@@"+m.group(1)])
                bGraph = True
            lGraphRule.append([i, sLine])
            bGraph = True
        elif sLine.startswith("@@@@END_GRAPH"):
            #lGraphRule.append([i, sLine])
            bGraph = False
        elif re.match("@@@@ *$", sLine):
            pass
        elif bGraph:
            lGraphRule.append([i, sLine])
        # Regex rules
        elif re.match("[  \t]*$", sLine):
            # empty line
            pass
        elif sLine.startswith(("    ", "\t")):
            # rule (continuation)
            lRuleLine[-1][1] += " " + sLine.strip()
        else:
            # new rule
            lRuleLine.append([i, sLine.strip()])

    # generating options files
    print("  parsing options...")
    try:
        dOptions, dOptPriority = prepareOptions(lOpt)
    except:

    # creating file with all functions callable by rules
    print("  creating callables...")
    sPyCallables = "# generated code, do not edit\n"
    sJSCallables = "// generated code, do not edit\nconst oEvalFunc = {\n"
    for sFuncName, sReturn in lFUNCTIONS:
        cType = sFuncName[0:1]
        if cType == "c": # condition
            sParams = "s, sx, m, dTokenPos, sCountry, bCondMemo"
        elif cType == "m": # message
            sParams = "s, m"
        elif cType == "s": # suggestion
            sParams = "s, m"
        elif cType == "p": # preprocessor
            sParams = "s, m"
        elif cType == "d": # disambiguator
            sParams = "s, m, dTokenPos"
        else:
            print("# Unknown function type in [" + sFuncName + "]")
            continue
        sPyCallables += "def {} ({}):\n".format(sFuncName, sParams)
        sPyCallables += "    return " + sReturn + "\n"
        sJSCallables += "    {}: function ({})".format(sFuncName, sParams) + " {\n"
        sJSCallables += "        return " + jsconv.py2js(sReturn) + ";\n"

          "gctests": sGCTests,
          "gctestsJS": sGCTestsJS,
          "paragraph_rules": mergeRulesByOption(lParagraphRules),
          "sentence_rules": mergeRulesByOption(lSentenceRules),
          "paragraph_rules_JS": jsconv.writeRulesToJSArray(mergeRulesByOption(lParagraphRulesJS)),
          "sentence_rules_JS": jsconv.writeRulesToJSArray(mergeRulesByOption(lSentenceRulesJS)) }
    d.update(dOptions)

    # compile graph rules
    d2 = crg.make(lGraphRule, dDEF, sLang, bJavaScript)
    d.update(d2)

    return d

# Create a Direct Acyclic Rule Graph (DARG)

import re
import traceback
import json

import darg


dACTIONS = {}
dFUNCTIONS = {}


def prepareFunction (s, bTokenValue=False):
    s = s.replace("__also__", "bCondMemo")
    s = s.replace("__else__", "not bCondMemo")
    s = re.sub(r"(morph|analyse|displayInfo)[(]\\(\d+)", 'g_\\1(lToken[\\2+nTokenOffset]', s)
    s = re.sub(r"(select|exclude|define)[(][\\](\d+)", 'g_\\1(lToken[\\2+nTokenOffset], dTags', s)
    s = re.sub(r"(tag_before|tag_after)[(][\\](\d+)", 'g_\\1(lToken[\\2+nTokenOffset], dTags', s)
    s = re.sub(r"(switchGender|has(?:Mas|Fem)Form)[(]\\(\d+)", '\\1(lToken[\\2+nTokenOffset]["sValue"]', s)
    s = re.sub(r"(morph|analyse)\(>1", 'g_\\1(lToken[nLastToken+1]', s)                     # next token
    s = re.sub(r"(morph|analyse)\(<1", 'g_\\1(lToken[nTokenOffset]', s)                     # previous token
    s = re.sub(r"[\\](\d+)\.is(upper|lower|title)\(\)", 'lToken[\\1+nTokenOffset]["sValue"].is\\2()', s)
    s = re.sub(r"\bspell *[(]", '_oSpellChecker.isValid(', s)
    s = re.sub(r"\bbefore\(\s*", 'look(sSentence[:lToken[1+nTokenOffset]["nStart"]], ', s)          # before(s)
    s = re.sub(r"\bafter\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', s)                 # after(s)
    s = re.sub(r"\bbefore0\(\s*", 'look(sSentence0[:lToken[1+nTokenOffset]["nStart"]], ', s)        # before0(s)
    s = re.sub(r"\bafter0\(\s*", 'look(sSentence[lToken[nLastToken]["nEnd"]:], ', s)                # after0(s)
    if bTokenValue:
        # token values are used as parameter
        s = re.sub(r"[\\](\d+)", 'lToken[\\1+nTokenOffset]["sValue"]', s)
    else:
        # tokens used as parameter
        s = re.sub(r"[\\](\d+)", 'lToken[\\1+nTokenOffset]', s)
    return s


def genTokenLines (sTokenLine, dDef):
    "tokenize a string and return a list of lines of tokens"
    lToken = sTokenLine.split()
    lTokenLines = None
    for i, sToken in enumerate(lToken):
        # optional token?
        bNullPossible = sToken.startswith("?") and sToken.endswith("¿")
        if bNullPossible:
            sToken = sToken[1:-1]
        # token with definition?
        if sToken.startswith("({") and sToken.endswith("})") and sToken[1:-1] in dDef:
            sToken = "(" + dDef[sToken[1:-1]] + ")"
        elif sToken.startswith("{") and sToken.endswith("}") and sToken in dDef:
            sToken = dDef[sToken]
        if ( (sToken.startswith("[") and sToken.endswith("]")) or (sToken.startswith("([") and sToken.endswith("])")) ):
            # multiple token
            bSelectedGroup = sToken.startswith("(") and sToken.endswith(")")
            if bSelectedGroup:
                sToken = sToken[1:-1]
            lNewToken = sToken[1:-1].split("|")
            if not lTokenLines:
                lTokenLines = [ [s]  for s  in lNewToken ]
                if bNullPossible:
                    lTokenLines.extend([ []  for i  in range(len(lNewToken)+1) ])
            else:
                lNewTemp = []
                if bNullPossible:
                    for aRule in lTokenLines:
                        for sElem in lNewToken:
                            aNewRule = list(aRule)
                            aNewRule.append(sElem)
                            lNewTemp.append(aNewRule)
                else:
                    sElem1 = lNewToken.pop(0)
                    for aRule in lTokenLines:
                        for sElem in lNewToken:
                            aNewRule = list(aRule)
                            aNewRule.append("(" + sElem + ")"  if bSelectedGroup  else sElem)
                            lNewTemp.append(aNewRule)
                        aRule.append("(" + sElem1 + ")"  if bSelectedGroup  else sElem1)
                lTokenLines.extend(lNewTemp)
        else:
            # simple token
            if not lTokenLines:
                lTokenLines = [[sToken], []]  if bNullPossible  else [[sToken]]
            else:
                if bNullPossible:
                    lNewTemp = []
                    for aRule in lTokenLines:
                        lNew = list(aRule)
                        lNew.append(sToken)
                        lNewTemp.append(lNew)
                    lTokenLines.extend(lNewTemp)
                else:
                    for aRule in lTokenLines:
                        aRule.append(sToken)
    for aRule in lTokenLines:
        yield aRule


def createRule (iLine, sRuleName, sTokenLine, iActionBlock, sActions, nPriority, dDef):
    # print(iLine, "//", sRuleName, "//", sTokenLine, "//", sActions, "//", nPriority)
    for lToken in genTokenLines(sTokenLine, dDef):
        # Calculate positions
        dPos = {}   # key: iGroup, value: iToken
        iGroup = 0
        for i, sToken in enumerate(lToken):
            if sToken.startswith("(") and sToken.endswith(")"):
                lToken[i] = sToken[1:-1]
                iGroup += 1
                dPos[iGroup] = i + 1    # we add 1, for we count tokens from 1 to n (not from 0)

        # Parse actions
        for iAction, sAction in enumerate(sActions.split(" <<- "), 1):
            sAction = sAction.strip()
            if sAction:
                sActionId = sRuleName + "__b" + str(iActionBlock) + "_a" + str(iAction) + "_" + str(len(lToken))
                aAction = createAction(sActionId, sAction, nPriority, len(lToken), dPos)
                if aAction:
                    dACTIONS[sActionId] = aAction
                    lResult = list(lToken)
                    lResult.extend(["##"+str(iLine), sActionId])
                    yield lResult


def changeReferenceToken (sText, dPos):
    for i in range(len(dPos), 0, -1):
        sText = sText.replace("\\"+str(i), "\\"+str(dPos[i]))
    return sText


def checkTokenNumbers (sText, sActionId, nToken):
    for x in re.finditer(r"\\(\d+)", sText):
        if int(x.group(1)) > nToken:
            print("# Error in token index at line " + sActionId + " ("+str(nToken)+" tokens only)")
            print(sText)


def checkIfThereIsCode (sText, sActionId):
    if re.search("[.]\\w+[(]|sugg\\w+[(]|\\([0-9]|\\[[0-9]", sText):
        print("# Warning at line " + sActionId + ":  This message looks like code. Line should probably begin with =")
        print(sText)


def createAction (sActionId, sAction, nPriority, nToken, dPos):
    # Option
    sOption = False
    m = re.match("/(\\w+)/", sAction) 
    if m:
        sOption = m.group(1)
        sAction = sAction[m.end():].strip()
    # valid action?
    m = re.search("(?P<action>[-~=/])(?P<start>\\d+|)(?P<end>:\\d+|)>> ", sAction)
    if not m:
        print(" # Error. No action found at: ", sActionId)
        print("   ==", sAction, "==")
        return None
    # Condition
    sCondition = sAction[:m.start()].strip()
    if sCondition:
        sCondition = prepareFunction(sCondition)
        sCondition = changeReferenceToken(sCondition, dPos)    
        dFUNCTIONS["g_c_"+sActionId] = sCondition
        sCondition = "g_c_"+sActionId
    else:
        sCondition = ""
    # Action
    cAction = m.group("action")
    sAction = sAction[m.end():].strip()
    sAction = changeReferenceToken(sAction, dPos)
    if not m.group("start"):
        iStartAction = 1
        iEndAction = 0
    else:
        iStartAction = int(m.group("start"))
        iEndAction = int(m.group("end")[1:])  if m.group("end")  else iStartAction
    if dPos:
        try:
            iStartAction = dPos[iStartAction]
            iEndAction = dPos[iEndAction]
        except:
            print("# Error. Wrong groups in: " + sActionId)

    if cAction == "-":
        ## error
        iMsg = sAction.find(" # ")
        if iMsg == -1:
            sMsg = "# Error. Error message not found."
            sURL = ""
            print(sMsg + " Action id: " + sActionId)
        else:
            sMsg = sAction[iMsg+3:].strip()
            sAction = sAction[:iMsg].strip()
            sURL = ""
            mURL = re.search("[|] *(https?://.*)", sMsg)
            if mURL:
                sURL = mURL.group(1).strip()
                sMsg = sMsg[:mURL.start(0)].strip()
            checkTokenNumbers(sMsg, sActionId, nToken)
            if sMsg[0:1] == "=":
                sMsg = prepareFunction(sMsg[1:], True)
                dFUNCTIONS["g_m_"+sActionId] = sMsg
                sMsg = "=g_m_"+sActionId
            else:
                checkIfThereIsCode(sMsg, sActionId)
            
    # checking consistancy
    checkTokenNumbers(sAction, sActionId, nToken)

    if cAction == ">":
        ## no action, break loop if condition is False
        return [sOption, sCondition, cAction, ""]

    if not sAction:
        print("# Error in action at line " + sActionId + ":  This action is empty.")

    if sAction[0:1] != "=":
        checkIfThereIsCode(sAction, sActionId)

    if cAction == "-":
        ## error detected --> suggestion
        if sAction[0:1] == "=":
            sAction = prepareFunction(sAction, True)
            dFUNCTIONS["g_s_"+sActionId] = sAction[1:]
            sAction = "=g_s_"+sActionId
        elif sAction.startswith('"') and sAction.endswith('"'):
            sAction = sAction[1:-1]
        if not sMsg:
            print("# Error in action at line " + sActionId + ":  The message is empty.")
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction, nPriority, sMsg, sURL]
    elif cAction == "~":
        ## text processor
        if sAction[0:1] == "=":
            dFUNCTIONS["g_p_"+sActionId] = sAction[1:]
            sAction = "=g_p_"+sActionId
        elif sAction.startswith('"') and sAction.endswith('"'):
            sAction = sAction[1:-1]
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction]
    elif cAction == "/":
        ## tags
        return [sOption, sCondition, cAction, sAction, iStartAction, iEndAction]
    elif cAction == "=":
        ## disambiguator
        if sAction[0:1] == "=":
            sAction = sAction[1:]
        if "define" in sAction and not re.search(r"define\(\\\d+ *, *\[.*\] *\)", sAction):
            print("# Error in action at line " + sActionId + ": second argument for <define> must be a list of strings")
        sAction = prepareFunction(sAction)
        dFUNCTIONS["g_d_"+sActionId] = sAction
        sAction = "g_d_"+sActionId
        return [sOption, sCondition, cAction, sAction]
    else:
        print("# Unknown action at line " + sActionId)
        return None


def make (lRule, dDef, sLang, bJavaScript):
    "compile rules, returns a dictionary of values"
    # for clarity purpose, don’t create any file here

    # removing comments, zeroing empty lines, creating definitions, storing tests, merging rule lines
    print("  parsing rules...")
    lTokenLine = []
    sActions = ""
    nPriority = 4
    dAllGraph = {}
    sGraphName = ""
    iActionBlock = 0

    for i, sLine in lRule:
        sLine = sLine.rstrip()
        if "\t" in sLine:
            # tabulation not allowed
            print("Error. Tabulation at line: ", i)
            exit()
        elif sLine.startswith("@@@@GRAPH: "):
            # rules graph call
            m = re.match(r"@@@@GRAPH: *(\w+)", sLine.strip())
            if m:
                sGraphName = m.group(1)
                if sGraphName in dAllGraph:
                    print("Error. Group name " + sGraphName + " already exists.")
                    exit()
                dAllGraph[sGraphName] = []
            else:
                print("Error. Graph name not found at line", i)
                exit()
        elif sLine.startswith("__") and sLine.endswith("__"):
            # new rule group
            m = re.match("__(\\w+)(!\\d|)__", sLine)
            if m:
                sRuleName = m.group(1)
                iActionBlock = 1
                nPriority = int(m.group(2)[1:]) if m.group(2)  else 4
            else:
                print("Error at rule group: ", sLine, " -- line:", i)
                break
        elif re.search("^    +<<- ", sLine) or sLine.startswith("        ") \
                or re.search("^    +#", sLine) or re.search(r"^    [-~=>/](?:\d(?::\d+|)|)>> ", sLine) :
            # actions
            sActions += " " + sLine.strip()
        elif re.match("[  ]*$", sLine):
            # empty line to end merging
            if not lTokenLine:
                continue
            if not sActions:
                print("Error. No action found at line:", i)
                exit()
            if not sGraphName:
                print("Error. All rules must belong to a named graph. Line: ", i)
                exit()
            for j, sTokenLine in lTokenLine:
                dAllGraph[sGraphName].append((j, sRuleName, sTokenLine, iActionBlock, sActions, nPriority))
            lTokenLine.clear()
            sActions = ""
            iActionBlock += 1
        elif sLine.startswith(("    ")):
            # tokens
            lTokenLine.append([i, sLine.strip()])
        else:
            print("Unknown line:")
            print(sLine)

    # processing rules
    print("  preparing rules...")
    for sGraphName, lRuleLine in dAllGraph.items():
        lPreparedRule = []
        for i, sRuleGroup, sTokenLine, iActionBlock, sActions, nPriority in lRuleLine:
            for lRule in createRule(i, sRuleGroup, sTokenLine, iActionBlock, sActions, nPriority, dDef):
                lPreparedRule.append(lRule)
        # Graph creation
        oDARG = darg.DARG(lPreparedRule, sLang)
        dAllGraph[sGraphName] = oDARG.createGraph()
        # Debugging
        #print("\nGRAPH:", sGraphName)
        #for e in lPreparedRule:
        #    print(e)
        #for k, v in dAllGraph[sGraphName].items():
        #    print(k, "\t", v)

    # creating file with all functions callable by rules
    print("  creating callables...")
    sPyCallables = "# generated code, do not edit\n"
    #sJSCallables = "// generated code, do not edit\nconst oEvalFunc = {\n"
    for sFuncName, sReturn in dFUNCTIONS.items():
        if sFuncName.startswith("g_c_"): # condition
            sParams = "lToken, nTokenOffset, nLastToken, sCountry, bCondMemo, dTags, sSentence, sSentence0"
        elif sFuncName.startswith("g_m_"): # message
            sParams = "lToken, nTokenOffset"
        elif sFuncName.startswith("g_s_"): # suggestion
            sParams = "lToken, nTokenOffset"
        elif sFuncName.startswith("g_p_"): # preprocessor
            sParams = "lToken"
        elif sFuncName.startswith("g_d_"): # disambiguator
            sParams = "lToken, nTokenOffset"
        else:
            print("# Unknown function type in [" + sFuncName + "]")
            continue
        sPyCallables += "def {} ({}):\n".format(sFuncName, sParams)
        sPyCallables += "    return " + sReturn + "\n"
        #sJSCallables += "    {}: function ({})".format(sFuncName, sParams) + " {\n"
        #sJSCallables += "        return " + jsconv.py2js(sReturn) + ";\n"
        #sJSCallables += "    },\n"
    #sJSCallables += "}\n"

    # Debugging
    if False:
        print("\nActions:")
        for sActionName, aAction in dACTIONS.items():
            print(sActionName, aAction)
        print("\nFunctions:")
        print(sPyCallables)

    # Result
    d = {
        "graph_callables": sPyCallables,
        "rules_graphs": dAllGraph,
        "rules_actions": dACTIONS
    }
    return d

    if not lNegLookBeforeRegex:
        lNegLookBeforeRegex = None
    return (sRegex, lNegLookBeforeRegex)


def pyRuleToJS (lRule, dJSREGEXES, sWORDLIMITLEFT):
    lRuleJS = copy.deepcopy(lRule)
    # graph rules
    if lRuleJS[0] == "@@@@":
        return lRuleJS
    del lRule[-1] # tGroups positioning codes are useless for Python
    # error messages
    for aAction in lRuleJS[6]:
        if aAction[1] == "-":
            aAction[2] = aAction[2].replace(" ", " ") # nbsp --> nnbsp
            aAction[4] = aAction[4].replace("« ", "« ").replace(" »", " »").replace(" :", " :").replace(" :", " :")
    # js regexes
    lRuleJS[1], lNegLookBehindRegex = regex2js(dJSREGEXES.get(lRuleJS[3], lRuleJS[1]), sWORDLIMITLEFT)
    lRuleJS.append(lNegLookBehindRegex)
    return lRuleJS


def writeRulesToJSArray (lRules):
    sArray = "[\n"
    for sOption, aRuleGroup in lRules:
        if sOption != "@@@@":
            sArray += '  ["' + sOption + '", [\n'  if sOption  else  "  [false, [\n"
            for sRegex, bCaseInsensitive, sLineId, sRuleId, nPriority, lActions, aGroups, aNegLookBehindRegex in aRuleGroup:
                sArray += '    [' + sRegex + ", "
                sArray += "true, " if bCaseInsensitive  else "false, "
                sArray += '"' + sLineId + '", '
                sArray += '"' + sRuleId + '", '
                sArray += str(nPriority) + ", "
                sArray += json.dumps(lActions, ensure_ascii=False) + ", "
                sArray += json.dumps(aGroups, ensure_ascii=False) + ", "
                sArray += json.dumps(aNegLookBehindRegex, ensure_ascii=False) + "],\n"
            sArray += "  ]],\n"
        else:
            sArray += '  ["' + sOption + '", [\n'
            for sGraphName, sLineId in aRuleGroup:
                sArray += '    ["' + sGraphName + '", "' + sLineId + '"],\n"'
            sArray += "  ]],\n"
    sArray += "]"
    return sArray


def groupsPositioningCodeToList (sGroupsPositioningCode):
    if not sGroupsPositioningCode:
        return None
    return [ int(sCode)  if sCode.isdigit() or (sCode[0:1] == "-" and sCode[1:].isdigit())  else sCode \
             for sCode in sGroupsPositioningCode.split(",") ]

#!python3

# RULE GRAPH BUILDER
#
# by Olivier R.
# License: MPL 2


import json
import time
import traceback

from graphspell.progressbar import ProgressBar



class DARG:
    """DIRECT ACYCLIC RULE GRAPH"""
    # This code is inspired from Steve Hanov’s DAWG, 2011. (http://stevehanov.ca/blog/index.php?id=115)

    def __init__ (self, lRule, sLangCode):
        print("===== Direct Acyclic Rule Graph - Minimal Acyclic Finite State Automaton =====")

        # Preparing DARG
        print(" > Preparing list of tokens")
        self.sLangCode = sLangCode
        self.nRule = len(lRule)
        self.aPreviousRule = []
        Node.resetNextId()
        self.oRoot = Node()
        self.lUncheckedNodes = []  # list of nodes that have not been checked for duplication.
        self.lMinimizedNodes = {}  # list of unique nodes that have been checked for duplication.
        self.nNode = 0
        self.nArc = 0
        
        # build
        lRule.sort()
        oProgBar = ProgressBar(0, len(lRule))
        for aRule in lRule:
            self.insert(aRule)
            oProgBar.increment(1)
        oProgBar.done()
        self.finish()
        self.countNodes()
        self.countArcs()
        self.displayInfo()

    # BUILD DARG
    def insert (self, aRule):
        if aRule < self.aPreviousRule:
            sys.exit("# Error: tokens must be inserted in order.")
    
        # find common prefix between word and previous word
        nCommonPrefix = 0
        for i in range(min(len(aRule), len(self.aPreviousRule))):
            if aRule[i] != self.aPreviousRule[i]:
                break
            nCommonPrefix += 1

        # Check the lUncheckedNodes for redundant nodes, proceeding from last
        # one down to the common prefix size. Then truncate the list at that point.
        self._minimize(nCommonPrefix)

        # add the suffix, starting from the correct node mid-way through the graph
        if len(self.lUncheckedNodes) == 0:
            oNode = self.oRoot
        else:
            oNode = self.lUncheckedNodes[-1][2]

        iToken = nCommonPrefix
        for sToken in aRule[nCommonPrefix:]:
            oNextNode = Node()
            oNode.dArcs[sToken] = oNextNode
            self.lUncheckedNodes.append((oNode, sToken, oNextNode))
            if iToken == (len(aRule) - 2): 
                oNode.bFinal = True
            iToken += 1
            oNode = oNextNode
        oNode.bFinal = True
        self.aPreviousRule = aRule

    def finish (self):
        "minimize unchecked nodes"
        self._minimize(0)

    def _minimize (self, downTo):
        # proceed from the leaf up to a certain point
        for i in range( len(self.lUncheckedNodes)-1, downTo-1, -1 ):
            oNode, sToken, oChildNode = self.lUncheckedNodes[i]
            if oChildNode in self.lMinimizedNodes:
                # replace the child with the previously encountered one
                oNode.dArcs[sToken] = self.lMinimizedNodes[oChildNode]
            else:
                # add the state to the minimized nodes.
                self.lMinimizedNodes[oChildNode] = oChildNode
            self.lUncheckedNodes.pop()

    def countNodes (self):
        self.nNode = len(self.lMinimizedNodes)

    def countArcs (self):
        self.nArc = 0
        for oNode in self.lMinimizedNodes:
            self.nArc += len(oNode.dArcs)

    def displayInfo (self):
        print(" * {:<12} {:>16,}".format("Rules:", self.nRule))
        print(" * {:<12} {:>16,}".format("Nodes:", self.nNode))
        print(" * {:<12} {:>16,}".format("Arcs:", self.nArc))

    def createGraph (self):
        dGraph = { 0: self.oRoot.getNodeAsDict() }
        for oNode in self.lMinimizedNodes:
            sHashId = oNode.__hash__() 
            if sHashId not in dGraph:
                dGraph[sHashId] = oNode.getNodeAsDict()
            else:
                print("Error. Double node… same id: ", sHashId)
                print(str(oNode.getNodeAsDict()))
        return dGraph



class Node:
    NextId = 0
    
    def __init__ (self):
        self.i = Node.NextId
        Node.NextId += 1
        self.bFinal = False
        self.dArcs = {}          # key: arc value; value: a node

    @classmethod
    def resetNextId (cls):
        cls.NextId = 0

    def __str__ (self):
        # Caution! this function is used for hashing and comparison!
        cFinal = "1"  if self.bFinal  else "0"
        l = [cFinal]
        for (key, oNode) in self.dArcs.items():
            l.append(str(key))
            l.append(str(oNode.i))
        return "_".join(l)

    def __hash__ (self):
        # Used as a key in a python dictionary.
        return self.__str__().__hash__()

    def __eq__ (self, other):
        # Used as a key in a python dictionary.
        # Nodes are equivalent if they have identical arcs, and each identical arc leads to identical states.
        return self.__str__() == other.__str__()        

    def getNodeAsDict (self):
        "returns the node as a dictionary structure"
        dNode = {}
        dReValue = {}
        dReMorph = {}
        dRule = {}
        dLemma = {}
        dMeta = {}
        for sArc, oNode in self.dArcs.items():
            if sArc.startswith("@") and len(sArc) > 1:
                dReMorph[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("~") and len(sArc) > 1:
                dReValue[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith(">") and len(sArc) > 1:
                dLemma[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("*") and len(sArc) > 1:
                dMeta[sArc[1:]] = oNode.__hash__()
            elif sArc.startswith("##"):
                dRule[sArc[1:]] = oNode.__hash__()
            else:
                dNode[sArc] = oNode.__hash__()
        if dReValue:
            dNode["<re_value>"] = dReValue
        if dReMorph:
            dNode["<re_morph>"] = dReMorph
        if dLemma:
            dNode["<lemmas>"] = dLemma
        if dMeta:
            dNode["<meta>"] = dMeta
        if dRule:
            dNode["<rules>"] = dRule
        #if self.bFinal:
        #    dNode["<final>"] = 1
        return dNode

// data
let _sAppContext = "";                                  // what software is running
let _dOptions = null;
let _aIgnoredRules = new Set();
let _oSpellChecker = null;



var gc_engine = {

    //// Informations

    lang: "${lang}",

                var spellchecker = require("resource://grammalecte/graphspell/spellchecker.js");
                _oSpellChecker = new spellchecker.SpellChecker("${lang}", "", "${dic_main_filename_js}", "${dic_extended_filename_js}", "${dic_community_filename_js}", "${dic_personal_filename_js}");
            } else {
                _oSpellChecker = new SpellChecker("${lang}", sPath, "${dic_main_filename_js}", "${dic_extended_filename_js}", "${dic_community_filename_js}", "${dic_personal_filename_js}");
            }
            _sAppContext = sContext;
            _dOptions = gc_options.getOptions(sContext).gl_shallowCopy();     // duplication necessary, to be able to reset to default
            _oSpellChecker.activateStorage();
        }
        catch (e) {
            helpers.logerror(e);
        }
    },

    getSpellChecker: function () {

function displayInfo (dDA, aWord) {
    // for debugging: info of word
    if (!aWord) {
        helpers.echo("> nothing to find");
        return true;
    }
    let lMorph = _oSpellChecker.getMorph(aWord[1]);
    if (lMorph.length === 0) {
        helpers.echo("> not in dictionary");
        return true;
    }
    if (dDA.has(aWord[0])) {
        helpers.echo("DA: " + dDA.get(aWord[0]));
    }
    helpers.echo("FSA: " + lMorph);
    return true;
}








function morph (dDA, aWord, sPattern, bStrict=true, bNoWord=false) {
    // analyse a tuple (position, word), return true if sPattern in morphologies (disambiguation on)
    if (!aWord) {
        //helpers.echo("morph: noword, returns " + bNoWord);
        return bNoWord;
    }
    //helpers.echo("aWord: "+aWord.toString());



    let lMorph = dDA.has(aWord[0]) ? dDA.get(aWord[0]) : _oSpellChecker.getMorph(aWord[1]);
    //helpers.echo("lMorph: "+lMorph.toString());
    if (lMorph.length === 0) {
        return false;
    }
    //helpers.echo("***");
    if (bStrict) {
        return lMorph.every(s  =>  (s.search(sPattern) !== -1));
    }
    return lMorph.some(s  =>  (s.search(sPattern) !== -1));
}

function morphex (dDA, aWord, sPattern, sNegPattern, bNoWord=false) {
    // analyse a tuple (position, word), returns true if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation on)
    if (!aWord) {
        //helpers.echo("morph: noword, returns " + bNoWord);
        return bNoWord;
    }
    //helpers.echo("aWord: "+aWord.toString());



    let lMorph = dDA.has(aWord[0]) ? dDA.get(aWord[0]) : _oSpellChecker.getMorph(aWord[1]);
    //helpers.echo("lMorph: "+lMorph.toString());
    if (lMorph.length === 0) {
        return false;
    }
    //helpers.echo("***");
    // check negative condition
    if (lMorph.some(s  =>  (s.search(sNegPattern) !== -1))) {
        return false;
    }
    // search sPattern
    return lMorph.some(s  =>  (s.search(sPattern) !== -1));
}

function analyse (sWord, sPattern, bStrict=true) {
    // analyse a word, return true if sPattern in morphologies (disambiguation off)
    let lMorph = _oSpellChecker.getMorph(sWord);
    if (lMorph.length === 0) {
        return false;
    }
    if (bStrict) {
        return lMorph.every(s  =>  (s.search(sPattern) !== -1));
    }
    return lMorph.some(s  =>  (s.search(sPattern) !== -1));
}

function analysex (sWord, sPattern, sNegPattern) {
    // analyse a word, returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation off)
    let lMorph = _oSpellChecker.getMorph(sWord);
    if (lMorph.length === 0) {
        return false;
    }
    // check negative condition
    if (lMorph.some(s  =>  (s.search(sNegPattern) !== -1))) {
        return false;
    }
    // search sPattern
    return lMorph.some(s  =>  (s.search(sPattern) !== -1));











}


//// functions to get text outside pattern scope

// warning: check compile_rules.py to understand how it works

function select (dDA, nPos, sWord, sPattern, lDefault=null) {
    if (!sWord) {
        return true;
    }
    if (dDA.has(nPos)) {
        return true;
    }
    let lMorph = _oSpellChecker.getMorph(sWord);


    if (lMorph.length === 0  ||  lMorph.length === 1) {
        return true;
    }
    let lSelect = lMorph.filter( sMorph => sMorph.search(sPattern) !== -1 );
    if (lSelect.length > 0) {
        if (lSelect.length != lMorph.length) {
            dDA.set(nPos, lSelect);
        }
    } else if (lDefault) {
        dDA.set(nPos, lDefaul);
    }
    return true;
}

function exclude (dDA, nPos, sWord, sPattern, lDefault=null) {
    if (!sWord) {
        return true;
    }
    if (dDA.has(nPos)) {
        return true;
    }
    let lMorph = _oSpellChecker.getMorph(sWord);


    if (lMorph.length === 0  ||  lMorph.length === 1) {
        return true;
    }
    let lSelect = lMorph.filter( sMorph => sMorph.search(sPattern) === -1 );
    if (lSelect.length > 0) {
        if (lSelect.length != lMorph.length) {
            dDA.set(nPos, lSelect);
        }
    } else if (lDefault) {
        dDA.set(nPos, lDefault);
    }
    return true;
}

#import unicodedata
from itertools import chain

from ..graphspell.spellchecker import SpellChecker
from ..graphspell.echo import echo
from . import gc_options

from ..graphspell.tokenizer import Tokenizer
from .gc_rules_graph import dAllGraph, dRule

try:
    # LibreOffice / OpenOffice
    from com.sun.star.linguistic2 import SingleProofreadingError
    from com.sun.star.text.TextMarkupType import PROOFREADING
    from com.sun.star.beans import PropertyValue
    #import lightproof_handler_${implname} as opt
    _bWriterError = True
except ImportError:
    _bWriterError = False


__all__ = [ "lang", "locales", "pkg", "name", "version", "author", \
            "load", "parse", "getSpellChecker", \
            "setOption", "setOptions", "getOptions", "getDefaultOptions", "getOptionsLabels", "resetOptions", "displayOptions", \
            "ignoreRule", "resetIgnoreRules", "reactivateRule", "listRules", "displayRules" ]

__version__ = "${version}"

author = "${author}"

_rules = None                               # module gc_rules

# data
_sAppContext = ""                           # what software is running
_dOptions = None
_oSpellChecker = None
_oTokenizer = None
_aIgnoredRules = set()

# functions
_createRegexError = None


#### Initialization

def load (sContext="Python"):
    global _oSpellChecker
    global _sAppContext
    global _dOptions
    global _oTokenizer
    global _createRegexError
    global _createTokenError
    try:
        _oSpellChecker = SpellChecker("${lang}", "${dic_main_filename_py}", "${dic_extended_filename_py}", "${dic_community_filename_py}", "${dic_personal_filename_py}")
        _sAppContext = sContext
        _dOptions = dict(gc_options.getOptions(sContext))   # duplication necessary, to be able to reset to default
        _oTokenizer = _oSpellChecker.getTokenizer()
        _oSpellChecker.activateStorage()
        _createRegexError = _createRegexWriterError  if _bWriterError  else _createRegexDictError
    except:
        traceback.print_exc()


def _getRules (bParagraph):
    try:
        if not bParagraph:
            return _rules.lSentenceRules
        return _rules.lParagraphRules
    except:
        _loadRules()
    if not bParagraph:
        return _rules.lSentenceRules
    return _rules.lParagraphRules


def _loadRules ():
    from . import gc_rules
    global _rules
    _rules = gc_rules
    # compile rules regex
    for sOption, lRuleGroup in chain(_rules.lParagraphRules, _rules.lSentenceRules):
        if sOption != "@@@@":
            for aRule in lRuleGroup:
                try:
                    aRule[0] = re.compile(aRule[0])
                except:
                    echo("Bad regular expression in # " + str(aRule[2]))
                    aRule[0] = "(?i)<Grammalecte>"


#### Parsing

_zEndOfSentence = re.compile(r'([.?!:;…][ .?!… »”")]*|.$)')
_zBeginOfParagraph = re.compile(r"^\W*")
_zEndOfParagraph = re.compile(r"\W*$")

def _getSentenceBoundaries (sText):
    iStart = _zBeginOfParagraph.match(sText).end()
    for m in _zEndOfSentence.finditer(sText):
        yield (iStart, m.end())
        iStart = m.end()


def parse (sText, sCountry="${country_default}", bDebug=False, dOptions=None, bContext=False):
    "analyses the paragraph sText and returns list of errors"
    #sText = unicodedata.normalize("NFC", sText)
    aErrors = None
    sRealText = sText

    dPriority = {}  # Key = position; value = priority
    dOpt = _dOptions  if not dOptions  else dOptions
    bShowRuleId = option('idrule')

    # parse paragraph
    try:
        sNew, aErrors = _proofread(None, sText, sRealText, 0, True, dPriority, sCountry, dOpt, bShowRuleId, bDebug, bContext)
        if sNew:
            sText = sNew
    except:
        raise

    # cleanup
    if " " in sText:
        sText = sText.replace(" ", ' ') # nbsp
    if " " in sText:
        sText = sText.replace(" ", ' ') # nnbsp
    if "'" in sText:
        sText = sText.replace("'", "’")
    if "‑" in sText:
        sText = sText.replace("‑", "-") # nobreakdash

    # parse sentences
    for iStart, iEnd in _getSentenceBoundaries(sText):
        if 4 < (iEnd - iStart) < 2000:

            try:
                oSentence = TokenSentence(sText[iStart:iEnd], sRealText[iStart:iEnd], iStart)
                _, errs = _proofread(oSentence, sText[iStart:iEnd], sRealText[iStart:iEnd], iStart, False, dPriority, sCountry, dOpt, bShowRuleId, bDebug, bContext)
                aErrors.update(errs)
            except:
                raise
    return aErrors.values() # this is a view (iterable)







def _proofread (oSentence, s, sx, nOffset, bParagraph, dPriority, sCountry, dOptions, bShowRuleId, bDebug, bContext):


    dErrs = {}
    bParagraphChange = False
    bSentenceChange = False
    dTokenPos = oSentence.dTokenPos if oSentence else {}
    for sOption, lRuleGroup in _getRules(bParagraph):
        if sOption == "@@@@":
            # graph rules
            if not bParagraph and bSentenceChange:
                oSentence.update(s)
                bSentenceChange = False
            for sGraphName, sLineId in lRuleGroup:
                if bDebug:
                    print("\n>>>> GRAPH:", sGraphName, sLineId)
                bParagraphChange, errs = oSentence.parse(dAllGraph[sGraphName], dPriority, sCountry, dOptions, bShowRuleId, bDebug, bContext)
                dErrs.update(errs)
                if bParagraphChange:
                    s = oSentence.rewrite(bDebug)
        elif not sOption or dOptions.get(sOption, False):
            # regex rules
            for zRegex, bUppercase, sLineId, sRuleId, nPriority, lActions in lRuleGroup:
                if sRuleId not in _aIgnoredRules:
                    for m in zRegex.finditer(s):
                        bCondMemo = None
                        for sFuncCond, cActionType, sWhat, *eAct in lActions:
                            # action in lActions: [ condition, action type, replacement/suggestion/action[, iGroup[, message, URL]] ]
                            try:
                                bCondMemo = not sFuncCond or globals()[sFuncCond](s, sx, m, dTokenPos, sCountry, bCondMemo)
                                if bCondMemo:
                                    if cActionType == "-":
                                        # grammar error
                                        nErrorStart = nOffset + m.start(eAct[0])
                                        if nErrorStart not in dErrs or nPriority > dPriority.get(nErrorStart, -1):
                                            dErrs[nErrorStart] = _createRegexError(s, sx, sWhat, nOffset, m, eAct[0], sLineId, sRuleId, bUppercase, eAct[1], eAct[2], bShowRuleId, sOption, bContext)
                                            dPriority[nErrorStart] = nPriority
                                    elif cActionType == "~":
                                        # text processor
                                        s = _rewrite(s, sWhat, eAct[0], m, bUppercase)
                                        bParagraphChange = True
                                        bSentenceChange = True
                                        if bDebug:
                                            echo("~ " + s + "  -- " + m.group(eAct[0]) + "  # " + sLineId)
                                    elif cActionType == "=":
                                        # disambiguation
                                        if not bParagraph:
                                            globals()[sWhat](s, m, dTokenPos)
                                            if bDebug:
                                                echo("= " + m.group(0) + "  # " + sLineId)
                                    elif cActionType == ">":
                                        # we do nothing, this test is just a condition to apply all following actions
                                        pass
                                    else:
                                        echo("# error: unknown action at " + sLineId)
                                elif cActionType == ">":
                                    break
                            except Exception as e:
                                raise Exception(str(e), "# " + sLineId + " # " + sRuleId)
    if bParagraphChange:
        return (s, dErrs)
    return (False, dErrs)


def _createRegexWriterError (s, sx, sRepl, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bShowRuleId, sOption, bContext):
    "error for Writer (LO/OO)"
    xErr = SingleProofreadingError()
    #xErr = uno.createUnoStruct( "com.sun.star.linguistic2.SingleProofreadingError" )
    xErr.nErrorStart = nOffset + m.start(iGroup)
    xErr.nErrorLength = m.end(iGroup) - m.start(iGroup)
    xErr.nErrorType = PROOFREADING
    xErr.aRuleIdentifier = sRuleId

        xErr.aSuggestions = ()
    else:
        if bUppercase and m.group(iGroup)[0:1].isupper():
            xErr.aSuggestions = tuple(map(str.capitalize, m.expand(sRepl).split("|")))
        else:
            xErr.aSuggestions = tuple(m.expand(sRepl).split("|"))
    # Message

    sMessage = globals()[sMsg[1:]](s, m)  if sMsg[0:1] == "="  else  m.expand(sMsg)


    xErr.aShortComment = sMessage   # sMessage.split("|")[0]     # in context menu
    xErr.aFullComment = sMessage   # sMessage.split("|")[-1]    # in dialog
    if bShowRuleId:
        xErr.aShortComment += "  # " + sLineId + " # " + sRuleId
    # URL
    if sURL:
        p = PropertyValue()
        p.Name = "FullCommentURL"
        p.Value = sURL
        xErr.aProperties = (p,)
    else:
        xErr.aProperties = ()
    return xErr


def _createRegexDictError (s, sx, sRepl, nOffset, m, iGroup, sLineId, sRuleId, bUppercase, sMsg, sURL, bShowRuleId, sOption, bContext):
    "error as a dictionary"
    dErr = {}
    dErr["nStart"] = nOffset + m.start(iGroup)
    dErr["nEnd"] = nOffset + m.end(iGroup)
    dErr["sLineId"] = sLineId
    dErr["sRuleId"] = sRuleId
    dErr["sType"] = sOption  if sOption  else "notype"
    # suggestions
    if sRepl[0:1] == "=":
        sugg = globals()[sRepl[1:]](s, m)
        if sugg:
            if bUppercase and m.group(iGroup)[0:1].isupper():
                dErr["aSuggestions"] = list(map(str.capitalize, sugg.split("|")))
            else:
                dErr["aSuggestions"] = sugg.split("|")
        else:
            dErr["aSuggestions"] = []
    elif sRepl == "_":
        dErr["aSuggestions"] = []
    else:
        if bUppercase and m.group(iGroup)[0:1].isupper():
            dErr["aSuggestions"] = list(map(str.capitalize, m.expand(sRepl).split("|")))
        else:
            dErr["aSuggestions"] = m.expand(sRepl).split("|")
    # Message




    dErr["sMessage"] = globals()[sMsg[1:]](s, m)  if sMsg[0:1] == "="  else  m.expand(sMsg)
    if bShowRuleId:
        dErr["sMessage"] += "  # " + sLineId + " # " + sRuleId
    # URL
    dErr["URL"] = sURL  if sURL  else ""
    # Context
    if bContext:
        dErr['sUnderlined'] = sx[m.start(iGroup):m.end(iGroup)]
        dErr['sBefore'] = sx[max(0,m.start(iGroup)-80):m.start(iGroup)]
        dErr['sAfter'] = sx[m.end(iGroup):m.end(iGroup)+80]
    return dErr


def _rewrite (sSentence, sRepl, iGroup, m, bUppercase):
    "text processor: write <sRepl> in <sSentence> at <iGroup> position"
    nLen = m.end(iGroup) - m.start(iGroup)
    if sRepl == "*":
        sNew = " " * nLen
    elif sRepl == "_":
        sNew = sRepl + " " * (nLen-1)


    elif sRepl[0:1] == "=":
        sNew = globals()[sRepl[1:]](sSentence, m)
        sNew = sNew + " " * (nLen-len(sNew))
        if bUppercase and m.group(iGroup)[0:1].isupper():
            sNew = sNew.capitalize()
    else:
        sNew = m.expand(sRepl)
        sNew = sNew + " " * (nLen-len(sNew))
    return sSentence[0:m.start(iGroup)] + sNew + sSentence[m.end(iGroup):]


def ignoreRule (sRuleId):
    _aIgnoredRules.add(sRuleId)


def resetIgnoreRules ():

    if sFilter:
        try:
            zFilter = re.compile(sFilter)
        except:
            echo("# Error. List rules: wrong regex.")
            sFilter = None
    for sOption, lRuleGroup in chain(_getRules(True), _getRules(False)):
        if sOption != "@@@@":
            for _, _, sLineId, sRuleId, _, _ in lRuleGroup:
                if not sFilter or zFilter.search(sRuleId):
                    yield (sOption, sLineId, sRuleId)


def displayRules (sFilter=None):
    echo("List of rules. Filter: << " + str(sFilter) + " >>")
    for sOption, sLineId, sRuleId in listRules(sFilter):
        echo("{:<10} {:<10} {}".format(sOption, sLineId, sRuleId))



























def setOption (sOpt, bVal):
    if sOpt in _dOptions:
        _dOptions[sOpt] = bVal


def setOptions (dOpt):

    global _dOptions
    _dOptions = dict(gc_options.getOptions(_sAppContext))


def getSpellChecker ():
    return _oSpellChecker




























def _getPath ():
    return os.path.join(os.path.dirname(sys.modules[__name__].__file__), __name__ + ".py")



#### common functions









def option (sOpt):
    "return True if option sOpt is active"
    return _dOptions.get(sOpt, False)


def displayInfo (dTokenPos, tWord):
    "for debugging: retrieve info of word"
    if not tWord:
        echo("> nothing to find")
        return True
    lMorph = _oSpellChecker.getMorph(tWord[1])
    if not lMorph:
        echo("> not in dictionary")
        return True
    if tWord[0] in dTokenPos and "lMorph" in dTokenPos[tWord[0]]:
        echo("DA: " + str(dTokenPos[tWord[0]]["lMorph"]))
    echo("FSA: " + str(lMorph))
    return True









def morph (dTokenPos, tWord, sPattern, bStrict=True, bNoWord=False):
    "analyse a tuple (position, word), return True if sPattern in morphologies (disambiguation on)"
    if not tWord:
        return bNoWord


    lMorph = dTokenPos[tWord[0]]["lMorph"]  if tWord[0] in dTokenPos and "lMorph" in dTokenPos[tWord[0]]  else _oSpellChecker.getMorph(tWord[1])
    if not lMorph:
        return False
    p = re.compile(sPattern)
    if bStrict:
        return all(p.search(s)  for s in lMorph)
    return any(p.search(s)  for s in lMorph)


def morphex (dTokenPos, tWord, sPattern, sNegPattern, bNoWord=False):
    "analyse a tuple (position, word), returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation on)"
    if not tWord:
        return bNoWord
    lMorph = dTokenPos[tWord[0]]["lMorph"]  if tWord[0] in dTokenPos and "lMorph" in dTokenPos[tWord[0]]  else _oSpellChecker.getMorph(tWord[1])
    if not lMorph:
        return False

    # check negative condition
    np = re.compile(sNegPattern)
    if any(np.search(s)  for s in lMorph):
        return False
    # search sPattern
    p = re.compile(sPattern)
    return any(p.search(s)  for s in lMorph)


def analyse (sWord, sPattern, bStrict=True):
    "analyse a word, return True if sPattern in morphologies (disambiguation off)"
    lMorph = _oSpellChecker.getMorph(sWord)

    if not lMorph:
        return False
    p = re.compile(sPattern)
    if bStrict:
        return all(p.search(s)  for s in lMorph)
    return any(p.search(s)  for s in lMorph)


def analysex (sWord, sPattern, sNegPattern):
    "analyse a word, returns True if not sNegPattern in word morphologies and sPattern in word morphologies (disambiguation off)"
    lMorph = _oSpellChecker.getMorph(sWord)
    if not lMorph:
        return False
    # check negative condition
    np = re.compile(sNegPattern)
    if any(np.search(s)  for s in lMorph):
        return False
    # search sPattern
    p = re.compile(sPattern)
    return any(p.search(s)  for s in lMorph)











## functions to get text outside pattern scope

# warning: check compile_rules.py to understand how it works

_zNextWord = re.compile(r" +(\w[\w-]*)")
_zPrevWord = re.compile(r"(\w[\w-]*) +$")

def nextword (s, iStart, n):
    "get the nth word of the input string or empty string"
    m = re.match("(?: +[\\w%-]+){" + str(n-1) + "} +([\\w%-]+)", s[iStart:])
    if not m:
        return None
    return (iStart+m.start(1), m.group(1))

    if sNegPattern and re.search(sNegPattern, s):
        return False
    if re.search(sPattern, s):
        return True
    return False


def look_chk1 (dTokenPos, s, nOffset, sPattern, sPatternGroup1, sNegPatternGroup1=None):
    "returns True if s has pattern sPattern and m.group(1) has pattern sPatternGroup1"
    m = re.search(sPattern, s)
    if not m:
        return False
    try:
        sWord = m.group(1)
        nPos = m.start(1) + nOffset
    except:
        return False
    if sNegPatternGroup1:
        return morphex(dTokenPos, (nPos, sWord), sPatternGroup1, sNegPatternGroup1)
    return morph(dTokenPos, (nPos, sWord), sPatternGroup1, False)


#### Disambiguator

def select (dTokenPos, nPos, sWord, sPattern, lDefault=None):
    if not sWord:
        return True
    if nPos not in dTokenPos:
        print("Error. There should be a token at this position: ", nPos)
        return True
    lMorph = _oSpellChecker.getMorph(sWord)
    if not lMorph or len(lMorph) == 1:
        return True
    lSelect = [ sMorph  for sMorph in lMorph  if re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dTokenPos[nPos]["lMorph"] = lSelect
    elif lDefault:
        dTokenPos[nPos]["lMorph"] = lDefault
    return True


def exclude (dTokenPos, nPos, sWord, sPattern, lDefault=None):
    if not sWord:
        return True
    if nPos not in dTokenPos:
        print("Error. There should be a token at this position: ", nPos)
        return True
    lMorph = _oSpellChecker.getMorph(sWord)
    if not lMorph or len(lMorph) == 1:
        return True
    lSelect = [ sMorph  for sMorph in lMorph  if not re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dTokenPos[nPos]["lMorph"] = lSelect
    elif lDefault:
        dTokenPos[nPos]["lMorph"] = lDefault
    return True


def define (dTokenPos, nPos, lMorph):
    if nPos not in dTokenPos:
        print("Error. There should be a token at this position: ", nPos)
        return True
    dTokenPos[nPos]["lMorph"] = lMorph
    return True






#### TOKEN SENTENCE CHECKER

class TokenSentence:

    def __init__ (self, sSentence, sSentence0, nOffset):
        self.sSentence = sSentence
        self.sSentence0 = sSentence0
        self.nOffsetWithinParagraph = nOffset
        self.lToken = list(_oTokenizer.genTokens(sSentence, True))
        self.dTokenPos = { dToken["nStart"]: dToken  for dToken in self.lToken }
        self.dTags = {}
        self.createError = self._createWriterError  if _bWriterError  else self._createDictError


    def update (self, sSentence):
        self.sSentence = sSentence
        self.lToken = list(_oTokenizer.genTokens(sSentence, True))

    def _getNextMatchingNodes (self, dToken, dGraph, dNode, bDebug=False):
        "generator: return nodes where <dToken> “values” match <dNode> arcs"
        # token value
        if dToken["sValue"] in dNode:
            if bDebug:
                print("  MATCH:", dToken["sValue"])
            yield dGraph[dNode[dToken["sValue"]]]
        if dToken["sValue"][0:2].istitle(): # we test only 2 first chars, to make valid words such as "Laissez-les", "Passe-partout".
            sValue = dToken["sValue"].lower()
            if sValue in dNode:
                if bDebug:
                    print("  MATCH:", sValue)
                yield dGraph[dNode[sValue]]
        elif dToken["sValue"].isupper():
            sValue = dToken["sValue"].lower()
            if sValue in dNode:
                if bDebug:
                    print("  MATCH:", sValue)
                yield dGraph[dNode[sValue]]
            sValue = dToken["sValue"].capitalize()
            if sValue in dNode:
                if bDebug:
                    print("  MATCH:", sValue)
                yield dGraph[dNode[sValue]]
        # token lemmas
        if "<lemmas>" in dNode:
            for sLemma in _oSpellChecker.getLemma(dToken["sValue"]):
                if sLemma in dNode["<lemmas>"]:
                    if bDebug:
                        print("  MATCH: >" + sLemma)
                    yield dGraph[dNode["<lemmas>"][sLemma]]
        # regex value arcs
        if "<re_value>" in dNode:
            for sRegex in dNode["<re_value>"]:
                if "¬" not in sRegex:
                    # no anti-pattern
                    if re.search(sRegex, dToken["sValue"]):
                        if bDebug:
                            print("  MATCH: ~" + sRegex)
                        yield dGraph[dNode["<re_value>"][sRegex]]
                else:
                    # there is an anti-pattern
                    sPattern, sNegPattern = sRegex.split("¬", 1)
                    if sNegPattern and re.search(sNegPattern, dToken["sValue"]):
                        continue
                    if not sPattern or re.search(sPattern, dToken["sValue"]):
                        if bDebug:
                            print("  MATCH: ~" + sRegex)
                        yield dGraph[dNode["<re_value>"][sRegex]]
        # regex morph arcs
        if "<re_morph>" in dNode:
            for sRegex in dNode["<re_morph>"]:
                if "¬" not in sRegex:
                    # no anti-pattern
                    if any(re.search(sRegex, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                        if bDebug:
                            print("  MATCH: @" + sRegex)
                        yield dGraph[dNode["<re_morph>"][sRegex]]
                else:
                    # there is an anti-pattern
                    sPattern, sNegPattern = sRegex.split("¬", 1)
                    if sNegPattern == "*":
                        # all morphologies must match with <sPattern>
                        if sPattern and all(re.search(sPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                            if bDebug:
                                print("  MATCH: @" + sRegex)
                            yield dGraph[dNode["<re_morph>"][sRegex]]
                    else:
                        if sNegPattern and any(re.search(sNegPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                            continue
                        if not sPattern or any(re.search(sPattern, sMorph)  for sMorph in _oSpellChecker.getMorph(dToken["sValue"])):
                            if bDebug:
                                print("  MATCH: @" + sRegex)
                            yield dGraph[dNode["<re_morph>"][sRegex]]
        # meta arc (for token type)
        if "<meta>" in dNode:
            for sMeta in dNode["<meta>"]:
                if sMeta == "*":
                    if bDebug:
                        print("  MATCH: *" + sMeta)
                    yield dGraph[dNode["<meta>"]["*"]]
                elif "¬" in sMeta:
                    if dNode["sType"] not in sMeta:
                        if bDebug:
                            print("  MATCH: *" + sMeta)
                        yield dGraph[dNode["<meta>"][sMeta]]
                elif dNode["sType"] in sMeta:
                    if bDebug:
                        print("  MATCH: *" + sMeta)
                    yield dGraph[dNode["<meta>"][sMeta]]


    def parse (self, dGraph, dPriority, sCountry="${country_default}", dOptions=None, bShowRuleId=False, bDebug=False, bContext=False):
        dErr = {}
        dPriority = {}  # Key = position; value = priority
        dOpt = _dOptions  if not dOptions  else dOptions
        lPointer = []
        bChange = False
        for dToken in self.lToken:
            if bDebug:
                print("TOKEN:", dToken["sValue"])
            # check arcs for each existing pointer
            lNextPointer = []
            for dPointer in lPointer:
                for dNode in self._getNextMatchingNodes(dToken, dGraph, dPointer["dNode"], bDebug):
                    lNextPointer.append({"iToken": dPointer["iToken"], "dNode": dNode})
            lPointer = lNextPointer
            # check arcs of first nodes
            for dNode in self._getNextMatchingNodes(dToken, dGraph, dGraph[0], bDebug):
                lPointer.append({"iToken": dToken["i"], "dNode": dNode})
            # check if there is rules to check for each pointer
            for dPointer in lPointer:
                #if bDebug:
                #    print("+", dPointer)
                if "<rules>" in dPointer["dNode"]:
                    bHasChanged, errs = self._executeActions(dGraph, dPointer["dNode"]["<rules>"], dPointer["iToken"]-1, dToken["i"], dPriority, dOpt, sCountry, bShowRuleId, bDebug, bContext)
                    dErr.update(errs)
                    if bHasChanged:
                        bChange = True
        return (bChange, dErr)

    def _executeActions (self, dGraph, dNode, nTokenOffset, nLastToken, dPriority, dOptions, sCountry, bShowRuleId, bDebug, bContext):
        "execute actions found in the DARG"
        dErrs = {}
        bChange = False
        for sLineId, nextNodeKey in dNode.items():
            bCondMemo = None
            for sRuleId in dGraph[nextNodeKey]:
                try:
                    if bDebug:
                        print("ACTION:", sRuleId)
                        print(dRule[sRuleId])
                    sOption, sFuncCond, cActionType, sWhat, *eAct = dRule[sRuleId]
                    # Suggestion    [ option, condition, "-", replacement/suggestion/action, iTokenStart, iTokenEnd, nPriority, message, URL ]
                    # TextProcessor [ option, condition, "~", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                    # Disambiguator [ option, condition, "=", replacement/suggestion/action ]
                    # Tag           [ option, condition, "/", replacement/suggestion/action, iTokenStart, iTokenEnd ]
                    # Test          [ option, condition, ">", "" ]
                    if not sOption or dOptions.get(sOption, False):
                        bCondMemo = not sFuncCond or globals()[sFuncCond](self.lToken, nTokenOffset, nLastToken, sCountry, bCondMemo, self.dTags, self.sSentence, self.sSentence0)
                        if bCondMemo:
                            if cActionType == "-":
                                # grammar error
                                nTokenErrorStart = nTokenOffset + eAct[0]
                                nTokenErrorEnd = (nTokenOffset + eAct[1])  if eAct[1]  else nLastToken
                                nErrorStart = self.nOffsetWithinParagraph + self.lToken[nTokenErrorStart]["nStart"]
                                nErrorEnd = self.nOffsetWithinParagraph + self.lToken[nTokenErrorEnd]["nEnd"]
                                if nErrorStart not in dErrs or eAct[2] > dPriority.get(nErrorStart, -1):
                                    dErrs[nErrorStart] = self.createError(sWhat, nTokenOffset, nTokenErrorStart, nErrorStart, nErrorEnd, sLineId, sRuleId, True, eAct[3], eAct[4], bShowRuleId, "notype", bContext)
                                    dPriority[nErrorStart] = eAct[2]
                                    if bDebug:
                                        print("-", sRuleId, dErrs[nErrorStart])
                            elif cActionType == "~":
                                # text processor
                                nEndToken = (nTokenOffset + eAct[1])  if eAct[1]  else nLastToken
                                self._tagAndPrepareTokenForRewriting(sWhat, nTokenOffset + eAct[0], nEndToken, bDebug)
                                if bDebug:
                                    print("~", sRuleId)
                                bChange = True
                            elif cActionType == "=":
                                # disambiguation
                                globals()[sWhat](self.lToken, nTokenOffset)
                                if bDebug:
                                    print("=", sRuleId)
                            elif cActionType == ">":
                                # we do nothing, this test is just a condition to apply all following actions
                                if bDebug:
                                    print(">", sRuleId)
                                pass
                            elif cActionType == "/":
                                # tags
                                nTokenTag = nTokenOffset + eAct[0]
                                if sWhat not in self.dTags:
                                    self.dTags[sWhat] = (nTokenTag, nTokenTag)
                                elif nTokenTag > self.dTags[sWhat][1]:
                                    self.dTags[sWhat] = (self.dTags[sWhat][0], nTokenTag)
                                if bDebug:
                                    print("/", sRuleId)
                            else:
                                print("# error: unknown action at " + sLineId)
                        elif cActionType == ">":
                            if bDebug:
                                print(">!", sRuleId)
                            break
                except Exception as e:
                    raise Exception(str(e), sLineId, sRuleId, self.sSentence)
        return bChange, dErrs

    def _createWriterError (self, sSugg, nTokenOffset, iFirstToken, nStart, nEnd, sLineId, sRuleId, bUppercase, sMsg, sURL, bShowRuleId, sOption, bContext):
        "error for Writer (LO/OO)"
        xErr = SingleProofreadingError()
        #xErr = uno.createUnoStruct( "com.sun.star.linguistic2.SingleProofreadingError" )
        xErr.nErrorStart = nStart
        xErr.nErrorLength = nEnd - nStart
        xErr.nErrorType = PROOFREADING
        xErr.aRuleIdentifier = sRuleId
        # suggestions
        if sSugg[0:1] == "=":
            sSugg = globals()[sSugg[1:]](self.lToken, nTokenOffset)
            if sSugg:
                if bUppercase and self.lToken[iFirstToken]["sValue"][0:1].isupper():
                    xErr.aSuggestions = tuple(map(str.capitalize, sSugg.split("|")))
                else:
                    xErr.aSuggestions = tuple(sSugg.split("|"))
            else:
                xErr.aSuggestions = ()
        elif sSugg == "_":
            xErr.aSuggestions = ()
        else:
            if bUppercase and self.lToken[iFirstToken]["sValue"][0:1].isupper():
                xErr.aSuggestions = tuple(map(str.capitalize, self._expand(sSugg, nTokenOffset).split("|")))
            else:
                xErr.aSuggestions = tuple(self._expand(sSugg, nTokenOffset).split("|"))
        # Message
        sMessage = globals()[sMsg[1:]](self.lToken)  if sMsg[0:1] == "="  else self._expand(sMsg, nTokenOffset)
        xErr.aShortComment = sMessage   # sMessage.split("|")[0]     # in context menu
        xErr.aFullComment = sMessage   # sMessage.split("|")[-1]    # in dialog
        if bShowRuleId:
            xErr.aShortComment += "  " + sLineId + " # " + sRuleId
        # URL
        if sURL:
            p = PropertyValue()
            p.Name = "FullCommentURL"
            p.Value = sURL
            xErr.aProperties = (p,)
        else:
            xErr.aProperties = ()
        return xErr

    def _createDictError (self, sSugg, nTokenOffset, iFirstToken, nStart, nEnd, sLineId, sRuleId, bUppercase, sMsg, sURL, bShowRuleId, sOption, bContext):
        "error as a dictionary"
        dErr = {}
        dErr["nStart"] = nStart
        dErr["nEnd"] = nEnd
        dErr["sLineId"] = sLineId
        dErr["sRuleId"] = sRuleId
        dErr["sType"] = sOption  if sOption  else "notype"
        # suggestions
        if sSugg[0:1] == "=":
            sSugg = globals()[sSugg[1:]](self.lToken, nTokenOffset)
            if sSugg:
                if bUppercase and self.lToken[iFirstToken]["sValue"][0:1].isupper():
                    dErr["aSuggestions"] = list(map(str.capitalize, sSugg.split("|")))
                else:
                    dErr["aSuggestions"] = sSugg.split("|")
            else:
                dErr["aSuggestions"] = []
        elif sSugg == "_":
            dErr["aSuggestions"] = []
        else:
            if bUppercase and self.lToken[iFirstToken]["sValue"][0:1].isupper():
                dErr["aSuggestions"] = list(map(str.capitalize, self._expand(sSugg, nTokenOffset).split("|")))
            else:
                dErr["aSuggestions"] = self._expand(sSugg, nTokenOffset).split("|")
        # Message
        dErr["sMessage"] = globals()[sMsg[1:]](self.lToken)  if sMsg[0:1] == "="  else self._expand(sMsg, nTokenOffset)
        if bShowRuleId:
            dErr["sMessage"] += "  " + sLineId + " # " + sRuleId
        # URL
        dErr["URL"] = sURL  if sURL  else ""
        # Context
        if bContext:
            dErr['sUnderlined'] = self.sSentence0[dErr["nStart"]:dErr["nEnd"]]
            dErr['sBefore'] = self.sSentence0[max(0,dErr["nStart"]-80):dErr["nStart"]]
            dErr['sAfter'] = self.sSentence0[dErr["nEnd"]:dErr["nEnd"]+80]
        return dErr

    def _expand (self, sMsg, nTokenOffset):
        #print("*", sMsg)
        for m in re.finditer(r"\\([0-9]+)", sMsg):
            sMsg = sMsg.replace(m.group(0), self.lToken[int(m.group(1))+nTokenOffset]["sValue"])
        #print(">", sMsg)
        return sMsg

    def _tagAndPrepareTokenForRewriting (self, sWhat, nTokenRewriteStart, nTokenRewriteEnd, bUppercase=True, bDebug=False):
        "text processor: rewrite tokens between <nTokenRewriteStart> and <nTokenRewriteEnd> position"
        if bDebug:
            print("REWRITING:", nTokenRewriteStart, nTokenRewriteEnd)
        if sWhat == "*":
            # purge text
            if nTokenRewriteEnd - nTokenRewriteStart == 0:
                self.lToken[nTokenRewriteStart]["bToRemove"] = True
            else:
                for i in range(nTokenRewriteStart, nTokenRewriteEnd+1):
                    self.lToken[i]["bToRemove"] = True
        else:
            if sWhat.startswith("="):
                sWhat = globals()[sWhat[1:]](self.lToken)
            bUppercase = bUppercase and self.lToken[nTokenRewriteStart]["sValue"][0:1].isupper()
            if nTokenRewriteEnd - nTokenRewriteStart == 0:
                sWhat = sWhat + " " * (len(self.lToken[nTokenRewriteStart]["sValue"])-len(sWhat))
                if bUppercase:
                    sWhat = sWhat[0:1].upper() + sWhat[1:]
                self.lToken[nTokenRewriteStart]["sNewValue"] = sWhat
            else:
                lTokenValue = sWhat.split("|")
                if len(lTokenValue) != (nTokenRewriteEnd - nTokenRewriteStart + 1):
                    print("Error. Text processor: number of replacements != number of tokens.")
                    return
                for i, sValue in zip(range(nTokenRewriteStart, nTokenRewriteEnd+1), lTokenValue):
                    if bUppercase:
                        sValue = sValue[0:1].upper() + sValue[1:]
                    self.lToken[i]["sNewValue"] = sValue

    def rewrite (self, bDebug=False):
        "rewrite the sentence, modify tokens, purge the token list"
        lNewToken = []
        for i, dToken in enumerate(self.lToken):
            if "bToRemove" in dToken:
                # remove useless token
                self.sSentence = self.sSentence[:dToken["nStart"]] + " " * (dToken["nEnd"] - dToken["nStart"]) + self.sSentence[dToken["nEnd"]:]
                if bDebug:
                    print("removed:", dToken["sValue"])
            else:
                lNewToken.append(dToken)
                if "sNewValue" in dToken:
                    # rewrite token and sentence
                    if bDebug:
                        print(dToken["sValue"], "->", dToken["sNewValue"])
                    dToken["sRealValue"] = dToken["sValue"]
                    dToken["sValue"] = dToken["sNewValue"]
                    nDiffLen = len(dToken["sRealValue"]) - len(dToken["sNewValue"])
                    sNewRepl = (dToken["sNewValue"] + " " * nDiffLen)  if nDiffLen >= 0  else dToken["sNewValue"][:len(dToken["sRealValue"])]
                    self.sSentence = self.sSentence[:dToken["nStart"]] + sNewRepl + self.sSentence[dToken["nEnd"]:]
                    del dToken["sNewValue"]
        if bDebug:
            print(self.sSentence)
        self.lToken.clear()
        self.lToken = lNewToken
        return self.sSentence



#### Analyse tokens

def g_morph (dToken, sPattern, sNegPattern=""):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies"
    if "lMorph" in dToken:
        lMorph = dToken["lMorph"]
    else:
        lMorph = _oSpellChecker.getMorph(dToken["sValue"])
        if not lMorph:
            return False
    # check negative condition
    if sNegPattern:
        if sNegPattern == "*":
            # all morph must match sPattern
            zPattern = re.compile(sPattern)
            return all(zPattern.search(sMorph)  for sMorph in lMorph)
        else:
            zNegPattern = re.compile(sNegPattern)
            if any(zNegPattern.search(sMorph)  for sMorph in lMorph):
                return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)


def g_analyse (dToken, sPattern, sNegPattern=""):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies (disambiguation off)"
    lMorph = _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph:
        return False
    # check negative condition
    if sNegPattern:
        if sNegPattern == "*":
            zPattern = re.compile(sPattern)
            return all(zPattern.search(sMorph)  for sMorph in lMorph)
        else:
            zNegPattern = re.compile(sNegPattern)
            if any(zNegPattern.search(sMorph)  for sMorph in lMorph):
                return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)


def g_tag_before (dToken, dTags, sTag):
    if sTag not in dTags:
        return False
    if dToken["i"] > dTags[sTag][0]:
        return True
    return False


def g_tag_after (dToken, dTags, sTag):
    if sTag not in dTags:
        return False
    if dToken["i"] < dTags[sTag][1]:
        return True
    return False


#### Disambiguator

def g_select (dToken, sPattern, lDefault=None):
    "select morphologies for <dToken> according to <sPattern>, always return True"
    lMorph = dToken["lMorph"]  if "lMorph" in dToken  else _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph or len(lMorph) == 1:

        if lDefault:

            dToken["lMorph"] = lDefault
            #print("DA:", dToken["sValue"], dToken["lMorph"])

        return True
    lSelect = [ sMorph  for sMorph in lMorph  if re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect

    elif lDefault:
        dToken["lMorph"] = lDefault

    #print("DA:", dToken["sValue"], dToken["lMorph"])
    return True


def g_exclude (dToken, sPattern, lDefault=None):
    "select morphologies for <dToken> according to <sPattern>, always return True"
    lMorph = dToken["lMorph"]  if "lMorph" in dToken  else _oSpellChecker.getMorph(dToken["sValue"])
    if not lMorph or len(lMorph) == 1:
        if lDefault:
            dToken["lMorph"] = lDefault
            #print("DA:", dToken["sValue"], dToken["lMorph"])
        return True






    lSelect = [ sMorph  for sMorph in lMorph  if not re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect

    elif lDefault:
        dToken["lMorph"] = lDefault

    #print("DA:", dToken["sValue"], dToken["lMorph"])
    return True


def g_define (dToken, lMorph):
    "set morphologies of <dToken>, always return True"
    dToken["lMorph"] = lMorph

    #print("DA:", dToken["sValue"], lMorph)
    return True



#### GRAMMAR CHECKER PLUGINS

${plugins}


#### CALLABLES FOR REGEX RULES (generated code)

${callables}


#### CALLABLES FOR GRAPH RULES (generated code)

${graph_callables}

# generated code, do not edit

dAllGraph = ${rules_graphs}

dRule = ${rules_actions}

# Sentence checker

from ..graphspell.tokenizer import Tokenizer
from .gc_rules_graph import dGraph


oTokenizer = Tokenizer("${lang}")


class TokenSentence:

    def __init__ (self, sSentence, sSentence0, nOffset):
        self.sSentence = sSentence
        self.sSentence0 = sSentence0
        self.nOffset = nOffset
        self.lToken = list(oTokenizer.genTokens())

    def parse (self):
        dErr = {}
        lPointer = []
        for dToken in self.lToken:
            for i, dPointer in enumerate(lPointer):
                bValid = False
                for dNode in self._getNextMatchingNodes(dToken, dPointer["dNode"]):
                    dPointer["nOffset"] = dToken["i"]
                    dPointer["dNode"] = dNode
                    bValid = True
                if not bValid:
                    del lPointer[i]
            for dNode in self._getNextMatchingNodes(dToken, dGraph):
                lPointer.append({"nOffset": 0, "dNode": dNode})
            for dPointer in lPointer:
                if "<rules>" in dPointer["dNode"]:
                    for dNode in dGraph[dPointer["dNode"]["<rules>"]]:
                        dErr = self._executeActions(dNode, nOffset)
        return dErr

    def _getNextMatchingNodes (self, dToken, dNode):
        # token value
        if dToken["sValue"] in dNode:
            yield dGraph[dNode[dToken["sValue"]]]
        # token lemmas
        for sLemma in dToken["lLemma"]:
            if sLemma in dNode:
                yield dGraph[dNode[sLemma]]
        # universal arc
        if "*" in dNode:
            yield dGraph[dNode["*"]]
        # regex arcs
        if "~" in dNode:
            for sRegex in dNode["~"]:
                for sMorph in dToken["lMorph"]:
                    if re.search(sRegex, sMorph):
                        yield dGraph[dNode["~"][sRegex]]

    def _executeActions (self, dNode, nOffset):
        for sLineId, nextNodeKey in dNode.items():
            for sArc in dGraph[nextNodeKey]:
                bCondMemo = None
                sFuncCond, cActionType, sWhat, *eAct = dRule[sArc]
                # action in lActions: [ condition, action type, replacement/suggestion/action[, iGroupStart, iGroupEnd[, message, URL]] ]
                try:
                    bCondMemo = not sFuncCond or globals()[sFuncCond](self, sCountry, bCondMemo)
                    if bCondMemo:
                        if cActionType == "-":
                            # grammar error
                            nErrorStart = nSentenceOffset + m.start(eAct[0])
                            nErrorEnd = nSentenceOffset + m.start(eAct[1])
                            if nErrorStart not in dErrs or nPriority > dPriority[nErrorStart]:
                                dErrs[nErrorStart] = _createError(self, sWhat, nErrorStart, nErrorEnd, sLineId, bUppercase, eAct[2], eAct[3], bIdRule, sOption, bContext)
                                dPriority[nErrorStart] = nPriority
                        elif cActionType == "~":
                            # text processor
                            self._rewrite(sWhat, nErrorStart, nErrorEnd)
                        elif cActionType == "@":
                            # jump
                            self._jump(sWhat)
                        elif cActionType == "=":
                            # disambiguation
                            globals()[sWhat](self.lToken)
                        elif cActionType == ">":
                            # we do nothing, this test is just a condition to apply all following actions
                            pass
                        else:
                            print("# error: unknown action at " + sLineId)
                    elif cActionType == ">":
                        break
                except Exception as e:
                    raise Exception(str(e), "# " + sLineId + " # " + sRuleId)

    def _createWriterError (self):
        d = {}
        return d

    def _createDictError (self):
        d = {}
        return d

    def _rewrite (self, sWhat, nErrorStart, nErrorEnd):
        "text processor: rewrite tokens between <nErrorStart> and <nErrorEnd> position"
        lTokenValue = sWhat.split("|")
        if len(lTokenValue) != (nErrorEnd - nErrorStart + 1):
            print("Error. Text processor: number of replacements != number of tokens.")
            return
        for i, sValue in zip(range(nErrorStart, nErrorEnd+1), lTokenValue):
            self.lToken[i]["sValue"] = sValue

    def _jump (self, sWhat):
        try:
            nFrom, nTo = sWhat.split(">")
            self.lToken[int(nFrom)]["iJump"] = int(nTo)
        except:
            print("# Error. Jump failed: ", sWhat)
            traceback.print_exc()
            return


#### Analyse tokens

def g_morph (dToken, sPattern, bStrict=True):
    "analyse a token, return True if <sPattern> in morphologies"
    if "lMorph" in dToken:
        lMorph = dToken["lMorph"]
    else:
        if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
            return False
        if not _dAnalyses[dToken["sValue"]]:
            return False
        lMorph = _dAnalyses[dToken["sValue"]]
    zPattern = re.compile(sPattern)
    if bStrict:
        return all(zPattern.search(sMorph)  for sMorph in lMorph)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)

def g_morphex (dToken, sPattern, sNegPattern):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies"
    if "lMorph" in dToken:
        lMorph = dToken["lMorph"]
    else:
        if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
            return False
        if not _dAnalyses[dToken["sValue"]]:
            return False
        lMorph = _dAnalyses[dToken["sValue"]]
    # check negative condition
    zNegPattern = re.compile(sNegPattern)
    if any(zNegPattern.search(sMorph)  for sMorph in lMorph):
        return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in lMorph)

def g_analyse (dToken, sPattern, bStrict=True):
    "analyse a token, return True if <sPattern> in morphologies (disambiguation off)"
    if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
        return False
    if not _dAnalyses[dToken["sValue"]]:
        return False
    zPattern = re.compile(sPattern)
    if bStrict:
        return all(zPattern.search(sMorph)  for sMorph in _dAnalyses[dToken["sValue"]])
    return any(zPattern.search(sMorph)  for sMorph in _dAnalyses[dToken["sValue"]])


def g_analysex (dToken, sPattern, sNegPattern):
    "analyse a token, return True if <sNegPattern> not in morphologies and <sPattern> in morphologies (disambiguation off)"
    if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
        return False
    if not _dAnalyses[dToken["sValue"]]:
        return False
    # check negative condition
    zNegPattern = re.compile(sNegPattern)
    if any(zNegPattern.search(sMorph)  for sMorph in _dAnalyses[dToken["sValue"]]):
        return False
    # search sPattern
    zPattern = re.compile(sPattern)
    return any(zPattern.search(sMorph)  for sMorph in _dAnalyses[dToken["sValue"]])


#### Go outside the rule scope

def g_nextToken (i):
    pass

def g_prevToken (i):
    pass

def g_look ():
    pass

def g_lookAndCheck ():
    pass


#### Disambiguator

def g_select (dToken, sPattern, lDefault=None):
    "select morphologies for <dToken> according to <sPattern>, always return True"
    if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
        return True
    if len(_dAnalyses[dToken["sValue"]]) == 1:
        return True
    lMorph = dToken["lMorph"] or _dAnalyses[dToken["sValue"]]
    lSelect = [ sMorph  for sMorph in lMorph  if re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect
    elif lDefault:
        dToken["lMorph"] = lDefault
    return True


def g_exclude (dToken, sPattern, lDefault=None):
    "select morphologies for <dToken> according to <sPattern>, always return True"
    if dToken["sValue"] not in _dAnalyses and not _storeMorphFromFSA(dToken["sValue"]):
        return True
    if len(_dAnalyses[dToken["sValue"]]) == 1:
        return True
    lMorph = dToken["lMorph"] or _dAnalyses[dToken["sValue"]]
    lSelect = [ sMorph  for sMorph in lMorph  if not re.search(sPattern, sMorph) ]
    if lSelect:
        if len(lSelect) != len(lMorph):
            dToken["lMorph"] = lSelect
    elif lDefault:
        dToken["lMorph"] = lDefault
    return True


def g_define (dToken, lMorph):
    "set morphologies of <dToken>, always return True"
    dToken["lMorph"] = lMorph
    return True


#### CALLABLES (generated code)

${graph_callables}

        return this._lVtyp[this._dVerb[sVerb][0]];
    },

    getSimil: function (sWord, sMorph, bSubst=false) {
        if (!sMorph.includes(":V")) {
            return new Set();
        }
        let sInfi = sMorph.slice(1, sMorph.indexOf("/"));
        let aSugg = new Set();
        let tTags = this._getTags(sInfi);
        if (tTags) {
            if (!bSubst) {
                // we suggest conjugated forms
                if (sMorph.includes(":V1")) {
                    aSugg.add(sInfi);

    if (s2 == "vous") {
        return "vous";
    }
    if (s2 == "eux") {
        return "ils";
    }
    if (s2 == "elle" || s2 == "elles") {

        if (cregex.mbNprMasNotFem(_oSpellChecker.getMorph(s1))) {
            return "ils";
        }
        // si épicène, indéterminable, mais OSEF, le féminin l’emporte
        return "elles";
    }
    return s1 + " et " + s2;
}

function apposition (sWord1, sWord2) {
    // returns true if nom + nom (no agreement required)

    return cregex.mbNomNotAdj(_oSpellChecker.getMorph(sWord2)) && cregex.mbPpasNomNotAdj(_oSpellChecker.getMorph(sWord1));
}

function isAmbiguousNAV (sWord) {
    // words which are nom|adj and verb are ambiguous (except être and avoir)
    let lMorph = _oSpellChecker.getMorph(sWord);
    if (lMorph.length === 0) {
        return false;
    }
    if (!cregex.mbNomAdj(lMorph) || sWord == "est") {
        return false;
    }
    if (cregex.mbVconj(lMorph) && !cregex.mbMG(lMorph)) {
        return true;
    }
    return false;
}

function isAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj) {
    //// use it if sWord1 won’t be a verb; word2 is assumed to be true via isAmbiguousNAV

    let a2 = _oSpellChecker.getMorph(sWord2);
    if (a2.length === 0) {
        return false;
    }
    if (cregex.checkConjVerb(a2, sReqMorphConj)) {
        // verb word2 is ok
        return false;
    }
    let a1 = _oSpellChecker.getMorph(sWord1);
    if (a1.length === 0) {
        return false;
    }
    if (cregex.checkAgreement(a1, a2) && (cregex.mbAdj(a2) || cregex.mbAdj(a1))) {
        return false;
    }
    return true;
}

function isVeryAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj, bLastHopeCond) {
    //// use it if sWord1 can be also a verb; word2 is assumed to be true via isAmbiguousNAV

    let a2 = _oSpellChecker.getMorph(sWord2);
    if (a2.length === 0) {
        return false;
    }
    if (cregex.checkConjVerb(a2, sReqMorphConj)) {
        // verb word2 is ok
        return false;
    }
    let a1 = _oSpellChecker.getMorph(sWord1);
    if (a1.length === 0) {
        return false;
    }
    if (cregex.checkAgreement(a1, a2) && (cregex.mbAdj(a2) || cregex.mbAdjNb(a1))) {
        return false;
    }
    // now, we know there no agreement, and conjugation is also wrong
    if (cregex.isNomAdj(a1)) {
        return true;
    }
    //if cregex.isNomAdjVerb(a1): # considered true
    if (bLastHopeCond) {
        return true;
    }
    return false;
}

function checkAgreement (sWord1, sWord2) {

    let a2 = _oSpellChecker.getMorph(sWord2);
    if (a2.length === 0) {
        return true;
    }
    let a1 = _oSpellChecker.getMorph(sWord1);
    if (a1.length === 0) {
        return true;
    }
    return cregex.checkAgreement(a1, a2);
}

function mbUnit (s) {
    if (/[µ\/⁰¹²³⁴⁵⁶⁷⁸⁹Ωℓ·]/.test(s)) {

    var phonet = require("resource://grammalecte/fr/phonet.js");
}


//// verbs

function suggVerb (sFlex, sWho, funcSugg2=null) {

    let aSugg = new Set();
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        let tTags = conj._getTags(sStem);
        if (tTags) {
            // we get the tense
            let aTense = new Set();
            for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
                let m;
                let zVerb = new RegExp (">"+sStem+"/.*?(:(?:Y|I[pqsf]|S[pq]|K))", "g");
                while ((m = zVerb.exec(sMorph)) !== null) {
                    // stem must be used in regex to prevent confusion between different verbs (e.g. sauras has 2 stems: savoir and saurer)
                    if (m) {
                        if (m[1] === ":Y") {
                            aTense.add(":Ip");
                            aTense.add(":Iq");
                            aTense.add(":Is");

        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggVerbPpas (sFlex, sWhat=null) {
    let aSugg = new Set();
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        let tTags = conj._getTags(sStem);
        if (tTags) {
            if (!sWhat) {
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"));
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2"));
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3"));
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4"));

        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggVerbTense (sFlex, sTense, sWho) {
    let aSugg = new Set();
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        if (conj.hasConj(sStem, sTense, sWho)) {
            aSugg.add(conj.getConj(sStem, sTense, sWho));
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggVerbImpe (sFlex) {
    let aSugg = new Set();
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        let tTags = conj._getTags(sStem);
        if (tTags) {
            if (conj._hasConjWithTags(tTags, ":E", ":2s")) {
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":2s"));
            }
            if (conj._hasConjWithTags(tTags, ":E", ":1p")) {
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":1p"));
            }
            if (conj._hasConjWithTags(tTags, ":E", ":2p")) {
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":2p"));
            }
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggVerbInfi (sFlex) {
    return _oSpellChecker.getLemma(sFlex).filter(sStem => conj.isVerb(sStem)).join("|");
}


const _dQuiEst = new Map ([
    ["je", ":1s"], ["j’", ":1s"], ["j’en", ":1s"], ["j’y", ":1s"],
    ["tu", ":2s"], ["il", ":3s"], ["on", ":3s"], ["elle", ":3s"],
    ["nous", ":1p"], ["vous", ":2p"], ["ils", ":3p"], ["elles", ":3p"]

    if (!sWho) {
        if (sSuj[0].gl_isLowerCase()) { // pas un pronom, ni un nom propre
            return "";
        }
        sWho = ":3s";
    }
    let aSugg = new Set();
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        let tTags = conj._getTags(sStem);
        if (tTags) {
            for (let sTense of lMode) {
                if (conj._hasConjWithTags(tTags, sTense, sWho)) {
                    aSugg.add(conj._getConjWithTags(sStem, tTags, sTense, sWho));
                }
            }
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

//// Nouns and adjectives

function suggPlur (sFlex, sWordToAgree=null) {
    // returns plural forms assuming sFlex is singular
    if (sWordToAgree) {
        let lMorph = _oSpellChecker.getMorph(sWordToAgree);
        if (lMorph.length === 0) {
            return "";
        }
        let sGender = cregex.getGender(lMorph);
        if (sGender == ":m") {
            return suggMasPlur(sFlex);
        } else if (sGender == ":f") {
            return suggFemPlur(sFlex);
        }
    }
    let aSugg = new Set();

        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggMasSing (sFlex, bSuggSimil=false) {
    // returns masculine singular forms

    let aSugg = new Set();
    for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
        if (!sMorph.includes(":V")) {
            // not a verb
            if (sMorph.includes(":m") || sMorph.includes(":e")) {
                aSugg.add(suggSing(sFlex));
            } else {
                let sStem = cregex.getLemmaOfMorph(sMorph);
                if (mfsp.isFemForm(sStem)) {

        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggMasPlur (sFlex, bSuggSimil=false) {
    // returns masculine plural forms

    let aSugg = new Set();
    for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
        if (!sMorph.includes(":V")) {
            // not a verb
            if (sMorph.includes(":m") || sMorph.includes(":e")) {
                aSugg.add(suggPlur(sFlex));
            } else {
                let sStem = cregex.getLemmaOfMorph(sMorph);
                if (mfsp.isFemForm(sStem)) {

    }
    return "";
}


function suggFemSing (sFlex, bSuggSimil=false) {
    // returns feminine singular forms

    let aSugg = new Set();
    for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
        if (!sMorph.includes(":V")) {
            // not a verb
            if (sMorph.includes(":f") || sMorph.includes(":e")) {
                aSugg.add(suggSing(sFlex));
            } else {
                let sStem = cregex.getLemmaOfMorph(sMorph);
                if (mfsp.isFemForm(sStem)) {

        return Array.from(aSugg).join("|");
    }
    return "";
}

function suggFemPlur (sFlex, bSuggSimil=false) {
    // returns feminine plural forms

    let aSugg = new Set();
    for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
        if (!sMorph.includes(":V")) {
            // not a verb
            if (sMorph.includes(":f") || sMorph.includes(":e")) {
                aSugg.add(suggPlur(sFlex));
            } else {
                let sStem = cregex.getLemmaOfMorph(sMorph);
                if (mfsp.isFemForm(sStem)) {

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

function hasFemForm (sFlex) {
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        if (mfsp.isFemForm(sStem) || conj.hasConj(sStem, ":PQ", ":Q3")) {
            return true;
        }
    }
    if (phonet.hasSimil(sFlex, ":f")) {
        return true;
    }
    return false;
}

function hasMasForm (sFlex) {
    for (let sStem of _oSpellChecker.getLemma(sFlex)) {
        if (mfsp.isFemForm(sStem) || conj.hasConj(sStem, ":PQ", ":Q1")) {
            // what has a feminine form also has a masculine form
            return true;
        }
    }
    if (phonet.hasSimil(sFlex, ":m")) {
        return true;
    }
    return false;
}

function switchGender (sFlex, bPlur=null) {

    let aSugg = new Set();
    if (bPlur === null) {
        for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
            if (sMorph.includes(":f")) {
                if (sMorph.includes(":s")) {
                    aSugg.add(suggMasSing(sFlex));
                } else if (sMorph.includes(":p")) {
                    aSugg.add(suggMasPlur(sFlex));
                }
            } else if (sMorph.includes(":m")) {
                if (sMorph.includes(":s")) {
                    aSugg.add(suggFemSing(sFlex));
                } else if (sMorph.includes(":p")) {
                    aSugg.add(suggFemPlur(sFlex));
                } else {
                    aSugg.add(suggFemSing(sFlex));
                    aSugg.add(suggFemPlur(sFlex));
                }
            }
        }
    } else if (bPlur) {
        for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
            if (sMorph.includes(":f")) {
                aSugg.add(suggMasPlur(sFlex));
            } else if (sMorph.includes(":m")) {
                aSugg.add(suggFemPlur(sFlex));
            }
        }
    } else {
        for (let sMorph of _oSpellChecker.getMorph(sFlex)) {
            if (sMorph.includes(":f")) {
                aSugg.add(suggMasSing(sFlex));
            } else if (sMorph.includes(":m")) {
                aSugg.add(suggFemSing(sFlex));
            }
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

function switchPlural (sFlex) {
    let aSugg = new Set();
    for (let sMorph of _oSpellChecker.getMorph(sFlex)) { 
        if (sMorph.includes(":s")) {
            aSugg.add(suggPlur(sFlex));
        } else if (sMorph.includes(":p")) {
            aSugg.add(suggSing(sFlex));
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }
    return "";
}

function hasSimil (sWord, sPattern=null) {
    return phonet.hasSimil(sWord, sPattern);
}

function suggSimil (sWord, sPattern=null, bSubst=false) {
    // return list of words phonetically similar to sWord and whom POS is matching sPattern
    let aSugg = phonet.selectSimil(sWord, sPattern);
    for (let sMorph of _oSpellChecker.getMorph(sWord)) {
        for (let e of conj.getSimil(sWord, sMorph, bSubst)) {
            aSugg.add(e);
        }
    }
    if (aSugg.size > 0) {
        return Array.from(aSugg).join("|");
    }

    if (sWord[0] == "h" || sWord[0] == "H") {
        return "ce|cet";
    }
    return "ce";
}

function suggLesLa (sWord) {

    if (_oSpellChecker.getMorph(sWord).some(s  =>  s.includes(":p"))) {
        return "les|la";
    }
    return "la";
}

function formatNumber (s) {
    let nLen = s.length;

${regex_gctestsJS}

        return None
    return _lVtyp[_dVerb[sVerb][0]]


def getSimil (sWord, sMorph, bSubst=False):
    if ":V" not in sMorph:
        return set()
    sInfi = sMorph[1:sMorph.find("/")]
    aSugg = set()
    tTags = _getTags(sInfi)
    if tTags:
        if not bSubst:
            # we suggest conjugated forms
            if ":V1" in sMorph:
                aSugg.add(sInfi)

        return "vous"
    if s2 == "nous":
        return "nous"
    if s2 == "vous":
        return "vous"
    if s2 == "eux":
        return "ils"
    if s2 == "elle" or s2 == "elles":    

        if cr.mbNprMasNotFem(_oSpellChecker.getMorph(s1)):
            return "ils"
        # si épicène, indéterminable, mais OSEF, le féminin l’emporte
        return "elles"
    return s1 + " et " + s2


def apposition (sWord1, sWord2):
    "returns True if nom + nom (no agreement required)"

    return cr.mbNomNotAdj(_oSpellChecker.getMorph(sWord2)) and cr.mbPpasNomNotAdj(_oSpellChecker.getMorph(sWord1))


def isAmbiguousNAV (sWord):
    "words which are nom|adj and verb are ambiguous (except être and avoir)"
    lMorph = _oSpellChecker.getMorph(sWord)

    if not cr.mbNomAdj(lMorph) or sWord == "est":
        return False
    if cr.mbVconj(lMorph) and not cr.mbMG(lMorph):
        return True
    return False


def isAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj):
    "use it if sWord1 won’t be a verb; word2 is assumed to be True via isAmbiguousNAV"

    a2 = _oSpellChecker.getMorph(sWord2)
    if not a2:
        return False
    if cr.checkConjVerb(a2, sReqMorphConj):
        # verb word2 is ok
        return False
    a1 = _oSpellChecker.getMorph(sWord1)
    if not a1:
        return False
    if cr.checkAgreement(a1, a2) and (cr.mbAdj(a2) or cr.mbAdj(a1)):
        return False
    return True


def isVeryAmbiguousAndWrong (sWord1, sWord2, sReqMorphNA, sReqMorphConj, bLastHopeCond):
    "use it if sWord1 can be also a verb; word2 is assumed to be True via isAmbiguousNAV"

    a2 = _oSpellChecker.getMorph(sWord2)
    if not a2:
        return False
    if cr.checkConjVerb(a2, sReqMorphConj):
        # verb word2 is ok
        return False
    a1 = _oSpellChecker.getMorph(sWord1)
    if not a1:
        return False
    if cr.checkAgreement(a1, a2) and (cr.mbAdj(a2) or cr.mbAdjNb(a1)):
        return False
    # now, we know there no agreement, and conjugation is also wrong
    if cr.isNomAdj(a1):
        return True
    #if cr.isNomAdjVerb(a1): # considered True
    if bLastHopeCond:
        return True
    return False


def checkAgreement (sWord1, sWord2):

    a2 = _oSpellChecker.getMorph(sWord2)
    if not a2:
        return True
    a1 = _oSpellChecker.getMorph(sWord1)
    if not a1:
        return True
    return cr.checkAgreement(a1, a2)


_zUnitSpecial = re.compile("[µ/⁰¹²³⁴⁵⁶⁷⁸⁹Ωℓ·]")
_zUnitNumbers = re.compile("[0-9]")

#### GRAMMAR CHECKING ENGINE PLUGIN: Suggestion mechanisms

from . import conj
from . import mfsp
from . import phonet


## Verbs

def suggVerb (sFlex, sWho, funcSugg2=None):
    aSugg = set()
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            # we get the tense
            aTense = set()
            for sMorph in _oSpellChecker.getMorph(sFlex):
                for m in re.finditer(">"+sStem+"/.*?(:(?:Y|I[pqsf]|S[pq]|K|P))", sMorph):
                    # stem must be used in regex to prevent confusion between different verbs (e.g. sauras has 2 stems: savoir and saurer)
                    if m:
                        if m.group(1) == ":Y":
                            aTense.add(":Ip")
                            aTense.add(":Iq")
                            aTense.add(":Is")
                        elif m.group(1) == ":P":

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggVerbPpas (sFlex, sWhat=None):
    aSugg = set()
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            if not sWhat:
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q1"))
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q2"))
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q3"))
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":PQ", ":Q4"))

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggVerbTense (sFlex, sTense, sWho):
    aSugg = set()
    for sStem in _oSpellChecker.getLemma(sFlex):
        if conj.hasConj(sStem, sTense, sWho):
            aSugg.add(conj.getConj(sStem, sTense, sWho))
    if aSugg:
        return "|".join(aSugg)
    return ""


def suggVerbImpe (sFlex):
    aSugg = set()
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            if conj._hasConjWithTags(tTags, ":E", ":2s"):
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":2s"))
            if conj._hasConjWithTags(tTags, ":E", ":1p"):
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":1p"))
            if conj._hasConjWithTags(tTags, ":E", ":2p"):
                aSugg.add(conj._getConjWithTags(sStem, tTags, ":E", ":2p"))
    if aSugg:
        return "|".join(aSugg)
    return ""


def suggVerbInfi (sFlex):
    return "|".join([ sStem  for sStem in _oSpellChecker.getLemma(sFlex)  if conj.isVerb(sStem) ])


_dQuiEst = { "je": ":1s", "j’": ":1s", "j’en": ":1s", "j’y": ":1s", \
             "tu": ":2s", "il": ":3s", "on": ":3s", "elle": ":3s", "nous": ":1p", "vous": ":2p", "ils": ":3p", "elles": ":3p" }
_lIndicatif = [":Ip", ":Iq", ":Is", ":If"]
_lSubjonctif = [":Sp", ":Sq"]

        return ""
    sWho = _dQuiEst.get(sSuj.lower(), None)
    if not sWho:
        if sSuj[0:1].islower(): # pas un pronom, ni un nom propre
            return ""
        sWho = ":3s"
    aSugg = set()
    for sStem in _oSpellChecker.getLemma(sFlex):
        tTags = conj._getTags(sStem)
        if tTags:
            for sTense in lMode:
                if conj._hasConjWithTags(tTags, sTense, sWho):
                    aSugg.add(conj._getConjWithTags(sStem, tTags, sTense, sWho))
    if aSugg:
        return "|".join(aSugg)
    return ""


## Nouns and adjectives

def suggPlur (sFlex, sWordToAgree=None):
    "returns plural forms assuming sFlex is singular"
    if sWordToAgree:
        lMorph = _oSpellChecker.getMorph(sFlex)
        if not lMorph:
            return ""
        sGender = cr.getGender(lMorph)
        if sGender == ":m":
            return suggMasPlur(sFlex)
        elif sGender == ":f":
            return suggFemPlur(sFlex)
    aSugg = set()
    if "-" not in sFlex:
        if sFlex.endswith("l"):

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggMasSing (sFlex, bSuggSimil=False):
    "returns masculine singular forms"

    aSugg = set()
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":m" in sMorph or ":e" in sMorph:
                aSugg.add(suggSing(sFlex))
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isFemForm(sStem):

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggMasPlur (sFlex, bSuggSimil=False):
    "returns masculine plural forms"

    aSugg = set()
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":m" in sMorph or ":e" in sMorph:
                aSugg.add(suggPlur(sFlex))
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isFemForm(sStem):

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggFemSing (sFlex, bSuggSimil=False):
    "returns feminine singular forms"

    aSugg = set()
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":f" in sMorph or ":e" in sMorph:
                aSugg.add(suggSing(sFlex))
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isFemForm(sStem):

    if aSugg:
        return "|".join(aSugg)
    return ""


def suggFemPlur (sFlex, bSuggSimil=False):
    "returns feminine plural forms"

    aSugg = set()
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if not ":V" in sMorph:
            # not a verb
            if ":f" in sMorph or ":e" in sMorph:
                aSugg.add(suggPlur(sFlex))
            else:
                sStem = cr.getLemmaOfMorph(sMorph)
                if mfsp.isFemForm(sStem):

            aSugg.add(e)
    if aSugg:
        return "|".join(aSugg)
    return ""


def hasFemForm (sFlex):
    for sStem in _oSpellChecker.getLemma(sFlex):
        if mfsp.isFemForm(sStem) or conj.hasConj(sStem, ":PQ", ":Q3"):
            return True
    if phonet.hasSimil(sFlex, ":f"):
        return True
    return False


def hasMasForm (sFlex):
    for sStem in _oSpellChecker.getLemma(sFlex):
        if mfsp.isFemForm(sStem) or conj.hasConj(sStem, ":PQ", ":Q1"):
            # what has a feminine form also has a masculine form
            return True
    if phonet.hasSimil(sFlex, ":m"):
        return True
    return False


def switchGender (sFlex, bPlur=None):

    aSugg = set()
    if bPlur == None:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                if ":s" in sMorph:
                    aSugg.add(suggMasSing(sFlex))
                elif ":p" in sMorph:
                    aSugg.add(suggMasPlur(sFlex))
            elif ":m" in sMorph:
                if ":s" in sMorph:
                    aSugg.add(suggFemSing(sFlex))
                elif ":p" in sMorph:
                    aSugg.add(suggFemPlur(sFlex))
                else:
                    aSugg.add(suggFemSing(sFlex))
                    aSugg.add(suggFemPlur(sFlex))
    elif bPlur:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                aSugg.add(suggMasPlur(sFlex))
            elif ":m" in sMorph:
                aSugg.add(suggFemPlur(sFlex))
    else:
        for sMorph in _oSpellChecker.getMorph(sFlex):
            if ":f" in sMorph:
                aSugg.add(suggMasSing(sFlex))
            elif ":m" in sMorph:
                aSugg.add(suggFemSing(sFlex))
    if aSugg:
        return "|".join(aSugg)
    return ""


def switchPlural (sFlex):

    aSugg = set()
    for sMorph in _oSpellChecker.getMorph(sFlex):
        if ":s" in sMorph:
            aSugg.add(suggPlur(sFlex))
        elif ":p" in sMorph:
            aSugg.add(suggSing(sFlex))
    if aSugg:
        return "|".join(aSugg)
    return ""


def hasSimil (sWord, sPattern=None):
    return phonet.hasSimil(sWord, sPattern)


def suggSimil (sWord, sPattern=None, bSubst=False):
    "return list of words phonetically similar to sWord and whom POS is matching sPattern"

    aSugg = phonet.selectSimil(sWord, sPattern)
    for sMorph in _oSpellChecker.getMorph(sWord):
        aSugg.update(conj.getSimil(sWord, sMorph, bSubst))
        break
    if aSugg:
        return "|".join(aSugg)
    return ""


def suggCeOrCet (sWord):
    if re.match("(?i)[aeéèêiouyâîï]", sWord):
        return "cet"
    if sWord[0:1] == "h" or sWord[0:1] == "H":
        return "ce|cet"
    return "ce"


def suggLesLa (sWord):

    if any( ":p" in sMorph  for sMorph in _oSpellChecker.getMorph(sWord) ):
        return "les|la"
    return "la"


_zBinary = re.compile("^[01]+$")

def formatNumber (s):

!!
!!
!! Définitions pour les regex                                                                       
!!
!!

# REGEX
DEF: avoir          [aeo]\w*
DEF: etre           [êeésf]\w+
DEF: avoir_etre     [aeêésfo]\w*
DEF: aller          (?:ai?ll|v[ao]|ir[aio])\w*
DEF: ppas           \w[\w-]+[éiust]e?s?
DEF: infi           \w[\w-]+(?:er|ir|re)
DEF: w_1            \w[\w-]*
DEF: w_2            \w[\w-]+
DEF: w_3            \w[\w-]+\w
DEF: w_4            \w[\w-][\w-]+\w
DEF: w1             \w+
DEF: w2             \w\w+
DEF: w3             \w\w\w+
DEF: w4             \w\w\w\w+

# GRAPH
DEF: mois           [>janvier|>février|>mars|>avril|>mai|>juin|>juillet|>août|>aout|>septembre|>octobre|>novembre|>décembre|>vendémiaire|>brumaire|>frimaire|>nivôse|>pluviôse|>ventôse|>germinal|>floréal|>prairial|>messidor|>thermidor|>fructidor]
DEF: mi_mois        [>mi-janvier|>mi-février|>mi-mars|>mi-avril|>mi-mai|>mi-juin|>mi-juillet|>mi-août|>mi-aout|>mi-septembre|>mi-octobre|>mi-novembre|>mi-décembre|mi-vendémiaire|mi-brumaire|mi-frimaire|mi-nivôse|mi-pluviôse|mi-ventôse|mi-germinal|mi-floréal|mi-prairial|mi-messidor|mi-thermidor|mi-fructidor]
DEF: pronom_obj     [moi|toi|soi|lui|elle|nous|vous|eux|elles|moi-même|toi-même|soi-même|lui-même|elle-même|nous-mêmes|vous-même|vous-mêmes|eux-mêmes|elles-mêmes]


!!
!!
!!
!!
!!

# URL
__<i>(p_URL)__
    https?://[\w./?&!%=+*"'@$#-]+ <<- ~>> *
__<i](p_URL2)__
    ((?:{w_1}[.])*)({w_2})([.](?:com|net|org|info|fr|ca|be|ch|i[ot]|co[.]uk|tk|es|jp|zh|ru|us|nl|xyz)) @@0,**,$
    <<- ~1>> *
    <<- ~2>> =\2.capitalize()

    <<- ~3>> *

# Numéro de chapitre
__<i>(p_chapitre)__
    ^\d+[.][\d.-]* <<- ~>> *

# Numéro suivi de plusieurs espaces, considéré comme une numérotation de chapitre

__[i>/virg(virgule_manquante_avant_etc)__   {w_1}( etc[.])  @@$ <<- -1>> , etc.                     # Avant « etc. », il faut mettre une virgule.
__[i>/virg(virgule_manquante_avant_car)__
    ({w_1})( car)(?= (?:j[e’]|tu|ils?|nous|vous|elles?|on|les?|l[a’]|ces?|des?|cette|[mts](?:on|a|es))\b)  @@0,$
    <<- not morph(\1, ":[DR]", False) -2>> , car
    # Si « car » est la conjonction de coordination, une virgule est peut-être souhaitable.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=3447
__[i>/virg(virgule_manquante_avant_mais)__
    ({w_1})( mais)(?= (?:j[e’]|tu|ils?|nous|vous|elles?|on)\b)  @@0,$
    <<- not morph(\1, ">(?:[mtscl]es|[nv]os|quels)/", False) -2>> , mais
    # Si « mais » est la conjonction de coordination, une virgule est souhaitable si elle introduit une nouvelle proposition.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=3445
__[i>/virg(virgule_manquante_avant_donc)__
    ({w_1})( donc)(?= (?:j[e’]|tu|ils?|elles?|on)\b)  @@0,$
    <<- not morph(\1, ":V", False) -2>> , donc
    # Si « mais » est la conjonction de coordination, une virgule est souhaitable si elle introduit une nouvelle proposition.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=3448

TEST: Un chien, un chat{{ etc.}}                                            ->> , etc.

!!
!!
!!!! Redondances                                                                                    
!!
!!
__[i]/redon1(redondances_paragraphe)__
    ({w_4})[  ,.;!?:].*[  ](\1)  @@0,$
    <<- not morph(\1, ":(?:G|V0)|>(?:t(?:antôt|emps|rès)|loin|souvent|parfois|quelquefois|côte|petit|même)/", False) and not \1[0].isupper()
    -2>> _                                                      # Dans ce paragraphe, répétition de « \1 » (à gauche).
    <<- __also__ -1>> _                                         # Dans ce paragraphe, répétition de « \1 » (à droite).

TEST: __redon1__ Tu es son {{avenir}}. Et lui aussi est ton {{avenir}}.
TEST: __redon1__ Car parfois il y en a. Mais parfois il n’y en a pas.

!!
!!

__<i]/tu(tu_t_euphonique_incorrect)__
    ([-–—− ]t(?:[’' ][-–—−]?|[-–—−][’' ]?))(ils?|elles?|on|tu)  @@0,$
    <<- re.search("(?i)^(?:ils|elles|tu)$", \2) -1>> -      # Le “t” euphonique n’est pas nécessaire avec “\2”.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513
    <<- __else__ and \1 != "-t-" and \1 != "-T-" -1>> -t-   # Pour le “t” euphonique, il faut deux traits d’union. Pas d’apostrophe. Pas d’espace.
    <<- \1 != "-t-" ~1>> -t-
__<i]/tu(tu_t_euphonique_superflu)__
    [td]([- ]t[-’' ])(?:il|elle|on)  @@1
    <<- -1>> -                                              # Le “t” euphonique est superflu quand le verbe se termine par “t” ou “d”.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513
    <<- \1 != "-t-" ~1>> -t-
__<i]/tu(tu_t_euphonique_manquant)__
    [aec](-(il|elle|on))  @@1,2  <<- -1>> -t-\2             # Il faut un “t” euphonique.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?T1=t+euphonique&id=2513

TEST: va{{ t’}}il y parvenir ?                          ->> -t-
TEST: A{{ t’}}elle soif ?                               ->> -t-
TEST: A{{ t-}}elle faim ?                               ->> -t-
TEST: a{{ t'}}elle                                      ->> -t-

TEST: des {{stock options}}
TEST: Un autre chantier important, celui si sensible de la préservation des données personnelles des élèves


# est-ce … ?
__[i]/tu(tu_est_ce)__
    (?<![cCdDlL][’'])(est ce) ({w_2})  @@0,$
    <<- morphex(\2, ":", ":N.*:[me]:[si]|>qui/") and morph(word(-1), ":Cs", False, True)
    -1>> est-ce                                                                                     # S’il s’agit d’une interrogation, il manque un trait d’union.

TEST: {{est ce}} que c’est grave ?                                              ->> est-ce
TEST: qu’{{est ce}} que c’est ?                                                 ->> est-ce
TEST: elles reviendront, {{n’est ce pas}} ?
TEST: nous en sommes à l’étape où nous voulons définir ce qu’est ce projet

TEST: {{Parce-qu}}’ils y croient plus que tout.
TEST: Oui, ça{{-aussi}}.
TEST: Peu {{d’entre-nous}} savent ce dont il s’agit.


__[i]/tu(tu_y_attaché)__
    (y[’-])({avoir_etre})(?:-(?:t-|)(?:ils?|elles?|je|tu|on|nous|vous)|) @@0,2
    <<- morph(\2, ":V0|>en/", False) -1>> "y "                                                      # Ici, ni apostrophe, ni trait d’union.

TEST: {{Y’}}a trop de malheureux sur Terre.
TEST: {{Y’}}en a marre, de ces conneries.
TEST: {{y-}}a-t-il des beignets ?                     ->> "y "


__[i]/tu(tu_lorsque)__

TEST: donne{{-le-moi}} Camille.
TEST: donne-moi Alice.
TEST: Tape-toi Patrick.


__[u]/virg(virgule_après_verbe_COD)__
    l(?:es?|a) ({w_2}(?:[ei]r|re)) ([A-ZÉÂÔÈ][\w-]+)  @@w,$
    <<- morph(\1, ":Y", False) and morph(\2, ":M", False) and not morph(word(-1), ">à/", False, False)
    -1>> \1,                                                                                        # Une virgule est probablement souhaitable.

TEST: Tu vas les {{donner}} Rachel.
TEST: Il va la {{tuer}} Paul.
TEST: Cependant les promesses n’engagent que ceux qui les croient, comme aimait à le dire Jacques Chirac.

!!!! A / À: accentuation la préposition en début de phrase                                          

__<s]/typo(typo_À_début_phrase1)__
    ^ *(A) (?!t[’-](?:ils?|elles?|on))({w_2})  @@*,$
    <<- morphex(\2, ":[GNAY]", ":(?:Q|3s)|>(?:priori|post[eé]riori|contrario|capella|fortiori)/")
        or (\2 == "bientôt" and isEnd())
    -1>> À                                                                                          # S’il s’agit de la préposition « à », il faut accentuer la majuscule.
__<s>/typo(typo_À_début_phrase2)__
    ^ *(A) [ldnms]’  @@*  <<- -1>> À                                                                # S’il s’agit de la préposition « à », il faut accentuer la majuscule.
__<s>/typo(typo_À_début_phrase3)__
    ^ *(A) t’(?!il |elle |ont? )  @@*  <<- -1>> À                                                   # S’il s’agit de la préposition « à », il faut accentuer la majuscule.

!!! Désambiguïsation                                                                                
!!!
!!!

# mots grammaticaux
__[i](d_dans)__
    dans
    <<- not morph(word(-1), ":D.*:p|>[a-z]+ièmes/", False, False) =>> select(\0, ":R")

__[i](d_ton_son)__
    (\w+) ([ts]on)  @@0,$
    <<- morph(\1, ">(?:le|ce[st]?|ton|mon|son|quel(?:que|)s?|[nv]otre|un|leur|ledit|dudit)/") =>> exclude(\2, ":D")

# Pronoms le/la/les
__[i](d_je_le_la_les)__
    je (l(?:e(?:ur|s|)|a)) @@$                  <<- not morph(word(-1), ":1s", False, False) =>> select(\1, ":Oo")
__[i](d_tu_le_la_les)__
    tu (l(?:e(?:ur|s|)|a)) @@$                  <<- not morph(word(-1), ":2s", False, False) =>> select(\1, ":Oo")
__[i](d_il_elle_on_le_la_les)__

__[i](d_tu_verbe)__
    tu +(?:l(?:es? +|la +|’)|[nv]ous +|)({w_1}) @@$
    <<- morph(word(-1), ":Cs", False, True) and not morph(\1, ":(?:Oo|X)", False) =>> select(\1, ":[123][sp]")
__[s](d_nom_propre_verbe)__
    ([A-ZÉÈ]{w_1}) +({w_1})  @@0,$
    <<- morph(\1, ":M") and \2.islower() and morphex(\2, ":[123][sg]", ":Q") and morph(\2, ":N", False) and morph(word(-1), ":Cs", False, True)
    =>> select(\2, ":[123][sp]")
    <<- morph(\1, ":M", False) and morphex(\2, ":[123]s|>(?:[nmts]e|nous|vous)/", ":A") and isStart() =>> =select(\1, ":M")
__[i](d_que_combien_pourquoi_en_y_verbe)__
    (?:que?|combien|pourquoi) +(?:en +|y +|)({w_3}) @@$
    <<- =>> exclude(\1, ":E")

# groupe nominal
__[i](d_aucun_non_verbe)__
    aucun +({w_4}) @@$

# cette / cotte
__[i]/ocr(ocr_cette2)__     cotte <<- not morph(word(-1), ":D.*:f:[si]") ->> cette                  # Erreur de numérisation ?

TEST: __ocr__ on poirautait, {{cotte}} mariée n’arrivait pas à se décider.


# Comme / Gomme
__[s]/ocr(ocr_comme)__      Gomme <<- not morph(word(1), ">(?:et|o[uù])/") ->> Comme                # Erreur de numérisation ?

TEST: __ocr__ {{Gomme}} il était sage à cette époque-là !


# Comment / Gomment
__[s]/ocr(ocr_comment)__    Gomment <<- ->> Comment                                                 # Erreur de numérisation ?

# Mais / Hais / Mats / niais
__[u]/ocr(ocr_mais1)__      Hais <<- ->> Mais                                                       # Erreur de numérisation ?
__[i]/ocr(ocr_mais2)__      mats <<- not morph(word(-1), ":D:[me]:p", False, False) ->> mais        # Erreur de numérisation ?
__[i]/ocr(ocr_mais3)__      maïs <<- not morph(word(-1), ":D:(?:m:s|e:p)", False, False) ->> mais   # Erreur de numérisation ?
__[s]/ocr(ocr_mais4)__
    niais <<- not morph(word(-1), ">(?:homme|ce|quel|être)/", False, False) ->> mais                # Erreur de numérisation ?

TEST: __ocr__ {{Hais}} il en sait trop.
TEST: __ocr__ c’était bien, {{mats}} quelle journée
TEST: __ocr__ c’est bien, {{niais}} trop subtil.
TEST: __ocr__ c’est parfait, {{maïs}} trop subtil.

## Casse
__[s]/ocr(ocr_casse1)__
    [A-ZÉÈÂÊÎÔ]{w_1}
    <<- \0.istitle() and before(r"(?i)\w") >>>
    <<- morphex(\0, ":G", ":M") ->> =\0.lower()                                                     # Erreur de numérisation ? Casse improbable.
    <<- __else__ and morphex(\0, ":[123][sp]", ":[MNA]|>Est/") ->> =\0.lower()                      # Erreur de numérisation ? Casse improbable.

TEST: __ocr__ votre ami la regarde, {{Vous}} ne l’avez pas achetée
TEST: __ocr__ pour accommoder son regard, {{La}} lourde forme demeure
TEST: __ocr__ parler de Nicole, {{Le}} sommeil ne vient pas.
TEST: __ocr__ a fait de toi, Charles, {{Tu}} étais beau quand
TEST: __ocr__ s’habituer à se faire servir, {{Au}} début ça
TEST: __ocr__ Tu as tué ce petit garçon, Henri, {{Et}} tu le sais.

TEST: {{Ces}} {{cette}} canaille qui nous a donné tant de fil à retordre.
TEST: Mon {{il}} est une merveille.


__[s](incohérence_globale_au_qqch)__
    ([aA]u) ({w2})  @@0,$
    <<- not \2.isupper() >>>
    <<- morph(\2, ">(?:[cdlmst]es|[nv]os|cettes?|[mts]a|mon|je|tu|ils?|elle?|[vn]ous|on|parce)/", False)
    -2>> =suggSimil(\2, ":[NA].*:[si]", True)                                                       # Incohérence : les mots “\1” et “\2” ne devraient pas se succéder.
    <<- __else__ and morph(\2, ">quelle/", False) ->> auquel|auxquels|auxquelles                    # Incohérence. Soudez les deux mots.|https://fr.wiktionary.org/wiki/auquel
    <<- __else__ and \2 == "combien" and morph(word(1), ":[AY]", False) -1>> ô                      # Incohérence probable.|https://fr.wiktionary.org/wiki/%C3%B4_combien

TEST: au {{nos}} enfants.
TEST: {{Au quel}} faut-il s’adresser ?
TEST: Au MES, rien de nouveau.


__[s](incohérence_globale_aux_qqch)__
    ([aA]ux) ({w2})  @@0,$
    <<- not \2.isupper() >>>
    <<- morph(\2, ">(?:[cdlmst]es|[nv]os|cettes?|[mts]a|mon|je|tu|ils?|elle?|[vn]ous|on|parce)/", False)
    -2>> =suggSimil(\2, ":[NA].*:[pi]", True)                                                       # Incohérence : les mots “\1” et “\2” ne devraient pas se succéder.
    <<- __else__ and morph(\2, ">quelle/", False) ->> auxquels|auxquelles                           # Incohérence. Soudez les deux mots.|https://fr.wiktionary.org/wiki/auquel
    <<- __else__ and \2 == "combien" and morph(word(1), ":[AY]", False) -1>> ô                      # Incohérence probable.|https://fr.wiktionary.org/wiki/%C3%B4_combien

TEST: ils jouent aux {{des}}.
TEST: {{Aux quels}} a-t-il adressé sa requête. ?
TEST: Des individus {{aux}} combien sensibles aux usages.

TEST: {{En}} Avignon
TEST: {{En}} Agen


# avoir été
__[i]/bs(bs_avoir_été_chez)__
    (?<!l’)({avoir}) été chez  @@0
    <<- not re.search("(?i)^avoir$", \1) and morph(\1, ">avoir/", False)
    ->> _                                                                                           # Tournure familière. Utilisez « être allé ».

TEST: J’{{ai été chez}} le coiffeur.
TEST: Chez les intellectuels, le mot utopie n’a jamais été synonyme de folie, mais il l’a été pour l’homme de la rue.


# abyme / abîme
__[i]/bs(bs_mise_en_abyme)__
    mis\w+ en (ab[îi]mes?) @@$ <<- -1>> abyme
    # Classiquement, on écrit plutôt « abyme » dans cette expression.|https://fr.wiktionary.org/wiki/mise_en_abyme

TEST: La mise en {{abîme}}.


# à date / jusqu’à date
__[i]/bs(bs_à_date)__
    ({etre}|m\w+) ([aà] date)  @@0,$  <<- morph(\1, ">(?:être|mettre)/", False) -2>> à jour         # Anglicisme incompris hors du Québec.
__[i]/bs(bs_jusquà_date)__
    jusqu [àa] date <<- ->> jusqu’ici|jusqu’à maintenant|jusqu’à ce jour|à ce jour                  # Anglicisme incompris hors du Québec.

TEST: être {{à date}}
TEST: mettre {{a date}}
TEST: {{jusqu’à date}}

!!
!!
!!!! Pléonasmes                                                                                     
!!
!!

__[i]/pleo(pleo_abolir)__               (abol\w+) (?:absolument|entièrement|compl[èé]tement|totalement) @@0 <<- morph(\1, ">abolir/", False) ->> \1         # Pléonasme.
__[i]/pleo(pleo_acculer)__              (accul\w+) aux? pieds? du mur @@0 <<- morph(\1, ">acculer/", False) ->> \1                                          # Pléonasme.
__[i]/pleo(pleo_achever)__              (ach[eè]v\w+) (?:absolument|entièrement|compl[èé]tement|totalement) @@0 <<- morph(\1, ">achever/", False) ->> \1    # Pléonasme.
__[i]/pleo(pleo_en_cours)__             actuellement en cours <<- not after(r" +de?\b") ->> en cours                                            # Pléonasme.
__[i]/pleo(pleo_en_train_de)__          (actuellement en train) d(?:e(?! nuit)|’{w_2}) @@0 <<- -1>> en train                                    # Pléonasme.
__[i]/pleo(pleo_ajouter)__              (ajout\w+) en plus @@0 <<- ->> \1                                                                       # Pléonasme.
__[i]/pleo(pleo_apanage)__              (apanages?) exclusifs? @@0 <<- ->> \1                                                                   # Pléonasme.
__[i]/pleo(pleo_applaudir)__            (applaudi\w+) des deux mains @@0 <<- ->> \1                                                             # Pléonasme.
__[i]/pleo(pleo_aujourd_hui)__          au jour d’aujourd’hui <<- ->> aujourd’hui                                                               # Pléonasme.
__[i]/pleo(pleo_avancer)__              (avan[cç]\w+) en avant @@0 <<- morph(\1, ">avancer/", False) ->> \1                                     # Pléonasme.
__[i]/pleo(pleo_s_avérer)__             s’av([éè]r\w+) vrai(e?s?) @@4,$ <<- ->> s’av\1 exact\2                                                  # Pléonasme.
__[i]/pleo(pleo_avéré)__                (avérée?s?) vraie?s? @@0 <<- ->> \1                                                                     # Pléonasme.
__[i]/pleo(pleo_avenir)__               avenir devant (?:lui|[mts]oi|eux|[nv]ous) <<- morph(word(-1), ":A|>un", False) ->> avenir               # Pléonasme.
__[i]/pleo(pleo_bourrasque)__           (bourrasques?) de vent @@0 <<- ->> \1                                                                   # Pléonasme.
__[i]/pleo(pleo_car_en_effet)__         car en effet <<- ->> car|en effet                                                                       # Pléonasme.
__[i]/pleo(pleo_cirrhose)__             (cirrhoses?) du foie @@0 <<- ->> \1                                                                     # Pléonasme.
__[i]/pleo(pleo_collaborer)__           (collabor\w+) ensemble @@0 <<- morph(\1, ">collaborer/", False) ->> \1                                  # Pléonasme.
__[i]/pleo(pleo_comme_par_exemple)__    comme par exemple <<- ->> comme|par exemple                                                             # Pléonasme.
__[i]/pleo(pleo_comparer)__             (compar\w+) entre (?:eux|elles) @@0 <<- morph(\1, ">comparer/", False) ->> \1                           # Pléonasme.
__[i]/pleo(pleo_contraindre)__          (contrai\w+) malgré (?:soi|eux|lui|moi|elle|toi) @@0 <<- morph(\1, ">contraindre/", False) ->> \1       # Pléonasme.
__[i]/pleo(pleo_descendre)__            (descend\w+) en bas(?! de) @@0 <<- ->> \1                                                               # Pléonasme.
__[i]/pleo(pleo_dessiner)__             (dessin\w+) un dessin @@0 <<- ->> \1                                                                    # Pléonasme.
__[i]/pleo(pleo_dorénavant)__           à (?:partir|compter) de dorénavant <<- ->> dorénavant|à partir de maintenant                            # Pléonasme.
__[i]/pleo(pleo_donc_par_conséquent)__  donc par conséquent <<- ->> donc|par conséquent|c’est pourquoi                                          # Pléonasme.
__[i]/pleo(pleo_enchevêtrer)__          (enchevêtr\w+) les uns dans les autres @@0 <<- morph(\1, ">enchevêtrer/", False) ->> \1                 # Pléonasme.
__[i]/pleo(pleo_entraider)__            (entraid\w+) (?:mutuellement|les uns les autres) @@0 <<- morph(\1, ">entraider/", False) ->> \1         # Pléonasme.
__[i]/pleo(pleo_entraide)__             (entraides?) mutuelles? @@0 <<- ->> \1                                                                  # Pléonasme.
__[i]/pleo(pleo_erreur)__               (erreurs?) involontaires? @@0 <<- ->> \1                                                                # Pléonasme.
__[i]/pleo(pleo_étape)__                (étapes?) intermédiaires? @@0 <<- ->> \1                                                                # Pléonasme.
__[i]/pleo(pleo_hasard)__               (hasards?) imprévus? @@0 <<- ->> \1                                                                     # Pléonasme.
__[i]/pleo(pleo_hémorragie)__           (hémorragies?) de sang @@0 <<- ->> \1                                                                   # Pléonasme.
__[i]/pleo(pleo_joindre)__              (join\w+) ensemble @@0 <<- morph(\1, ">joindre/") ->> \1|mettre ensemble                                # Pléonasme.
__[i]/pleo(pleo_lever)__                lever debout <<- ->> lever                                                                              # Pléonasme.
__[i]/pleo(pleo_mais_qqch)__            mais (cependant|pourtant|toutefois) @@5 <<- ->> mais|cependant|pourtant|toutefois                       # Pléonasme.
__[i]/pleo(pleo_marche)__               (marches?) à pieds? @@0 <<- ->> \1                                                                      # Pléonasme.
__[i]/pleo(pleo_méandre)__              (méandres?) sinueux @@0 <<- ->> \1                                                                      # Pléonasme.
__[i]/pleo(pleo_media)__                (m[eé]dias?) d’informations? @@0 <<- ->> \1                                                             # Pléonasme.
__[i]/pleo(pleo_monopole)__             (monopoles?) exclusifs? @@0 <<- ->> \1                                                                  # Pléonasme.
__[i]/pleo(pleo_monter)__               (mont\w+) en haut(?! d[eu’]) @@0 <<- morph(\1, ">monter/", False) ->> \1                                # Pléonasme.
__[i]/pleo(pleo_opportunité)__          (opportunités?) à saisir @@0 <<- ->> \1                                                                 # Pléonasme.
__[i]/pleo(pleo_orage)__                (orages?) électriques? @@0 <<- ->> \1                                                                   # Pléonasme.
__[i]/pleo(pleo_jumelles)__             paires? de jumelles? <<- ->> jumelles                                                                   # Pléonasme.
__[i]/pleo(pleo_panacée)__              (panacées?) universelles? @@0 <<- ->> \1|remède universel                                               # Pléonasme.
__[i]/pleo(pleo_perspective)__          (perspectives?) d’avenir @@0 <<- ->> \1                                                                 # Pléonasme.
__[i]/pleo(pleo_balbutiement)__         premiers? (balbutiements?) @@$ <<- ->> \1                                                               # Pléonasme.
__[i]/pleo(pleo_priorité)__             premières? (priorités?) @@$ <<- ->> \1                                                                  # Pléonasme.
__[i]/pleo(pleo_projet1)__              (projets?) futurs? @@0 <<- ->> \1                                                                       # Pléonasme.
__[i]/pleo(pleo_projet2)__              futurs? (projets?) @@$ <<- ->> \1                                                                       # Pléonasme.
__[i]/pleo(pleo_prototype)__            (prototypes?) expérimenta(?:l|ux) @@0 <<- ->> \1                                                        # Pléonasme.
__[i]/pleo(pleo_rénover)__              (rénov\w+) à neuf @@0 <<- morph(\1, ">rénov(?:er|ation)/", False) ->> \1                                # Pléonasme.
__[i]/pleo(pleo_puis_qqch)__            puis (?:après|ensuite|alors) <<- ->> puis|après|ensuite|alors                                           # Pléonasme.
__[i]/pleo(pleo_réunir)__               (réuni\w*) ensemble @@0 <<- morph(\1, ">réunir/", False) ->> \1                                         # Pléonasme.
__[i]/pleo(pleo_reculer)__              (recul\w*) en arrière @@0 <<- morph(\1, ">recul(?:er|)/", False) ->> \1                                 # Pléonasme.
__[i]/pleo(pleo_risque)__               (risques?) (?:potentiels?|de menaces?) @@0 <<- ->> \1                                                   # Pléonasme.
__[i]/pleo(pleo_secousse)__             (secousses?) sé?ismiques? @@0 <<- ->> secousse tellurique|secousses telluriques|tremblement de terre    # Pléonasme.
__[i]/pleo(pleo_solidaire)__            (solidaires?) les uns des autres @@0 <<- ->> \1                                                         # Pléonasme.
__[i]/pleo(pleo_suffire)__              (suffi\w+) simplement @@0 <<- morph(\1, ">suffire/", False) ->> \1                                      # Pléonasme.
__[i]/pleo(pleo_talonner)__             (talonn\w+) de près @@0 <<- morph(\1, ">talonner/", False) ->> \1                                       # Pléonasme.
__[i]/pleo(pleo_taux_alcoolémie)__      taux d’alcoolémies? @@7 <<- ->> taux d’alcool|alcoolémie                                                # Pléonasme. L’alcoolémie est le taux d’alcool dans le sang.
__[i]/pleo(pleo_tunnel)__               (tunnels?) souterrains? @@0 <<- ->> \1                                                                  # Pléonasme.
__[i]/pleo(pleo_hardes)__               vieilles hardes <<- ->> hardes                                                                          # Pléonasme.
__[i]/pleo(pleo_voire_même)__           voire même <<- ->> voire|même                                                                           # Pléonasme.|https://fr.wiktionary.org/wiki/voire_m%C3%AAme

TEST: il faut {{abolir totalement}} ces pratiques   ->> abolir
TEST: il faut {{achever complètement}} ce projet    ->> achever

TEST: {{vieilles hardes}}                           ->> hardes
TEST: {{voire même}}                                ->> voire|même


# d’avance / à l’avance
__[i]/pleo(pleo_verbe_à_l_avance)__
    ((?:pré[pvds]|pressen|pronostiqu|réserv|dev(?:an[cç]|in)|avert)\w+) (?:d’avance|à l’avance)  @@0
    <<- morph(\1, ">(?:prévenir|prévoir|prédire|présager|préparer|pressentir|pronostiquer|avertir|devancer|deviner|réserver)/", False)
    ->> \1                                                                                                              # Pléonasme.

TEST: {{prédire à l’avance}}                  ->> prédire
TEST: {{pronostiquer d’avance}}               ->> pronostiquer
TEST: {{réserver d’avance}}                         ->> réserver


# plus tard / à une date ultérieure
__[i]/pleo(pleo_différer_ajourner_reporter)__
    ((?:diff|ajourn|report)\w+) à (?:plus tard|date ultérieure|une date ultérieure)  @@0
    <<- morph(\1, ">(?:ajourner|différer|reporter)/", False)
    ->> \1                                                                                                              # Pléonasme.

TEST: {{Ajourner à une date ultérieure}}      ->> Ajourner
TEST: {{différer à une date ultérieure}}      ->> différer
TEST: {{reporter à plus tard}}                ->> reporter

TEST: d’une {{habille}} femme
TEST: plus d’un ont été traumatisés
TEST: plus d’une sont parties aussi vite qu’elles étaient venues


__[i]/conf(conf_il_on_pas_verbe)__
    (?<!t’)(?:il|on) (?:l’|l(?:es?|a|eur|ui) +|[nv]ous +|)({w_2}) @@$
    <<- morphex(\1, ":", ":(?:[123][sp]|O[onw]|X)|>ou/") and morphex(word(-1), ":", ":3s", True)
    -1>> =suggSimil(\1, ":(?:3s|Oo)", False)                                                        # Incohérence : « \1 » devrait être un verbe, un pronom objet, un adverbe de négation, etc.

TEST: il {{et}} parti.


__[i]/conf(conf_ils_pas_verbe)__
    (?<!t’)ils (?:l’|l(?:es?|a|eur|ui) +|[nv]ous +|)({w_2}) @@$
    <<- morphex(\1, ":", ":(?:[123][sp]|O[onw]|X)|>ou/") and morphex(word(-1), ":", ":3p", True)
    -1>> =suggSimil(\1, ":(?:3p|Oo)", False)                                                        # Incohérence avec « ils » : « \1 » devrait être un verbe, un pronom objet, un adverbe de négation, etc.

TEST: ils {{son}} du même bois.
TEST: Ils {{étai}} partie au {{restaurent}}


__[i]/conf(conf_je_pas_verbe)__

#    <<- morph(\1, ":W", False) and morphex(\2, ":[123][sp]", ":[GAQW]") -2>> _
#    # Incohérence avec « très » : « \2 » n’est ni un adjectif, ni un participe passé, ni un adverbe.

 
__[i]/conf(conf_très_verbe)__
    très +(?!envie)({w_2})  @@$
    <<- morphex(\1, ":(?:Y|[123][sp])", ":[AQW]") -1>> =suggSimil(\1, ":[AW]", True)                # Incohérence avec « très » : « \1 » n’est ni un adjectif, ni un participe passé, ni un adverbe.
    <<- morph(\1, ">jeûne/", False) -1>> =\1.replace("û", "u")                                      # Confusion. Le jeûne est une privation de nourriture.|https://fr.wiktionary.org/wiki/jeune

TEST: Il est très {{cite}}.
TEST: très {{suivit}} par ce détective
TEST: il était très {{habille}}
TEST: Très {{jeûne}}, elle a su qu’elle ne voulait pas d’une vie ordinaire.

TEST: Ces gens sont si {{prit}} par leur travail qu’ils en oublient de vivre.
TEST: Ça ira mieux demain, surtout si émerge une demande forte de la part des consommateurs.


__[i]/conf(conf_de_plus_en_plus_verbe)__
    de plus en plus +({w_2})  @@$
    <<- morphex(\1, ":(?:[123][sp]|Y)", ":(?:[GAQW]|3p)") and not morph(word(-1), ":V[123].*:[123][sp]|>(?:pouvoir|vouloir|falloir)/", False, False)
    -1>> =suggVerbPpas(@)
    # Incohérence avec « de plus en plus » : « \1 » n’est ni un adjectif, ni un participe passé, ni un adverbe.

TEST: de plus en plus {{gagnait}} par la folie.
TEST: de plus en plus {{concerner}} par ce problème
TEST: avec quel zèle ils remplissent leurs devoirs de citoyens (de plus en plus deviennent enseignant·e·s, infirmier·e·s ou s’engagent dans l’armée, etc.).
TEST: il faut de plus en plus aider ces gens.

__[i]/conf(conf_a_à_tout_à_coup)__  tout h?ah? co[uû][pt]?                                          <<- ->> tout à coup # Confusion.
__[i]/conf(conf_a_à_coup_sûr)__     a coup s[uû]r                                                   <<- ->> à coup sûr  # Confusion.
__[i]/conf(conf_a_à_face_à)__       face (a) @@5    <<- not before(r"(?i)\b(?:[lmts]a|leur|une|en) +$") -1>> à          # Confusion.
__[i]/conf(conf_a_à_pas_à_pas)__    pas (a) pas @@4                                                 <<- -1>> à          # Confusion.
__[i]/conf(conf_a_à_par_rapport)__  par rapport (a) ({w_2}) @@12,$  <<- morph(\2, ":(?:D|Oo|M)", False) -1>> à          # Confusion.
__[i]/conf(conf_a_à_être_à)__
    ({etre}) (a)(?! priori| posteriori| fortiori)  @@0,$
    <<- morph(\1, ">être/:V") and not before(r"(?i)\bce que? ") -2>> à                                # Confusion. Utilisez la préposition « à ».
__[i]/conf(conf_a_à_peu_près)__
    (?:a peu[tx]? (?:près|prés?|prêts?)|à peu[tx] (?:près|prés?|prêts?)|à peu (?:prés?|prêts?))
    <<- ->> à peu près                                                                              # Confusion.
    <<- ~>> *
__[i]/conf(conf_a_à_pronoms1)__     ne +l(?:es?|a) +(?:l(?:eur|ui) +|)(à)  @@$  <<- -1>> a          # Confusion : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_pronoms2)__     ne +[nv]ous +(?:les +|l’|)(à)  @@$          <<- -1>> a          # Confusion : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_pronoms3)!6__   [mtsn]e l(?:es +|’)(à)  @@$                 <<- -1>> a          # Confusion : “à” est une préposition. Pour le verbe avoir, écrivez :

    <<- re.search("(?i)^(?:côtés?|coups?|peu-près|pics?|propos|valoir|plat-ventrismes?)", \2)
    ->> l’à-\2                                                                                      # Il faut un trait d’union.
__[i]/conf(conf_a_à_il_on_à)__
    (?:il|on) +(?:l(?:es +|’)|en +|y +(?:en +|)|[vn]ous +|)(à)  @@$
    <<- not morph(word(-1), ":3s", False, False) -1>> a                                             # Confusion probable : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_elle_à)__
    elle +(?:l(?:es +|’)|en +|y +(?:en |)|[vn]ous +|)(à)  @@$
    <<- not morph(word(-1), ":(?:3s|R)", False, False) and not morph(word(1), ":Oo|>qui/", False, False)
    -1>> a                                                                                          # Confusion probable : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_qui_pronom_à)__
    qui (?:l(?:ui|eur)(?: en|)|nous|vous|en|y) +(à)  @@$ <<- -1>> a                                 # Confusion : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_qui_a)__
    qui (à) +({w_2})  @@4,$  <<- morphex(\2, ":Q", ":M[12P]") -1>> a                                # Confusion : “à” est une préposition. Pour le verbe avoir, écrivez :
__[i]/conf(conf_a_à_le)__
    (à le) ({w_2})  @@0,5

TEST: Ceux {{a}} qui nous avons notifié le problème sont partis.
TEST: Il y a qui au dîner ce soir ?


__[i]/conf(conf_mener_à_bien)__
    (m[eèé]n\w+) (a) bien  @@0,w
    <<- morph(\1, ">mener/", False) and ( not before(r"\bque? ") or morph(word(-1), ">(?:falloir|aller|pouvoir)/", False, True) )
    -2>> à                  # Confusion probable. Dans cette locution, utilisez la préposition « à ».|https://fr.wiktionary.org/wiki/mener_%C3%A0_bien
    <<- __also__ ~>> \1

TEST: Mener {{a}} bien cette guerre sera plus difficile qu’on le pense.
TEST: Je peux mener {{a}} bien cette opération.
TEST: Cette coalition que tu penses mener a bien l’intention de te trahir.


__[i]/conf(conf_mettre_à_profit)__
    (m(?:i[st]|ett)\w*).* (a) profit  @@0,w
    <<- morph(\1, ">mettre/", False) -2>> à     # Confusion probable. Dans « mettre à profit », utilisez la préposition « à ».|https://fr.wiktionary.org/wiki/mettre_%C3%A0_profit

TEST: Mettre {{a}} profit ses compétences
TEST: Il a mis son talent {{a}} profit.


__[s]/conf(conf_m_a_tuer)__
    m’a +(tuer) @@$

# ça / çà / sa
__[i]/conf(conf_ça_sa)__
    (ça) ({w_2}) @@0,3 <<- morph(\2, ":[NAQ].*:f") and not re.search("^seule?s?", \2) -1>> sa       # Confusion : “sa” (sa maison, sa passion) ≠ “ça” (ça vient, ça heurte).
__[i]/conf(conf_sa_ça1)__
    (sa) +({w_2}) @@0,$
    <<- morphex(\2, ":G", ">(?:tr(?:ès|op)|peu|bien|plus|moins|toute)/|:[NAQ].*:f") -1>> ça         # Confusion : “sa” (sa maison, sa passion) ≠ “ça” (ça vient, ça heurte).
__[i>/conf(conf_sa_ça2)__       (sa) +(?:[dnmtsjl]’|lorsqu |qu |puisqu )  @@0 <<- -1>> ça           # Confusion : “sa” (sa maison, sa passion) ≠ “ça” (ça vient, ça heurte).
__[i]/conf(conf_çà_ça)__        çà(?! et là) <<- not before(r"\b(?:[oO]h|[aA]h) +$") ->> ça         # Confusion : « çà » ne s’emploie plus guère que dans l’expression « çà et là ».
__[i]/conf(conf_çà_et_là)__     ça et là <<- not morph(word(-1), ":R") ->> çà et là                 # Confusion : « ça » équivaut à « cela ». Dans l’expression « çà et là », « çà » équivaut à « ici ».
__[s]/conf(conf_sa_fin)__       (sa) *$  @@0  <<- -1>> ça                           # Confusion probable : “sa” est un déterminant féminin singulier. Pour l’équivalent de “cela” ou “ceci”, écrivez :

TEST: Je prends {{sa}}…
TEST: {{ça}} patrie, il la détestait

TEST: sa toute nouvelle application de synchronisation de fichiers


# ce / se / ceux
__[s]/conf(conf_se_verbe)__
    ([cC]e) ({w_2})  @@0,3
    <<- \2[0].islower() and \2 != "faire"
        and ( morphex(\2, ":V[123].*:(?:Y|[123][sp])", ":[NAGM]|>(?:devoir|pouvoir|sembler)/") or re.search("-(?:ils?|elles?|on)$", \2) )
    -1>> se                                                                 # Confusion : « \2 » est un verbe. Exemples : ce bâtiment, se perdre.
__[i]/conf(conf_pour_ce_faire)__
    pour (se) faire,? ({w_2})  @@5,$
    <<- (\0.find(",") >= 0 or morphex(\2, ":G", ":[AYD]"))
    -1>> ce                                                                 # Confusion probable. Dans cette locution, il faut employer “ce”.|http://fr.wiktionary.org/wiki/pour_ce_faire
__[i]/conf(conf_ne_se1)!6__
    ne (ce) @@3 <<- -1>> se                                                 # Confusion. Ce chien, ce chat… Se demander, se croire…
__[i>/conf(conf_ne_se2)__
    ne ([cç]’) @@3 <<- -1>> s’                                              # Confusion. Ce chien, ce chat… Se demander, se croire…
__[i]/conf(conf_ce_conj_prep)__
    (se) (?:qu[ei]?|dont|malgré|pourquoi|avec|pour|par) @@0 <<- -1>> ce     # Confusion. Exemples : ce bâtiment, se perdre.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=2440
__[i]/conf(conf_qui_se_verbe)__
    qui (ce) ({w_2})  @@4,$
    <<- morphex(\2, ":V", ":[NAQ].*:[me]") or before(r"(?i)\b[cs]e +$")
    -1>> se                                                                 # Confusion probable. Exemples : ce bâtiment, se perdre.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=2440
__[i]/conf(conf_ceux_ce_être)__
    (ceux) (?:ne |)(?:sont|serai(?:en|)[ts]?|f[uû](?:ren|)t|n’(?!ayant|étant)\w+) @@0
    <<- -1>> ce                                                             # Confusion.|http://www.intellego.fr/soutien-scolaire-6eme/aide-scolaire-francais/ce-ceux-ou-se/3829
__[s]/conf(conf_ce_ne_être_doit)__
    ([sS]e) n(?:e |’)({être}|d[eouû]\w+|p[oeuû]\w+)  @@0,$
    <<- morph(\2, ">(?:être|pouvoir|devoir)/.*:3s", False)
    -1>> ce                                                                 # Confusion probable.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=2440
__[i]/conf(conf_ce_ne)__
    (ceux) ne ({w_2}) @@0,$
    <<- morphex(\2, ":[123]s", ":P") -1>> ce                                # Confusion.|http://www.intellego.fr/soutien-scolaire-6eme/aide-scolaire-francais/ce-ceux-ou-se/3829
__[i]/conf(conf_ce_nom1)__
    (se) ({w1}) @@0,3
    <<- morphex(\2, ":[NAQ]", ":([123][sp]|Y|P|Q)|>l[ea]?/") -1>> ce        # Confusion. Ce chien, ce chat… Se demander, se croire…
__[i]/conf(conf_ce_nom2)__
    (ceux) (?!l[aà] |qu[ie]? )({w_2}) @@0,$
    <<- morphex(\2, ":N.*:s", ":(?:A.*:[pi]|P|R)|>autour/") -1>> ce         # Confusion probable.|http://www.intellego.fr/soutien-scolaire-6eme/aide-scolaire-francais/ce-ceux-ou-se/3829

TEST: il ne {{ce}} compte pas parmi eux
TEST: il ne {{ç’}}avançait jamais sans avoir pesé toutes les conséquences
TEST: {{Se}} seraient des histoires.
TEST: {{se}} seraient des jours heureux.
TEST: {{Se}} sont de grands enfants.
TEST: {{Se}} sera une fille.

    ([scSC]es) [ld]’(?![A-Z])  @@0
    <<- -1>> c’est                                                                          # Confusion. Écrivez « c’est » pour dire « ceci est… ».
__[s]/conf(conf_c_est3)__
    ([scSC]es) (?:qu(?:lle|el?|)|comme|ce(?:t|tte|)|[nv]os|les?|eux|elles)  @@0
    <<- -1>> c’est                                                                          # Confusion probable. Écrivez « c’est » pour dire « ceci est… ».
__[s]/conf(conf_c_est4)__
    ([scSC]es) ({w_1}) ({w_1}) @@0,w,$
    <<- morph(\2, ":[WX]", ":N:.*:[pi]") and morph(\3, ":[RD]|>pire/", False) -1>> c’est           # Confusion probable. Écrivez « c’est » pour dire « ceci est… ».
__[i]/conf(conf_ces_ses)__
    (c’est) ({w_2})  @@0,6 <<- morphex(\2, ":N.*:p", ":(?:G|W|M|A.*:[si])") -1>> ces|ses    # Confusion. Exemples : c’est facile ; ces chats (désignation) ; ses chats (possession)…

TEST: {{ses}} au-dessus de ses forces.
TEST: {{ces}} comme la peste
TEST: car {{ses}} d’avance perdu
TEST: {{ces}} qu’il y a tant de pertes

    loin du (co[mn]te)  @@$
    <<- -1>> compte                                                             # Confusion. Locution “loin du compte”.|https://fr.wiktionary.org/wiki/loin_du_compte
__[i]/conf(règlement_de_comptes)__
    r[éè]glements? de (co[mn]tes?)  @@$
    <<- -1>> comptes                                                            # Confusion.|https://fr.wiktionary.org/wiki/r%C3%A8glement_de_comptes
__[i]/conf(régler_son_compte)__
    (r[éè]gl\w+) +(?:[mts]on|leurs?|[vn]otre) (co[mn]tes?)  @@0,$
    <<- morph(\1, ">régler/", False) -2>> compte                                # Confusion. Un conte est un récit fictif, “comte” est un titre de noblesse. Pour un état chiffré, un calcul… écrivez :|https://fr.wiktionary.org/wiki/r%C3%A9gler_son_compte
__[i]/conf(conf_tout_compte_fait)__
    tout (co[mn]te) fait  @@w
    <<- -1>> compte                                                             # Confusion. Locution “tout compte fait”.|https://fr.wiktionary.org/wiki/tout_compte_fait

TEST: il s’en est tiré à bon {{conte}}.
TEST: à ce {{conte}}-là, il ne va pas faire long feu.
TEST: mon {{comte}} bancaire est encore à sec.

    (?:peu|plein|beaucoup|trop|plus|moins|assez|suffisamment|tellement|obtentions?|régimes?) (davantage)  @@$
    <<- -1>> d’avantages                                                            # Confusion probable : “davantage” signifie “plus” ; un “avantage” signifie “faveur”, “bénéfice”, “profit”…
__[i]/conf(conf_être_davantage_ppas)__
    ({etre}) (d’avantages?) ({w_2}) @@0,w,$
    <<- morph(\1, ":V0e", False) and morphex(\3, ":[NAQ]", ":G") -2>> davantage     # Confusion possible : “davantage” signifie “plus” ; un “avantage” signifie “faveur”, “bénéfice”, “profit”…
__[i]/conf(conf_davantage1)__
    ({w1}) (d’avantages?) @@0,$
    <<- morphex(\1, ":V", ":Q|>(?:profiter|bénéficier|nombre)/") and not morph(word(1), ">(?:financi[eè]re?|pécuni(?:er|aire)|sociaux)s?/", False, False)
    -2>> davantage                                                                  # Confusion probable : “davantage” signifie “plus” ; un “avantage” signifie “faveur”, “bénéfice”, “profit”…
__[i]/conf(conf_davantage2)__
    ({w_1})-(?:je|tu|ils?|elles?|[nv]ous|on) +(d’avantages?) @@0,$
    <<- not morph(\1, ">(?:profiter|bénéficier)/", False) and not morph(word(1), ">(?:financi[eè]re?|pécuni(?:er|aire)|sociaux)s?/", False, False)
    -2>> davantage                                                                  # Confusion probable : “davantage” signifie “plus” ; un “avantage” signifie “faveur”, “bénéfice”, “profit”…
__[i>/conf(conf_davantage3)__
    (d’avantages?) d(?:e +|’) @@0
    <<- -1>> davantage                                                              # Confusion possible : “davantage” signifie “plus” ; un “avantage” signifie “faveur”, “bénéfice”, “profit”…

TEST: ils ont peu {{davantage}} à vivre ici.
TEST: Ils s’exerceront {{d’avantages}}.

TEST: et bien manger, c’est important.
TEST: il a été vaincu, et bien vaincu.


# faut / faux
__[i]/conf(conf_faux)__
    faut
    <<- not morph(word(-1), ">(?:ils?|ne|en|y|leur|lui|nous|vous|[mtsl]e|la|les)/", False, True) and morphex(word(1), ":",  ":(?:Y|Oo|X|M)", True)
    ->> faux                                                # Confusion probable : “faut” est une conjugaison de “falloir”. Pour indiquer la fausseté d’une chose, écrivez :

TEST: un homme {{faut}}
TEST: c’est {{faut}}
TEST: il m’en faut plus.
TEST: il faut réussir.
TEST: bien sûr, faut y arriver.

__[i]/conf(conf_flanc)__
    (flans?) (?:des? (?:la |)(?:colline|montagne)s?|gauches?|droites?|nord|sud|ouest)  @@0
    <<- -1>> =\0.replace("an", "anc").replace("AN", "ANC")                                          # Confusion probable. Le flan est une pâtisserie.|https://fr.wiktionary.org/wiki/flanc
__[i]/conf(conf_sur_le_flanc)__
    ((?:attaqu|allong|bless|couch|étend|touch)\w+) +sur (?:les?|[mts](?:on|es)|[nv]o(?:tre|s)) (flans?)  @@0,$
    <<- morph(\1, ">(?:attaquer|allonger|blesser|coucher|étendre|toucher)/", False)
    -2>> =\0.replace("an", "anc").replace("AN", "ANC")                                              # Confusion probable. Le flan est une pâtisserie.|https://fr.wiktionary.org/wiki/flanc
__[i]/conf(conf_tirer_au_flanc)__
    (tir\w*)[ -]+aux?[ -](flans?)  @@0,$
    <<- morph(\1, ">tir(?:er|)/", False) -2>> =\0.replace("an", "anc").replace("AN", "ANC")         # Confusion. Le flan est une pâtisserie.|https://fr.wiktionary.org/wiki/flanc

TEST: attaqué sur son {{flan}} droit
TEST: elle possède une maison à {{flan}} de colline.
TEST: étendu sur son {{flan}}.
TEST: Ce sale tir-au-{{flan}} le paiera cher.
TEST: le flan est une pâtisserie.
TEST: versez du caramel sur le flan.

TEST: Le peuple se sent hors jeu.


# la / là
__[s]/conf(conf_la_là)__
    ([lL]a) (?:a(?:fin|lors|près|uprès|ux?|vant|vec)|au(?:-de(?:dans|hors|là|sso?us|vant)|x|)|c(?:e(?:t|te|s|)|ar|hez|omme)|ça|d(?:ans|evant|es?|ès|onc|urant|’{w_1})|e(?:lles?|n|t)|ils?|je?|l(?:es?|a|orsque?|’{w_1})|m(?:algré|es|on|a|e)|n(?:e|ous)|o[uùn]|par(?:ce|fois|mi|)|p(?:arce|endant|our|uisque)|qu(?:e?|and)|s(?:on|a|es?|ouvent|ur)|t(?:andis|on|a|es?|u)|un|vous)
    @@0
    <<- not morph(word(-1), ":E|>le/", False, False)
    -1>> là                                                                                         # Confusion probable. Écrivez “là” si vous voulez dire “ici”.

TEST: nous serions encore {{la}} l’année prochaine
TEST: en reprenant le chandail de John {{la}} où elle l’avait abandonné.
TEST: Qui serait la ou le plus à même à occuper ce poste selon vous ?

TEST: je {{leurs}} apprends la programmation
TEST: après qu’un des leurs ait été gravement blessé par un tir de grenade


# loin s’en faut
__[i]/conf(conf_loin_s_en_faut)__
    loins? +(?:[sc]ens|san[gs]?s?|s[’ ]en) +fau[xt]
    <<- not re.search("(?i)loin s’en faut", \0) and morph(word(-1), ":N", ">(?:aller|venir|partir)/", True)
    ->> loin s’en faut                                                                              # Confusion probable. Cette locution s’écrit :|https://fr.wiktionary.org/wiki/loin_s%E2%80%99en_faut

TEST: Ils n’étaient guère prêts à ça, {{loins sans faux}}.
TEST: Et les intellectuels ? En France comme ailleurs, tous n’ont pas, loin s’en faut, une pleine lucidité sur cette précarité galopante.


# mai / mais

TEST: la {{plus part}}


# par-dessus / pardessus
__[i]/conf(conf_par_dessus)__
    (pardessus) +({w1})  @@0,$
    <<- morph(\2, ":D|>bord/", False) and not morph(word(-1), ":D.*:[me]|>(?:grande|petite)/", False, False)
    -1>> par-dessus                                                                                 # Confusion probable. Un pardessus est un vêtement. Pour la préposition, écrivez :

TEST: {{Pardessus}} les montagnes.
TEST: Il passa {{pardessus}} les collines.
TEST: Mets ton pardessus ce matin.


# pot aux roses / poteau rose
__[i]/conf(conf_pot_aux_roses)__
    poteau rose <<- ->> pot aux roses
    # Confusion probable. On dit : « découvrir le pot aux roses ».|http://fr.wiktionary.org/wiki/d%C3%A9couvrir_le_pot_aux_roses

TEST: Ils ont découvert le {{poteau rose}}.


# prêt / près / pré
__[i]/conf(conf_prêt_à)__
    (près) à ({w_2})  @@0,$
    <<- not before("(?i)(?:peu|de|au plus) $") and morph(\2, ":Y|>(?:tout|les?|la)/") -1>> prêt|prêts       # Confusion. Être près de (faire) quelque chose. Prêt à faire quelque chose.
__[i]/conf(conf_près_de)__
    (prêts?) d(?:e +|’)({w_1}) @@0,$
    <<- morph(\2, ":(?:Y|M[12P])|>(?:en|y|les?)/", False) -1>> près                                 # Confusion. Être près de (faire) quelque chose. Prêt à faire quelque chose.
__[i]/conf(conf_près)__         de(?: plus|puis) (prêts?)  @@$ <<- -1>> près                        # Confusion. Être prêt(e) à faire quelque chose. Être près de quelque chose.
__[i]/conf(conf_très_près)__    très (pr(?:êt|é)s?) @@$ <<- -1>> près                               # Confusion probable. Pour évoquer la proximité, utilisez :

TEST: ils se sont approchés très {{prêts}}.
TEST: Je suis si {{prêt}} d’y arriver.
TEST: Il est {{près}} à les aider
TEST: Elle va regarder ça de plus {{prêt}}.


# quand / quant / qu’en
__[i]/conf(conf_quant_à)__
    (?<![dD]e )(quand) (?:à|aux?)  @@0
    <<- not morph(word(-1), ">(?:arriver|venir|à|revenir|partir|aller)/")
        and not(\0.endswith("à") and after("^ +[mts]on tour[, ]")) -1>> quant                           # Confusion probable. Quand = à quel moment. Quant à = à propos de.
__[i]/conf(conf_quand1)__   quant(?! à| aux?| est[ -]il d(?:es?|u) ) <<- ->> quand                  # Confusion. Quand = à quel moment. Quant à = à propos de.
__[i]/conf(conf_qu_en1)__   (quan[dt]) est[ -]il d(?:es?|u) @@0 <<- -1>> qu’en                      # Confusion. Ce qu’il en est de… → Qu’en est-il de… ?
__[i]/conf(conf_qu_en2)__   (quan[dt]) ({w_2}ant) @@0,$ <<- morph(\2, ":P", False) -1>> qu’en       # Confusion probable.
__[i]/conf(conf_quand2)__
    (qu en) (?:je|tu|ils?) @@0
    <<- not after("^ +ne s(?:ai[st]|u[st]|urent|avai(?:[ts]|ent)) ") -1>> quand                     # Confusion probable. Pour évoquer un moment, écrivez :

    <<- morphex(\2, ":[NAQ]", ":(?:G|[123][sp]|W)") -1>> =\1.replace(" ", "")                       # Confusion probable. Ex : Quelle femme ! Je crois qu’elle réussira.

TEST: {{qu’elle}} emmerdeuse.


__[i]/conf(conf_qu_elle_verbe)__
    (quelles?) +({w_1})  @@0,$
    <<- \2.islower() and (morphex(\2, ":V|>(?:ne?|me?|te?|se?|[nv]ous|l(?:e|a|es|ui|leur|)|en|y)/", ":[NA].*:[fe]|>(?:plus|moins)") or \2 == "t" or \2 == "s")
        and not (morph(\2, ">(?:pouvoir|devoir|en)/", False) and morph(word(1), ":V0e", False)) >>>
    <<- \1.endswith("e") and not morph(\2, ":V0e", False) and not (morph(\2, ":V0a", False) and after("^ +été "))
    -1>> qu’elle                                                                                    # Confusion. Le sujet “elle” doit être séparée de la conjonction “que”. 1
    <<- __else__ and \1.endswith("s") and not morph(\2, ":V0e", False)  and not (morph(\2, ":V0a", False) and after("^ +été "))
    -1>> qu’elles                                                                                   # Confusion. Le sujet “elles” doit être séparée de la conjonction “que”. 2
    <<- __else__ and morph(\2, ":V0e", False) and morphex(word(1), ":[QA]", ":G", False) >>>
    <<- \1.endswith("e") -1>> qu’elle                                                               # Confusion. Le sujet “elle” doit être séparée de la conjonction “que”. 3
    <<- __else__ and \1.endswith("s") -1>> qu’elles                                                 # Confusion. Le sujet “elles” doit être séparée de la conjonction “que”. 4

    ne (?:l(?:e|eur|ui) |[nv]ous |)(son)  @@$
    <<- -1>> sont                   # Confusion : “son” est un déterminant ou un nom masculin. Le verbe “être” à la 3ᵉ personne du pluriel s’écrit “sont”.
__[i]/conf(conf_me_te_se_son)!6__
    [mts]e (son)  @@3
    <<- -1>> sont                   # Confusion : “son” est un déterminant ou un nom masculin. Le verbe “être” à la 3ᵉ personne du pluriel s’écrit “sont”.
__[i]/conf(conf_son_qqch)__
    (sont) ({w_2})  @@0,$
    <<- morphex(\2, ":[NA].*:[me]:s|>[aeéiîou].*/:[NA].*:f:s", ":[GW]")
        and morphex(word(-1), ":V|>(?:à|avec|chez|dès|contre|devant|derrière|en|par|pour|sans|sur)/", ":[NA].*:[pi]|>(?:ils|elles|vous|nous|leur|lui|[nmts]e)/", True)
        and not before(r"(?i)\bce que? |[mts]’en +$")
    -1>> son                        # Confusion : “sont” est le verbe “être” à la 3ᵉ personne du pluriel. Pour le déterminant, écrivez “son”.
__[i]/conf(conf_qui_sont_les)__
    (?:qu[ie]|comment|pourquoi) +(son) @@$
    <<- morph(word(1), ":[DR]", False, True) -1>> sont      # Confusion probable : “son” est un déterminant ou un nom masculin. Le verbe “être” à la 3ᵉ personne du pluriel s’écrit “sont”.

TEST: ne leur {{son}} pas odieux.

__[i]/conf(conf_sûr_de_nom_propre)__
    (sur) d(?:e |’)([A-ZÉÈ][\w-]+)  @@0,$
    <<- morph(\2, ":M[12]", False) -1>> sûr
    # Confusion probable : “sur” est une préposition ou un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur

TEST: Je suis {{sur}} de Patrick.

__[i]/conf(conf_sûr_que)__
    (sure?s?) que?  @@0
    <<- -1>> =\1.replace("sur", "sûr")
    # Confusion probable : “sur” est une préposition ou un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur
__[i]/conf(conf_sûre_surs_de)__
    (sur(?:es?|s)) de?  @@0
    <<- -1>> =\1.replace("sur", "sûr")
    # Confusion probable : “sur” un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur
__[i]/conf(conf_sûr_de)__
    (sur) d(?:e (?:m(?:oi|es?|on|a)|t(?:oi|es?|on|a)|vous|nous|l(?:ui|es?)|s(?:oi|es?|on|a)|ce(?:ci|la|s|tte|t|)|ça)|’(?:elles?|eux))  @@0
    <<- -1>> sûr
    # Confusion probable : “sur” est une préposition ou un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur
__[i]/conf(conf_sûr_de_vinfi)__
    (sur) de (?:l(?:a |’|es? |ui |eur )|)({infi})  @@0,$
    <<- morph(\2, ":Y", False)
    -1>> =\1.replace("sur", "sûr")
    # Confusion probable : “sur” est une préposition ou un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur
__[i]/conf(conf_en_lieu_sûr)__
    en lieu (sur)  @@8
    <<- -1>> sûr
    # Confusion probable : “sur” est une préposition ou un adjectif signifiant acide ou aigre ; utilisez “sûr” pour certain, vrai ou sans danger.|http://fr.wiktionary.org/wiki/sur

TEST: Je suis {{sure}} qu’il ne va pas tarder à venir
TEST: {{sures}} d’elles-mêmes, elles ne s’en laissent pas conter.
TEST: {{sur}} de toi et de moi, que peut-il nous arriver, sinon le meilleur.
TEST: Il est tellement {{sur}} de la trouver.
TEST: ils sont en lieu {{sur}} et introuvables.


# tant / temps (1re partie)
__[i]/conf(conf_en_temps_de)__
    en (tant?) de?  @@3
    <<- not after("^[ ’](?:lieux|endroits|places|mondes|villes|pays|régions|cités)") -1>> temps     # Confusion. Écrivez « en temps de » si vous évoquez une période de temps.
__[i]/conf(conf_de_temps_en_temps)__    de tant? en tant?                   <<- ->> de temps en temps   # Confusion. Écrivez « de temps en temps ».
__[i]/conf(conf_un_temps_soit_peu)__    un (temps|tan) soi[tes]? peu  @@3   <<- -1>> tant           # Confusion. Écrivez « un tant soit peu ».

# ->> voie
__[i]/conf(conf_sur_la_bonne_voie)__        sur la bonne (voix) @@$     <<- -1>> voie               # Confusion.|http://fr.wiktionary.org/wiki/voix
__[i]/conf(conf_en_voie_de)__
    en (voix) d(?:e (?:développement|disparition|guérison|résorption)|’(?:acquisition|achèvement|extinction|obtention))  @@3
    <<- -1>> voie                                                                                   # Confusion.|http://fr.wiktionary.org/wiki/voie
__[i]/conf(conf_ouvrir_la_voix)__
    (ouv\w+) +la (voix) (?:à|aux?)  @@0,w <<- morph(\1, ">ouvrir/", False) -2>> voie                # Confusion.|http://fr.wiktionary.org/wiki/voie
__[i]/conf(conf_par_voie_de_conséquence)__  par (voix) de conséquence   @@4 <<- -1>> voie           # Confusion.|http://fr.wiktionary.org/wiki/voie
__[i]/conf(conf_voie_adj)__
    (voix) (?:abdominale|anale|biliaire|carrossable|communale|express|interdite|intramusculaire|intraveineuse|piétonne|principale|prioritaire|privée|publique|déserte|romaine|appienne|flaminienne|ferrée|ferroviaire|lactée|lacrymale|aérienne|maritime|fluviale|terrestre|navigable|détournée|déviée|buccale|digestive|urinaire|respiratoire|parallèle|administrative|diplomatique|gouvernementale|législative|hiérarchique|rectiligne|sinueuse|souterraine|urbaine)s? @@0
    <<- -1>> voie                                                                                   # Confusion.|http://fr.wiktionary.org/wiki/voie

TEST: sur la bonne {{voix}}
TEST: ces patients sont en {{voix}} de guérison.
TEST: il faut ouvrir la {{voix}} aux nouveaux venus.
TEST: Je propse que, par {{voix}} de conséquence, nous partions immédiatement.
TEST: C’est une {{voix}} interdite.


# voire / voir
__[i]/conf(conf_voir_voire)__
    (voir) ({w_2}) @@0,$
    <<- not re.search("^(?:grand|petit|rouge)$", \2) and morphex(\2, ":A", ":[NGM]") and not \2.istitle()
        and not before(r"(?i)\b[ndmts](?:e |’(?:en |y ))(?:pas |jamais |) *$") and not morph(word(-1), ":O[os]|>(?:[ndmts]e|falloir|pouvoir|savoir|de)/", False)
    -1>> voire 
    # Confusion probable : “voir” est un verbe concernant la perception visuelle. Pour signifier “et même possiblement”, écrivez :|https://fr.wiktionary.org/wiki/voire

__[i]/conf(conf_voire_voir)__
    voire
    <<- morph(word(-1), ":Cs|>(?:ni|et|sans|pour|falloir|[pv]ouvoir|aller)/", True, False) ->> voir
    # Confusion probable : “voire” signifie “et même possiblement”. Pour le verbe, écrivez “voir”.|https://fr.wiktionary.org/wiki/voire

TEST: Elles sont fatiguées, {{voir}} épuisées.
TEST: Ce serait pour aider, ainsi que {{voire}} l’avancement du projet.
TEST: Elles vont voir rouge en apprenant cet échec.
TEST: Voir les enfants jouer ne me rend pas nostalgique.
TEST: Il faut voir grand.

__[i]/conf(conf_j_y_en_qqch)__
    (j’(?:en +|y +|))({w_1})  @@0,$
    <<- morphex(\2, ":", ":(?:[123][sp]|O[onw])")
    -2>> =suggSimil(\2, ":1s", False)                                                               # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_ne_qqch)__
    (n(?:e +|’))({w_1})  @@0,$
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P|O[onw]|X)|>(?:[lmtsn]|surtout|guère|presque|même|tout|parfois|vraiment|réellement|justement)/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Oo|Y)", False)                                               # Incohérence avec « \1 » : « \2 » devrait être un verbe ou un pronom personnel objet.
__[i]/conf(conf_n_y_en_qqch)__
    (n’(?:en|y)) ({w_1})  @@0,$
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P|O[onw]|X)") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Y)", False)                                                  # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_ne_pronom_qqch)__
    (ne (?:l(?:es? +|eur +|a +|’)|[nv]ous))({w_1})  @@0,$
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P|O[onw]|X)") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Y)", False)                                                  # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_me_te_se_qqch)__
    ([mts]e +(?:les? |la |l’|))(?!voi(?:là|ci))({w_1})  @@0,$
    <<- not re.search("(?i)^se que?", \0)
        and morphex(\2, ":", ":(?:[123][sp]|Y|P|Oo)|>[lmts]/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Oo|Y)", False)                                               # Incohérence avec « \1 » : « \2 » devrait être un verbe ou un pronom personnel objet.
__[i]/conf(conf_m_t_s_y_en_qqch)__
    ([mts]’(?:en|y)) (?!voilà)({w_1})  @@0,$
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P|X|Oo)|>rien/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Y)", False)                                                  # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_m_s_qqch)__
    ([ms]’)({w_1})  @@0,2
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P)|>(?:en|y|ils?)/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Y)", False)                                                  # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_t_qqch)__
    (t’)({w_1})  @@0,2
    <<- morphex(\2, ":", ":(?:[123][sp]|Y|P)|>(?:en|y|ils?|elles?)/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|ce)$", \2)
    -2>> =suggSimil(\2, ":(?:[123][sp]|Y)", False)                                                  # Incohérence avec « \1 » : « \2 » devrait être un verbe.
__[i]/conf(conf_c_ç_qqch)__
    ([cç]’)({w_1})  @@0,2
    <<- morphex(\2, ":", ":[123][sp]|>(?:en|y|que?)/") and not re.search("(?i)-(?:ils?|elles?|[nv]ous|je|tu|on|dire)$", \2)
    -2>> =suggSimil(\2, ":3s", False)                                                               # Incohérence avec « \1 » : « \2 » devrait être un verbe.

TEST: ne l’{{oubli}} pas
TEST: elle ne la {{croix}} pas
TEST: ils me les {{laissés}}.
TEST: ne {{pensée}} rien, jamais
TEST: n’en {{laissée}} que des miettes

    ->> =suggVerb(@, ":3s")                                     # Incohérence. Ceci est un verbe à la 2ᵉ personne du singulier. Sujet (“tu” ou “toi qui”) introuvable.
__[i]/conj(conj_xxxas_sans_sujet)!3__
    \w+as(?! tu)
    <<- morphex(\0, ":2s", ":(?:G|W|M|J|[13][sp]|2p)") and not (\0[0:1].isupper() and before0(r"\w"))
        and ( not morph(\0, ":[NAQ]", False) or before("> +$") )
        and not before(r"(?i)\bt(?:u |[’']|oi,? qui |oi seul )")
    ->> =suggVerb(@, ":3s")                                     # Incohérence. Ceci est un verbe à la 2ᵉ personne du singulier. Sujet (“tu” ou “toi qui”) introuvable.





@@@@
@@@@
@@@@
@@@@
@@@@GRAPH: graphe1                                                                                  
@@@@
@@@@
@@@@
@@@@

__tag_sujets__
    [je|j’]
    [moi|moi-même] qui
    [moi|moi-même] [seul|seule]
        <<- />> 1s

    tu
    [toi|toi-même] ?,¿ qui
    [toi|toi-même] [seul|seule]
        <<- />> 2s

    nous
    nous ?,¿ qui
    nous-même
    nous-mêmes
    nous [seul|seuls|seules]
    [et|ou] [moi|moi-même]
    ni [moi|moi-même]
    [moi|moi-même] et
        <<- />> 1p

    vous
    vous ?,¿ qui
    vous-même
    vous-mêmes
    vous [seul|seule|seuls|seules]
    [et|ou] [toi|toi-même]
    ni [toi|toi-même]
    [toi|toi-même] et
        <<- />> 2p


__conj_xxxxs_sans_sujet!3__
    étais  ~¬(?:[tT]u|[jJ]e)
        <<- not (\1.istitle() and before0(r"\w")) and not morph(<1, ":[DA].*:p")
            and not tag_before(\1, "1s") and not tag_before(\1, "2s")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

    se  ~[iudnrtpcï]s$
        <<- not \1.isupper() and morph(\2, ":[12]s", ":(?:E|G|W|M|J|3[sp]|2p|1p)")
        -2>> =suggVerb(\2, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

    s’  ~[iudnrtpcï]s$
        <<- morph(\2, ":[12]s", ":(?:E|G|W|M|J|3[sp]|2p|1p)")
        -2>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

    [ne|n’] ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|en|y]¿  ~[iudnrtpcï]s$  ~¬(?:[tT]u|[jJ]e)
        <<- morph(\1, ":[12]s", ":(?:E|G|W|M|J|3[sp]|2p|1p|V0e)")
            and not tag_before(\1, "1s") and not tag_before(\1, "2s")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

    ~[iudnrtpcï]s$  ~¬(?:[tT]u|[jJ]e)
        <<- morph(\1, ":[12]s", ":(?:E|G|W|M|J|3[sp]|2p|1p|V0e|N|A|Q)") and not (\1.istitle() and before0(r"\w"))
            and not tag_before(\1, "1s") and not tag_before(\1, "2s")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.


__conj_peux_veux_sans_sujet!3__
    [peux|veux]  ~¬(?:[tT]u|[jJ]e)
        <<- /conj/ not (\1.istitle() and before0(r"\w")) and not tag_before(\1, "1s") and not tag_before(\1, "2s")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

__conj_vaux_équivaux_prévaux_sans_sujet!3__
    vaux  ~¬(?:[tT]u|[jJ]e)
        <<- /conj/ not (\1.istitle() and before0(r"\w")) and not tag_before(\1, "1s") and not tag_before(\1, "2s")
            and not morph(<1, ":(?:R|D.*:p)")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

    [équivaux|prévaux]  ~¬(?:[tT]u|[jJ]e)
        <<- /conj/ not (\1.istitle() and before0(r"\w")) and not tag_before(\1, "1s") and not tag_before(\1, "2s")
        -1>> =suggVerb(\1, ":3s")                                                                   # Incohérence. Le sujet de cette forme verbale est introuvable.

TEST: Caroline, quand l’heure viendra, {{décideras}} de la conduite à tenir.
TEST: ceux-là, dans tous les cas de figure et dans tous les coups ratés, {{comprenais}} mal pourquoi on leur en voulait.
TEST: Lui, quand il y pensait, en {{arrivai}} à chaque fois à la même conclusion.
TEST: Elle, ici et dans tous les cas de figure, {{veux}} toujours en faire plus.
TEST: Le total de cette opération, contrairement à ce qu’on pense, {{équivaux}} à au moins trois d’entre eux.
TEST: {{j'}}ai signalé que {{j'}}essayais de regrouper les paragraphes. (Tests avec apostrophe droite.)
TEST: je me questionne, {{exiges}} des réponses mais n’en obtiens pas…
TEST: dans tous les cas de figure imaginés par cette bande de nuls, il n’y en a pas un qui les sauvera.
TEST: ces gens qui vont par monts et par vaux.
TEST: pour ne justement pas donner l’impression de s’être trompé.


## Incohérences avec formes verbales 1pl et 2 pl sans sujet
__conj_xxxons_sans_sujet!3__

    @:1p¬:[EGMNAJ]  ~¬[nN]ous

        <<- /conj/ not (\1.istitle() and before0(r"\w")) and not tag_before(\1, "1p") -1>> =suggVerb(\1, ":3p")     # Ceci est un verbe à la 1ʳᵉ personne du pluriel. Sujet (“nous” ou équivalent) introuvable.

__conj_xxxez_sans_sujet!3__

    @:2p¬:[EGMNAJ]  ~¬[vV]ous

        <<- /conj/ not (\1.istitle() and before0(r"\w")) and not tag_before(\2, "2p") -1>> =suggVerb(\1, ":3p")     # Ceci est un verbe à la 2ᵉ personne du pluriel. Sujet (“vous” ou équivalent) introuvable.

TEST: les hommes et les femmes, qui sans un bruit, sans une parole amère, {{continuerons}} leur tâche n’en seront pas plus récompensés.
TEST: il était dit que cette femme et son frère {{promènerez}} leur chien à cette heure de la journée.
TEST: cet homme et cette femme {{pouvez}} y parvenir avec de la persévérance
TEST: Comme on lui disait que vous-même aviez déjà consulté le notaire
TEST: ce sont des terroristes et ça ne nous arrivera pas à nous, qui n’avons rien à nous reprocher
TEST: mes supérieurs et moi-même avons pris la décision de ne pas vendre
TEST: Ni lui ni moi n’avions mangé
TEST: Mon épouse et moi-même avons toujours dit
TEST: que vous ou moi ignorions à peu près tout du boson de Higgs n’a pas du tout le même sens



!!
!!
!!!! Locutions invariables                                                                          
!!
!!

__locutions_invariables__
    [plus|moins|autant]  que  [prévue|prévus|prévues]
        <<- -3>> prévu                                                                              # Invariable. Implicitement, \1 que ce qui était prévu.

    [plus|moins|aussi]  **  que  [prévue|prévus|prévues]
        <<- -4>> prévu                                                                              # Invariable. Implicitement, \1 \2 que ce qui était prévu.

    [plus|moins|autant]  [de|d’]  **  que  [prévue|prévus|prévues]
        <<- -5>> prévu                                                                              # Invariable. Implicitement, \1 \2 \3 que ce qui était prévu.

    comme [annoncés|annoncée|annoncées]
        <<- -2>> annoncé                                                                            # Invariable. Implicitement, comme ce qui était annoncé.

    comme [convenus|convenue|convenues]
        <<- -2>> convenu                                                                            # Invariable. Implicitement, comme ce qui était convenu.

    comme [prévue|prévus|prévues]
        <<- -2>> prévu                                                                              # Invariable. Implicitement, comme ce qui était prévu.


TEST: il y en a autant que {{prévus}}.
TEST: elles sont plus nombreuses plus que {{prévues}}
TEST: il y a moins de bouffe que {{prévue}}
TEST: comme {{annoncés}}, ils sont arrivés
TEST: moins loin que {{prévus}}                               ->> prévu
TEST: plus rapide que {{prévues}}                             ->> prévu
TEST: autant d’hommes que {{prévus}}                          ->> prévu
TEST: il y en a moins que {{prévues}}                         ->> prévu
TEST: comme {{convenus}}                                      ->> convenu



!!
!!
!!!! Tout, tous, toute, toutes                                                                      
!!
!!

__purge_tout_tous_toutes__
    [fais-les|fais-nous]                        [tous|toutes]
    [faisons-les|faisons-nous|faisons-vous]     [tous|toutes]
    [faites-les|faites-nous|faites-vous]        [tous|toutes]


        <<- ~2>> *

    [laisse-les|laisse-nous]                    [tous|toutes]
    [laissons-les|laissons-nous|laissons-vous]  [tous|toutes]

    [laissez-les|laissez-nous|laissez-vous]     [tous|toutes]

        <<- ~2>> *




    [les|des|mes|tes|ses|ces|nos|vos|leurs|aux]  tout  [débuts|petits]

    [les|des|mes|tes|ses|ces|nos|vos|leurs|aux]  tout  @:A.*:[pi]
        <<- ~2>> *


__tout_det__
    [<start>|,]  tout [deux|trois]

        <<- -2>> tous                                                                               # Locution pronominale : « tous deux ».|https://fr.wiktionary.org/wiki/tous_deux


    tout [mes|tes|ses|ces|nos|vos|leurs|ceux|celles]
        <<- not morph(<1, ">(?:d[eu]|avant|après|malgré)/") -1>> tous                               # Erreur d’accord probable avec « \2 ».


    tout les @:¬:(?:3s|Oo)
        <<- not morph(<1, ">(?:d[eu]|avant|après|malgré)/") -1>> tous                               # Erreur d’accord probable avec « les \3 ».

TEST: {{Tout}} deux sont partis les premiers.
TEST: {{Tout}} mes hommes sont venus.
TEST: {{Tout}} les hommes sont dingues.
TEST: Donne à manger à {{tout}} ceux qui sont là.
TEST: Revenus de tout ceux qui sont partis ont perdu la foi.
TEST: car malgré tout ceux qui persistent obtiennent parfois justice.
TEST: je ne connais pas du tout ceux dont tu parles.
TEST: Malgré tout ces hommes sont quand même revenus.
TEST: Les tout premiers hommes.
TEST: Les tout petits ne sont pas des légumes.


__toute_det__
    toute [celles|les|des|mes|tes|ses|ces]
        <<- /gn/ -1>> toutes                                                                        # Erreur d’accord probable avec “\2”.

    toute [ce|cet]
        <<- /gn/ -1>> tout                                                                          # Erreur d’accord probable avec “\2”.

    toute mon ~^[bcdfgjklmnpqrstvwxz]
        <<- /gn/ -1>> tout                                                                          # Erreur d’accord probable avec “\2”.

TEST: {{Toute}} celles qui viendront…
TEST: et {{toute}} ce barouf ne nous a apporté que des ennuis.
TEST: car {{toute}} mon savoir vient d’elle


__tous_det_nom__
    [<start>|,]     tous    [des|mes|tes|ses|ces]   @:[NA].*:f¬:[me]
    [<start>|,]     tous    [les]                   @:[NA].*:f¬:(?:3p|[me])
        <<- /gn/ -2>> toutes                                                                        # Erreur d’accord probable : « \4 » est féminin.
        <<- /gn/ __also__ and hasFemForm(\4) -4>> =suggMasPlur(\4, True)                            # Erreur d’accord probable : « \2 » est masculin.

    tous    [des|mes|tes|ses|ces]   @:[NA].*:f¬:[me]
    tous    [les]                   @:[NA].*:f¬:(?:3p|[me])
        <<- /gn/ morph(<1, ":", ":(?:R|[123][sp]|Q)|>(?:[nv]ous|eux)/") -1>> toutes                 # Erreur d’accord probable : « \3 » est féminin.
        <<- /gn/ __also__ and hasFemForm(\3) -3>> =suggMasPlur(\3, True)                            # Erreur d’accord probable : « \1 » est masculin.

TEST: {{tous}} ces {{idiotes}}
TEST: indubitablement {{tous}} des {{privilégiées}}


__toutes_det_nom__
    [<start>|,]     toutes  [des|mes|tes|ses|ces]   @:[NA].*:m¬:[fe]
    [<start>|,]     toutes  [les]                   @:[NA].*:m¬:(?:3p|[fe])
        <<- /gn/ -2>> tous                                                                          # Erreur d’accord probable : « \4 » est masculin.
        <<- /gn/ __also__ and hasFemForm(\4) -4>> =suggFemPlur(\4, True)                            # Erreur d’accord probable : « \2 » est féminin.

    toutes  [des|mes|tes|ses|ces]   @:[NA].*:m¬:[fe]
    toutes  [les]                   @:[NA].*:m¬:(?:3p|[fe])
        <<- /gn/ morph(<1, ":", ":(?:R|[123][sp]|Q)|>(?:[nv]ous|eux)/") -1>> tous                   # Erreur d’accord probable : « \3 » est masculin.
        <<- /gn/ __also__ and hasFemForm(\3) -3>> =suggFemPlur(\3, True)                            # Erreur d’accord probable : « \1 » est féminin.

TEST: {{toutes}} mes {{bars}}
TEST: vraiment {{toutes}} des {{costauds}}


__tout_nom__
    [<start>|,] tout  @:N.*:[fp]¬:(?:A|W|G|M|Y|[me]:[is]|3s)
    de          tout  @:N.*:[fp]¬:(?:A|W|G|M|Y|[me]:[is]|3s)
        <<- /gn/ -3>> =suggMasSing(\3, True)                                                        # Accord avec “tout” : “\3” devrait être au masculin singulier.

    tout  @:N.*:[fp]¬:(?:A|W|G|M|Y|[me]:[is]|3s)
        <<- /gn/ morph(<1, ":R", ":D.*:p") -2>> =suggMasSing(\2, True)                              # Accord avec “tout” : “\2” devrait être au masculin singulier.

__toute_nom__
    [<start>|,] toute  @:[NA].*:[mp]¬:(?:W|G|M|[fe]:[is])
    de          toute  @:[NA].*:[mp]¬:(?:W|G|M|Y|[fe]:[is])
        <<- /gn/ -3>> =suggFemSing(\3, True)                                                        # Accord avec “toute” : “\3” devrait être au féminin singulie

    toute  @:[NA].*:[mp]¬:(?:W|G|M|Y|[fe]:[is])
        <<- /gn/ morph(<1, ":R") -2>> =suggFemSing(\2, True)                                        # Accord avec “toute” : “\2” devrait être au féminin singulier.

__tous_nom__
    [<start>|,] tous  @:[NA].*:[fs]¬:(?:W|G|M|[me]:[ip])
    de          tous  @:[NA].*:[fs]¬:(?:W|G|M|Y|[me]:[ip])
        <<- /gn/ -3>> =suggMasPlur(\3, True)                                                        # Accord avec “tous” : “\3” devrait être au masculin pluriel.

    tous  @:[NA].*:[fs]¬:(?:W|G|M|Y|[me]:[ip])
        <<- /gn/ morph(<1, ":R") -2>> =suggMasPlur(\2, True)                                        # Accord avec “tous” : “\2” devrait être au masculin pluriel.

__toutes_nom__
    [<start>|,] toutes  @:[NA].*:[ms]¬:(?:W|G|M|[fe]:[ip])
    de          toutes  @:[NA].*:[ms]¬:(?:W|G|M|Y|[fe]:[ip])
        <<- /gn/ -3>> =suggFemPlur(\3, True)                                                        # Accord avec “toutes” : “\3” devrait être au féminin pluriel.

    toutes  @:[NA].*:[ms]¬:(?:W|G|M|Y|[fe]:[ip])
        <<- /gn/ morph(<1, ":R") -2>> =suggFemPlur(\2, True)                                        # Accord avec “toutes” : “\2” devrait être au féminin pluriel.

TEST: Tout {{hommes}}
TEST: De tous {{âge}} !
TEST: avec toutes {{femme}}                                     ->> femmes
TEST: sur toutes {{armure}}                                     ->> armures
TEST: Toute {{époux}} doit faire preuve de bienveillance
TEST: Il se souvient de toute mon histoire.
TEST: Tout les sépare.
TEST: les tout débuts du mouvement ouvrier
TEST: vos tout débuts furent difficiles
TEST: aux tout débuts, il y eut bien des erreurs
TEST: comment les inégalités sociales impactent la santé des tout petits



!!
!!
!!!! Adverbes de négation                                                                           
!!
!!

__ne_manquant__
    [<start>|,]  je             @>[bcdfgjklmnpqrstvwxz].*:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  tu             @>[bcdfgjklmnpqrstvwxz].*:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   @>[bcdfgjklmnpqrstvwxz].*:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           @>[bcdfgjklmnpqrstvwxz].*:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           @>[bcdfgjklmnpqrstvwxz].*:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    @>[bcdfgjklmnpqrstvwxz].*:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
        <<- /neg/ -3>> ne \3                                                                        # Ne … \4 : il manque l’adverbe de négation.

    [<start>|,]  je             [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  tu             [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    [le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’]     @:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
        <<- /neg/ -3>> ne \3                                                                        # Ne … \5 : il manque l’adverbe de négation.

    [<start>|,]  je             [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  tu             [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            @:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  je             [me|te|nous|vous] [le|la|les]                           @:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]

    [<start>|,]  tu             [me|te|nous|vous] [le|la|les]                           @:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   [me|te|nous|vous] [le|la|les]                           @:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           [me|te|nous|vous] [le|la|les]                           @:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           [me|te|nous|vous] [le|la|les]                           @:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    [me|te|nous|vous] [le|la|les]                           @:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  je             [le|la|les] [lui|leur]                                  @:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  tu             [le|la|les] [lui|leur]                                  @:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   [le|la|les] [lui|leur]                                  @:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           [le|la|les] [lui|leur]                                  @:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           [le|la|les] [lui|leur]                                  @:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    [le|la|les] [lui|leur]                                  @:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
        <<- /neg/ -3>> ne \3                                                                        # Ne … \6 : il manque l’adverbe de négation.


    [<start>|,]  [je|j’]        @>[aeéiouœ].*:1s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]

    [<start>|,]  tu             @>[aeéiouœ].*:2s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [il|elle|on]   @>[aeéiouœ].*:3s¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  nous           @>[aeéiouœ].*:1p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  vous           @>[aeéiouœ].*:2p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    @>[aeéiouœ].*:3p¬:(?:Oo|X)  [pas|rien|jamais|guère|point]
        <<- /neg/ -3>> n’\3                                                                         # Ne … \4 : il manque l’adverbe de négation.


    [<start>|,]  [je|j’]        [en|y]  @:1s¬:(?:Oo|X)      [pas|rien|jamais|guère|point]
    [<start>|,]  tu             [en|y]  @:2s¬:(?:Oo|X)      [pas|rien|jamais|guère|point]

    [<start>|,]  [il|elle|on]   [en|y]  @:3s¬:(?:Oo|X)      [pas|rien|jamais|guère|point]
    [<start>|,]  nous           [en|y]  @:1p¬:(?:Oo|X)      [pas|rien|jamais|guère|point]
    [<start>|,]  vous           [en|y]  @:2p¬:(?:Oo|X)      [pas|rien|jamais|guère|point]
    [<start>|,]  [ils|elles]    [en|y]  @:3p¬:(?:Oo|X)      [pas|rien|jamais|guère|point]
        <<- /neg/ -3>> n’\3                                                                         # Ne … \5 : il manque l’adverbe de négation.

TEST: __neg__ On {{a}} pas compris.
TEST: __neg__ Il {{part}} pas encore.
TEST: __neg__ On {{vous}} a pas compris.
TEST: __neg__ On {{en}} a pas.
TEST: __neg__ Il {{y}} a jamais d’eau.
TEST: __neg__ je {{deviendrai}} pas hargneux.
TEST: __neg__ il {{le}} lui donne pas souvent.


!!
!!
!!!! Infinitif                                                                                      
!!
!!

__infi_ne_pas_jamais_etc__
    ne [pas|rien|guère|point]                   ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] [trop|beaucoup]   ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] non plus          ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus|trop|beaucoup]¿       ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus]¿ non plus            ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère|trop|beaucoup]¿ ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère]¿ non plus      ?[le|la|l’|les|leur|lui|nous|vous|me|m’|te|t’|se|s’|en|y]¿  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point]                   [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] [trop|beaucoup]   [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] non plus          [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus|trop|beaucoup]¿       [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus]¿ non plus            [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère|trop|beaucoup]¿ [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère]¿ non plus      [m’|t’|s’|nous|vous|les|lui|leur|l’]  [en|y]            (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point]                   [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] [trop|beaucoup]   [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] non plus          [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus|trop|beaucoup]¿       [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus]¿ non plus            [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère|trop|beaucoup]¿ [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère]¿ non plus      [me|te|nous|vous] [le|la|les]                           (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point]                   [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] [trop|beaucoup]   [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne [pas|rien|guère|point] non plus          [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus|trop|beaucoup]¿       [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne jamais ?[rien|plus]¿ non plus            [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère|trop|beaucoup]¿ [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
    ne plus ?[jamais|rien|guère]¿ non plus      [le|la|les] [lui|leur]                                  (@:[VNA]¬:(?:Y|W|X|O[ow])|>que?/)
        <<- /infi/ -1>> =suggVerbInfi(\1)                                                           # Après “ne pas”, “ne jamais”, “ne plus”, “ne rien”… le verbe devrait être à l’infinitif.


    ne [pas|jamais|plus|rien|guère|point] [beaucoup|trop]

        <<- ~3>> *


TEST: ne jamais les {{cédé}}
TEST: ne point nous {{donné}}
TEST: ne rien {{finit}}
TEST: ne jamais plus s’y {{frottait}}
TEST: ne plus guère y {{pensée}}
TEST: ne pas les {{contrariés}}
TEST: Ne rien m’en {{dit}}
TEST: Ne jamais lui {{donnait}} sa chance.
TEST: Ne jamais les leur {{montré}}
TEST: Il a décidé de ne plus {{mangés}} avec nous.
TEST: ne plus {{mangez}} fait maigrir
TEST: ne plus {{mangées}} fait maigrir
TEST: ne pas {{allé}}
TEST: ne jamais plus me les {{montrés}}
TEST: Ne jamais {{mangez}} de viande !
TEST: J’espère ne pas te déranger
TEST: Ne pas te le donner, ce serait une insulte.
TEST: ne jamais vraiment évoquer le sujet
TEST: déterminés à ne pas se laisser récupérer
TEST: de ne pas en élire du tout
TEST: Mais gare à ne pas non plus trop surestimer la menace
TEST: ne jamais beaucoup bosser, c’est sa devise.


__imp_ne_infinitif_negadv__
    [<start>|,]  [ne|n’]  @:V1.*:Y  [pas|plus|jamais]
        <<- /imp/ -3>> =suggVerbTense(\3, ":E", ":2p")                                              # Confusion probable : “\1” est un verbe à l’infinitif. Si vous vouliez utiliser l’impératif, écrivez :

TEST: Non, ne {{manger}} pas ça.                                    ->> mangez
TEST: Ne {{donner}} jamais à manger ces saloperies au chat.         ->> donnez



!!!
!!!
!!! Processeur: épuration des adverbes, locutions adverbiales, interjections et expressions usuelles
!!!
!!!

__purge_dates__
    depuis le           [1er|1ᵉʳ|~\d\d?]  {mois}    ?[dernier|prochain|~\d{2,5}]¿
    [le|du|au]          [1er|1ᵉʳ|~\d\d?]  {mois}    ?[dernier|prochain|~\d{2,5}]¿
    [jusqu’|jusqu]  au  [1er|1ᵉʳ|~\d\d?]  {mois}    ?[dernier|prochain|~\d{2,5}]¿
    à  compter  du      [1er|1ᵉʳ|~\d\d?]  {mois}    ?[dernier|prochain|~\d{2,5}]¿
    en  l’  an  ~\d{2,5}
    en  l’  an  de  grâce  ~\d{2,5}
    en  {mois}  ~\d{2,5}
    [de|d’|D’]  {mois}  ~\d{2,5}

    en  ~\d{2,5}  [,|<end>]
    en  ~\d{2,5}  @:¬:[AN].*:[pi]
    de  ~\d{2,5}  @:A.*:s
    à  la  {mi_mois}    ?~\d{2,5}¿
        <<- ~>> *

TEST: ils sont depuis le 2 janvier {{parti}} à l’étranger.
TEST: ils sont depuis le 2 janvier 2012 {{parti}} à l’étranger.


__purge_saisons__
    à  l’  [été|automne|hiver]  ~\d{2,4}
    au  printemps  ~\d{2,4}
        <<- ~>> *

TEST: Une étude de 2005 publiée dans le Journal
TEST: Les cinq variantes de la couverture du magazine Wired d’avril 2016 consacrée à Silicon Valley.
TEST: c’est donc la cinquième en 50 ans


__purge_un_nombre__
    un  ~\d+  @:A.*:s¬:G
        <<-  ~2>> *

TEST: l’équipe veut aussi voir dans la lettre le nombre d’or, un symbole d’harmonie, ainsi qu’un 6 retourné.


## moi/toi/lui/elle/nous/vous/eux/elles seul·e·s
__purge_pronom_seul__
    [moi|toi]       [seul|seule]
    lui             seul
    elle            seule
    [nous|vous]     [seuls|seules]
    eux             seuls
    elles           seules
        <<- ~1>> *


__purge_début_phrase__
    <start>  car
    <start>  de plus
    <start>  et  ?puis¿
    <start>  mais
    <start>  m’  est   avis  [que|qu’|qu]
    <start>  or  donc
    <start>  puis
    [<start>|,] grand bien lui fasse
        <<- ~1:0>> *


__purge_horaires_et_durée__
    24  [heures|h]  [sur|/]  24
    7   [jours|j]   [sur|/]  7
    sept [jours|j]  [sur|/]  sept
    vingt-quatre  heures  [sur|/] vingt-quatre
        <<- ~>> *

    heure       après   heure
    minute      après   minute
    seconde     après   seconde
    jour        après   jour
    nuit        après   nuit
    semaine     après   semaine
    trimestre   après   trimestre
    semestre    après   semestre
    mois        après   mois
    décennie    après   décennie
    année       après   année
    siècle      après   siècle
    génération  après   génération
        <<- ~>> *

    [à|de]  ~\d\d?  h  ?~\d\d?¿
    [à|de]  ~\d\d?  h  ?~\d\d?¿   [du|ce]  [matin|soir]
    [à|de]  ~\d\d?  h  ?~\d\d?¿   de  l’ après-midi
    [à|de]  ~\d\d?  h  ?~\d\d?¿   cet  après-midi
    [à|de]  ~\d\d?  h  ?~\d\d?¿   demain  [matin|soir|après-midi]
        <<- ~>> *

TEST: Le train de 2 h 47 {{arriveraient}} en retard.
TEST: Le train de 2 h 47 du matin {{arriveraient}} en retard.


__purge_prépositions_qqn__
    [après|avant|avec|pour|contre|sans|envers|chez|en|malgré|selon] les uns et les autres           [<end>|,|@:[VXG]¬>qui]
        <<- ~1:6>> *

    [après|avant|avec|pour|contre|sans|envers|chez|d’|D’|malgré|selon] on ne sait [qui|quoi]        [<end>|,|@:[VXG]¬>qui]
        <<- ~1:5>> *

    [après|avant|avec|pour|contre|sans|envers|chez|de|en|malgré|selon] tout un chacun               [<end>|,|@:[VXG]¬>qui]
    [après|avant|avec|pour|contre|sans|envers|chez|de|en|malgré|selon] tout le monde                [<end>|,|@:[VXG]¬>qui]
        <<- ~1:4>> *

    [après|avant|avec|pour|contre|sans|envers|chez|de|en|malgré] tout ça                            [<end>|,|@:[VXG]¬>qui]
    [après|avant|avec|pour|contre|sans|envers|chez|de|en|malgré|selon] [vous|nous] autres           [<end>|,|@:[VXG]¬>qui]
        <<- ~1:3>> *

    [après|avant|avec|pour|contre|sans|envers|chez|de|d’|D’|en|malgré|selon]  [autrui|quelqu’un|quelqu’une]     [<end>|,|@:[VXG]¬>qui]
    [après|avant|avec|envers|chez|malgré|selon]                               {pronom_obj}                      [<end>|,|@:[VXG]¬>qui]
    [contre|pour|sans|de|en]   [moi|toi|soi|elle|eux|elles|moi-même|toi-même|soi-même|lui-même|elle-même|nous-mêmes|vous-même|vous-mêmes|eux-mêmes|elles-mêmes]    [<end>|,|@:[VXG]¬>qui]
        <<- ~1:2>> *

    par égard pour   [moi|toi|soi|elle|eux|elles|moi-même|toi-même|soi-même|lui-même|elle-même|nous-mêmes|vous-même|vous-mêmes|eux-mêmes|elles-mêmes]    [<end>|,|@:[VXG]¬>qui]
        <<- ~1:4>> *

    en   [moi|toi|soi|elle|eux|elles|moi-même|toi-même|soi-même|lui-même|elle-même|nous-mêmes|vous-même|vous-mêmes|eux-mêmes|elles-mêmes]
        <<- ~>> *

    [après|avant|avec|pour|contre|sans|envers|chez|de|en|malgré|selon] [celui-ci|celui-là|celle-ci|celle-là|ceux-ci|ceux-là|celles-ci|celles-là]
        <<- ~>> *

    entre [moi|toi|lui|elle|elles|nous|vous|eux] et [moi|toi|lui|elle|elles|nous|vous|eux]
    entre [nous|vous|eux|elles] [deux|trois|quatre|cinq|six|sept|huit|neuf|dix]
        <<- ~>> *

    ni   [après|avec|chez|contre|de|derrière|devant|envers|malgré|pour|sans|sous|sur] [moi|toi|lui|elle|elles|eux|nous|vous] ?,¿ ni [après|avec|chez|contre|de|derrière|devant|envers|malgré|pour|sans|sous|sur] [moi|toi|lui|elle|elles|eux|nous|vous]
        <<- ~>> *

    parmi [nous|vous] ?autres¿
    parmi [eux|elles]
        <<- ~>> *

    par-devers [moi|toi|lui|elle|elles|lui|eux|nous|vous]
        <<- ~>> *

    quant à [moi|toi|lui|elle|elles|lui|eux|nous|vous]  [<end>|,|@:[VXG]¬>qui]
        <<- ~1:3>> *

TODO: comme


__simplifications_partielles__
    comme tant d’ autres  @:R
        <<- ~1:4>> *

    en cours @¬>de
        <<- ~1:2>> *

    et  /  ou
        <<- ~2:3>> *

    personne  d’ autre [que|qu’|qu]  [moi|toi|lui|elle|elles|nous|vous|eux]
        <<- ~2:0>> *


__purge_locutions_latines__
    [a|à]       [priori|postériori|posteriori|contrario|cappella|minima]
    ab          [absurdo|initio]
    ad          [hoc|hominem|infinitum|nauseam|valorem|patres]
    ad          vitam æternam
    ex          [nihilo|cathedra|absurdo|abrupto]
    id          est
    in          [abstracto|extenso|extremis|fine|petto|situ|utero|vitro|vivo]
    ipso        facto
    mutatis     mutandis
        <<- ~>> *


__purge_locutions__
    à ~\d+(?:,\d+|)  %
    à [autrui|bâbord|califourchon|chacun|confesse|contrecœur|contre-cœur|contretemps|demi-mot|foison|grand-peine|loisir|merveille|moitié|nouveau|outrance|peine|perpétuité|présent|raison|rallonge|rebrousse-poil|reculons|regret|renverse|risque|tâtons|tort|tribord|tout-va]
    à aucun prix
    à autre chose
    à bas [cout|coût|prix]
    à bâtons rompus
    à beaucoup près
    à belles dents
    à bien des égards
    à bien pire
    à bon [compte|escient|droit]
    à bout  de [bras|souffle|force|forces|nerf|nerfs]
    à bout  [portant|touchant]
    à bras ouverts
    à bras le corps
    à brève échéance
    à but ?non¿ lucratif
    à cause [de|d’]  [ça|moi|toi|lui|nous|vous|elle|elles|eux]
    à ce [compte-là|moment-là|titre]
    à cet égard
    à cet instant ?[exact|précis]¿
    à cette [date|occasion]
    à cette époque
    à cette époque de l’ année
    à cette heure
    à cette heure du jour
    à cette heure de la [journée|nuit]
    à cette heure [tardive|matinale]
    à ciel ouvert
    à chaque [fois|instant]
    à chaudes larmes
    à cœur [joie|ouvert|perdu]
    à corps perdu
    à côté  [de|d’]  [ça|moi|toi|lui|nous|vous|elle|elles|eux]
    à couilles rabattues
    à coup sûr
    à couper le souffle
    à court terme
    à courte [échéance|portée]
    à des kilomètres à la ronde
    à défaut d’autre chose
    à dose homéopathique
    à durée limitée
    à de  [nombreuses|multiples]  reprises
    à double [titre|tranchant]
    à en juger par [mon|ton|son|notre|votre|leur] expérience
    à en perdre haleine
    à en perdre la tête
    à faible  [allure|revenu]
    à feu et à sang
    à flanc de [colline|montagne]
    à fleur de peau
    à franchement parler
    à géométrie variable
    à grande échelle
    à haut risque
    à hue et à dia
    à huis clos
    à intervalles [irréguliers|réguliers]
    à juste [raison|titre]
    à l’ heure actuelle
    à l’ heure [qu’|qu] il est
    à l’ accoutumée
    à l’ amiable
    à l’ avance
    à l’ avenir
    à l’ avenir incertain
    à l’ avenant
    à l’ air libre
    à l’ aveuglette
    à l’ emporte-pièce
    à l’ échelle [nationale|mondiale|régionale|départementale|cantonale|locale|galactique|universelle]
    à l’ évidence
    à l’ exclusion de toute autre chose
    à l’ improviste
    à l’ inverse
    à l’ occasion
    à l’ ordre du jour
    à l’ œil nu
    à l’ en croire
    à l’ unanimité
    à l’ un d’ entre eux
    à l’ une d’ entre elles
    à l’ [un|une] des leurs
    à la  [bourre|con|dérive|dérobée|diable|fois|leur|longue|manque|mords-moi-le-nœud|papa|ramasse|renverse|redresse|rescousse|sauvette|volée]
    à la  bonne franquette
    à la  limite du supportable
    à la  lumière de tout [ceci|cela|ça]
    à la  petite semaine
    à la  pointe du progrès
    à la  première occasion
    à la  queue leu leu
    à la  surprise générale
    à la  virgule près
    à long terme
    à longue [échéance|portée]
    à longueur [de|d’] [temps|journée|année]
    à loyer modéré
    à main [armée|droite|gauche|levée]
    à mains nues
    à maints égards
    à maintes reprises
    à marche forcée
    à merveille
    à [midi|minuit]  ?pile¿
    à [mi-course|mi-distance|mi-temps]
    à moindres frais
    à mots couverts
    à moyen terme
    à moyenne échéance
    à [mes|tes|ses|nos|vos|leurs] [côtés|dépens|trousses]
    à [mes|tes|ses|nos|vos|leurs] risques et périls
    à [ma|ta|sa|notre|votre|leur] [connaissance|disposition|guise|portée]
    à [ma|ta|sa|notre|votre|leur] grande [surprise|tristesse]
    à [ma|ta|sa|notre|votre|leur] juste mesure
    à [mon|ton|son|notre|votre|leur] [avis|détriment|encontre|égard|insu|sujet|tour]
    à [mon|ton|son|notre|votre|leur] [cœur|corps] défendant
    à [mon|ton|son|notre|votre|leur] grand [désarroi|soulagement]
    à n’ en pas douter
    à n’ en plus finir
    à n’ en point douter
    à parler franc
    à part [entière|ça|cela|ceci]
    à parts égales
    à partir [de|d’]  [aujourd’hui|ici|là|maintenant|rien]
    à partir [de|d’]  [demain|hier]  ?[matin|midi|soir]¿
    à pas de [géant|loup|tortue|velours]
    à personne en danger
    à perte de vue
    à petit feu
    à petite [dose|échelle]
    à peu de choses près
    à peu de [distance|frais]
    à peu près
    à pieds joints
    à pile ou face







    à plat ventre
    à plate couture
    à plein [régime|temps|nez]
    à pleins poumons
    à plus forte raison
    à plus d’un titre
    à point nommé
    à portée de [main|tir]
    à première vue
    à prix [cassé|modique|cassés|modiques]
    à proprement parler
    à qui de droit
    à qui mieux mieux
    à qui que ce soit
    à quelque distance
    à quelques [exceptions|nuances] près
    à quelques-uns d’ entre [nous|vous|eux]
    à quelques-unes d’ entre [nous|vous|elles]
    à ras [bord|bords]
    à rude épreuve
    à s’ y méprendre
    à somme nulle
    à tel point
    à temps  [plein|partiel|complet]
    à tête reposée
    à tire d’ [aile|ailes]
    à [tire-d’aile|tire-d’ailes]
    à titre  [conservatoire|expérimental|indicatif|informatif|grâcieux|personnel|posthume]
    à titre  d’ exemple
    à tombeau ouvert
    à tort ou à raison
    à tort et à travers
    à tour de  [bras|rôle]
    à tout [âge|crin|instant|jamais|moment|prix]
    à tout bout de champ
    à tout le [moins|monde]
    à tout point de vue
    à tout un chacun
    à toute [allure|bride|épreuve|force|vitesse|volée]
    à toute heure
    à toute heure du jour
    à toute heure du jour et de la nuit
    à toute heure de la nuit
    à toute heure de la nuit et du jour
    à tous crins
    à tous points de vue
    à toutes fins utiles
    à toutes jambes
    à tu et à toi
    à un moment donné

    à usage interne
    à visage découvert
    à visage humain
    à vive allure
    à voix [haute|basse]
    à vol d’ oiseau
    à vrai dire
    à vue d’ œil
    à ?bien¿ y regarder de plus près
    à ?bien¿ y [penser|réfléchir|songer|repenser]
    advienne que pourra
    ah
    après cette date ?fatidique¿
    après [moi|toi|soi|lui|eux]
    après mûre réflexion
    après tout ,
    après un certain temps
    après un bon bout de temps


    au-dessus [de|d’] {pronom_obj}
    au-delà du descriptible
    au [dernier|même|bon|mauvais] [moment|instant]
    au bas mot
    au beau fixe
    au bon moment
    au bout du [compte|rouleau]
    au bout d’ un moment
    au cas par cas
    au commencement
    au contraire
    au coude à coude
    au coup par coup
    au cours des @:B [dernières|derniers|prochaines|prochains] [années|mois|siècles] <<- ~>> *
    au demeurant
    au doigt mouillé
    au débotté
    au début
    au fil des ans
    au fil du temps

    au grand [complet|jamais]
    au hasard
    au jour et à l’ heure dits
    au jugé
    au le jour
    au leur
    au lieu de [cela|ceci|ça|quoi]
    au loin
    au milieu de nulle part
    au moment opportun
    au même titre que n’ importe [laquelle|lequel] d’ entre [nous|vous|eux|elles]
    au pas de [charge|course]
    au plus [près|pressé|vite|tôt|tard]
    au plus haut point
    au premier abord
    au propre comme au figuré
    au préalable
    au quotidien
    au ras des pâquerettes

    au saut du lit
    au sens [figuré|large|propre]
    au surplus
    au ~[xXvViI]+[eᵉ] siècle
    ?tout¿ au fond [de|d’] {pronom_obj}
    aux [abois|leurs|mien|miens|mienne|miennes|tien|tiens|tienne|tiennes|sien|siens|sienne|siennes|nôtres|vôtres]
    autant que [nécessaire|possible|prévu]
    autant que faire se peut


    autour [de|d’] {pronom_obj}
    autrement dit
    av. J.-C.
    avant longtemps

    avant terme
    avant tout le monde
    avant toute chose
    avant toutes choses
    avant d’ aller plus loin
    avant J.-C.
    avant Jésus-Christ
    avant d’ en arriver là
    avant de faire quoi que ce soit
    avant de faire quoi que ce soit [de|d’] ?@:W¿ [stupide|crétin|con|idiot]
    avant [qu’|qu] il ne soit trop tard
    avant un bon bout de temps
    avec [brio|joie|légèreté|insistance|peine]
    avec autre chose
    avec le plus grand soin
    avec pertes et fracas
    avec un peu de chance
    avec tout le respect que je [vous|te|leur|lui] dois
    avec tout le respect que nous [vous|te|leur|lui] devons
    avec tout un chacun
    avec un peu de chance
    beaucoup [plus|moins]
    bel et bien
    bien assez tôt
    bien des fois
    bien souvent
    bon gré ?,¿ mal gré
    bras dessus ?,¿ bras dessous
    çà et là
    ce faisant
    [cela|ça|ceci] mis à part 
    [cela|ça|ceci] va sans dire
    ces derniers temps
    cette [fois-là|fois-ci]
    chaque fois
    comme avant
    comme autrefois
    comme d’ habitude
    comme toujours
    comme de juste
    comme bon [me|te|lui|leur|nous|vous] semble
    comme au bon vieux temps
    comme cul et chemise

    comme [frappé|frappée|frappés|frappées] par la foudre
    comme n’ importe où ?ailleurs¿
    comme par [enchantement|magie]

    comme par un fait exprès
    comme promis
    comme qui dirait
    comme si de rien n’ était
    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é
    côte à côte


    [coute|coûte] que [coute|coûte]
    [croyez-le|crois-le] ou [non|pas]
    cul par-dessus tête
    dans [ce|ces] [cas-là|cas-ci]
    dans ce cas [précis|particulier]
    dans ces cas [précis|particuliers]
    dans l’ [idéal|immédiat]
    dans la mesure du possible
    dans les années ~\d\d+
    dans peu de temps
    dans tout [cela|ça|ceci]
    dans très peu de temps
    dans un cas comme dans l’autre
    dans une [certaine|large|moindre] mesure
    début {mois} ~\d\d{2,5}
    au début {mois} ~\d\d{2,5}
    en ce début {mois} ~\d\d{2,5}
    d’ abord
    d’ affilée
    d’ ailleurs
    d’ année en année
    d’ aujourd’hui
    d’ antan
    d’ autant [plus|moins]
    d’ [autrefois|part]
    d’ autres fois
    d’ [arrache-pied|arrachepied]
    d’ arrière en avant
    d’ avant en arrière
    d’ à côté
    d’ âge mûr
    d’ emblée
    d’ empoigne
    d’ en face
    d’ entre [nous|vous|eux|elles]
    d’ entrée de jeu
    d’ est en ouest
    d’ extrême [droite|gauche]
    d’ [extrême-droite|extrême-gauche]
    d’ [égal|égale] à [égal|égale]
    d’ habitude
    d’ heure en heure
    d’ hier ?[matin|soir|après-midi]¿
    d’ ici ?[là|peu]¿
    d’ ici peu de temps
    d’ ordinaire
    d’ origine [inconnue|douteuse|plébéienne|aristocratique]
    d’ ordre général
    d’ où [qu’|qu] [il|elle|on] vienne
    d’ où [qu’|qu] [ils|elles] viennent
    d’ ouest en est
    d’ [ors|ores] et déjà
    d’ un autre côté
    d’ un [bout|jour] à l’ autre
    d’ un côté comme de l’ autre
    d’ un commun accord
    d’ une autre trempe
    d’ une [façon|manière] ou d’une autre
    d’ une certaine [façon|manière]
    d’ une tout autre ampleur
    d’ une [minute|seconde] à l’ autre
    de-ci ?,¿ de-là

    de ~\d+(?:,\d+|) %
    de [cesse|conserve|facto|fait|guingois|luxe|nouveau|permanence|partout|préférence|profundis|rechange|routine|surcroît|surcroit|visu]
    de A à Z
    de bas (?:en haut|étage)
    de basse [condition|extraction]
    de bon [aloi|cœur|gré|matin|sens|ton]
    de bonne [facture|famille|foi|heure|humeur|grâce|qualité|compagnie]
    de bric et de broc
    de but en blanc
    de ce fait ?[incontestable|irréfutable|même]¿
    de ce seul fait
    de ce point de vue
    de cette sorte
    de cet acabit
    de courte [durée|vue]
    de dernière minute
    de demain [matin|soir|après-midi]
    de droite à gauche
    de droite comme de gauche
    de fâcheuse mémoise
    de fil en aiguille
    de fond en comble
    de fort [loin|près]
    de [fraîche|fraiche] date
    de [gaieté|gaîté|gaité] de cœur
    de gauche à droite
    de gauche comme de droite
    de grande [taille|envergure]
    de gré ou de force
    de guerre lasse
    de haut en bas
    de haut [rang|vol]
    de haute [lutte|stature|volée]
    de jour comme de nuit
    de là-bas
    de la meilleure [manière|façon] possible
    de la même [façon|manière]
    de la sorte
    de la tête aux pieds
    de la veille
    de loin
    de loin en loin
    de longue [date|durée|haleine]
    de main de [maître|maitre]
    de mauvais [aloi|goût|gout|gré]
    de mauvaise [foi|grâce|humeur]
    de mieux en mieux
    de nature [étrangère|inconnue|indéterminée|insolite]
    de nombreuses années plus [tôt|tard]
    de nombreuses fois
    de nos jours
    de notoriété publique
    de nulle part
    de pire en pire
    de près
    de près ou de loin
    de par le monde ?entier¿
    de part et d’autre
    de petite taille
    de pied ferme
    de plein [droit|fouet]
    de plus [belle|près]
    de premier [ordre|plan]
    de première [catégorie|main|nécessité]
    de prime abord
    de proche en proche
    de pure forme
    de sang-froid
    de seconde [catégorie|zone|importance|main]
    de si bon matin
    de si bonne heure
    de source sûre
    de taille moyenne
    de telle sorte
    de temps à autre
    de temps en temps
    de [très|trop] [loin|près]
    de vive voix
    de [nous|vous] tous
    de tous [côtés|bords]
    de tout [poil|temps]
    de tout à l’ heure
    de tout premier [ordre|plan]
    de toute [éternité|évidence|façon|urgence]

    de toutes [parts|pièces|sortes]
    de toutes [mes|tes|ses|nos|vos|leurs] forces
    de [mon|ton|son|notre|votre|leur] mieux
    de [mon|ton|son|notre|votre|leur] plein gré
    de [mon|ton|son|notre|votre|leur] point de vue
    de [mon|ton|son|notre|votre|leur] propre [cru|chef]
    de [mon|ton|son|notre|votre|leur] vivant
    de [ma|ta|sa|notre|votre|leur] part

    de moins en moins
    de plus en plus
    de mieux en mieux
    de pire en pire
    de jour en jour
    de minute en minute
    de semaine en semaine
    de mois en mois
    de trimestre en trimestre
    de semestre en semestre
    de siècle en siècle
    de millénaire en millénaire

    de décennie en décennie
    [après-demain|demain] ?[matin|soir|après-midi]¿
    avant demain ?[matin|soir|après-midi]¿
    depuis @:B [ans|années|mois|semaines|jours|heures|minutes|secondes]

    depuis ~\d+ [ans|années|mois|semaines|jours|heures|minutes|secondes]
    depuis assez longtemps
    depuis belle lurette
    depuis bien longtemps
    depuis de ?très¿ longues années
    depuis des lustres
    depuis les années ~\d\d+
    depuis longtemps
    depuis lors
    depuis peu de temps
    depuis quelque temps
    depuis quelques [secondes|minutes|heures|jours|semaines|mois|trimestres|semestres|années|décennies|siècles|millénaires]
    depuis si longtemps
    depuis toujours
    depuis tout ce temps
    depuis très longtemps
    des fois
    des pieds à la tête
    des uns et des autres
    des [années|mois|siècles|millénaires|décennies|semaines] plus [tôt|tard]
    dès [maintenant|lors|aujourd’hui]
    dès à présent
    dès que possible
    dès [demain|hier] ?[soir|matin|après-midi]¿
    Dieu [m’|t’] en [garde|préserve]
    Dieu [m’|t’] en soit témoin
    Dieu [nous|vous] en [garde|préserve]
    Dieu [nous|vous] en soit témoin
    Dieu [les|l’] en [garde|préserve]
    Dieu [leur|lui] en soit témoin
    du ~[xXvViI]+[eᵉ] siècle
    du [Ier|Iᵉʳ|1er|1ᵉʳ] siècle
    du bout des lèvres
    du début à la fin
    du fond du cœur
    du jour au lendemain

    du haut en bas
    du même [acabit|coup|ordre|tonneau]



    du moins ?,¿ pas
    du [nord|sud] au [nord|sud]
    du tout au tout
    eh bien
    en \d\d+ [ans|années|mois|semaines|jours|heures|minutes|secondes]
    en [aparté|apparence|arrière|avance|avant|cachette|ceci|cela|clair|commun|conséquence|continu|contrepartie|définitive|détail|direct|douce|effet|émoi|filigrane|général|goguette|hâte|majorité|outre|pâmoison|parallèle|partie|particulier|permanence|personne|pratique|prime|privé|principe|priorité|public|réalité|retour|revanche|rien|rogne|route|secret|silence|somme|suspens|théorie|trompe-l’œil|vain|vérité|ville|vitesse]
    en aucun cas
    en aucune [circonstance|façon|manière]
    en bon état
    en bonne [compagnie|posture|voie]
    en bonne et due forme|
    en bonne santé ?[physique|mentale|psychique]¿
    en bout de course
    en cas [de|d’] [besoin|doute|urgence]
    en [chacun|chacune] [de|d’] [nous|vous|eux|elles]
    en chair et en os
    en chute libre
    en comparution immédiate
    en connaissance de cause
    en coupe réglée
    en cours de route
    en d’autres [circonstances|termes|temps]
    en de telles circonstances
    en début [de|d’] [journée|matinée|soirée|après-midi]
    en définitive
    en dehors de ?tout¿ [ça|cela|ceci]
    en dents de scie
    en dernier [lieu|recours|ressort]
    en désespoir de cause
    en détention provisoire
    en direction de l’ [est|ouest]
    en direction du [nord|nord-est|nord-ouest|sud|sud-est|sud-ouest]
    en état de choc ?circulatoire¿
    en état de marche
    en état d’ ébriété ?avancée¿
    en excellent état
    en file indienne
    en fin [de|d’] [compte|journée|matinée|soirée|après-midi]
    en forte [baisse|hausse]
    en gage de bonne foi
    en garde à vue ?prolongée¿
    en grand nombre
    en grende [difficulté|majorité|partie|pompe]
    en haut lieu
    en l’occurrence
    en lieu sûr
    en ligne de [compte|mire]
    en mains propres
    en mauvais état
    en mauvaise [posture|santé]
    en même temps
    en milieu [de|d’] [journée|matinée|soirée|après-midi]
    en nombre suffisant
    en nombre plus que suffisant
    en partant de zéro
    en plein [air|cœur|jour]
    en pleine [gueule|figure|forme|poire|nuit|tronche]
    en perte de vitesse
    en peu de temps
    en piteux état
    en point [de|d’] [mire|orgue]
    en position de [force|faiblesse]
    en premier lieu
    en première [instance|ligne]
    en pure perte
    en quantité suffisante
    en quantité plus que suffisante
    en quelque sorte
    en queue de peloton
    en rangs serrés
    en rase campagne
    en règle générale
    en roue libre
    en sens inverse
    en si peu de temps
    en sous-main
    en tête à tête
    en temps et en heure
    en temps [normal|opportun|ordinaire|utile|voulu]
    en termes choisis
    en toile de fond
    en tous les cas
    en tous les sens
    en tout bien tout honneur
    en tout [cas|genre|lieu|sens|temps]
    en tout et pour tout
    en tout état de cause
    en tout premier lieu
    en toute bonne foi
    en toute connaissance de cause
    en toute [circonstance|confiance|discrétion|franchise|hâte|impartialité|impunité|innocence|légalité|liberté|logique|sécurité|simplicité]
    en toutes circonstances
    en un clin d’œil
    en un rien de temps
    en une autre occasion
    en vase clos
    en voie de développement
    en y réfléchissant bien
    en [janvier|février|mars|avril|mai|juin|juillet|août|aout|septembre|octobre|novembre|décembre] dernier
    en [mon|ton|son|leur|notre|votre] âme et conscience
    en [mon|ton|son|leur|notre|votre] for intérieur
    en [mon|ton|son|leur|notre|votre] nom propre
    en ce [moment|temps-là]
    en ce qui [me|te|le|la|les|nous|vous] [concerne|concernait]
    en cet instant
    encore une fois
    encore et [encore|toujours]
    entre {mois} ?~\d{2,5}¿ et {mois} ?~\d{2,5}¿
    entre chien et loup
    entre de [bonnes|mauvaises] mains
    entre l’ [un|une] et l’ autre
    entre les uns et les autres
    entre [quatre|quatr’|quat’] [zyeux|yeux]
    entre [quatre-zyeux|quatr’zyeux|quat’zyeux|quatre-yeux|quatr’yeux|quat’yeux]
    envers et contre tout
    épaule contre épaule
    et   ainsi de suite
    et   tutti quanti
    été comme hiver
    euh
    face à face
    @:B fois de suite
    grosso modo

    [hier|avant-hier] ?[matin|soir|après-midi]¿
    hors [de|d’] [contrôle|portée|atteinte]
    hors d’ état de nuire
    hors du commun
    ici [comme|ou] ailleurs
    ici et [là|maintenant]

    ici même
    ici-bas
    il y a ?très¿ longtemps
    il y a ?très¿ peu de temps
    il y a quelques [secondes|minutes|heures|jours|semaines|mois|année|ans|siècles|millénaires]
    il y a moins de ~\d+ [secondes|minutes|heures|jours|semaines|mois|année|ans|siècles|millénaires]
    il y a ~\d+ [secondes|minutes|heures|jours|semaines|mois|année|ans|siècles|millénaires]
    il y a quelque temps
    il n’y a pas ?si¿ longtemps
    illico presto


    j’ en passe et des [meilleurs|meilleures]
    jour pour jour
    [jusqu’|jusqu] [alors|ici|aujourd’hui|Noël|Pâques]
    [jusqu’|jusqu] au bout des ongles
    [jusqu’|jusqu] au nouvel an
    [jusqu’|jusqu] à aujourd’hui
    [jusqu’|jusqu] à bac
    [jusqu’|jusqu] à présent
    [jusqu’|jusqu] à maintenant
    [jusqu’|jusqu] à récemment
    [jusqu’|jusqu] à [demain|hier] ?[matin|soir|après-midi]¿
    [jusqu’|jusqu] à nouvel ordre
    [jusqu’|jusqu] à plus ample informé
    [jusqu’|jusqu] à plus soif
    [jusqu’|jusqu] à preuve du contraire
    [jusqu’|jusqu] à la fin de [mes|tes|ses|nos|vos|leurs] jours
    [jusqu’|jusqu] à la fin des temps
    [jusqu’|jusqu] à la tombée de la nuit
    [jusqu’|jusqu] à [mon|ton|son|notre|votre|leur] dernier souffle
    [jusqu’|jusqu] à [mon|ton|son|notre|votre|leur] dernier souffle de vie
    [jusqu’|jusqu] à ce que mort s’ensuive
    [jusqu’|jusqu] à ce que [j’|il|elle|on] en sache plus
    [jusqu’|jusqu] à ce que tu en saches plus
    [jusqu’|jusqu] à ce que nous en sachions plus
    [jusqu’|jusqu] à ce que vous en sachiez plus
    [jusqu’|jusqu] à ce que [ils|elles] en sachent plus
    jusque-là
    la plupart du temps
    la main dans la main
    là-bas
    là-haut
    là-dedans
    là-dehors
    là-derrière
    là-dessous
    là-dessus
    là-devant
    là non plus
    la mort dans l’ âme
    le cas échéant
    le moins du monde
    le [moins|plus] [tôt|tard|souvent]

    le [moins|plus] de [temps|monde] possible
    le moment venu
    les [uns|unes] des autres
    les [uns|unes] [après|avec|chez|contre|de|derrière|devant|envers|malgré|pour|sans|sous|sur] les autres
    l’ [un|une] [après|avec|chez|contre|de|derrière|devant|envers|malgré|pour|sans|sous|sur] l’ autre
    l’ [un|une] près de l’autre
    loin [de|d’] là
    loin [de|d’] tout [ça|cela|ceci]
    loin d’ [être|ici]
    loin s’ en [faut|fallait]
    maintes fois
    malgré [ça|cela|ceci|tout]
    manu militari
    mieux [vaut|valait] tard que jamais
    moins que [nécessaire|prévu]
    moitié ** ?,¿ moitié **
    mot pour mot

    ne [lui|leur|m’|t’|nous|vous] en déplaise
    nez à nez
    non loin [de|d’] [ici|là]
    nulle part
    ô combien
    oh
    ou quelque chose d’ approchant
    où bon [me|te|lui|nous|vous|leur] semble
    oui [ou|et] non
    outre mesure
    ni de près ?,¿ ni de loin
    ni plus ?,¿ ni moins
    ni vu ?,¿ ni connu
    non [plus|seulement]
    non sans raison
    quant à présent
    par [à-coups|ailleurs|avance|chance|conséquent|curiosité|contre|défaut|définition|endroits|essence|excellence|exemple|hasard|ici|inadvertance|là|moments|nature|principe|terre]
    par acquit de conscience
    par beau temps
    par bien des [aspects|côtés]
    par bonté de cœur
    par ce biais
    par certains [aspects|côtés]
    par la même occasion
    par la suite
    par le passé
    par les temps qui courent
    par monts et par vaux
    par temps de pluie
    par tout le monde
    par voie de [conséquence|mer|terre]
    par voie d’exception
    par @:B fois
    un par un
    une par une
    deux par deux
    trois par trois
    quatre par quatre
    cinq par cinq
    six par six
    sept par sept
    huit par huit
    neuf par neuf
    dix par dix
    onze par onze
    douze par douze
    treize par treize
    quatorze par quatorze
    quinze par quinze
    seize par seize
    vingt par vingt
    trente par trente
    quarante par quarante
    cinquante par cinquante
    soixante par soixante
    cent par cent
    mille par mille
    bout par bout
    étage par étage
    étape par étape
    fragment par fragment
    morceau par morceau
    niveau par niveau
    pièce par pièce
    par-ci ?,¿ par-là
    par-devant
    par-derrière
    par-dessus le marché
    par-dessus tout
    partant de là

    pas du tout
    pas à pas
    pas le moins du monde
    pendant ce temps-là
    pendant ?[bien|si|assez|très]¿ longtemps
    pendant plusieurs [heures|minutes|secondes|mois|semaines|jours|années|siècles|millénaires|décennies]
    pendant quelque temps
    petit à petit
    peu à peu
    peu de temps auparavant
    peu ou prou
    pile poil
    plein [nord|sud|ouest]
    plein de fois

    plus bas que terre
    plus d’ une fois
    plus du tout

    plus jamais
    plus que [nécessaire|prévu|jamais]

    plus que tout au monde
    plus que toute autre chose
    plus [tôt|tard] que [prévu|nécessaire]
    plusieurs fois
    plusieurs fois de suite
    pour ainsi dire
    pour ce faire
    pour ce que [j’|tu] en [sais|savais]
    pour couronner le tout
    pour de bon
    pour faire bonne mesure
    pour faire simple
    pour la [première|seconde|dernière|~ième$] fois
    pour la [première|seconde|dernière|~ième$] fois de ma vie
    pour la [première|seconde|dernière|~ième$] fois de suite
    pour la suite
    pour le [moment|moins]
    pour le meilleur et pour le pire
    pour l’ [essentiel|instant|heure]
    pour quelque [part|temps]
    pour rien au monde
    pour tout dire
    pour un oui ou pour un non
    pour une fois
    pour y parvenir
    pour ça [vaut|valait]
    pour [ma|ta|sa|notre|votre|leur] [gouverne|part]
    pour [mon|ton|son|notre|votre|leur] propre [compte|bien]
    pour [celui|celle|ceux|celles] que [ça|cela|ceci] intéresse
    pour [celui|celle|ceux|celles] et [celui|celle|ceux|celles] que [ça|cela|ceci] intéresse
    pour [m’|t’|s’|nous|vous] en rendre compte
    quand bien même
    quand bon [me|te|lui|nous|vous|leur] [semble|semblera|semblait]
    quant à [ça|cela|ceci]
    que [ça|ceci|cela] [me|te|lui|leur|nous|vous] plaise ou non
    que je le veuille ou non
    que tu le veuilles ou non
    [qu’|qu] [il|elle|on] le veuille ou non
    que vous le vouliez ou non
    que nous le voulions ou non
    [qu’|qu] [ils|elles] le veuillent ou non
    [qu’|qu] à cela ne tienne

    quel [qu’|qu] en soit le [moyen|prix|danger]
    quel [qu’|qu] en soit le risque ?financier¿
    quelle [qu’|qu] en soit la [cause|raison]
    quelque [part|temps]
    quelques fois
    quelques [instants|secondes|minutes|heures|jours|semaines|mois|années|décennies|siècles|millénaires|trimestres|semestres] auparavant
    quelques [instants|secondes|minutes|heures|jours|semaines|mois|années|décennies|siècles|millénaires|trimestres|semestres] plus [tard|tôt]
    qui plus est
    quoi [qu’|qu] il [arrive|arrivât|advienne|advînt]
    quoi [qu’|qu] il en [coûte|coûtât|coute|coutât]
    sans [grande|grosse] difficulté ?[apparente|aucune|financière|majeure|particulière]¿
    sans [ambages|arrêt|cesse|conteste|doute|encombre|encombres|fin|relâche|répit|trêve|vergogne]
    sans aucun doute
    sans autre forme de procès
    sans commune mesure

    sans coup férir
    sans crier gare
    sans difficulté ?[apparente|aucune|financière|majeure|particulière]¿
    sans dire mot
    sans états d’ âme
    sans foi ?,¿ ni loi
    sans l’ ombre d’ un doute
    sans le faire exprès
    sans le vouloir
    sans mot dire
    sans nul doute
    sans queue ni tête
    sans raison apparente
    sans ?grand¿ succès
    sans faire de vagues
    sans s’ en rendre compte
    sans s’ en apercevoir
    sans l’ aide de personne
    sans y faire attention
    sans y prendre [garde|goût|gout]
    sans y [parvenir|réussir|réfléchir|songer|penser]
    sans pour autant y faire attention
    sans pour autant y prendre [garde|goût|gout]
    sans pour autant y [parvenir|réussir|réfléchir|songer|penser]
    séance tenante
    selon toute vraisemblance
    semble-t-il

    semblait-il
    sens dessus dessous
    [seule|seul] à [seule|seul]
    s’ il [te|vous] [plaît|plait]
    si besoin est
    si [bas|haut|longtemps|nécessaire|possible|soudain]
    si [cela|ça|ceci] ne tenait [qu’|qu] à [moi|toi|lui|eux|elle|elles|nous|vous]
    six pieds sous terre
    sine die
    sine qua non
    soit dit en passant
    soi-disant
    sous aucun prétexte
    sous bonne [escorte|garde]
    sous coupe réglée
    sous haute surveillance
    stricto sensu
    sur ce ,
    sur ce plan-là
    sur le [long|moyen|court] terme
    sur le qui-vive
    sur la forme comme sur le fond
    sur la même longueur d’ onde
    sur [mon|ton|son|notre|votre|leur] [trente-et-un|31]
    sur [mon|ton|son|notre|votre|leur] trente et un
    tant bien que mal
    tant s’ en faut
    tôt ou tard
    tous comptes faits
    tous frais payés
    tout à [fait|coup]
    tout à l’ heure
    tout au plus
    tout aussi bien
    tout bien [considéré|réfléchi]
    tout compte fait
    tout de [même|suite|go]
    tout du long
    tout [bonnement|simplement]
    tout feu ?,¿ tout [flamme|flammes]
    tout le temps
    toutes affaires cessantes
    toutes choses égales par ailleurs
    toutes griffes dehors
    toutes proportions gardées
    trait pour trait
    très [bas|haut|bien|mal]
    un à un
    une à une
    un jour ou l’autre
    un instant plus [tôt|tard]
    un [millier|million|milliard] de fois
    un moment plus [tôt|tard]
    un peu mieux
    un peu moins bien
    un peu partout
    un peu plus [tôt|tard] que prévu
    un tant soit peu
    une à une
    une autre fois
    une bonne fois pour toutes
    une dernière fois
    une fois de plus
    une fois n’ est pas coutume
    une fois pour toutes
    urbi et orbi
    vaille que vaille
    ventre à terre
    vers nulle part
        <<- ~>> *


@@@@
@@@@END_GRAPH                                                                                       
@@@@

 

__[i](p_plus_avant)__           plus avant(?! de | que?) <<- ~>> *




















__[i](p_qui_loc_tps)__          qui (ce (?:jour|matin|après-midi|soir)-là|cette (?:nuit|matinée|soirée)-là) @@4 <<- ~1>> *    


    

































TEST: ils vont et viennent, toujours {{cotes a cotes}}…
TEST: Nous irons {{tours à tours}} chercher du bois.
TEST: Ma thèse en 180 secondes.


# je / tu / il / elles / nous / vous / ils / elles 
__[i](p_je_vous_en_prie)__      je (?:t’en|vous en) (?:prie|supplie) <<- ~>> *
__[i](p_nous_vous_en_prions)__  nous (?:t’en|vous en) (?:prions|supplions) <<- ~>> *

# mot-là
__[i](p_qqch_tiret_là)__        ({w1})(-là) @@0,$ <<- morphex(\1, ":[NAQ]", ":G") ~2>> *

# Après
__[i](p_adv_longtemps)__        (?:bien|si|assez) longtemps <<- ~>> *
__[i](p_plus_loc_adv)__         plus (?:près|loin|tôt|tard|ou moins|que (?:nécessaire|jamais)|d’une fois) <<- ~>> *

## Simplification partielle
__[i](p_ceux_d_entre_pronom)__  ce(?:lui|lles?|ux) (d’entre (?:[nv]ous|eux|elles)) @@$ <<- ~1>> *
__[i](p_chacun_d_entre_nous)__  chacune? (d’entre (?:[nv]ous|eux|elles)) @@$ <<- ~1>> *
__[i](p_tout_au_long_de)__      (tout au long) d(?:es?|u) @@0 <<- not morph(word(-1), ":R", False, False) ~1>> au
__[i](p_à_loc_de1)__            à (bonne distance|bord|cause|contre-courant|côté|court|défaut|droite|gauche|hauteur|l’(?:aff[ûu]t|arrière|autre bout|aune|avant|écart|égard|extérieur|encontre|ins(?:u|tar)|intérieur|opposé|orée|approche)|la (?:hauteur|portée|suite)|partir|portée|pro(?:ximité|pos)|quelques (?:mètres|kilomètres|lieues|pas|centaines de mètres|minutes|heures)|rebours) d(?:es?|u) @@2 <<- ~1>> *
__[i](p_à_loc_de2)__            à (base|force|grand(?: renfort|s coups)|raison) de? @@2 <<- ~1>> *
__[i](p_au_loc_de)__            au (bout|beau milieu|courant|cours|détriment|fin fond|grand dam|fur et à mesure|gré|l(?:ieu|ong|arge)|milieu|nez et à la barbe|plus profond|profit|s(?:ein|ortir|ujet)|vu(?: et au su|)) d(?:es?|u) @@3 <<- ~1>> *
__[i](p_aux_loc_de)__           aux (abords|dépens) d(?:es?|u) @@4 <<- ~1>> *
__[i](p_ceux_et_celles_qui)__   ceux (et celles?) +qui @@5 <<- ~1>> *
__[i](p_compte_tenu_de)__       (compte tenu) d(?:es?|u) @@0 <<- ~1>> avec