Grammalecte  Check-in [0dba21491a]

Overview
Comment:[build] check if rules have same id
Downloads: Tarball | ZIP archive | SQL archive
Timelines: family | ancestors | descendants | both | trunk | build
Files: files | file ages | folders
SHA3-256: 0dba21491a1ec5223aeba119e899c5ebee0ab3bd9ade3ce894e7efb62259673b
User & Date: olr on 2017-05-03 08:00:11
Other Links: manifest | tags
Context
2017-05-03
10:03
[build] use named groups in regex check-in: c761d5a874 user: olr tags: build, trunk
08:00
[build] check if rules have same id check-in: 0dba21491a user: olr tags: build, trunk
2017-05-01
10:46
[build] useless conditions check-in: c4e9c97a0e user: olr tags: build, trunk
Changes

Modified compile_rules.py from [94acd166e0] to [2d30706580].

     6      6   import json
     7      7   from distutils import file_util
     8      8   
     9      9   
    10     10   DEF = {}
    11     11   FUNCTIONS = []
    12     12   
           13  +RULESET = set()     # set of rule-ids to check if there is several rules with the same id
           14  +
    13     15   JSREGEXES = {}
    14     16   
    15     17   WORDLIMITLEFT  = r"(?<![\w.,–-])"   # r"(?<![-.,—])\b"  seems slower
    16     18   WORDLIMITRIGHT = r"(?![\w–-])"      # r"\b(?!-—)"       seems slower
    17     19   
    18     20   
    19     21   def prepareFunction (s):
................................................................................
   177    179       if m:
   178    180           cWordLimitLeft = m.group(1)[0]
   179    181           cCaseMode = m.group(1)[1]
   180    182           cWordLimitRight = m.group(1)[2]
   181    183           sOption = m.group(2)[1:]  if m.group(2)  else False
   182    184           if m.group(3):
   183    185               sRuleId =  m.group(3)[1:-1]
          186  +            if sRuleId in RULESET:
          187  +                print("# Warning. Several rules have the same id: " + sRuleId)
          188  +            RULESET.add(sRuleId)
   184    189           nPriority = dOptPriority.get(sOption, 4)
   185    190           if m.group(4):
   186    191               nPriority = int(m.group(4)[1:])
   187    192           s = s[m.end(0):]
   188    193       else:
   189         -        print("Warning. No option defined at line: " + sLineId)
          194  +        print("# Warning. No option defined at line: " + sLineId)
   190    195   
   191    196       #### REGEX TRIGGER
   192    197       i = s.find(" <<-")
   193    198       if i == -1:
   194    199           print("# Error: no condition at line " + sLineId)
   195    200           return None
   196    201       sRegex = s[:i].strip()
................................................................................
   218    223       for sDef, sRepl in DEF.items():
   219    224           sRegex = sRegex.replace(sDef, sRepl)
   220    225   
   221    226       ## count number of groups (must be done before modifying the regex)
   222    227       nGroup = countGroupInRegex(sRegex)
   223    228       if nGroup > 0:
   224    229           if not tGroups:
   225         -            print("# warning: groups positioning code for JavaScript should be defined at line " + sLineId)
          230  +            print("# Warning: groups positioning code for JavaScript should be defined at line " + sLineId)
   226    231           else:
   227    232               if nGroup != len(tGroups):
   228         -                print("# error: groups positioning code irrelevant at line " + sLineId)
          233  +                print("# Error: groups positioning code irrelevant at line " + sLineId)
   229    234   
   230    235       ## word limit
   231    236       if cWordLimitLeft == '[' and not sRegex.startswith(("^", '’', "'", ",")):
   232    237           sRegex = WORDLIMITLEFT + sRegex
   233    238       if cWordLimitRight == ']' and not sRegex.endswith(("$", '’', "'", ",")):
   234    239           sRegex = sRegex + WORDLIMITRIGHT
   235    240   
