[packages/vim.git] / 7.3.109

To: vim_dev@googlegroups.com
Subject: Patch 7.3.109
Fcc: outbox
From: Bram Moolenaar <Bram@moolenaar.net>
Mime-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
------------

Patch 7.3.109
Problem:    Processing new Esperanto spell file fails and crashes Vim.
	    (Dominique Pelle)
Solution:   When running out of memory give an error.  Handle '?' in
	    COMPOUNDRULE properly.
Files:	    src/spell.c


*** ../vim-7.3.108/src/spell.c	2010-12-17 18:06:00.000000000 +0100
--- src/spell.c	2011-02-01 13:43:52.000000000 +0100
***************
*** 3634,3640 ****
  	}
  
  	/* Add all flags to "sl_compallflags". */
! 	if (vim_strchr((char_u *)"+*[]/", c) == NULL
  		&& !byte_in_str(slang->sl_compallflags, c))
  	{
  	    *ap++ = c;
--- 3634,3640 ----
  	}
  
  	/* Add all flags to "sl_compallflags". */
! 	if (vim_strchr((char_u *)"?*+[]/", c) == NULL
  		&& !byte_in_str(slang->sl_compallflags, c))
  	{
  	    *ap++ = c;
***************
*** 3664,3670 ****
  	/* Copy flag to "sl_comprules", unless we run into a wildcard. */
  	if (crp != NULL)
  	{
! 	    if (c == '+' || c == '*')
  	    {
  		vim_free(slang->sl_comprules);
  		slang->sl_comprules = NULL;
--- 3664,3670 ----
  	/* Copy flag to "sl_comprules", unless we run into a wildcard. */
  	if (crp != NULL)
  	{
! 	    if (c == '?' || c == '+' || c == '*')
  	    {
  		vim_free(slang->sl_comprules);
  		slang->sl_comprules = NULL;
***************
*** 3682,3689 ****
  	}
  	else		    /* normal char, "[abc]" and '*' are copied as-is */
  	{
! 	    if (c == '+' || c == '~')
! 		*pp++ = '\\';	    /* "a+" becomes "a\+" */
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  		pp += mb_char2bytes(c, pp);
--- 3682,3689 ----
  	}
  	else		    /* normal char, "[abc]" and '*' are copied as-is */
  	{
! 	    if (c == '?' || c == '+' || c == '~')
! 		*pp++ = '\\';	    /* "a?" becomes "a\?", "a+" becomes "a\+" */
  #ifdef FEAT_MBYTE
  	    if (enc_utf8)
  		pp += mb_char2bytes(c, pp);
***************
*** 4951,4956 ****
--- 4951,4958 ----
  
      sblock_T	*si_blocks;	/* memory blocks used */
      long	si_blocks_cnt;	/* memory blocks allocated */
+     int		si_did_emsg;	/* TRUE when ran out of memory */
+ 
      long	si_compress_cnt;    /* words to add before lowering
  				       compression limit */
      wordnode_T	*si_first_free; /* List of nodes that have been freed during
***************
*** 5477,5497 ****
  	    }
  	    else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2))
  	    {
! 		/* Concatenate this string to previously defined ones, using a
! 		 * slash to separate them. */
! 		l = (int)STRLEN(items[1]) + 1;
! 		if (compflags != NULL)
! 		    l += (int)STRLEN(compflags) + 1;
! 		p = getroom(spin, l, FALSE);
! 		if (p != NULL)
  		{
  		    if (compflags != NULL)
  		    {
! 			STRCPY(p, compflags);
! 			STRCAT(p, "/");
  		    }
- 		    STRCAT(p, items[1]);
- 		    compflags = p;
  		}
  	    }
  	    else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
--- 5479,5503 ----
  	    }
  	    else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2))
  	    {
! 		/* Don't use the first rule if it is a number. */
! 		if (compflags != NULL || *skipdigits(items[1]) != NUL)
  		{
+ 		    /* Concatenate this string to previously defined ones,
+ 		     * using a slash to separate them. */
+ 		    l = (int)STRLEN(items[1]) + 1;
  		    if (compflags != NULL)
+ 			l += (int)STRLEN(compflags) + 1;
+ 		    p = getroom(spin, l, FALSE);
+ 		    if (p != NULL)
  		    {
! 			if (compflags != NULL)
! 			{
! 			    STRCPY(p, compflags);
! 			    STRCAT(p, "/");
! 			}
! 			STRCAT(p, items[1]);
! 			compflags = p;
  		    }
  		}
  	    }
  	    else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
***************
*** 6291,6297 ****
  
      for (p = compflags; *p != NUL; )
      {
! 	if (vim_strchr((char_u *)"/*+[]", *p) != NULL)
  	    /* Copy non-flag characters directly. */
  	    *tp++ = *p++;
  	else
--- 6297,6303 ----
  
      for (p = compflags; *p != NUL; )
      {
! 	if (vim_strchr((char_u *)"/?*+[]", *p) != NULL)
  	    /* Copy non-flag characters directly. */
  	    *tp++ = *p++;
  	else
***************
*** 6320,6326 ****
  		    {
  			check_renumber(spin);
  			id = spin->si_newcompID--;
! 		    } while (vim_strchr((char_u *)"/+*[]\\-^", id) != NULL);
  		    ci->ci_newID = id;
  		    hash_add(&aff->af_comp, ci->ci_key);
  		}
--- 6326,6332 ----
  		    {
  			check_renumber(spin);
  			id = spin->si_newcompID--;
! 		    } while (vim_strchr((char_u *)"/?*+[]\\-^", id) != NULL);
  		    ci->ci_newID = id;
  		    hash_add(&aff->af_comp, ci->ci_key);
  		}
***************
*** 7364,7373 ****
  
      if (bl == NULL || bl->sb_used + len > SBLOCKSIZE)
      {
! 	/* Allocate a block of memory. This is not freed until much later. */
! 	bl = (sblock_T *)alloc_clear((unsigned)(sizeof(sblock_T) + SBLOCKSIZE));
  	if (bl == NULL)
  	    return NULL;
  	bl->sb_next = spin->si_blocks;
  	spin->si_blocks = bl;
  	bl->sb_used = 0;
--- 7370,7390 ----
  
      if (bl == NULL || bl->sb_used + len > SBLOCKSIZE)
      {
! 	if (len >= SBLOCKSIZE)
! 	    bl = NULL;
! 	else
! 	    /* Allocate a block of memory. It is not freed until much later. */
! 	    bl = (sblock_T *)alloc_clear(
! 				   (unsigned)(sizeof(sblock_T) + SBLOCKSIZE));
  	if (bl == NULL)
+ 	{
+ 	    if (!spin->si_did_emsg)
+ 	    {
+ 		EMSG(_("E845: Insufficient memory, word list will be incomplete"));
+ 		spin->si_did_emsg = TRUE;
+ 	    }
  	    return NULL;
+ 	}
  	bl->sb_next = spin->si_blocks;
  	spin->si_blocks = bl;
  	bl->sb_used = 0;
***************
*** 7382,7387 ****
--- 7399,7405 ----
  
  /*
   * Make a copy of a string into memory allocated with getroom().
+  * Returns NULL when out of memory.
   */
      static char_u *
  getroom_save(spin, s)
***************
*** 7416,7421 ****
--- 7434,7440 ----
  
  /*
   * Allocate the root of a word tree.
+  * Returns NULL when out of memory.
   */
      static wordnode_T *
  wordtree_alloc(spin)
***************
*** 7700,7705 ****
--- 7719,7725 ----
  /*
   * Get a wordnode_T, either from the list of previously freed nodes or
   * allocate a new one.
+  * Returns NULL when out of memory.
   */
      static wordnode_T *
  get_wordnode(spin)
***************
*** 7717,7723 ****
  	--spin->si_free_count;
      }
  #ifdef SPELL_PRINTTREE
!     n->wn_nr = ++spin->si_wordnode_nr;
  #endif
      return n;
  }
--- 7737,7744 ----
  	--spin->si_free_count;
      }
  #ifdef SPELL_PRINTTREE
