1 To: [email protected]

     2 Subject: Patch 7.2.060

     3 Fcc: outbox

     4 From: Bram Moolenaar <[email protected]>

     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 -- [email protected] -- 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    ///