................................................................................
   316    321               sURL = mURL.group(1).strip()
   317    322               sMsg = sMsg[:mURL.start(0)].strip()
   318    323           if sMsg[0:1] == "=":
   319    324               sMsg = prepareFunction(sMsg[1:])
   320    325               FUNCTIONS.append(("m"+sIdAction, sMsg))
   321    326               for x in re.finditer("group[(](\d+)[)]", sMsg):
   322    327                   if int(x.group(1)) > nGroup:
   323         -                    print("# error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)")
          328  +                    print("# Error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)")
   324    329               sMsg = "=m"+sIdAction
   325    330           else:
   326    331               for x in re.finditer(r"\\(\d+)", sMsg):
   327    332                   if int(x.group(1)) > nGroup:
   328         -                    print("# error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)")
          333  +                    print("# Error in groups in message at line " + sIdAction + " ("+str(nGroup)+" groups only)")
   329    334               if re.search("[.]\\w+[(]", sMsg):
   330         -                print("# error in message at line " + sIdAction + ":  This message looks like code. Line should begin with =")
          335  +                print("# Error in message at line " + sIdAction + ":  This message looks like code. Line should begin with =")
   331    336               
   332    337       if sAction[0:1] == "=" or cAction == "=":
   333    338           if "define" in sAction and not re.search(r"define\(\\\d+ *, *\[.*\] *\)", sAction):
   334         -            print("# error in action at line " + sIdAction + ": second argument for define must be a list of strings")
          339  +            print("# Error in action at line " + sIdAction + ": second argument for define must be a list of strings")
   335    340           sAction = prepareFunction(sAction)
   336    341           sAction = sAction.replace("m.group(i[4])", "m.group("+str(iGroup)+")")
   337    342           for x in re.finditer("group[(](\d+)[)]", sAction):
   338    343               if int(x.group(1)) > nGroup:
   339         -                print("# error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)")
          344  +                print("# Error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)")
   340    345       else:
   341    346           for x in re.finditer(r"\\(\d+)", sAction):
   342    347               if int(x.group(1)) > nGroup:
   343         -                print("# error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)")
          348  +                print("# Error in groups in replacement at line " + sIdAction + " ("+str(nGroup)+" groups only)")
   344    349           if re.search("[.]\\w+[(]", sAction):
   345         -            print("# error in action at line " + sIdAction + ":  This action looks like code. Line should begin with =")
          350  +            print("# Error in action at line " + sIdAction + ":  This action looks like code. Line should begin with =")
   346    351   
   347    352       if cAction == "-":
   348    353           ## error detected
   349    354           if not sAction:
   350         -            print("# error in action at line " + sIdAction + ":  This action is empty.")
          355  +            print("# Error in action at line " + sIdAction + ":  This action is empty.")
   351    356           if sAction[0:1] == "=":
   352    357               FUNCTIONS.append(("s"+sIdAction, sAction[1:]))
   353    358               sAction = "=s"+sIdAction
   354    359           elif sAction.startswith('"') and sAction.endswith('"'):
   355    360               sAction = sAction[1:-1]
   356    361           if not sMsg:
   357         -            print("# error in action at line " + sIdAction + ":  the message is empty.")
          362  +            print("# Error in action at line " + sIdAction + ":  the message is empty.")
   358    363           return [sCondition, cAction, sAction, iGroup, sMsg, sURL]
   359    364       elif cAction == "~":
   360    365           ## text preprocessor
   361    366           if not sAction:
   362         -            print("# error in action at line " + sIdAction + ":  This action is empty.")
          367  +            print("# Error in action at line " + sIdAction + ":  This action is empty.")
   363    368           if sAction[0:1] == "=":
   364    369               FUNCTIONS.append(("p"+sIdAction, sAction[1:]))
   365    370               sAction = "=p"+sIdAction
   366    371           elif sAction.startswith('"') and sAction.endswith('"'):
   367    372               sAction = sAction[1:-1]
   368    373           return [sCondition, cAction, sAction, iGroup]
   369    374       elif cAction == "=":
   370    375           ## disambiguator
   371    376           if sAction[0:1] == "=":
   372    377               sAction = sAction[1:]
   373    378           if not sAction:
   374         -            print("# error in action at line " + sIdAction + ":  This action is empty.")
          379  +            print("# Error in action at line " + sIdAction + ":  This action is empty.")
   375    380           FUNCTIONS.append(("d"+sIdAction, sAction))
   376    381           sAction = "d"+sIdAction
   377    382           return [sCondition, cAction, sAction]
   378    383       elif cAction == ">":
   379    384           ## no action, break loop if condition is False
   380    385           return [sCondition, cAction, ""]
   381    386       else:

