7.2.060

   1 To: vim-dev@vim.org
   2 Subject: Patch 7.2.060
   3 Fcc: outbox
   4 From: Bram Moolenaar <Bram@moolenaar.net>
   5 Mime-Version: 1.0
   6 Content-Type: text/plain; charset=ISO-8859-1
   7 Content-Transfer-Encoding: 8bit
   8 ------------
   9
  10 Patch 7.2.060
  11 Problem:    When a spell files has many compound rules it may take a very long
  12             time making the list of suggestions.  Displaying also can be slow
  13             when there are misspelled words.
  14             Can't parse some Hunspell .aff files.
  15 Solution:   Check if a compounding can possibly work before trying a
  16             combination, if the compound rules don't contain wildcards.
  17             Implement using CHECKCOMPOUNDPATTERN.
  18             Ignore COMPOUNDRULES.  Ignore a comment after most items.
  19             Accept ONLYINCOMPOUND as an alias for NEEDCOMPOUND.
  20             Accept FORBIDDENWORD as an alias for BAD.
  21 Files:      runtime/doc/spell.txt, src/spell.c
  22
  23
  24 *** ../vim-7.2.059/runtime/doc/spell.txt        Sat Aug  9 19:36:52 2008
  25 --- runtime/doc/spell.txt       Sun Nov 30 16:30:02 2008
  26 ***************
  27 *** 1,4 ****
  28 ! *spell.txt*   For Vim version 7.2.  Last change: 2008 Jun 21
  29
  30
  31                   VIM REFERENCE MANUAL    by Bram Moolenaar
  32 --- 1,4 ----
  33 ! *spell.txt*   For Vim version 7.2.  Last change: 2008 Nov 30
  34
  35
  36                   VIM REFERENCE MANUAL    by Bram Moolenaar
  37 ***************
  38 *** 831,838 ****
  39
  40         # comment line ~
  41
  42 ! With some items it's also possible to put a comment after it, but this isn't
  43 ! supported in general.
  44
  45
  46   ENCODING                                                      *spell-SET*
  47 --- 831,841 ----
  48
  49         # comment line ~
  50
  51 ! Items with a fixed number of arguments can be followed by a comment.  But only
  52 ! if none of the arguments can contain white space.  The comment must start with
  53 ! a "#" character.  Example:
  54 !
  55 !       KEEPCASE =  # fix case for words with this flag ~
  56
  57
  58   ENCODING                                                      *spell-SET*
  59 ***************
  60 *** 965,970 ****
  61 --- 968,976 ----
  62
  63   Note: When using utf-8 only characters up to 65000 may be used for flags.
  64
  65 + Note: even when using "num" or "long" the number of flags available to
  66 + compounding and prefixes is limited to about 250.
  67 +
  68
  69   AFFIXES
  70                                             *spell-PFX* *spell-SFX*
  71 ***************
  72 *** 1178,1183 ****
  73 --- 1185,1193 ----
  74   The flag also applies to the word with affixes, thus this can be used to mark
  75   a whole bunch of related words as bad.
  76
  77 +                                                       *spell-FORBIDDENWORD*
  78 + FORBIDDENWORD can be used just like BAD.  For compatibility with Hunspell.
  79 +
  80                                                         *spell-NEEDAFFIX*
  81   The NEEDAFFIX flag is used to require that a word is used with an affix.  The
  82   word itself is not a good word (unless there is an empty affix).  Example:
  83 ***************
  84 *** 1268,1273 ****
  85 --- 1278,1287 ----
  86
  87         NEEDCOMPOUND & ~
  88
  89 +                                                       *spell-ONLYINCOMPOUND*
  90 + The ONLYINCOMPOUND does exactly the same as NEEDCOMPOUND.  Supported for
  91 + compatiblity with Hunspell.
  92 +
  93                                                         *spell-COMPOUNDMIN*
  94   The minimal character length of a word used for compounding is specified with
  95   COMPOUNDMIN.  Example:
  96 ***************
  97 *** 1328,1333 ****
  98 --- 1342,1361 ----
  99   rules.  Can also be used for an affix to count the affix as a compounding
 100   word.
 101
 102 +                                               *spell-CHECKCOMPOUNDPATTERN*
 103 + CHECKCOMPOUNDPATTERN is used to define patterns that, when matching at the
 104 + position where two words are compounded together forbids the compound.
 105 + For example:
 106 +       CHECKCOMPOUNDPATTERN o e ~
 107 +
 108 + This forbids compounding if the first word ends in "o" and the second word
 109 + starts with "e".
 110 +
 111 + The arguments must be plain text, no patterns are actually supported, despite
 112 + the item name.  Case is always ignored.
 113 +
 114 + The Hunspell feature to use three arguments and flags is not supported.
 115 +
 116                                                         *spell-SYLLABLE*
 117   The SYLLABLE item defines characters or character sequences that are used to
 118   count the number of syllables in a word.  Example:
 119 ***************
 120 *** 1496,1501 ****
 121 --- 1524,1533 ----
 122   ACCENT                (Hunspell)                              *spell-ACCENT*
 123                 Use MAP instead. |spell-MAP|
 124
 125 + BREAK         (Hunspell)                              *spell-BREAK*
 126 +               Define break points.  Unclear how it works exactly.
 127 +               Not supported.
 128 +
 129   CHECKCOMPOUNDCASE  (Hunspell)                 *spell-CHECKCOMPOUNDCASE*
 130                 Disallow uppercase letters at compound word boundaries.
 131                 Not supported.
 132 ***************
 133 *** 1512,1520 ****
 134                 Forbid three identical characters when compounding.  Not
 135                 supported.
 136
 137 - CHECKCOMPOUNDPATTERN  (Hunspell)              *spell-CHECKCOMPOUNDPATTERN*
 138 -               Forbid compounding when patterns match.  Not supported.
 139 -
 140   COMPLEXPREFIXES  (Hunspell)                           *spell-COMPLEXPREFIXES*
 141                 Enables using two prefixes.  Not supported.
 142
 143 --- 1544,1549 ----
 144 ***************
 145 *** 1536,1548 ****
 146   COMPOUNDMIDDLE        (Hunspell)                              *spell-COMPOUNDMIDDLE*
 147                 Use COMPOUNDRULE instead. |spell-COMPOUNDRULE|
 148
 149   COMPOUNDSYLLABLE  (Hunspell)                  *spell-COMPOUNDSYLLABLE*
 150                 Use SYLLABLE and COMPOUNDSYLMAX instead. |spell-SYLLABLE|
 151                 |spell-COMPOUNDSYLMAX|
 152
 153 ! FORBIDDENWORD (Hunspell)                              *spell-FORBIDDENWORD*
 154 !               Use BAD instead. |spell-BAD|
 155 !
 156   LANG          (Hunspell)                              *spell-LANG*
 157                 This specifies language-specific behavior.  This actually
 158                 moves part of the language knowledge into the program,
 159 --- 1565,1582 ----
 160   COMPOUNDMIDDLE        (Hunspell)                              *spell-COMPOUNDMIDDLE*
 161                 Use COMPOUNDRULE instead. |spell-COMPOUNDRULE|
 162
 163 + COMPOUNDRULES (Hunspell)                              *spell-COMPOUNDRULES*
 164 +               Number of COMPOUNDRULE lines following.  Ignored, but the
 165 +               argument must be a number.
 166 +
 167   COMPOUNDSYLLABLE  (Hunspell)                  *spell-COMPOUNDSYLLABLE*
 168                 Use SYLLABLE and COMPOUNDSYLMAX instead. |spell-SYLLABLE|
 169                 |spell-COMPOUNDSYLMAX|
 170
 171 ! KEY           (Hunspell)                              *spell-KEY*
 172 !               Define characters that are close together on the keyboard.
 173 !               Used to give better suggestions.  Not supported.
 174 !
 175   LANG          (Hunspell)                              *spell-LANG*
 176                 This specifies language-specific behavior.  This actually
 177                 moves part of the language knowledge into the program,
 178 ***************
 179 *** 1553,1562 ****
 180                 Only needed for morphological analysis.
 181
 182   MAXNGRAMSUGS  (Hunspell)                              *spell-MAXNGRAMSUGS*
 183 !               Not supported.
 184 !
 185 ! ONLYINCOMPOUND        (Hunspell)                              *spell-ONLYINCOMPOUND*
 186 !               Use NEEDCOMPOUND instead. |spell-NEEDCOMPOUND|
 187
 188   PSEUDOROOT    (Hunspell)                              *spell-PSEUDOROOT*
 189                 Use NEEDAFFIX instead. |spell-NEEDAFFIX|
 190 --- 1587,1593 ----
 191                 Only needed for morphological analysis.
 192
 193   MAXNGRAMSUGS  (Hunspell)                              *spell-MAXNGRAMSUGS*
 194 !               Set number of n-gram suggestions.  Not supported.
 195
 196   PSEUDOROOT    (Hunspell)                              *spell-PSEUDOROOT*
 197                 Use NEEDAFFIX instead. |spell-NEEDAFFIX|
 198 *** ../vim-7.2.059/src/spell.c  Sat Nov 29 20:18:44 2008
 199 --- src/spell.c Sun Nov 30 20:59:13 2008
 200 ***************
 201 *** 469,474 ****
 202 --- 469,475 ----
 203       garray_T  sl_comppat;     /* CHECKCOMPOUNDPATTERN items */
 204       regprog_T *sl_compprog;   /* COMPOUNDRULE turned into a regexp progrm
 205                                  * (NULL when no compounding) */
 206 +     char_u    *sl_comprules;  /* all COMPOUNDRULE concatenated (or NULL) */
 207       char_u    *sl_compstartflags; /* flags for first compound word */
 208       char_u    *sl_compallflags; /* all flags for compound words */
 209       char_u    sl_nobreak;     /* When TRUE: no spaces between words */
 210 ***************
 211 *** 839,845 ****
 212 --- 840,849 ----
 213   static void slang_clear __ARGS((slang_T *lp));
 214   static void slang_clear_sug __ARGS((slang_T *lp));
 215   static void find_word __ARGS((matchinf_T *mip, int mode));
 216 + static int match_checkcompoundpattern __ARGS((char_u *ptr, int wlen, garray_T *gap));
 217   static int can_compound __ARGS((slang_T *slang, char_u *word, char_u *flags));
 218 + static int can_be_compound __ARGS((trystate_T *sp, slang_T *slang, char_u *compflags, int flag));
 219 + static int match_compoundrule __ARGS((slang_T *slang, char_u *compflags));
 220   static int valid_word_prefix __ARGS((int totprefcnt, int arridx, int flags, char_u *word, slang_T *slang, int cond_req));
 221   static void find_prefix __ARGS((matchinf_T *mip, int mode));
 222   static int fold_more __ARGS((matchinf_T *mip));
 223 ***************
 224 *** 1519,1524 ****
 225 --- 1523,1533 ----
 226                                             ((unsigned)flags >> 24)))
 227                     continue;
 228
 229 +               /* If there is a match with a CHECKCOMPOUNDPATTERN rule
 230 +                * discard the compound word. */
 231 +               if (match_checkcompoundpattern(ptr, wlen, &slang->sl_comppat))
 232 +                   continue;
 233 +
 234                 if (mode == FIND_COMPOUND)
 235                 {
 236                     int     capflags;
 237 ***************
 238 *** 1577,1582 ****
 239 --- 1586,1596 ----
 240                     if (!can_compound(slang, fword, mip->mi_compflags))
 241                         continue;
 242                 }
 243 +               else if (slang->sl_comprules != NULL
 244 +                            && !match_compoundrule(slang, mip->mi_compflags))
 245 +                   /* The compound flags collected so far do not match any
 246 +                    * COMPOUNDRULE, discard the compounded word. */
 247 +                   continue;
 248             }
 249
 250             /* Check NEEDCOMPOUND: can't use word without compounding. */
 251 ***************
 252 *** 1727,1732 ****
 253 --- 1741,1779 ----
 254   }
 255
 256   /*
 257 +  * Return TRUE if there is a match between the word ptr[wlen] and
 258 +  * CHECKCOMPOUNDPATTERN rules, assuming that we will concatenate with another
 259 +  * word.
 260 +  * A match means that the first part of CHECKCOMPOUNDPATTERN matches at the
 261 +  * end of ptr[wlen] and the second part matches after it.
 262 +  */
 263 +     static int
 264 + match_checkcompoundpattern(ptr, wlen, gap)
 265 +     char_u    *ptr;
 266 +     int               wlen;
 267 +     garray_T  *gap;  /* &sl_comppat */
 268 + {
 269 +     int               i;
 270 +     char_u    *p;
 271 +     int               len;
 272 +
 273 +     for (i = 0; i + 1 < gap->ga_len; i += 2)
 274 +     {
 275 +       p = ((char_u **)gap->ga_data)[i + 1];
 276 +       if (STRNCMP(ptr + wlen, p, STRLEN(p)) == 0)
 277 +       {
 278 +           /* Second part matches at start of following compound word, now
 279 +            * check if first part matches at end of previous word. */
 280 +           p = ((char_u **)gap->ga_data)[i];
 281 +           len = STRLEN(p);
 282 +           if (len <= wlen && STRNCMP(ptr + wlen - len, p, len) == 0)
 283 +               return TRUE;
 284 +       }
 285 +     }
 286 +     return FALSE;
 287 + }
 288 +
 289 + /*
 290    * Return TRUE if "flags" is a valid sequence of compound flags and "word"
 291    * does not have too many syllables.
 292    */
 293 ***************
 294 *** 1773,1778 ****
 295 --- 1820,1917 ----
 296   }
 297
 298   /*
 299 +  * Return TRUE when the sequence of flags in "compflags" plus "flag" can
 300 +  * possibly form a valid compounded word.  This also checks the COMPOUNDRULE
 301 +  * lines if they don't contain wildcards.
 302 +  */
 303 +     static int
 304 + can_be_compound(sp, slang, compflags, flag)
 305 +     trystate_T        *sp;
 306 +     slang_T   *slang;
 307 +     char_u    *compflags;
 308 +     int               flag;
 309 + {
 310 +     /* If the flag doesn't appear in sl_compstartflags or sl_compallflags
 311 +      * then it can't possibly compound. */
 312 +     if (!byte_in_str(sp->ts_complen == sp->ts_compsplit
 313 +               ? slang->sl_compstartflags : slang->sl_compallflags, flag))
 314 +       return FALSE;
 315 +
 316 +     /* If there are no wildcards, we can check if the flags collected so far
 317 +      * possibly can form a match with COMPOUNDRULE patterns.  This only
 318 +      * makes sense when we have two or more words. */
 319 +     if (slang->sl_comprules != NULL && sp->ts_complen > sp->ts_compsplit)
 320 +     {
 321 +       int v;
 322 +
 323 +       compflags[sp->ts_complen] = flag;
 324 +       compflags[sp->ts_complen + 1] = NUL;
 325 +       v = match_compoundrule(slang, compflags + sp->ts_compsplit);
 326 +       compflags[sp->ts_complen] = NUL;
 327 +       return v;
 328 +     }
 329 +
 330 +     return TRUE;
 331 + }
 332 +
 333 +
 334 + /*
 335 +  * Return TRUE if the compound flags in compflags[] match the start of any
 336 +  * compound rule.  This is used to stop trying a compound if the flags
 337 +  * collected so far can't possibly match any compound rule.
 338 +  * Caller must check that slang->sl_comprules is not NULL.
 339 +  */
 340 +     static int
 341 + match_compoundrule(slang, compflags)
 342 +     slang_T   *slang;
 343 +     char_u    *compflags;
 344 + {
 345 +     char_u    *p;
 346 +     int               i;
 347 +     int               c;
 348 +
 349 +     /* loop over all the COMPOUNDRULE entries */
 350 +     for (p = slang->sl_comprules; *p != NUL; ++p)
 351 +     {
 352 +       /* loop over the flags in the compound word we have made, match
 353 +        * them against the current rule entry */
 354 +       for (i = 0; ; ++i)
 355 +       {
 356 +           c = compflags[i];
 357 +           if (c == NUL)
 358 +               /* found a rule that matches for the flags we have so far */
 359 +               return TRUE;
 360 +           if (*p == '/' || *p == NUL)
 361 +               break;  /* end of rule, it's too short */
 362 +           if (*p == '[')
 363 +           {
 364 +               int match = FALSE;
 365 +
 366 +               /* compare against all the flags in [] */
 367 +               ++p;
 368 +               while (*p != ']' && *p != NUL)
 369 +                   if (*p++ == c)
 370 +                       match = TRUE;
 371 +               if (!match)
 372 +                   break;  /* none matches */
 373 +           }
 374 +           else if (*p != c)
 375 +               break;  /* flag of word doesn't match flag in pattern */
 376 +           ++p;
 377 +       }
 378 +
 379 +       /* Skip to the next "/", where the next pattern starts. */
 380 +       p = vim_strchr(p, '/');
 381 +       if (p == NULL)
 382 +           break;
 383 +     }
 384 +
 385 +     /* Checked all the rules and none of them match the flags, so there
 386 +      * can't possibly be a compound starting with these flags. */
 387 +     return FALSE;
 388 + }
 389 +
 390 + /*
 391    * Return non-zero if the prefix indicated by "arridx" matches with the prefix
 392    * ID in "flags" for the word "word".
 393    * The WF_RAREPFX flag is included in the return value for a rare prefix.
 394 ***************
 395 *** 2513,2521 ****
 396 --- 2652,2662 ----
 397       lp->sl_midword = NULL;
 398
 399       vim_free(lp->sl_compprog);
 400 +     vim_free(lp->sl_comprules);
 401       vim_free(lp->sl_compstartflags);
 402       vim_free(lp->sl_compallflags);
 403       lp->sl_compprog = NULL;
 404 +     lp->sl_comprules = NULL;
 405       lp->sl_compstartflags = NULL;
 406       lp->sl_compallflags = NULL;
 407
 408 ***************
 409 *** 3460,3465 ****
 410 --- 3601,3607 ----
 411       char_u    *pp;
 412       char_u    *cp;
 413       char_u    *ap;
 414 +     char_u    *crp;
 415       int               cnt;
 416       garray_T  *gap;
 417
 418 ***************
 419 *** 3545,3550 ****
 420 --- 3687,3698 ----
 421       slang->sl_compallflags = ap;
 422       *ap = NUL;
 423
 424 +     /* And a list of all patterns in their original form, for checking whether
 425 +      * compounding may work in match_compoundrule().  This is freed when we
 426 +      * encounter a wildcard, the check doesn't work then. */
 427 +     crp = alloc(todo + 1);
 428 +     slang->sl_comprules = crp;
 429 +
 430       pp = pat;
 431       *pp++ = '^';
 432       *pp++ = '\\';
 433 ***************
 434 *** 3587,3592 ****
 435 --- 3735,3754 ----
 436                     atstart = 0;
 437             }
 438         }
 439 +
 440 +       /* Copy flag to "sl_comprules", unless we run into a wildcard. */
 441 +       if (crp != NULL)
 442 +       {
 443 +           if (c == '+' || c == '*')
 444 +           {
 445 +               vim_free(slang->sl_comprules);
 446 +               slang->sl_comprules = NULL;
 447 +               crp = NULL;
 448 +           }
 449 +           else
 450 +               *crp++ = c;
 451 +       }
 452 +
 453         if (c == '/')       /* slash separates two items */
 454         {
 455             *pp++ = '\\';
 456 ***************
 457 *** 3611,3616 ****
 458 --- 3773,3781 ----
 459       *pp++ = '$';
 460       *pp = NUL;
 461
 462 +     if (crp != NULL)
 463 +       *crp = NUL;
 464 +
 465       slang->sl_compprog = vim_regcomp(pat, RE_MAGIC + RE_STRING + RE_STRICT);
 466       vim_free(pat);
 467       if (slang->sl_compprog == NULL)
 468 ***************
 469 *** 4915,4920 ****
 470 --- 5080,5086 ----
 471   } spellinfo_T;
 472
 473   static afffile_T *spell_read_aff __ARGS((spellinfo_T *spin, char_u *fname));
 474 + static int is_aff_rule __ARGS((char_u **items, int itemcnt, char *rulename, int        mincount));
 475   static void aff_process_flags __ARGS((afffile_T *affile, affentry_T *entry));
 476   static int spell_info_item __ARGS((char_u *s));
 477   static unsigned affitem2flag __ARGS((int flagtype, char_u *item, char_u       *fname, int lnum));
 478 ***************
 479 *** 5223,5230 ****
 480         /* Handle non-empty lines. */
 481         if (itemcnt > 0)
 482         {
 483 !           if (STRCMP(items[0], "SET") == 0 && itemcnt == 2
 484 !                                                      && aff->af_enc == NULL)
 485             {
 486   #ifdef FEAT_MBYTE
 487                 /* Setup for conversion from "ENC" to 'encoding'. */
 488 --- 5389,5395 ----
 489         /* Handle non-empty lines. */
 490         if (itemcnt > 0)
 491         {
 492 !           if (is_aff_rule(items, itemcnt, "SET", 2) && aff->af_enc == NULL)
 493             {
 494   #ifdef FEAT_MBYTE
 495                 /* Setup for conversion from "ENC" to 'encoding'. */
 496 ***************
 497 *** 5239,5245 ****
 498                     smsg((char_u *)_("Conversion in %s not supported"), fname);
 499   #endif
 500             }
 501 !           else if (STRCMP(items[0], "FLAG") == 0 && itemcnt == 2
 502                                               && aff->af_flagtype == AFT_CHAR)
 503             {
 504                 if (STRCMP(items[1], "long") == 0)
 505 --- 5404,5410 ----
 506                     smsg((char_u *)_("Conversion in %s not supported"), fname);
 507   #endif
 508             }
 509 !           else if (is_aff_rule(items, itemcnt, "FLAG", 2)
 510                                               && aff->af_flagtype == AFT_CHAR)
 511             {
 512                 if (STRCMP(items[1], "long") == 0)
 513 ***************
 514 *** 5284,5352 ****
 515                         spin->si_info = p;
 516                     }
 517             }
 518 !           else if (STRCMP(items[0], "MIDWORD") == 0 && itemcnt == 2
 519                                                            && midword == NULL)
 520             {
 521                 midword = getroom_save(spin, items[1]);
 522             }
 523 !           else if (STRCMP(items[0], "TRY") == 0 && itemcnt == 2)
 524             {
 525                 /* ignored, we look in the tree for what chars may appear */
 526             }
 527             /* TODO: remove "RAR" later */
 528 !           else if ((STRCMP(items[0], "RAR") == 0
 529 !                       || STRCMP(items[0], "RARE") == 0) && itemcnt == 2
 530 !                                                      && aff->af_rare == 0)
 531             {
 532                 aff->af_rare = affitem2flag(aff->af_flagtype, items[1],
 533                                                                  fname, lnum);
 534             }
 535             /* TODO: remove "KEP" later */
 536 !           else if ((STRCMP(items[0], "KEP") == 0
 537 !                   || STRCMP(items[0], "KEEPCASE") == 0) && itemcnt == 2
 538                                                      && aff->af_keepcase == 0)
 539             {
 540                 aff->af_keepcase = affitem2flag(aff->af_flagtype, items[1],
 541                                                                  fname, lnum);
 542             }
 543 !           else if (STRCMP(items[0], "BAD") == 0 && itemcnt == 2
 544 !                                                      && aff->af_bad == 0)
 545             {
 546                 aff->af_bad = affitem2flag(aff->af_flagtype, items[1],
 547                                                                  fname, lnum);
 548             }
 549 !           else if (STRCMP(items[0], "NEEDAFFIX") == 0 && itemcnt == 2
 550                                                     && aff->af_needaffix == 0)
 551             {
 552                 aff->af_needaffix = affitem2flag(aff->af_flagtype, items[1],
 553                                                                  fname, lnum);
 554             }
 555 !           else if (STRCMP(items[0], "CIRCUMFIX") == 0 && itemcnt == 2
 556                                                     && aff->af_circumfix == 0)
 557             {
 558                 aff->af_circumfix = affitem2flag(aff->af_flagtype, items[1],
 559                                                                  fname, lnum);
 560             }
 561 !           else if (STRCMP(items[0], "NOSUGGEST") == 0 && itemcnt == 2
 562                                                     && aff->af_nosuggest == 0)
 563             {
 564                 aff->af_nosuggest = affitem2flag(aff->af_flagtype, items[1],
 565                                                                  fname, lnum);
 566             }
 567 !           else if (STRCMP(items[0], "NEEDCOMPOUND") == 0 && itemcnt == 2
 568                                                      && aff->af_needcomp == 0)
 569             {
 570                 aff->af_needcomp = affitem2flag(aff->af_flagtype, items[1],
 571                                                                  fname, lnum);
 572             }
 573 !           else if (STRCMP(items[0], "COMPOUNDROOT") == 0 && itemcnt == 2
 574                                                      && aff->af_comproot == 0)
 575             {
 576                 aff->af_comproot = affitem2flag(aff->af_flagtype, items[1],
 577                                                                  fname, lnum);
 578             }
 579 !           else if (STRCMP(items[0], "COMPOUNDFORBIDFLAG") == 0
 580 !                                  && itemcnt == 2 && aff->af_compforbid == 0)
 581             {
 582                 aff->af_compforbid = affitem2flag(aff->af_flagtype, items[1],
 583                                                                  fname, lnum);
 584 --- 5449,5519 ----
 585                         spin->si_info = p;
 586                     }
 587             }
 588 !           else if (is_aff_rule(items, itemcnt, "MIDWORD", 2)
 589                                                            && midword == NULL)
 590             {
 591                 midword = getroom_save(spin, items[1]);
 592             }
 593 !           else if (is_aff_rule(items, itemcnt, "TRY", 2))
 594             {
 595                 /* ignored, we look in the tree for what chars may appear */
 596             }
 597             /* TODO: remove "RAR" later */
 598 !           else if ((is_aff_rule(items, itemcnt, "RAR", 2)
 599 !                       || is_aff_rule(items, itemcnt, "RARE", 2))
 600 !                                                        && aff->af_rare == 0)
 601             {
 602                 aff->af_rare = affitem2flag(aff->af_flagtype, items[1],
 603                                                                  fname, lnum);
 604             }
 605             /* TODO: remove "KEP" later */
 606 !           else if ((is_aff_rule(items, itemcnt, "KEP", 2)
 607 !                       || is_aff_rule(items, itemcnt, "KEEPCASE", 2))
 608                                                      && aff->af_keepcase == 0)
 609             {
 610                 aff->af_keepcase = affitem2flag(aff->af_flagtype, items[1],
 611                                                                  fname, lnum);
 612             }
 613 !           else if ((is_aff_rule(items, itemcnt, "BAD", 2)
 614 !                       || is_aff_rule(items, itemcnt, "FORBIDDENWORD", 2))
 615 !                                                         && aff->af_bad == 0)
 616             {
 617                 aff->af_bad = affitem2flag(aff->af_flagtype, items[1],
 618                                                                  fname, lnum);
 619             }
 620 !           else if (is_aff_rule(items, itemcnt, "NEEDAFFIX", 2)
 621                                                     && aff->af_needaffix == 0)
 622             {
 623                 aff->af_needaffix = affitem2flag(aff->af_flagtype, items[1],
 624                                                                  fname, lnum);
 625             }
 626 !           else if (is_aff_rule(items, itemcnt, "CIRCUMFIX", 2)
 627                                                     && aff->af_circumfix == 0)
 628             {
 629                 aff->af_circumfix = affitem2flag(aff->af_flagtype, items[1],
 630                                                                  fname, lnum);
 631             }
 632 !           else if (is_aff_rule(items, itemcnt, "NOSUGGEST", 2)
 633                                                     && aff->af_nosuggest == 0)
 634             {
 635                 aff->af_nosuggest = affitem2flag(aff->af_flagtype, items[1],
 636                                                                  fname, lnum);
 637             }
 638 !           else if ((is_aff_rule(items, itemcnt, "NEEDCOMPOUND", 2)
 639 !                       || is_aff_rule(items, itemcnt, "ONLYINCOMPOUND", 2))
 640                                                      && aff->af_needcomp == 0)
 641             {
 642                 aff->af_needcomp = affitem2flag(aff->af_flagtype, items[1],
 643                                                                  fname, lnum);
 644             }
 645 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDROOT", 2)
 646                                                      && aff->af_comproot == 0)
 647             {
 648                 aff->af_comproot = affitem2flag(aff->af_flagtype, items[1],
 649                                                                  fname, lnum);
 650             }
 651 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDFORBIDFLAG", 2)
 652 !                                                  && aff->af_compforbid == 0)
 653             {
 654                 aff->af_compforbid = affitem2flag(aff->af_flagtype, items[1],
 655                                                                  fname, lnum);
 656 ***************
 657 *** 5354,5361 ****
 658                     smsg((char_u *)_("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
 659                             fname, lnum);
 660             }
 661 !           else if (STRCMP(items[0], "COMPOUNDPERMITFLAG") == 0
 662 !                                  && itemcnt == 2 && aff->af_comppermit == 0)
 663             {
 664                 aff->af_comppermit = affitem2flag(aff->af_flagtype, items[1],
 665                                                                  fname, lnum);
 666 --- 5521,5528 ----
 667                     smsg((char_u *)_("Defining COMPOUNDFORBIDFLAG after PFX item may give wrong results in %s line %d"),
 668                             fname, lnum);
 669             }
 670 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDPERMITFLAG", 2)
 671 !                                                  && aff->af_comppermit == 0)
 672             {
 673                 aff->af_comppermit = affitem2flag(aff->af_flagtype, items[1],
 674                                                                  fname, lnum);
 675 ***************
 676 *** 5363,5369 ****
 677                     smsg((char_u *)_("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
 678                             fname, lnum);
 679             }
 680 !           else if (STRCMP(items[0], "COMPOUNDFLAG") == 0 && itemcnt == 2
 681                                                          && compflags == NULL)
 682             {
 683                 /* Turn flag "c" into COMPOUNDRULE compatible string "c+",
 684 --- 5530,5536 ----
 685                     smsg((char_u *)_("Defining COMPOUNDPERMITFLAG after PFX item may give wrong results in %s line %d"),
 686                             fname, lnum);
 687             }
 688 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDFLAG", 2)
 689                                                          && compflags == NULL)
 690             {
 691                 /* Turn flag "c" into COMPOUNDRULE compatible string "c+",
 692 ***************
 693 *** 5376,5382 ****
 694                     compflags = p;
 695                 }
 696             }
 697 !           else if (STRCMP(items[0], "COMPOUNDRULE") == 0 && itemcnt == 2)
 698             {
 699                 /* Concatenate this string to previously defined ones, using a
 700                  * slash to separate them. */
 701 --- 5543,5557 ----
 702                     compflags = p;
 703                 }
 704             }
 705 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDRULES", 2))
 706 !           {
 707 !               /* We don't use the count, but do check that it's a number and
 708 !                * not COMPOUNDRULE mistyped. */
 709 !               if (atoi((char *)items[1]) == 0)
 710 !                   smsg((char_u *)_("Wrong COMPOUNDRULES value in %s line %d: %s"),
 711 !                                                      fname, lnum, items[1]);
 712 !           }
 713 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2))
 714             {
 715                 /* Concatenate this string to previously defined ones, using a
 716                  * slash to separate them. */
 717 ***************
 718 *** 5395,5401 ****
 719                     compflags = p;
 720                 }
 721             }
 722 !           else if (STRCMP(items[0], "COMPOUNDWORDMAX") == 0 && itemcnt == 2
 723                                                               && compmax == 0)
 724             {
 725                 compmax = atoi((char *)items[1]);
 726 --- 5570,5576 ----
 727                     compflags = p;
 728                 }
 729             }
 730 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
 731                                                               && compmax == 0)
 732             {
 733                 compmax = atoi((char *)items[1]);
 734 ***************
 735 *** 5403,5409 ****
 736                     smsg((char_u *)_("Wrong COMPOUNDWORDMAX value in %s line %d: %s"),
 737                                                        fname, lnum, items[1]);
 738             }
 739 !           else if (STRCMP(items[0], "COMPOUNDMIN") == 0 && itemcnt == 2
 740                                                            && compminlen == 0)
 741             {
 742                 compminlen = atoi((char *)items[1]);
 743 --- 5578,5584 ----
 744                     smsg((char_u *)_("Wrong COMPOUNDWORDMAX value in %s line %d: %s"),
 745                                                        fname, lnum, items[1]);
 746             }
 747 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDMIN", 2)
 748                                                            && compminlen == 0)
 749             {
 750                 compminlen = atoi((char *)items[1]);
 751 ***************
 752 *** 5411,5417 ****
 753                     smsg((char_u *)_("Wrong COMPOUNDMIN value in %s line %d: %s"),
 754                                                        fname, lnum, items[1]);
 755             }
 756 !           else if (STRCMP(items[0], "COMPOUNDSYLMAX") == 0 && itemcnt == 2
 757                                                            && compsylmax == 0)
 758             {
 759                 compsylmax = atoi((char *)items[1]);
 760 --- 5586,5592 ----
 761                     smsg((char_u *)_("Wrong COMPOUNDMIN value in %s line %d: %s"),
 762                                                        fname, lnum, items[1]);
 763             }
 764 !           else if (is_aff_rule(items, itemcnt, "COMPOUNDSYLMAX", 2)
 765                                                            && compsylmax == 0)
 766             {
 767                 compsylmax = atoi((char *)items[1]);
 768 ***************
 769 *** 5419,5450 ****
 770                     smsg((char_u *)_("Wrong COMPOUNDSYLMAX value in %s line %d: %s"),
 771                                                        fname, lnum, items[1]);
 772             }
 773 !           else if (STRCMP(items[0], "CHECKCOMPOUNDDUP") == 0 && itemcnt == 1)
 774             {
 775                 compoptions |= COMP_CHECKDUP;
 776             }
 777 !           else if (STRCMP(items[0], "CHECKCOMPOUNDREP") == 0 && itemcnt == 1)
 778             {
 779                 compoptions |= COMP_CHECKREP;
 780             }
 781 !           else if (STRCMP(items[0], "CHECKCOMPOUNDCASE") == 0 && itemcnt == 1)
 782             {
 783                 compoptions |= COMP_CHECKCASE;
 784             }
 785 !           else if (STRCMP(items[0], "CHECKCOMPOUNDTRIPLE") == 0
 786 !                                                             && itemcnt == 1)
 787             {
 788                 compoptions |= COMP_CHECKTRIPLE;
 789             }
 790 !           else if (STRCMP(items[0], "CHECKCOMPOUNDPATTERN") == 0
 791 !                                                             && itemcnt == 2)
 792             {
 793                 if (atoi((char *)items[1]) == 0)
 794                     smsg((char_u *)_("Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"),
 795                                                        fname, lnum, items[1]);
 796             }
 797 !           else if (STRCMP(items[0], "CHECKCOMPOUNDPATTERN") == 0
 798 !                                                             && itemcnt == 3)
 799             {
 800                 garray_T    *gap = &spin->si_comppat;
 801                 int         i;
 802 --- 5594,5622 ----
 803                     smsg((char_u *)_("Wrong COMPOUNDSYLMAX value in %s line %d: %s"),
 804                                                        fname, lnum, items[1]);
 805             }
 806 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDDUP", 1))
 807             {
 808                 compoptions |= COMP_CHECKDUP;
 809             }
 810 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDREP", 1))
 811             {
 812                 compoptions |= COMP_CHECKREP;
 813             }
 814 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDCASE", 1))
 815             {
 816                 compoptions |= COMP_CHECKCASE;
 817             }
 818 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDTRIPLE", 1))
 819             {
 820                 compoptions |= COMP_CHECKTRIPLE;
 821             }
 822 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDPATTERN", 2))
 823             {
 824                 if (atoi((char *)items[1]) == 0)
 825                     smsg((char_u *)_("Wrong CHECKCOMPOUNDPATTERN value in %s line %d: %s"),
 826                                                        fname, lnum, items[1]);
 827             }
 828 !           else if (is_aff_rule(items, itemcnt, "CHECKCOMPOUNDPATTERN", 3))
 829             {
 830                 garray_T    *gap = &spin->si_comppat;
 831                 int         i;
 832 ***************
 833 *** 5463,5486 ****
 834                                                = getroom_save(spin, items[2]);
 835                 }
 836             }
 837 !           else if (STRCMP(items[0], "SYLLABLE") == 0 && itemcnt == 2
 838                                                           && syllable == NULL)
 839             {
 840                 syllable = getroom_save(spin, items[1]);
 841             }
 842 !           else if (STRCMP(items[0], "NOBREAK") == 0 && itemcnt == 1)
 843             {
 844                 spin->si_nobreak = TRUE;
 845             }
 846 !           else if (STRCMP(items[0], "NOSPLITSUGS") == 0 && itemcnt == 1)
 847             {
 848                 spin->si_nosplitsugs = TRUE;
 849             }
 850 !           else if (STRCMP(items[0], "NOSUGFILE") == 0 && itemcnt == 1)
 851             {
 852                 spin->si_nosugfile = TRUE;
 853             }
 854 !           else if (STRCMP(items[0], "PFXPOSTPONE") == 0 && itemcnt == 1)
 855             {
 856                 aff->af_pfxpostpone = TRUE;
 857             }
 858 --- 5635,5658 ----
 859                                                = getroom_save(spin, items[2]);
 860                 }
 861             }
 862 !           else if (is_aff_rule(items, itemcnt, "SYLLABLE", 2)
 863                                                           && syllable == NULL)
 864             {
 865                 syllable = getroom_save(spin, items[1]);
 866             }
 867 !           else if (is_aff_rule(items, itemcnt, "NOBREAK", 1))
 868             {
 869                 spin->si_nobreak = TRUE;
 870             }
 871 !           else if (is_aff_rule(items, itemcnt, "NOSPLITSUGS", 1))
 872             {
 873                 spin->si_nosplitsugs = TRUE;
 874             }
 875 !           else if (is_aff_rule(items, itemcnt, "NOSUGFILE", 1))
 876             {
 877                 spin->si_nosugfile = TRUE;
 878             }
 879 !           else if (is_aff_rule(items, itemcnt, "PFXPOSTPONE", 1))
 880             {
 881                 aff->af_pfxpostpone = TRUE;
 882             }
 883 ***************
 884 *** 5771,5794 ****
 885                     }
 886                 }
 887             }
 888 !           else if (STRCMP(items[0], "FOL") == 0 && itemcnt == 2
 889 !                                                              && fol == NULL)
 890             {
 891                 fol = vim_strsave(items[1]);
 892             }
 893 !           else if (STRCMP(items[0], "LOW") == 0 && itemcnt == 2
 894 !                                                              && low == NULL)
 895             {
 896                 low = vim_strsave(items[1]);
 897             }
 898 !           else if (STRCMP(items[0], "UPP") == 0 && itemcnt == 2
 899 !                                                              && upp == NULL)
 900             {
 901                 upp = vim_strsave(items[1]);
 902             }
 903 !           else if ((STRCMP(items[0], "REP") == 0
 904 !                       || STRCMP(items[0], "REPSAL") == 0)
 905 !                   && itemcnt == 2)
 906             {
 907                 /* Ignore REP/REPSAL count */;
 908                 if (!isdigit(*items[1]))
 909 --- 5943,5962 ----
 910                     }
 911                 }
 912             }
 913 !           else if (is_aff_rule(items, itemcnt, "FOL", 2) && fol == NULL)
 914             {
 915                 fol = vim_strsave(items[1]);
 916             }
 917 !           else if (is_aff_rule(items, itemcnt, "LOW", 2) && low == NULL)
 918             {
 919                 low = vim_strsave(items[1]);
 920             }
 921 !           else if (is_aff_rule(items, itemcnt, "UPP", 2) && upp == NULL)
 922             {
 923                 upp = vim_strsave(items[1]);
 924             }
 925 !           else if (is_aff_rule(items, itemcnt, "REP", 2)
 926 !                    || is_aff_rule(items, itemcnt, "REPSAL", 2))
 927             {
 928                 /* Ignore REP/REPSAL count */;
 929                 if (!isdigit(*items[1]))
 930 ***************
 931 *** 5819,5825 ****
 932                                          : &spin->si_rep, items[1], items[2]);
 933                 }
 934             }
 935 !           else if (STRCMP(items[0], "MAP") == 0 && itemcnt == 2)
 936             {
 937                 /* MAP item or count */
 938                 if (!found_map)
 939 --- 5987,5993 ----
 940                                          : &spin->si_rep, items[1], items[2]);
 941                 }
 942             }
 943 !           else if (is_aff_rule(items, itemcnt, "MAP", 2))
 944             {
 945                 /* MAP item or count */
 946                 if (!found_map)
 947 ***************
 948 *** 5856,5864 ****
 949                     ga_append(&spin->si_map, '/');
 950                 }
 951             }
 952 !           /* Accept "SAL from to" and "SAL from to # comment". */
 953 !           else if (STRCMP(items[0], "SAL") == 0
 954 !                   && (itemcnt == 3 || (itemcnt > 3 && items[3][0] == '#')))
 955             {
 956                 if (do_sal)
 957                 {
 958 --- 6024,6031 ----
 959                     ga_append(&spin->si_map, '/');
 960                 }
 961             }
 962 !           /* Accept "SAL from to" and "SAL from to  #comment". */
 963 !           else if (is_aff_rule(items, itemcnt, "SAL", 3))
 964             {
 965                 if (do_sal)
 966                 {
 967 ***************
 968 *** 5877,5888 ****
 969                                                                 : items[2]);
 970                 }
 971             }
 972 !           else if (STRCMP(items[0], "SOFOFROM") == 0 && itemcnt == 2
 973                                                           && sofofrom == NULL)
 974             {
 975                 sofofrom = getroom_save(spin, items[1]);
 976             }
 977 !           else if (STRCMP(items[0], "SOFOTO") == 0 && itemcnt == 2
 978                                                             && sofoto == NULL)
 979             {
 980                 sofoto = getroom_save(spin, items[1]);
 981 --- 6044,6055 ----
 982                                                                 : items[2]);
 983                 }
 984             }
 985 !           else if (is_aff_rule(items, itemcnt, "SOFOFROM", 2)
 986                                                           && sofofrom == NULL)
 987             {
 988                 sofofrom = getroom_save(spin, items[1]);
 989             }
 990 !           else if (is_aff_rule(items, itemcnt, "SOFOTO", 2)
 991                                                             && sofoto == NULL)
 992             {
 993                 sofoto = getroom_save(spin, items[1]);
 994 ***************
 995 *** 6017,6022 ****
 996 --- 6184,6205 ----
 997   }
 998
 999   /*
1000 +  * Return TRUE when items[0] equals "rulename", there are "mincount" items or
1001 +  * a comment is following after item "mincount".
1002 +  */
1003 +     static int
1004 + is_aff_rule(items, itemcnt, rulename, mincount)
1005 +     char_u    **items;
1006 +     int               itemcnt;
1007 +     char      *rulename;
1008 +     int               mincount;
1009 + {
1010 +     return (STRCMP(items[0], rulename) == 0
1011 +           && (itemcnt == mincount
1012 +               || (itemcnt > mincount && items[mincount][0] == '#')));
1013 + }
1014 +
1015 + /*
1016    * For affix "entry" move COMPOUNDFORBIDFLAG and COMPOUNDPERMITFLAG from
1017    * ae_flags to ae_comppermit and ae_compforbid.
1018    */
1019 ***************
1020 *** 11492,11506 ****
1021                     vim_strncpy(preword + sp->ts_prewordlen,
1022                             tword + sp->ts_splitoff,
1023                             sp->ts_twordlen - sp->ts_splitoff);
1024 !                   p = preword;
1025 !                   while (*skiptowhite(p) != NUL)
1026 !                       p = skipwhite(skiptowhite(p));
1027 !                   if (fword_ends && !can_compound(slang, p,
1028 !                                               compflags + sp->ts_compsplit))
1029 !                       /* Compound is not allowed.  But it may still be
1030 !                        * possible if we add another (short) word. */
1031                         compound_ok = FALSE;
1032
1033                     /* Get pointer to last char of previous word. */
1034                     p = preword + sp->ts_prewordlen;
1035                     mb_ptr_back(preword, p);
1036 --- 11675,11698 ----
1037                     vim_strncpy(preword + sp->ts_prewordlen,
1038                             tword + sp->ts_splitoff,
1039                             sp->ts_twordlen - sp->ts_splitoff);
1040 !
1041 !                   /* Verify CHECKCOMPOUNDPATTERN  rules. */
1042 !                   if (match_checkcompoundpattern(preword,  sp->ts_prewordlen,
1043 !                                                         &slang->sl_comppat))
1044                         compound_ok = FALSE;
1045
1046 +                   if (compound_ok)
1047 +                   {
1048 +                       p = preword;
1049 +                       while (*skiptowhite(p) != NUL)
1050 +                           p = skipwhite(skiptowhite(p));
1051 +                       if (fword_ends && !can_compound(slang, p,
1052 +                                               compflags + sp->ts_compsplit))
1053 +                           /* Compound is not allowed.  But it may still be
1054 +                            * possible if we add another (short) word. */
1055 +                           compound_ok = FALSE;
1056 +                   }
1057 +
1058                     /* Get pointer to last char of previous word. */
1059                     p = preword + sp->ts_prewordlen;
1060                     mb_ptr_back(preword, p);
1061 ***************
1062 *** 11697,11706 ****
1063                         && (slang->sl_compsylmax < MAXWLEN
1064                             || sp->ts_complen + 1 - sp->ts_compsplit
1065                                                           < slang->sl_compmax)
1066 !                       && (byte_in_str(sp->ts_complen == sp->ts_compsplit
1067 !                                           ? slang->sl_compstartflags
1068 !                                           : slang->sl_compallflags,
1069 !                                                   ((unsigned)flags >> 24))))
1070                 {
1071                     try_compound = TRUE;
1072                     compflags[sp->ts_complen] = ((unsigned)flags >> 24);
1073 --- 11889,11897 ----
1074                         && (slang->sl_compsylmax < MAXWLEN
1075                             || sp->ts_complen + 1 - sp->ts_compsplit
1076                                                           < slang->sl_compmax)
1077 !                       && (can_be_compound(sp, slang,
1078 !                                        compflags, ((unsigned)flags >> 24))))
1079 !
1080                 {
1081                     try_compound = TRUE;
1082                     compflags[sp->ts_complen] = ((unsigned)flags >> 24);
1083 *** ../vim-7.2.059/src/version.c        Sun Nov 30 15:15:56 2008
1084 --- src/version.c       Sun Nov 30 21:09:23 2008
1085 ***************
1086 *** 678,679 ****
1087 --- 678,681 ----
1088   {   /* Add new patch number below this line */
1089 + /**/
1090 +     60,
1091   /**/
1092
1093 --
1094 DEAD PERSON:  I'm getting better!
1095 CUSTOMER:     No, you're not -- you'll be stone dead in a moment.
1096 MORTICIAN:    Oh, I can't take him like that -- it's against regulations.
1097                                   The Quest for the Holy Grail (Monty Python)
1098
1099  /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
1100 ///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
1101 \\\        download, build and distribute -- http://www.A-A-P.org        ///
1102  \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///