!     if (n != NULL)
! 	n->wn_nr = ++spin->si_wordnode_nr;
  #endif
      return n;
  }
*** ../vim-7.3.108/src/version.c	2011-02-01 13:48:47.000000000 +0100
--- src/version.c	2011-02-01 13:56:38.000000000 +0100
***************
*** 716,717 ****
--- 716,719 ----
  {   /* Add new patch number below this line */
+ /**/
+     109,
  /**/

-- 
hundred-and-one symptoms of being an internet addict:
174. You know what a listserv is.

 /// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net   \\\
///        sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
\\\  an exciting new programming language -- http://www.Zimbu.org        ///
 \\\            help me help AIDS victims -- http://ICCF-Holland.org    ///
Commit	Line	Data
21b7d176 ER	1	To: vim_dev@googlegroups.com
	2	Subject: Patch 7.3.109
	3	Fcc: outbox
	4	From: Bram Moolenaar <Bram@moolenaar.net>
	5	Mime-Version: 1.0
	6	Content-Type: text/plain; charset=UTF-8
	7	Content-Transfer-Encoding: 8bit
	8	------------
	9
	10	Patch 7.3.109
	11	Problem: Processing new Esperanto spell file fails and crashes Vim.
	12	(Dominique Pelle)
	13	Solution: When running out of memory give an error. Handle '?' in
	14	COMPOUNDRULE properly.
	15	Files: src/spell.c
	16
	17
	18	*** ../vim-7.3.108/src/spell.c 2010-12-17 18:06:00.000000000 +0100
	19	--- src/spell.c 2011-02-01 13:43:52.000000000 +0100
	20	***************
	21	* 3634,3640 **
	22	}
	23
	24	/* Add all flags to "sl_compallflags". */
	25	! if (vim_strchr((char_u )"+[]/", c) == NULL
	26	&& !byte_in_str(slang->sl_compallflags, c))
	27	{
	28	*ap++ = c;
	29	--- 3634,3640 ----
	30	}
	31
	32	/* Add all flags to "sl_compallflags". */
	33	! if (vim_strchr((char_u )"?+[]/", c) == NULL
	34	&& !byte_in_str(slang->sl_compallflags, c))
	35	{
	36	*ap++ = c;
	37	***************
	38	* 3664,3670 **
	39	/* Copy flag to "sl_comprules", unless we run into a wildcard. */
	40	if (crp != NULL)
	41	{
	42	! if (c == '+' \|\| c == '*')
	43	{
	44	vim_free(slang->sl_comprules);
	45	slang->sl_comprules = NULL;
	46	--- 3664,3670 ----
	47	/* Copy flag to "sl_comprules", unless we run into a wildcard. */
	48	if (crp != NULL)
	49	{
	50	! if (c == '?' \|\| c == '+' \|\| c == '*')
	51	{
	52	vim_free(slang->sl_comprules);
	53	slang->sl_comprules = NULL;
	54	***************
	55	* 3682,3689 **
	56	}
	57	else /* normal char, "[abc]" and '' are copied as-is /
	58	{
	59	! if (c == '+' \|\| c == '~')
	60	! pp++ = '\\'; / "a+" becomes "a\+" */
	61	#ifdef FEAT_MBYTE
	62	if (enc_utf8)
	63	pp += mb_char2bytes(c, pp);
	64	--- 3682,3689 ----
65	}
66	else /* normal char, "[abc]" and '' are copied as-is /
67	{
68	! if (c == '?' \|\| c == '+' \|\| c == '~')
69	! pp++ = '\\'; / "a?" becomes "a\?", "a+" becomes "a\+" */
70	#ifdef FEAT_MBYTE
71	if (enc_utf8)
72	pp += mb_char2bytes(c, pp);
73	***************
74	* 4951,4956 **
75	--- 4951,4958 ----
76
77	sblock_T si_blocks; / memory blocks used */
78	long si_blocks_cnt; /* memory blocks allocated */
79	+ int si_did_emsg; /* TRUE when ran out of memory */
80	+
81	long si_compress_cnt; /* words to add before lowering
82	compression limit */
83	wordnode_T si_first_free; / List of nodes that have been freed during
84	***************
85	* 5477,5497 **
86	}
87	else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2))
88	{
89	! /* Concatenate this string to previously defined ones, using a
90	! * slash to separate them. */
91	! l = (int)STRLEN(items[1]) + 1;
92	! if (compflags != NULL)
93	! l += (int)STRLEN(compflags) + 1;
94	! p = getroom(spin, l, FALSE);
95	! if (p != NULL)
96	{
97	if (compflags != NULL)
98	{
99	! STRCPY(p, compflags);
100	! STRCAT(p, "/");
101	}
102	- STRCAT(p, items[1]);
103	- compflags = p;
104	}
105	}
106	else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
107	--- 5479,5503 ----
108	}
109	else if (is_aff_rule(items, itemcnt, "COMPOUNDRULE", 2))
110	{
111	! /* Don't use the first rule if it is a number. */
112	! if (compflags != NULL \|\| *skipdigits(items[1]) != NUL)
113	{
114	+ /* Concatenate this string to previously defined ones,
115	+ * using a slash to separate them. */
116	+ l = (int)STRLEN(items[1]) + 1;
117	if (compflags != NULL)
118	+ l += (int)STRLEN(compflags) + 1;
119	+ p = getroom(spin, l, FALSE);
120	+ if (p != NULL)
121	{
122	! if (compflags != NULL)
123	! {
124	! STRCPY(p, compflags);
125	! STRCAT(p, "/");
126	! }
127	! STRCAT(p, items[1]);
128	! compflags = p;
129	}
130	}
131	}
132	else if (is_aff_rule(items, itemcnt, "COMPOUNDWORDMAX", 2)
133	***************
134	* 6291,6297 **
135
136	for (p = compflags; *p != NUL; )
137	{
138	! if (vim_strchr((char_u )"/+[]", *p) != NULL)
139	/* Copy non-flag characters directly. */
140	tp++ = p++;
141	else
142	--- 6297,6303 ----
143
144	for (p = compflags; *p != NUL; )
145	{
146	! if (vim_strchr((char_u )"/?+[]", *p) != NULL)
147	/* Copy non-flag characters directly. */
148	tp++ = p++;
149	else
150	***************
151	* 6320,6326 **
152	{
153	check_renumber(spin);
154	id = spin->si_newcompID--;
155	! } while (vim_strchr((char_u )"/+[]\\-^", id) != NULL);
156	ci->ci_newID = id;
157	hash_add(&aff->af_comp, ci->ci_key);
158	}
159	--- 6326,6332 ----
160	{
161	check_renumber(spin);
162	id = spin->si_newcompID--;
163	! } while (vim_strchr((char_u )"/?+[]\\-^", id) != NULL);
164	ci->ci_newID = id;
165	hash_add(&aff->af_comp, ci->ci_key);
166	}
167	***************
168	* 7364,7373 **
169
170	if (bl == NULL \|\| bl->sb_used + len > SBLOCKSIZE)
171	{
172	! /* Allocate a block of memory. This is not freed until much later. */
173	! bl = (sblock_T *)alloc_clear((unsigned)(sizeof(sblock_T) + SBLOCKSIZE));
174	if (bl == NULL)
175	return NULL;
176	bl->sb_next = spin->si_blocks;
177	spin->si_blocks = bl;
178	bl->sb_used = 0;
179	--- 7370,7390 ----
180
181	if (bl == NULL \|\| bl->sb_used + len > SBLOCKSIZE)
182	{
183	! if (len >= SBLOCKSIZE)
184	! bl = NULL;
185	! else
186	! /* Allocate a block of memory. It is not freed until much later. */
187	! bl = (sblock_T *)alloc_clear(
188	! (unsigned)(sizeof(sblock_T) + SBLOCKSIZE));
189	if (bl == NULL)
190	+ {
191	+ if (!spin->si_did_emsg)
192	+ {
193	+ EMSG(_("E845: Insufficient memory, word list will be incomplete"));
194	+ spin->si_did_emsg = TRUE;
195	+ }
196	return NULL;
197	+ }
198	bl->sb_next = spin->si_blocks;
199	spin->si_blocks = bl;
200	bl->sb_used = 0;
201	***************
202	* 7382,7387 **
203	--- 7399,7405 ----
204
205	/*
206	* Make a copy of a string into memory allocated with getroom().
207	+ * Returns NULL when out of memory.
208	*/
209	static char_u *
210	getroom_save(spin, s)
211	***************
212	* 7416,7421 **
213	--- 7434,7440 ----
214
215	/*
216	* Allocate the root of a word tree.
217	+ * Returns NULL when out of memory.
218	*/
219	static wordnode_T *
220	wordtree_alloc(spin)
221	***************
222	* 7700,7705 **
223	--- 7719,7725 ----
224	/*
225	* Get a wordnode_T, either from the list of previously freed nodes or
226	* allocate a new one.
227	+ * Returns NULL when out of memory.
228	*/
229	static wordnode_T *
230	get_wordnode(spin)
231	***************
232	* 7717,7723 **
233	--spin->si_free_count;
234	}
235	#ifdef SPELL_PRINTTREE
236	! n->wn_nr = ++spin->si_wordnode_nr;
237	#endif
238	return n;
239	}
240	--- 7737,7744 ----
241	--spin->si_free_count;
242	}
243	#ifdef SPELL_PRINTTREE
244	! if (n != NULL)
245	! n->wn_nr = ++spin->si_wordnode_nr;
246	#endif
247	return n;
248	}
249	*** ../vim-7.3.108/src/version.c 2011-02-01 13:48:47.000000000 +0100
250	--- src/version.c 2011-02-01 13:56:38.000000000 +0100
251	***************
252	* 716,717 **
253	--- 716,719 ----
254	{ /* Add new patch number below this line */
255	+ /**/
256	+ 109,
257	/**/
258
259	--
260	hundred-and-one symptoms of being an internet addict:
261	174. You know what a listserv is.
262
263	/// Bram Moolenaar -- Bram@Moolenaar.net -- http://www.Moolenaar.net \\\
264	/// sponsor Vim, vote for features -- http://www.Vim.org/sponsor/ \\\
265	\\\ an exciting new programming language -- http://www.Zimbu.org ///
266	\\\ help me help AIDS victims -- http://ICCF-Holland.org ///