Modified gc_lang/fr/rules.grx from [6773fc0960] to [cda47f3642].

   420    420   # Patronymes composés avec Le/La/Les
   421    421   __[s]__  [A-ZÉÈÂÎ][\w-]+[-–—]L(?:es?|a) [A-ZÉÈÂÎ][\w-]+ <<- ~>> =\0.replace(" ", "_")
   422    422   # IP
   423    423   __[s]__  \d+[.:]\d+[.:]\d+[.:]\d+  <<- ~>> *
   424    424   # mètres (m)
   425    425   __[s>__  "\d+ (m) "  @@w <<- ~1>> _
   426    426   # heures
   427         -__[s]__  (?:à |)[012]?\d[h:]\d\d(?:[m:]\d\ds?|) <<- ~>> *
          427  +__[s]__  (?:de |à |)[012]?\d[h:]\d\d(?:[m:]\d\ds?|) <<- ~>> *
   428    428   # crochets
   429    429   __[s]__  \[…\] <<- ~>> *
   430    430   __[s]__  \[({w_1})\] @@1
   431    431       <<- \1.isdigit() ~>> *
   432    432       <<- __else__ ~>> _
   433    433   __[s]__  \(…\)
   434    434       <<- ->> […]                                                                                     # Pour indiquer une troncature de texte, on utilise usuellement des crochets.
................................................................................
  1891   1891       <<- \0.endswith("s") ->> Ils|ils                                                                # Erreur de numérisation ?
  1892   1892       <<- __else__ ->> Il|il                                                                          # Erreur de numérisation ?
  1893   1893   
  1894   1894   TEST: __ocr__ {{Us}} arrive demain.
  1895   1895   
  1896   1896   
  1897   1897   # il / i1 / if / 11
  1898         -__[i]/ocr(ocr_il_ils2)__
         1898  +__[i]/ocr(ocr_il_ils3)__
  1899   1899       [i1][1f]s?
  1900   1900       <<- not \0.endswith("s") ->> Il|il                                                              # Erreur de numérisation ?
  1901   1901       <<- __else__ ->> Ils|ils                                                                        # Erreur de numérisation ?
  1902   1902   
  1903   1903   TEST: __ocr__ {{i1s}} en savent beaucoup trop pour leur propre bien.
  1904   1904   
  1905   1905   
................................................................................
  3100   3100       ne ([cç]’) @@3 <<- -1>> s’                                              # Confusion. Ce chien, ce chat… Se demander, se croire…
  3101   3101   __[i]/conf(conf_ce_conj_prep)__
  3102   3102       (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
  3103   3103   __[i]/conf(conf_qui_se_verbe)__
  3104   3104       qui (ce) ({w_2})  @@4,$
  3105   3105       <<- morphex(\2, ":V", ":[NAQ].*:[me]") or before(r"(?i)\b[cs]e +")
  3106   3106       -1>> se                                                                 # Confusion probable. Exemples : ce bâtiment, se perdre.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=2440
  3107         -__[i]/conf(conf_ce_être)__
         3107  +__[i]/conf(conf_ceux_ce_être)__
  3108   3108       (ceux) (?:ne |)(?:sont|serai(?:en|)[ts]?|f[uû](?:ren|)t|n’(?!ayant|étant)\w+) @@0
  3109   3109       <<- -1>> ce                                                             # Confusion.|http://www.intellego.fr/soutien-scolaire-6eme/aide-scolaire-francais/ce-ceux-ou-se/3829
  3110   3110   __[s]/conf(conf_ce_ne_être_doit)__
  3111   3111       ([sS]e) n(?:e |’)({être}|d[eouû]\w+|p[oeuû]\w+)  @@0,$
  3112   3112       <<- morph(\2, ">(?:être|pouvoir|devoir) .*:3s", False)
  3113   3113       -1>> ce                                                                 # Confusion probable.|http://bdl.oqlf.gouv.qc.ca/bdl/gabarit_bdl.asp?id=2440
  3114   3114   __[i]/conf(conf_ce_ne)__
................................................................................
  3451   3451   TEST: Elle va regarder ça de plus {{prêt}}.
  3452   3452   
  3453   3453   
  3454   3454   # quand / quant / qu’en
  3455   3455   __[i]/conf(conf_quant_à)__
  3456   3456       (?<![dD]e )(quand) (?:à|aux?)  @@0
  3457   3457       <<- not morph(word(-1), ">(?:arriver|venir|à|revenir|partir|aller) ") -1>> quant                # Confusion probable. Quand = à quel moment. Quant à = à propos de.
  3458         -__[i]/conf(conf_quand)__    quant(?! à| aux?| est[ -]il d(?:es?|u) ) <<- ->> quand                  # Confusion. Quand = à quel moment. Quant à = à propos de.
         3458  +__[i]/conf(conf_quand1)__   quant(?! à| aux?| est[ -]il d(?:es?|u) ) <<- ->> quand                  # Confusion. Quand = à quel moment. Quant à = à propos de.
  3459   3459   __[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… ?
  3460   3460   __[i]/conf(conf_qu_en2)__   (quan[dt]) ({w_2}ant) @@0,$ <<- morph(\2, ":P", False) -1>> qu’en       # Confusion probable.
  3461         -__[i]/conf(conf_quand)__
         3461  +__[i]/conf(conf_quand2)__
  3462   3462       (qu en) (?:je|tu|ils?) @@0
  3463   3463       <<- not after("^ +ne s(?:ai[st]|u[st]|urent|avai(?:[ts]|ent)) ") -1>> quand                     # Confusion probable. Pour évoquer un moment, écrivez :
  3464   3464   
  3465   3465   TEST: {{Quant}} est-il du chien ?
  3466   3466   TEST: {{Quand}} à ma santé, elle est défaillante.
  3467   3467   TEST: {{Quant}} ils…
  3468   3468   TEST: {{quant}} je…
................................................................................
  6956   6956       comme même <<- morph(word(1), ":(?:Os|C)", False, True) ->> quand même                # Confusion probable.|http://fr.wiktionary.org/wiki/quand_m%C3%AAme
  6957   6957   
  6958   6958   TEST: {{comme même}} il y va fort, le saligaud !
  6959   6959   TEST: La météo disait qu’il ferait beau temps, mais il pleut {{comme même}}…
  6960   6960   
  6961   6961   
  6962   6962   # quel que soit / quoi qu’il en soit
  6963         -__[i]/conf(conf_quel_que_soit)__
         6963  +__[i]/conf(conf_quel_que_soit1)__
  6964   6964       quelques? soi(?:ent|t|s|)
  6965   6965       <<- ->> quel que soit|quelle que soit|quels que soient|quelles que soient             # Confusion.|https://fr.wiktionary.org/wiki/quel_que_soit
  6966   6966   __[i]/conf(conf_quoi_qu_il_en_soit)__
  6967   6967       quoiqu il en soit <<- not morph(word(1), ":[AQ]", False) ->> quoi qu’il en soit       # Confusion.|https://fr.wiktionary.org/wiki/quoi_qu%E2%80%99il_en_soit
  6968   6968   
  6969   6969   TEST: {{quelques soient}} les avantages d’un correcteur…
  6970   6970   TEST: {{quoiqu’il en soit}}, nous ne nous laisserons pas faire, vous pouvez compter sur nous.
................................................................................
  7101   7101   
  7102   7102   __[i]/conf(conf_prep_soi)__
  7103   7103       (?:chez|don de|sur|avec|pour) (soit) @@$ <<- not after(" soit ") -1>> soi                       # Confusion probable.
  7104   7104   __[i]/conf(conf_en_soi)__
  7105   7105       (?<!’)en (soit)  @@3
  7106   7106       <<- morph(word(1), ":[GY]", True, True) and not before("(?i)quel(?:s|les?|) qu $|on $|il $") and not after(" soit ")
  7107   7107       -1>> soi                                                                                        # Confusion probable.
  7108         -__[i]/conf(conf_quel_que_soit)__
         7108  +__[i]/conf(conf_quel_que_soit2)__
  7109   7109       quel(?:le|)s? que (soi(?:es?|)) @@$ <<- -1>> soit|soient                                        # Confusion probable. 
  7110   7110   __[i]/conf(conf_soi_même1)__
  7111   7111       (soi[tes]s? mêmes?) @@$
  7112   7112       <<- morph(word(-1), ":[YQ]|>(?:avec|contre|par|pour|sur) ", False, True) -1>> soi-même          # Confusion probable : moi-même, toi-même, lui-même, elle-même, soi-même, elles-mêmes, eux-mêmes.
  7113   7113   __[i]/conf(conf_soi_même2)__
  7114   7114       soi[tes]s?-mêmes? <<- ->> soi-même                                                              # Confusion : moi-même, toi-même, lui-même, elle-même, soi-même, elles-mêmes, eux-mêmes.
  7115   7115   
................................................................................
  8024   8024   TEST: Ils la laissèrent {{malades}}.
  8025   8025   TEST: Ils la laissent prendre le train.
  8026   8026   TEST: Elle te laisse finir le travail.
  8027   8027   TEST: Je me laisse de quoi finir.
  8028   8028   TEST: Il te laisse trois jours de délai.
  8029   8029   
  8030   8030   
  8031         -__[i]/ppas(ppas_me_te_laisser_adj)__
         8031  +__[i]/ppas(ppas_nous_les_laisser_adj)__
  8032   8032       (nous|les) +(laiss\w*) +({w_3})  @@0,w,$
  8033   8033       <<- morph(\2, ">laisser ", False) and morphex(\3, ":[AQ].*:s", ":(?:[YG]|[AQ].*:[ip])")
  8034   8034       and (\1.endswith("es") or ( \1.endswith("us") and not \2.endswith("ons") )) -3>> =suggPlur(@)   # Accord avec « \1 » : « \3 » devrait être au pluriel.
  8035   8035   
  8036   8036   TEST: je les laisse {{indifférent}}.
  8037   8037   TEST: elle nous laissera {{perdu}} dans nos délires.
  8038   8038   TEST: je les laisse indifférents.
................................................................................
  8549   8549       and (morphex(\3, ":[NAQ].*:s", ":[GWpi]") or morphex(\3, ":[NAQ].*:m", ":[GWYfe]"))
  8550   8550       and (not re.search("^(?:elles|celles-(?:ci|là)|lesquelles)$", \1) or not morph(word(-1), ":R", False, False))
  8551   8551       -3>> =suggFemPlur(@)                                                     # Accord avec le sujet « \1 » : « \3 » devrait être au féminin pluriel.
  8552   8552   
  8553   8553   TEST: elles se sentent {{perdu}}
  8554   8554   
  8555   8555   
  8556         -__[i]/ppas(ppas_le_verbe)__
         8556  +__[i]/ppas(ppas_le_verbe_pensée)__
  8557   8557       le ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2}[esx])  @@w,$
  8558   8558       <<- morph(\1, ">(?:trouver|considérer|croire|rendre|voilà) ", False) and morphex(\2, ":[AQ]:(?:[me]:p|f)", ":(?:G|Y|[AQ]:m:[is])")
  8559   8559       -2>> =suggMasSing(@)                                                     # Accord avec le COD “le” : « \2 » doit être au masculin singulier.
  8560         -__[i]/ppas(ppas_la_verbe)__
         8560  +__[i]/ppas(ppas_la_verbe_pensée)__
  8561   8561       la ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2}[uiéesx])  @@w,$
  8562   8562       <<- morph(\1, ">(?:trouver|considérer|croire|rendre|voilà) ", False) and morphex(\2, ":[AQ]:(?:[fe]:p|m)", ":(?:G|Y|[AQ]:f:[is])")
  8563   8563       -2>> =suggFemSing(@)                                                     # Accord avec le COD “la” : « \2 » doit être au féminin singulier.
  8564         -__[i]/ppas(ppas_les_verbe)__
         8564  +__[i]/ppas(ppas_les_verbe_pensée)__
  8565   8565       les ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2})  @@w,$
  8566   8566       <<- morph(\1, ">(?:trouver|considérer|croire|rendre|voilà) ", False) and morphex(\2, ":[AQ].*:s", ":(?:G|Y|[AQ].*:[ip])")
  8567   8567       -2>> =suggPlur(@)                                                        # Accord avec le COD “les” : « \2 » doit être au pluriel.
  8568         -__[i]/ppas(ppas_me_te_verbe)__
         8568  +__[i]/ppas(ppas_me_te_verbe_pensée)__
  8569   8569       ([mt]e) ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2}[sx])  @@0,w,$
  8570   8570       <<- morph(\2, ">(?:trouver|considérer|croire|rendre|voilà) ", False) and morphex(\3, ":[AQ].*:p", ":(?:G|Y|[AQ].*:[is])")
  8571   8571       -3>> =suggSing(@)                                                        # Accord avec le pronom “\1” : « \3 » doit être au singulier.
  8572         -__[i]/ppas(ppas_se_verbe)__
         8572  +__[i]/ppas(ppas_se_verbe_pensée)__
  8573   8573       se ((?:trouv|consid[éè]r|cr[ouû]|rend)\w*) +({w_3})  @@w,$
  8574   8574       <<- morph(\1, ">(?:trouver|considérer|croire|rendre) .*:3s", False) and morphex(\2, ":[AQ].*:p", ":(?:G|Y|[AQ].*:[is])")
  8575   8575       -2>> =suggSing(@)                                                        # Accord avec le pronom “se” (le verbe étant au singulier) : « \2 » doit être au singulier.
  8576   8576       <<- morph(\1, ">(?:trouver|considérer|croire|rendre) .*:3p", False) and morphex(\2, ":[AQ].*:s", ":(?:G|Y|[AQ].*:[ip])")
  8577   8577       -2>> =suggSing(@)                                                        # Accord avec le pronom “se” (le verbe étant au pluriel) : « \2 » doit être au pluriel.
  8578         -__[i]/ppas(ppas_nous_verbe)__
         8578  +__[i]/ppas(ppas_nous_verbe_pensée)__
  8579   8579       nous ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2})  @@w,$
  8580   8580       <<- ( morphex(\1, ">(?:trouver|considérer|croire|rendre|voilà) ", ":1p")
  8581   8581       or (morph(\1, ">(?:trouver|considérer|croire) .*:1p", False) and before(r"\bn(?:ous|e) +$")) )
  8582   8582       and morphex(\2, ":[AQ].*:s", ":(?:G|Y|[AQ].*:[ip])")
  8583   8583       -2>> =suggPlur(@)                                                        # Accord avec le pronom “nous” : « \2 » doit être au pluriel.
  8584   8584   #__[i]/ppas(ppas_vous_verbe)__
  8585   8585   #    vous ((?:trouv|consid[éè]r|cr[ouû]|rend|voilà)\w*) +({w_2})  @@w,$
