xemacs-beta: src/search.c comparison

comparison src/search.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	677f6a0ee643
children	c42ec1d1cded

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 static void
 fixup_search_regs_for_buffer (struct buffer *buf)
 {
 int i;
+int num_regs = search_regs.num_regs;
-for (i = 0; i < search_regs.num_regs; i++)
+for (i = 0; i < num_regs; i++)
 {
 if (search_regs.start[i] >= 0)
 	search_regs.start[i] = bytind_to_bufpos (buf, search_regs.start[i]);
 if (search_regs.end[i] >= 0)
 	search_regs.end[i] = bytind_to_bufpos (buf, search_regs.end[i]);
 /* Similar but for strings. */
 static void
 fixup_search_regs_for_string (Lisp_Object string)
 {
 int i;
+int num_regs = search_regs.num_regs;
 /* #### bytecount_to_charcount() is not that efficient.  This function
 could be faster if it did its own conversion (using INC_CHARPTR()
 and such), because the register ends are likely to be somewhat ordered.
 (Even if not, you could sort them.)
 Think about this if this function is a time hog, which it's probably
 not. */
-for (i = 0; i < search_regs.num_regs; i++)
+for (i = 0; i < num_regs; i++)
 {
 if (search_regs.start[i] > 0)
 	{
 	  search_regs.start[i] =
 	    bytecount_to_charcount (XSTRING_DATA (string),
 matcher_overflow ();
 val = (0 <= i ? Qt : Qnil);
 if (NILP (val))
 return Qnil;
-for (i = 0; i < search_regs.num_regs; i++)
+{
-if (search_regs.start[i] >= 0)
+int num_regs = search_regs.num_regs;
-{
+for (i = 0; i < num_regs; i++)
-	search_regs.start[i] += BI_BUF_BEGV (buf);
+if (search_regs.start[i] >= 0)
-	search_regs.end[i] += BI_BUF_BEGV (buf);
+	{
-}
+	  search_regs.start[i] += BI_BUF_BEGV (buf);
+	  search_regs.end[i] += BI_BUF_BEGV (buf);
+	}
+}
 XSETBUFFER (last_thing_searched, buf);
 fixup_search_regs_for_buffer (buf);
 return val;
 }
 if (NILP (start))
 s = 0;
 else
 {
-Charcount len = string_char_length (XSTRING (string));
+Charcount len = XSTRING_CHAR_LENGTH (string);
 CHECK_INT (start);
 s = XINT (start);
 if (s < 0 && -s <= len)
 	s = len + s;
 if (XINT (lim) < BUF_BEGV (buf))
 lim = make_int (BUF_BEGV (buf));
 p = XSTRING_DATA (string);
 pend = p + XSTRING_LENGTH (string);
-memset (fastmap, 0, sizeof (fastmap));
+xzero (fastmap);
 Fclear_range_table (Vskip_chars_range_table);
 if (p != pend && *p == '^')
 {
 /* If ^ was the first character, complement the fastmap.
 We don't complement the range table, however; we just use negate
 in the comparisons below. */
 if (negate)
-for (i = 0; i < sizeof fastmap; i++)
+for (i = 0; i < (int) (sizeof fastmap); i++)
 fastmap[i] ^= 1;
 {
 Bufpos start_point = BUF_PT (buf);
 	    {
 	      matcher_overflow ();
 	    }
 	  if (val >= 0)
 	    {
+	      int num_regs = search_regs.num_regs;
 	      j = BI_BUF_BEGV (buf);
-	      for (i = 0; i < search_regs.num_regs; i++)
+	      for (i = 0; i < num_regs; i++)
 		if (search_regs.start[i] >= 0)
 		  {
 		    search_regs.start[i] += j;
 		    search_regs.end[i] += j;
 		  }
 	    {
 	      matcher_overflow ();
 	    }
 	  if (val >= 0)
 	    {
+	      int num_regs = search_regs.num_regs;
 	      j = BI_BUF_BEGV (buf);
-	      for (i = 0; i < search_regs.num_regs; i++)
+	      for (i = 0; i < num_regs; i++)
 		if (search_regs.start[i] >= 0)
 		  {
 		    search_regs.start[i] += j;
 		    search_regs.end[i] += j;
 		  }
 			  (EMACS_INT) p_limit)
 			while ((EMACS_INT) cursor <=
 			       (EMACS_INT) p_limit)
 			  cursor += BM_tab[*cursor];
 		      else
-			while ((unsigned EMACS_INT) cursor <=
+			while ((EMACS_UINT) cursor <=
-			       (unsigned EMACS_INT) p_limit)
+			       (EMACS_UINT) p_limit)
 			  cursor += BM_tab[*cursor];
 		    }
 		  else
 		    {
 		      if ((EMACS_INT) (p_limit + infinity) <
 			  (EMACS_INT) p_limit)
 			while ((EMACS_INT) cursor >=
 			       (EMACS_INT) p_limit)
 			  cursor += BM_tab[*cursor];
 		      else
-			while ((unsigned EMACS_INT) cursor >=
+			while ((EMACS_UINT) cursor >=
-			       (unsigned EMACS_INT) p_limit)
+			       (EMACS_UINT) p_limit)
 			  cursor += BM_tab[*cursor];
 		    }
 /* If you are here, cursor is beyond the end of the searched region. */
 /* This can happen if you match on the far character of the pattern, */
 /* because the "stride" of that character is infinity, a number able */
 struct buffer *buf = decode_buffer (buffer, 0);
 struct Lisp_Char_Table *syntax_table =
 XCHAR_TABLE (buf->mirror_syntax_table);
 CHECK_STRING (string);
-len = string_char_length (XSTRING (string));
+len = XSTRING_CHAR_LENGTH (string);
 for (i = 0; i < len; i++)
 if (!WORD_SYNTAX_P (syntax_table, string_char (XSTRING (string), i)))
 {
 	punct_count++;
 }
 else
 {
 if (search_regs.start[0] < 0
 	  || search_regs.start[0] > search_regs.end[0]
-	  || search_regs.end[0] > string_char_length (XSTRING (string)))
+	  || search_regs.end[0] > XSTRING_CHAR_LENGTH (string))
 	args_out_of_range (make_int (search_regs.start[0]),
 			   make_int (search_regs.end[0]));
 }
 if (NILP (fixedcase))
 after = Fsubstring (string, make_int (search_regs.end[0]), Qnil);
 /* Do case substitution into NEWTEXT if desired.  */
 if (NILP (literal))
 	{
-	  Charcount stlen = string_char_length (XSTRING (newtext));
+	  Charcount stlen = XSTRING_CHAR_LENGTH (newtext);
 	  Charcount strpos;
 	  /* XEmacs change: rewrote this loop somewhat to make it
 	     cleaner.  Also added \U, \E, etc. */
 	  Charcount literal_start = 0;
 	  /* We build up the substituted string in ACCUM.  */
 			      make_opaque_ptr (ul_action_dynarr)));
 			}
 		      literal_end = strpos - 1;
 		      Dynarr_add (ul_pos_dynarr,
 				  (!NILP (accum)
-				  ? string_char_length (XSTRING (accum))
+				  ? XSTRING_CHAR_LENGTH (accum)
 				  : 0) + (literal_end - literal_start));
 		      Dynarr_add (ul_action_dynarr, c);
 		    }
 		  else if (c == '\\')
 		    /* So we get just one backslash. */
 /* Now finally, we need to process the \U's, \E's, etc. */
 if (ul_pos_dynarr)
 	{
 	  int i = 0;
 	  int cur_action = 'E';
-	  Charcount stlen = string_char_length (XSTRING (newtext));
+	  Charcount stlen = XSTRING_CHAR_LENGTH (newtext);
 	  Charcount strpos;
 	  for (strpos = 0; strpos < stlen; strpos++)
 	    {
 	      Emchar curchar = string_char (XSTRING (newtext), strpos);
 BUF_SET_PT (buf, search_regs.start[0]);
 if (!NILP (literal))
 Finsert (1, &newtext);
 else
 {
-Charcount stlen = string_char_length (XSTRING (newtext));
+Charcount stlen = XSTRING_CHAR_LENGTH (newtext);
 Charcount strpos;
 struct gcpro gcpro1;
 GCPRO1 (newtext);
 for (strpos = 0; strpos < stlen; strpos++)
 	{
 (list))
 {
 /* This function has been Mule-ized. */
 REGISTER int i;
 REGISTER Lisp_Object marker;
+int num_regs;
+int length;
 if (running_asynch_code)
 save_search_regs ();
-if (!CONSP (list) && !NILP (list))
+CONCHECK_LIST (list);
-list = wrong_type_argument (Qconsp, list);
 /* Unless we find a marker with a buffer in LIST, assume that this
 match data came from a string.  */
 last_thing_searched = Qt;
 /* Allocate registers if they don't already exist.  */
-{
+length = XINT (Flength (list)) / 2;
-int length = XINT (Flength (list)) / 2;
+num_regs = search_regs.num_regs;
-if (length > search_regs.num_regs)
+if (length > num_regs)
 {
-	if (search_regs.num_regs == 0)
+if (search_regs.num_regs == 0)
-	  {
+	{
-	    search_regs.start = xnew_array (regoff_t, length);
+	  search_regs.start = xnew_array (regoff_t, length);
-	    search_regs.end   = xnew_array (regoff_t, length);
+	  search_regs.end   = xnew_array (regoff_t, length);
-	  }
+	}
-	else
+else
-	  {
+	{
-	    XREALLOC_ARRAY (search_regs.start, regoff_t, length);
+	  XREALLOC_ARRAY (search_regs.start, regoff_t, length);
-	    XREALLOC_ARRAY (search_regs.end,   regoff_t, length);
+	  XREALLOC_ARRAY (search_regs.end,   regoff_t, length);
-	  }
+	}
-	search_regs.num_regs = length;
+search_regs.num_regs = length;
 }
-}
+for (i = 0; i < num_regs; i++)
-for (i = 0; i < search_regs.num_regs; i++)
 {
 marker = Fcar (list);
 if (NILP (marker))
 	{
 	  search_regs.start[i] = -1;

Mercurial > hg > xemacs-beta

comparison src/search.c @ 272:c5d627a313b1 r21-0b34