vim: src/spell.c comparison

comparison src/spell.c @ 249:f146656fb903

updated for version 7.0069

author	vimboss
date	Wed, 20 Apr 2005 19:37:22 +0000
parents	8ff168d3720a
children	c8742c8da9ab

comparison

equal deleted inserted replaced

-:f2d46e4a859d
+:f146656fb903
 #define BWF_ADDS	0x0100	    /* there are additions */
 #define BWF_PREFIX	0x0200	    /* has prefix NR list */
 #define BWF_ALLCAP	0x0400	    /* all letters must be capital (not used
 				       for single-letter words) */
 #define BWF_KEEPCAP	0x0800	    /* Keep case as-is */
+#define BWF_ADDS_M	0x1000	    /* there are more than 255 additions */
 #define BWF_ADDHASH	0x8000	    /* Internal: use hashtab for additions */
 #define NOWC_KEY (char_u *)"x"	    /* hashtab key used for additions without
 				       any word character */
 /* flags used for addition in the spell file */
 #define ADD_REGION	0x02	    /* region byte follows */
 #define ADD_ONECAP	0x04	    /* first letter must be capital */
+#define ADD_LEADLEN	0x10	    /* there is a leadlen byte */
+#define ADD_COPYLEN	0x20	    /* there is a copylen byte */
 #define ADD_ALLCAP	0x40	    /* all letters must be capital (not used
 				       for single-letter words) */
 #define ADD_KEEPCAP	0x80	    /* fixed case */
 /* Translate ADD_ flags to BWF_ flags.
 * (Needed to keep ADD_ flags in one byte.) */
 #define ADD2BWF(x)	(((x) & 0x0f) | (((x) & 0xf0) << 4))