................................................................................
  8679   8679       <<- morph(\1, ">avoir ", False) and morphex(\2, ":Q.*:(?:f|m:p)", ":m:[si]")
  8680   8680       -2>> =suggMasSing(@)
  8681   8681       # Le participe passé devrait être au masculin singulier.|http://fr.wikipedia.org/wiki/Accord_du_participe_pass%C3%A9_en_fran%C3%A7ais
  8682   8682   
  8683   8683   TEST: des hommes, des femmes, des enfants qui ne leur avaient {{faits}} que du bien.
  8684   8684   
  8685   8685   
  8686         -__[i]/ppas(ppas_avoir)__
         8686  +__[i]/ppas(ppas_avoir_ppas_mas_sing)__
  8687   8687       avoir +({w_2})  @@$
  8688   8688       <<- not re.search("(?i)^(?:confiance|cours|envie|peine|prise|crainte|cure|affaire|hâte|force|recours)$", \1)
  8689   8689       and morphex(\1, ":Q.*:(?:f|m:p)", ":m:[si]") and before("(?i)(?:après +$|sans +$|pour +$|que? +$|quand +$|, +$|^ *$)")
  8690   8690       -1>> =suggMasSing(@)
  8691   8691       # Le participe passé devrait être au masculin singulier.|http://fr.wikipedia.org/wiki/Accord_du_participe_pass%C3%A9_en_fran%C3%A7ais
  8692   8692   
  8693   8693   TEST: Il a {{prit}} le train.
................................................................................
  8788   8788       and (morphex(\2, ":V[0-3]..t.*:Q.*:f", ":[GWme]") or morphex(\2, ":V[0-3]..t.*:Q.*:p", ":[GWsi]"))
  8789   8789       -2>> =suggMasSing(@)
  8790   8790       # Le participe passé devrait être au masculin singulier.|http://fr.wikipedia.org/wiki/Accord_du_participe_pass%C3%A9_en_fran%C3%A7ais
  8791   8791   
  8792   8792   TEST: ce que ça a {{donnée}}
  8793   8793   
  8794   8794   
  8795         -__[i]/ppas(ppas_avoir)__
         8795  +__[i]/ppas(ppas_avoir_conf_infi)__
  8796   8796       ({avoir}) +({w_2}e[rz])  @@0,$
  8797   8797       <<- not re.search("^(?:A|avions)$", \1) and morph(\1, ":V0a", False) and morph(\2, ":V.+:(?:Y|2p)", False)
  8798   8798       -2>> =suggVerbPpas(@, ":m:s")                                                                   # Incohérence avec « \1 » : « \2 » n’est pas un participe passé.
  8799   8799       <<- __also__ and \1 == "a" and \2.endswith("r") and not before(r"(?i)\b(?:[mtn]’|il +|on +|elle +)$")
  8800   8800       -1>> à                                                                                          # Confusion probable : “a” est une conjugaison du verbe avoir. Pour la préposition, écrivez :
  8801   8801   
  8802   8802   TEST: Avoir {{marcher}} toute la journée m’a épuisée.