-#define VIMSPELLMAGIC "VIMspell02"  /* string at start of Vim spell file */
+#define VIMSPELLMAGIC "VIMspell03"  /* string at start of Vim spell file */
 #define VIMSPELLMAGICL 10
 /*
 * Structure to store info for word matching.
 */
 int
 spell_move_to(dir, allwords)
 int		dir;		/* FORWARD or BACKWARD */
 int		allwords;	/* TRUE for "[s" and "]s" */
 {
-pos_T	pos;
+linenr_T	lnum;
+pos_T	found_pos;
 char_u	*line;
 char_u	*p;
 int		wc;
 int		nwc;
 int		attr = 0;
 int		len;
+int		has_syntax = syntax_present(curbuf);
+int		col;
+int		can_spell;
 if (!curwin->w_p_spell || *curwin->w_buffer->b_p_spl == NUL)
 {
 	EMSG(_("E756: Spell checking not enabled"));
 	return FAIL;
 }
-/* TODO: moving backwards */
+/*
+* Start looking for bad word at the start of the line, because we can't
-/* Start looking for bad word at the start of the line, because we can't
+* start halfway a word, we don't know where it starts or ends.
-* start halfway a word and know where it ends. */
+*
-pos = curwin->w_cursor;
+* When searching backwards, we continue in the line to find the last
-pos.col = 0;
+* bad word (in the cursor line: before the cursor).
-wc = FALSE;
+*/
+lnum = curwin->w_cursor.lnum;
+found_pos.lnum = 0;
 while (!got_int)
 {
-	line = ml_get(pos.lnum);
+	line = ml_get(lnum);
-	p = line + pos.col;
+	p = line;
+	wc = FALSE;
 	while (*p != NUL)
 	{
 	    nwc = spell_iswordc(p);
 	    if (!wc && nwc)
 	    {
+		/* When searching backward don't search after the cursor. */
+		if (dir == BACKWARD
+			&& lnum == curwin->w_cursor.lnum
+			&& (colnr_T)(p - line) >= curwin->w_cursor.col)
+		    break;
 		/* start of word */
-		/* TODO: check for bad word attr */
 		len = spell_check(curwin, line, p, &attr);
 		if (attr != 0)
 		{
-		    if (curwin->w_cursor.lnum < pos.lnum
+		    /* We found a bad word.  Check the attribute. */
-			    || (curwin->w_cursor.lnum == pos.lnum
+		    /* TODO: check for syntax @Spell cluster. */
-				&& curwin->w_cursor.col < (colnr_T)(p - line)))
+		    if (allwords || attr == highlight_attr[HLF_SPB])
 		    {
-			curwin->w_cursor.lnum = pos.lnum;
+			/* When searching forward only accept a bad word after
-			curwin->w_cursor.col = p - line;
+			 * the cursor. */
-			return OK;
+			if (dir == BACKWARD
+				|| lnum > curwin->w_cursor.lnum
+				|| (lnum == curwin->w_cursor.lnum
+				    && (colnr_T)(p - line)
+						      > curwin->w_cursor.col))
+			{
+			    if (has_syntax)
+			    {
+				col = p - line;
+				(void)syn_get_id(lnum, (colnr_T)col,
+							   FALSE, &can_spell);
+				/* have to get the line again, a multi-line
+				 * regexp may make it invalid */
+				line = ml_get(lnum);
+				p = line + col;
+			    }
+			    else
+				can_spell = TRUE;
+			    if (can_spell)
+			    {
+				found_pos.lnum = lnum;
+				found_pos.col = p - line;
+#ifdef FEAT_VIRTUALEDIT
+				found_pos.coladd = 0;
+#endif
+				if (dir == FORWARD)
+				{
+				    /* No need to search further. */
+				    curwin->w_cursor = found_pos;
+				    return OK;
+				}
+			    }
+			}
 		    }
-		    attr = 0;	/* bad word is before or at cursor */
+		    attr = 0;
 		}
 		p += len;
 		if (*p == NUL)
 		    break;
 		nwc = FALSE;
 	    mb_ptr_adv(p);
 	    wc = nwc;
 	}
 	/* Advance to next line. */
-	if (pos.lnum == curbuf->b_ml.ml_line_count)
+	if (dir == BACKWARD)
-	    return FAIL;
+	{
-	++pos.lnum;
+	    if (found_pos.lnum != 0)
-	pos.col = 0;
+	    {
-	wc = FALSE;
+		/* Use the last match in the line. */
+		curwin->w_cursor = found_pos;
+		return OK;
+	    }
+	    if (lnum == 1)
+		return FAIL;
+	    --lnum;
+	}
+	else
+	{
+	    if (lnum == curbuf->b_ml.ml_line_count)
+		return FAIL;
+	    ++lnum;
+	}
 	line_breakcheck();
 }
 return FAIL;	/* interrupted */
 	    fw->fw_region = REGION_ALL;
 	fw->fw_adds = NULL;
 	if (flags & BWF_ADDS)
 	{
-	    adds = (getc(fd) << 8) + getc(fd);		/* <addcnt> */
+	    if (flags & BWF_ADDS_M)
+		adds = (getc(fd) << 8) + getc(fd);	/* <addcnt> */
+	    else
+		adds = getc(fd);			/* <addcnt> */
 	    if (adds > 30)
 	    {
 		/* Use a hashtable to loopup the part until the next word end.
 		 * This uses more memory and involves some overhead, thus only
 	    else
 		ht = NULL;
 	    while (--adds >= 0)
 	    {
-		/* <add>: <addflags> <addlen> [<leadlen> <addstring>]
+		/* <add>: <addflags> <addlen> [<leadlen>] [<copylen>]
-		 *			[<region>] */
+		 *				[<addstring>] [<region>] */
 		flags = getc(fd);			/* <addflags> */
 		addlen = getc(fd);			/* <addlen> */
 		if (addlen == EOF)
 		    goto truncerr;
 		if (addlen >= MAXWLEN)
 		    goto formerr;
+		if (flags & ADD_LEADLEN)
+		    leadlen = getc(fd);			/* <leadlen> */
+		else
+		    leadlen = 0;
 		if (addlen > 0)
 		{
-		    leadlen = getc(fd);			/* <leadlen> */
+		    if (flags & ADD_COPYLEN)
-		    for (i = 0; i < addlen; ++i)	/* <addstring> */
+			i = getc(fd);			/* <copylen> */
+		    else
+			i = 0;
+		    for ( ; i < addlen; ++i)		/* <addstring> */
 			cbuf[i] = getc(fd);
 		    cbuf[i] = NUL;
 		}
-		else
-		    leadlen = 0;
 		if (flags & ADD_KEEPCAP)
 		{
 		    /* <addstring> is in original case, need to get
 		     * case-folded word too. */
 } affhash_T;
 static affhash_T dumas;
 #define HI2AS(hi)	((affhash_T *)((hi)->hi_key - (dumas.as_word - (char_u *)&dumas)))
+/* info for writing the spell file */
+typedef struct winfo_S
+{
+FILE	*wif_fd;
+basicword_T	*wif_prevbw;	/* last written basic word */
+int		wif_regionmask;	/* regions supported */
+int		wif_prefm;	/* 1 or 2 bytes used for prefix NR */
+int		wif_suffm;	/* 1 or 2 bytes used for suffix NR */
+long	wif_wcount;	/* written word count */
+long	wif_acount;	/* written addition count */
+long	wif_addmax;	/* max number of additions on one word */
+char_u	*wif_addmaxw;	/* word with max additions */
+} winfo_T;
 static afffile_T *spell_read_aff __ARGS((char_u *fname, vimconv_T *conv, int ascii));
 static void spell_free_aff __ARGS((afffile_T *aff));
 static int has_non_ascii __ARGS((char_u *s));
 static int spell_read_dic __ARGS((hashtab_T *ht, char_u *fname, vimconv_T *conv, int ascii));
 static void add_to_wordlist __ARGS((hashtab_T *newwords, basicword_T *bw));
 static void put_bytes __ARGS((FILE *fd, long_u nr, int len));
 static void write_affix __ARGS((FILE *fd, affheader_T *ah));
 static void write_affixlist __ARGS((FILE *fd, garray_T *aff, int bytes));
 static void write_vim_spell __ARGS((char_u *fname, garray_T *prefga, garray_T *suffga, hashtab_T *newwords, int regcount, char_u *regchars));
-static void write_bword __ARGS((FILE *fd, basicword_T *bw, int lowcap, basicword_T **prevbw, int regionmask, int prefm, int suffm));
+static void write_bword __ARGS((winfo_T *wif, basicword_T *bw, int lowcap));
 static void free_wordtable __ARGS((hashtab_T *ht));
 static void free_basicword __ARGS((basicword_T *bw));
 static void free_affixentries __ARGS((affentry_T *first));
 static void free_affix_entry __ARGS((affentry_T *ap));
 * Vim spell file format:  <HEADER> <PREFIXLIST> <SUFFIXLIST>
 *						    <SUGGEST> <WORDLIST>
 *
 * <HEADER>: <fileID> <regioncnt> <regionname> ...
 *
-* <fileID>     10 bytes    "VIMspell02"
+* <fileID>     10 bytes    "VIMspell03"
 * <regioncnt>  1 byte	    number of regions following (8 supported)
 * <regionname>	2 bytes     Region name: ca, au, etc.
 *			    First <regionname> is region 1.
 *
 *
 *					BWF_ADDS
 *			    0x02: has prefixes, <affixcnt> and <affixNR> follow
 *					BWF_PREFIX
 *			    0x04: all letters must be upper-case, BWF_ALLCAP
 *			    0x08: case must match, BWF_KEEPCAP
+*			    0x10: has more than 255 additions, <addcnt> is two
+*				  bytes, BWF_ADDS_M
 *			    0x10-0x80: unset
 * <caselen>	1 byte	    Length of <caseword>.
 * <caseword>	N bytes	    Word with matching case.
 * <affixcnt>	1 byte	    Number of affix NRs following.
 * <affixNR>	1 or 2 byte Number of possible affix for this word.
 *			    When using 2 bytes MSB comes first.
 * <region>	1 byte	    Bitmask for regions in which word is valid.  When
 *			    omitted it's valid in all regions.
 *			    Lowest bit is for region 1.
-* <addcnt>	2 bytes	    Number of <add> items following.
+* <addcnt>	1 or 2 byte Number of <add> items following.
 *
-* <add>: <addflags> <addlen> [<leadlen> <addstring>] [<region>]
+* <add>: <addflags> <addlen> [<leadlen>] [<copylen>] [<addstring>] [<region>]
 *
 * <addflags>	1 byte	    0x01: unset
 *			    0x02: has region byte, ADD_REGION
 *			    0x04: first letter must be upper-case, ADD_ONECAP
-*			    0x08-0x20: unset
+*			    0x08: unset
+*			    0x10: has a <leadlen>, ADD_LEADLEN
+*			    0x20: has a <copylen>, ADD_COPYLEN
 *			    0x40: all letters must be upper-case, ADD_ALLCAP
 *			    0x80: fixed case, <addstring> is the whole word
 *				  with matching case, ADD_KEEPCAP.
 * <addlen>	1 byte	    Length of <addstring> in bytes.
 * <leadlen>	1 byte	    Number of bytes at start of <addstring> that must
 *			    come before the start of the basic word.
+* <copylen>	1 byte	    Number of bytes copied from previous <addstring>.
 * <addstring>	N bytes	    Word characters, before/in/after the word.
 *
 * All text characters are in 'encoding': <affchop>, <affadd>, <string>,
 * <caseword>> and <addstring>.
 * All other fields are ASCII: <regionname>
 garray_T	*suffga;	/* suffixes, affheader_T entries */
 hashtab_T	*newwords;	/* basic words, basicword_T entries */
 int		regcount;	/* number of regions */
 char_u	*regchars;	/* region names */
 {
-FILE	*fd;
+winfo_T	wif;
 garray_T	*gap;
 hashitem_T	*hi;
 char_u	**wtab;
 int		todo;
 int		flags, aflags;
-basicword_T	*bw, *bwf, *bw2 = NULL, *prevbw = NULL;
+basicword_T	*bw, *bwf, *bw2 = NULL;
-int		regionmask;	/* mask for all relevant region bits */
 int		i;
 int		cnt;
 affentry_T	*ae;
 int		round;
-int		prefm, suffm;
 garray_T	bwga;
-fd = fopen((char *)fname, "w");
+vim_memset(&wif, 0, sizeof(winfo_T));
-if (fd == NULL)
+wif.wif_fd = fopen((char *)fname, "w");
+if (wif.wif_fd == NULL)
 {
 	EMSG2(_(e_notopen), fname);
 	return;
 }
-fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, fd);
+fwrite(VIMSPELLMAGIC, VIMSPELLMAGICL, (size_t)1, wif.wif_fd);
 /* write the region names if there is more than one */
 if (regcount > 1)
 {
-	putc(regcount, fd);
+	putc(regcount, wif.wif_fd);
-	fwrite(regchars, (size_t)(regcount * 2), (size_t)1, fd);
+	fwrite(regchars, (size_t)(regcount * 2), (size_t)1, wif.wif_fd);
-	regionmask = (1 << regcount) - 1;
+	wif.wif_regionmask = (1 << regcount) - 1;
 }
 else
 {
-	putc(0, fd);
+	putc(0, wif.wif_fd);
-	regionmask = 0;
+	wif.wif_regionmask = 0;
 }
 /* Write the prefix and suffix lists. */
 for (round = 1; round <= 2; ++round)
 {
 	gap = round == 1 ? prefga : suffga;
-	put_bytes(fd, (long_u)gap->ga_len, 2);	    /* <affcount> */
+	put_bytes(wif.wif_fd, (long_u)gap->ga_len, 2);	    /* <affcount> */
 	/* Count the total number of affix items. */
 	cnt = 0;
 	for (i = 0; i < gap->ga_len; ++i)
 	    for (ae = ((affheader_T *)gap->ga_data + i)->ah_first;
 						 ae != NULL; ae = ae->ae_next)
 		++cnt;
-	put_bytes(fd, (long_u)cnt, 2);		    /* <afftotcnt> */
+	put_bytes(wif.wif_fd, (long_u)cnt, 2);		    /* <afftotcnt> */
 	for (i = 0; i < gap->ga_len; ++i)
-	    write_affix(fd, (affheader_T *)gap->ga_data + i);
+	    write_affix(wif.wif_fd, (affheader_T *)gap->ga_data + i);
 }
 /* Number of bytes used for affix NR depends on affix count. */
-prefm = (prefga->ga_len > 256) ? 2 : 1;
+wif.wif_prefm = (prefga->ga_len > 256) ? 2 : 1;
-suffm = (suffga->ga_len > 256) ? 2 : 1;
+wif.wif_suffm = (suffga->ga_len > 256) ? 2 : 1;
 /* Write the suggest info. TODO */
-put_bytes(fd, 0L, 4);
+put_bytes(wif.wif_fd, 0L, 4);
 /*
 * Write the word list.  <wordcount> <worditem> ...
 */
 /* number of basic words in 4 bytes */
-put_bytes(fd, newwords->ht_used, 4);	    /* <wordcount> */
+put_bytes(wif.wif_fd, newwords->ht_used, 4);	    /* <wordcount> */
 /*
-* Sort the word list, so that we can reuse as many bytes as possible.
+* Sort the word list, so that we can copy as many bytes as possible from
+* the previous word.
 */
 wtab = (char_u **)alloc((unsigned)(sizeof(char_u *) * newwords->ht_used));
 if (wtab != NULL)
 {
 	/* Make a table with pointers to each word. */
 	    /* Write first basic word.  If it's KEEPCAP then we need a word
 	     * without VALID flag first (makes it easier to read the list back
 	     * in). */
 	    if (bw->bw_flags & BWF_KEEPCAP)
-		write_bword(fd, bw, TRUE, &prevbw, regionmask, prefm, suffm);
+		write_bword(&wif, bw, TRUE);
-	    write_bword(fd, bw, FALSE, &prevbw, regionmask, prefm, suffm);
+	    write_bword(&wif, bw, FALSE);
 	    /* Write other basic words, with different caps. */
 	    for (i = 0; i < bwga.ga_len; ++i)
 	    {
 		bw2 = ((basicword_T **)bwga.ga_data)[i];
 		if (bw2 != bw)
-		    write_bword(fd, bw2, FALSE, &prevbw, regionmask,
+		    write_bword(&wif, bw2, FALSE);
-								prefm, suffm);
 	    }
 	}
 	ga_clear(&bwga);
 }
-fclose(fd);
+fclose(wif.wif_fd);
+/* Print a few statistics. */
+if (wif.wif_addmaxw == NULL)
+	wif.wif_addmaxw = (char_u *)"";
+smsg((char_u *)_("Maximum number of adds on a word: %ld (%s)"),
+					     wif.wif_addmax, wif.wif_addmaxw);
+smsg((char_u *)_("Average number of adds on a word: %f"),
+			       (float)wif.wif_acount / (float)wif.wif_wcount);
+}
+/*
+* Compare two basic words for their <addstring>.
+*/
+static int
+#ifdef __BORLANDC__
+_RTLENTRYF
+#endif
+bw_compare __ARGS((const void *s1, const void *s2));
+static int
+#ifdef __BORLANDC__
+_RTLENTRYF
+#endif
+bw_compare(s1, s2)
+const void	*s1;
+const void	*s2;
+{
+basicword_T *bw1 = *(basicword_T **)s1;
+basicword_T *bw2 = *(basicword_T **)s2;
+int		i = 0;
+/* compare the leadstrings */
+if (bw1->bw_leadstring == NULL)
+{
+	if (bw2->bw_leadstring != NULL)
+	    return 1;
+}
+else if (bw2->bw_leadstring == NULL)
+	return -1;
+else
+	i = STRCMP(bw1->bw_leadstring, bw2->bw_leadstring);
+if (i == 0)
+{
+	/* leadstrings are identical, compare the addstrings */
+	if (bw1->bw_addstring == NULL)
+	{
+	    if (bw2->bw_addstring != NULL)
+		return 1;
+	}
+	else if (bw2->bw_addstring == NULL)
+	    return -1;
+	else
+	    i = STRCMP(bw1->bw_addstring, bw2->bw_addstring);
+}
+return i;
 }
 /*
 * Write basic word, followed by any additions.
 *
 *			  [<affixcnt> <affixNR> ...]	(suffixes)
 *			  [<region>]
 *			  [<addcnt> <add> ...]
 */
 static void
-write_bword(fd, bwf, lowcap, prevbw, regionmask, prefm, suffm)
+write_bword(wif, bwf, lowcap)
-FILE	*fd;
+winfo_T	*wif;		/* info for writing */
 basicword_T	*bwf;
 int		lowcap;		/* write KEEPKAP word as not-valid */
-basicword_T **prevbw;	/* last written basic word */
+{
-int		regionmask;	/* mask that includes all possible regions */
+FILE	*fd = wif->wif_fd;
-int		prefm;
-int		suffm;
-{
 int		flags;
 int		aflags;
 int		len;
 int		leadlen, addlen;
+int		copylen;
 int		clen;
 int		adds = 0;
 int		i;
+int		idx;
 basicword_T *bw, *bw2;
+basicword_T **wtab;
+int		count;
+int		l;
 /* Check how many bytes can be copied from the previous word. */
 len = STRLEN(bwf->bw_word);
-if (*prevbw == NULL)
+if (wif->wif_prevbw == NULL)
 	clen = 0;
 else
 	for (clen = 0; clen < len
-		&& (*prevbw)->bw_word[clen] == bwf->bw_word[clen]; ++clen)
+		&& wif->wif_prevbw->bw_word[clen] == bwf->bw_word[clen]; ++clen)
 	    ;
 putc(clen, fd);				/* <nr> */
-*prevbw = bwf;
+wif->wif_prevbw = bwf;
 						/* <string> */
 if (len > clen)
 	fwrite(bwf->bw_word + clen, (size_t)(len - clen), (size_t)1, fd);
 /* Try to find a word without additions to use first. */
 {
 	flags |= BWF_VALID;
 	/* Flags: add the region byte if the word isn't valid in all
 	 * regions. */
-	if (regionmask != 0 && (bw->bw_region & regionmask) != regionmask)
+	if (wif->wif_regionmask != 0 && (bw->bw_region & wif->wif_regionmask)
+						       != wif->wif_regionmask)
 	    flags |= BWF_REGION;
 }
 /* Add the prefix/suffix list if there are prefixes/suffixes. */
 if (bw->bw_leadstring == NULL && bw->bw_prefix.ga_len > 0)
 	flags |= BWF_PREFIX;
 if (bw->bw_addstring == NULL && bw->bw_suffix.ga_len > 0)
 	flags |= BWF_SUFFIX;
 /* Flags: may have additions. */
 if (adds > 0)
+{
 	flags |= BWF_ADDS;
+	if (adds >= 256)
+	    flags |= BWF_ADDS_M;
+}
 /* The dummy word before a KEEPCAP word doesn't have any flags, they are
 * in the actual word that follows. */
 if (lowcap)
 	flags = 0;
 	    putc(bw->bw_caseword[i], fd);	/* <caseword> */
 }
 /* write prefix and suffix lists: <affixcnt> <affixNR> ... */
 if (flags & BWF_PREFIX)
-	write_affixlist(fd, &bw->bw_prefix, prefm);
+	write_affixlist(fd, &bw->bw_prefix, wif->wif_prefm);
 if (flags & BWF_SUFFIX)
-	write_affixlist(fd, &bw->bw_suffix, suffm);
+	write_affixlist(fd, &bw->bw_suffix, wif->wif_suffm);
 if (flags & BWF_REGION)
 	putc(bw->bw_region, fd);		/* <region> */
+++wif->wif_wcount;
 /*
 * Additions.
 */
 if (adds > 0)
 {
-	put_bytes(fd, (long_u)adds, 2);		/* <addcnt> */
+	if (adds >= 256)
+	    put_bytes(fd, (long_u)adds, 2);	/* 2 byte <addcnt> */
+	else
+	    putc(adds, fd);			/* 1 byte <addcnt> */
+	/* statistics */
+	wif->wif_acount += adds;
+	if (wif->wif_addmax < adds)
+	{
+	    wif->wif_addmax = adds;
+	    wif->wif_addmaxw = bw->bw_word;
+	}
+	/*
+	 * Sort the list of additions, so that we can copy as many bytes as
+	 * possible from the previous addstring.
+	 */
+	/* Make a table with pointers to each basic word that has additions. */
+	wtab = (basicword_T **)alloc((unsigned)(sizeof(basicword_T *) * adds));
+	if (wtab == NULL)
+	    return;
+	count = 0;
 	for (bw = bwf; bw != NULL; bw = bw->bw_cnext)
 	    if (bw->bw_leadstring != NULL || bw->bw_addstring != NULL)
-	    {
+		wtab[count++] = bw;
-		/* <add>: <addflags> <addlen> [<leadlen> <addstring>]
-		 *	  [<region>] */
+	/* Sort. */
-		aflags = 0;
+	qsort((void *)wtab, (size_t)count, sizeof(basicword_T *), bw_compare);
-		if (bw->bw_flags & BWF_ONECAP)
-		    aflags |= ADD_ONECAP;
+	/* Now write each basic word to the spell file.  Copy bytes from the
-		if (bw->bw_flags & BWF_ALLCAP)
+	 * previous leadstring/addstring if possible. */
-		    aflags |= ADD_ALLCAP;
+	bw2 = NULL;
-		if (bw->bw_flags & BWF_KEEPCAP)
+	for (idx = 0; idx < count; ++idx)
-		    aflags |= ADD_KEEPCAP;
+	{
-		if (regionmask != 0
+	    bw = wtab[idx];
-				&& (bw->bw_region & regionmask) != regionmask)
-		    aflags |= ADD_REGION;
+	    /* <add>: <addflags> <addlen> [<leadlen>] [<copylen>]
-		putc(aflags, fd);		    /* <addflags> */
+	     *				[<addstring>] [<region>] */
+	    copylen = 0;
-		if (bw->bw_leadstring == NULL)
+	    if (bw->bw_leadstring == NULL)
-		    leadlen = 0;
+		leadlen = 0;
+	    else
+	    {
+		leadlen = STRLEN(bw->bw_leadstring);
+		if (bw2 != NULL && bw2->bw_leadstring != NULL)
+		    for ( ; copylen < leadlen; ++copylen)
+			if (bw->bw_leadstring[copylen]
+					   != bw2->bw_leadstring[copylen])
+			    break;
+	    }
+	    if (bw->bw_addstring == NULL)
+		addlen = 0;
+	    else
+	    {
+		addlen = STRLEN(bw->bw_addstring);
+		if (bw2 != NULL && copylen == leadlen
+					     && bw2->bw_addstring != NULL)
+		{
+		    for (i = 0; i < addlen; ++i)
+			if (bw->bw_addstring[i] != bw2->bw_addstring[i])
+			    break;
+		    copylen += i;
+		}
+	    }
+	    aflags = 0;
+	    /* Only copy bytes when it's more than one, the length itself
+	     * takes an extra byte. */
+	    if (copylen > 1)
+		aflags |= ADD_COPYLEN;
+	    else
+		copylen = 0;
+	    if (bw->bw_flags & BWF_ONECAP)
+		aflags |= ADD_ONECAP;
+	    if (bw->bw_flags & BWF_ALLCAP)
+		aflags |= ADD_ALLCAP;
+	    if (bw->bw_flags & BWF_KEEPCAP)
+		aflags |= ADD_KEEPCAP;
+	    if (wif->wif_regionmask != 0 && (bw->bw_region
+			    & wif->wif_regionmask) != wif->wif_regionmask)
+		aflags |= ADD_REGION;
+	    if (leadlen > 0)
+		aflags |= ADD_LEADLEN;
+	    putc(aflags, fd);		    /* <addflags> */
+	    putc(leadlen + addlen, fd);			/* <addlen> */
+	    if (aflags & ADD_LEADLEN)
+		putc(leadlen, fd);			/* <leadlen> */
+	    if (aflags & ADD_COPYLEN)
+		putc(copylen, fd);			/* <copylen> */
+							/* <addstring> */
+	    if (leadlen > copylen && bw->bw_leadstring != NULL)
+		fwrite(bw->bw_leadstring + copylen,
+				  (size_t)(leadlen - copylen), (size_t)1, fd);
+	    if (leadlen + addlen > copylen && bw->bw_addstring != NULL)
+	    {
+		if (copylen >= leadlen)
+		    l = copylen - leadlen;
 		else
-		    leadlen = STRLEN(bw->bw_leadstring);
+		    l = 0;
-		if (bw->bw_addstring == NULL)
+		fwrite(bw->bw_addstring + l,
-		    addlen = 0;
+					 (size_t)(addlen - l), (size_t)1, fd);
-		else
+	    }
-		    addlen = STRLEN(bw->bw_addstring);
-		putc(leadlen + addlen, fd);		    /* <addlen> */
+	    if (aflags & ADD_REGION)
-		putc(leadlen, fd);			    /* <leadlen> */
+		putc(bw->bw_region, fd);		/* <region> */
-							    /* <addstring> */
-		if (bw->bw_leadstring != NULL)
+	    bw2 = bw;
-		    fwrite(bw->bw_leadstring, (size_t)leadlen, (size_t)1, fd);
+	}
-		if (bw->bw_addstring != NULL)
+	vim_free(wtab);
-		    fwrite(bw->bw_addstring, (size_t)addlen, (size_t)1, fd);
-		if (aflags & ADD_REGION)
-		    putc(bw->bw_region, fd);		/* <region> */
-	    }
 }
 }
 /*

Mercurial > vim

comparison src/spell.c @ 249:f146656fb903