................................................................................
 10235  10235   TEST: J’{{aimerai}} savoir ce dont il retourne.
 10236  10236   TEST: dans tous les cas j’{{aimerai}} ne rien savoir
 10237  10237   TEST: Je {{voudrai}} qu’il soit déjà là.
 10238  10238   TEST: J’aimerai ces cours-là autant que les autres.
 10239  10239   TEST: J’aimerai la danse et la musique, puisque vous l’exigez.
 10240  10240   
 10241  10241   
 10242         -__[i>/vmode(vmode_j_aurais_aimé_que_avoir_être)__
 10243         -    j’(aurai) +(?:aimé|souhaité|préféré|voulu) +(?:que? |> )  @@2
        10242  +__[i>/vmode(vmode_j_aurais_aimé_que_avoir_être1)__
        10243  +    j’(aurai) +(?:aimé|souhaité|préféré|voulu) +(?:que? |ne |> )  @@2
 10244  10244       <<- -1>> aurais|eusse                           # Pour un souhait passé, utilisez le conditionnel passé et non le futur antérieur. Exemple pour le futur antérieur : « quand j’aurai fini… »
 10245         -__[i]/vmode(vmode_j_aurais_aimé_que_avoir_être)__
 10246         -    j’(aurai) +(?:aimé|souhaité|préféré|voulu) +({infi}|ne)  @@2,$
 10247         -    <<- morph(\2, ":[YX]", False)
        10245  +__[i]/vmode(vmode_j_aurais_aimé_que_avoir_être2)__
        10246  +    j’(aurai) +(?:aimé|souhaité|préféré|voulu) +(?:[nmtsl]’|)({infi})  @@2,$
        10247  +    <<- morph(\2, ":Y", False)
 10248  10248       -1>> aurais|eusse                               # Pour un souhait passé, utilisez le conditionnel passé et non le futur antérieur. Exemple pour le futur antérieur : « quand j’aurai fini… »
 10249  10249   
 10250  10250   TEST: J’{{aurai}} aimé nous offrir ce magnifique cadeau.
 10251  10251   TEST: j’{{aurai}} voulu être un artiste.
 10252  10252   TEST: j’{{aurai}} préféré ne pas avoir à l’entendre.
 10253  10253   TEST: Quand j’en aurai fini avec eux, vous aurez du mal à les reconnaître.
 10254  10254   TEST: Quand j’aurai fini ce boulot, je ne sais pas ce que je ferai.