emacs: src/search.c comparison

comparison src/search.c @ 90982:a66921565bcb

Merge from emacs--devo--0 Patches applied: * emacs--devo--0 (patch 806-813) - Merge from emacs--rel--22 - Update from CVS * emacs--rel--22 (patch 51-58) - Update from CVS - Merge from gnus--rel--5.10 * gnus--rel--5.10 (patch 233-236) - Merge from emacs--devo--0 - Update from CVS Revision: emacs@sv.gnu.org/emacs--unicode--0--patch-230

author	Miles Bader <miles@gnu.org>
date	Sun, 15 Jul 2007 04:47:46 +0000
parents	e9f94688a064 54b5d7bec019
children	f55f9811f5d7

comparison

equal deleted inserted replaced

-:a37d5bf6cbb7
+:a66921565bcb
 /* Error condition used for failing searches */
 Lisp_Object Qsearch_failed;
 Lisp_Object Vsearch_spaces_regexp;
+/* If non-nil, the match data will not be changed during call to
+searching or matching functions.  This variable is for internal use
+only.  */
+Lisp_Object Vinhibit_changing_match_data;
 static void set_search_regs ();
 static void save_search_regs ();
 static int simple_search ();
 static int boyer_moore ();
 /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
 XCHAR_TABLE (current_buffer->case_canon_table)->extras[2]
 = current_buffer->case_eqv_table;
 CHECK_STRING (string);
-bufp = compile_pattern (string, &search_regs,
+bufp = compile_pattern (string,
+			  (NILP (Vinhibit_changing_match_data)
+			   ? &search_regs : NULL),
 			  (!NILP (current_buffer->case_fold_search)
 			   ? current_buffer->case_canon_table : Qnil),
 			  posix,
 			  !NILP (current_buffer->enable_multibyte_characters));
 }
 re_match_object = Qnil;
 i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2,
-		  PT_BYTE - BEGV_BYTE, &search_regs,
+		  PT_BYTE - BEGV_BYTE,
+		  (NILP (Vinhibit_changing_match_data)
+		   ? &search_regs : NULL),
 		  ZV_BYTE - BEGV_BYTE);
 immediate_quit = 0;
 if (i == -2)
 matcher_overflow ();
 val = (0 <= i ? Qt : Qnil);
-if (i >= 0)
+if (NILP (Vinhibit_changing_match_data) && i >= 0)
 for (i = 0; i < search_regs.num_regs; i++)
 if (search_regs.start[i] >= 0)
 	{
 	  search_regs.start[i]
 	    = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
 	  search_regs.end[i]
 	    = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
 	}
-XSETBUFFER (last_thing_searched, current_buffer);
+/* Set last_thing_searched only when match data is changed.  */
+if (NILP (Vinhibit_changing_match_data))
+XSETBUFFER (last_thing_searched, current_buffer);
 return val;
 }
 DEFUN ("looking-at", Flooking_at, Slooking_at, 1, 1, 0,
 doc: /* Return t if text after point matches regular expression REGEXP.
 /* This is so set_image_of_range_1 in regex.c can find the EQV table.  */
 XCHAR_TABLE (current_buffer->case_canon_table)->extras[2]
 = current_buffer->case_eqv_table;
-bufp = compile_pattern (regexp, &search_regs,
+bufp = compile_pattern (regexp,
+			  (NILP (Vinhibit_changing_match_data)
+			   ? &search_regs : NULL),
 			  (!NILP (current_buffer->case_fold_search)
 			   ? current_buffer->case_canon_table : Qnil),
 			  posix,
 			  STRING_MULTIBYTE (string));
 immediate_quit = 1;
 re_match_object = string;
 val = re_search (bufp, (char *) SDATA (string),
 		   SBYTES (string), pos_byte,
 		   SBYTES (string) - pos_byte,
-		   &search_regs);
+		   (NILP (Vinhibit_changing_match_data)
+		    ? &search_regs : NULL));
 immediate_quit = 0;
-last_thing_searched = Qt;
+/* Set last_thing_searched only when match data is changed.  */
+if (NILP (Vinhibit_changing_match_data))
+last_thing_searched = Qt;
 if (val == -2)
 matcher_overflow ();
 if (val < 0) return Qnil;
-for (i = 0; i < search_regs.num_regs; i++)
+if (NILP (Vinhibit_changing_match_data))
-if (search_regs.start[i] >= 0)
+for (i = 0; i < search_regs.num_regs; i++)
-{
+if (search_regs.start[i] >= 0)
-	search_regs.start[i]
+	{
-	  = string_byte_to_char (string, search_regs.start[i]);
+	  search_regs.start[i]
-	search_regs.end[i]
+	    = string_byte_to_char (string, search_regs.start[i]);
-	  = string_byte_to_char (string, search_regs.end[i]);
+	  search_regs.end[i]
-}
+	    = string_byte_to_char (string, search_regs.end[i]);
+	}
 return make_number (string_byte_to_char (string, val));
 }
 DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
 else					\
 out = d;					\
 }						\
 while (0)
+/* Only used in search_buffer, to record the end position of the match
+when searching regexps and SEARCH_REGS should not be changed
+(i.e. Vinhibit_changing_match_data is non-nil).  */
+static struct re_registers search_regs_1;
 static int
 search_buffer (string, pos, pos_byte, lim, lim_byte, n,
 	       RE, trt, inverse_trt, posix)
 Lisp_Object string;
 int pos;
 {
 unsigned char *p1, *p2;
 int s1, s2;
 struct re_pattern_buffer *bufp;
-bufp = compile_pattern (string, &search_regs, trt, posix,
+bufp = compile_pattern (string,
+			      (NILP (Vinhibit_changing_match_data)
+			       ? &search_regs : &search_regs_1),
+			      trt, posix,
 			      !NILP (current_buffer->enable_multibyte_characters));
 immediate_quit = 1;	/* Quit immediately if user types ^G,
 				   because letting this function finish
 				   can take too long. */
 while (n < 0)
 	{
 	  int val;
 	  val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
 			     pos_byte - BEGV_BYTE, lim_byte - pos_byte,
-			     &search_regs,
+			     (NILP (Vinhibit_changing_match_data)
+			      ? &search_regs : &search_regs_1),
 			     /* Don't allow match past current point */
 			     pos_byte - BEGV_BYTE);
 	  if (val == -2)
 	    {
 	      matcher_overflow ();
 	    }
 	  if (val >= 0)
 	    {
-	      pos_byte = search_regs.start[0] + BEGV_BYTE;
+	      if (NILP (Vinhibit_changing_match_data))
-	      for (i = 0; i < search_regs.num_regs; i++)
+		{
-		if (search_regs.start[i] >= 0)
+		  pos_byte = search_regs.start[0] + BEGV_BYTE;
-		  {
+		  for (i = 0; i < search_regs.num_regs; i++)
-		    search_regs.start[i]
+		    if (search_regs.start[i] >= 0)
-		      = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
+		      {
-		    search_regs.end[i]
+			search_regs.start[i]
-		      = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
+			  = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
-		  }
+			search_regs.end[i]
-	      XSETBUFFER (last_thing_searched, current_buffer);
+			  = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
-	      /* Set pos to the new position. */
+		      }
-	      pos = search_regs.start[0];
+		  XSETBUFFER (last_thing_searched, current_buffer);
+		  /* Set pos to the new position. */
+		  pos = search_regs.start[0];
+		}
+	      else
+		{
+		  pos_byte = search_regs_1.start[0] + BEGV_BYTE;
+		  /* Set pos to the new position.  */
+		  pos = BYTE_TO_CHAR (search_regs_1.start[0] + BEGV_BYTE);
+		}
 	    }
 	  else
 	    {
 	      immediate_quit = 0;
 	      return (n);
 while (n > 0)
 	{
 	  int val;
 	  val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
 			     pos_byte - BEGV_BYTE, lim_byte - pos_byte,
-			     &search_regs,
+			     (NILP (Vinhibit_changing_match_data)
+			      ? &search_regs : &search_regs_1),
 			     lim_byte - BEGV_BYTE);
 	  if (val == -2)
 	    {
 	      matcher_overflow ();
 	    }
 	  if (val >= 0)
 	    {
-	      pos_byte = search_regs.end[0] + BEGV_BYTE;
+	      if (NILP (Vinhibit_changing_match_data))
-	      for (i = 0; i < search_regs.num_regs; i++)
+		{
-		if (search_regs.start[i] >= 0)
+		  pos_byte = search_regs.end[0] + BEGV_BYTE;
-		  {
+		  for (i = 0; i < search_regs.num_regs; i++)
-		    search_regs.start[i]
+		    if (search_regs.start[i] >= 0)
-		      = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
+		      {
-		    search_regs.end[i]
+			search_regs.start[i]
-		      = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
+			  = BYTE_TO_CHAR (search_regs.start[i] + BEGV_BYTE);
-		  }
+			search_regs.end[i]
-	      XSETBUFFER (last_thing_searched, current_buffer);
+			  = BYTE_TO_CHAR (search_regs.end[i] + BEGV_BYTE);
-	      pos = search_regs.end[0];
+		      }
+		  XSETBUFFER (last_thing_searched, current_buffer);
+		  pos = search_regs.end[0];
+		}
+	      else
+		{
+		  pos_byte = search_regs_1.end[0] + BEGV_BYTE;
+		  pos = BYTE_TO_CHAR (search_regs_1.end[0] + BEGV_BYTE);
+		}
 	    }
 	  else
 	    {
 	      immediate_quit = 0;
 	      return (0 - n);
 		    }
 		}
 	      cursor += dirlen - i - direction;	/* fix cursor */
 	      if (i + direction == 0)
 		{
-		  int position;
+		  int position, start, end;
 		  cursor -= direction;
 		  position = pos_byte + cursor - p2 + ((direction > 0)
 						       ? 1 - len_byte : 0);
 		  set_search_regs (position, len_byte);
+		  if (NILP (Vinhibit_changing_match_data))
+		    {
+		      start = search_regs.start[0];
+		      end = search_regs.end[0];
+		    }
+		  else
+		    /* If Vinhibit_changing_match_data is non-nil,
+		       search_regs will not be changed.  So let's
+		       compute start and end here.  */
+		    {
+		      start = BYTE_TO_CHAR (position);
+		      end = BYTE_TO_CHAR (position + len_byte);
+		    }
 		  if ((n -= direction) != 0)
 		    cursor += dirlen; /* to resume search */
 		  else
-		    return ((direction > 0)
+		    return direction > 0 ? end : start;
-			    ? search_regs.end[0] : search_regs.start[0]);
 		}
 	      else
 		cursor += stride_for_teases; /* <sigh> we lose -  */
 	    }
 	  pos_byte += cursor - p2;
 		 back to the first pos (last pos if reverse).
 		 Set it once again at the last (first if reverse) char.  */
 	      pos_byte += dirlen - i- direction;
 	      if (i + direction == 0)
 		{
-		  int position;
+		  int position, start, end;
 		  pos_byte -= direction;
 		  position = pos_byte + ((direction > 0) ? 1 - len_byte : 0);
 		  set_search_regs (position, len_byte);
+		  if (NILP (Vinhibit_changing_match_data))
+		    {
+		      start = search_regs.start[0];
+		      end = search_regs.end[0];
+		    }
+		  else
+		    /* If Vinhibit_changing_match_data is non-nil,
+		       search_regs will not be changed.  So let's
+		       compute start and end here.  */
+		    {
+		      start = BYTE_TO_CHAR (position);
+		      end = BYTE_TO_CHAR (position + len_byte);
+		    }
 		  if ((n -= direction) != 0)
 		    pos_byte += dirlen; /* to resume search */
 		  else
-		    return ((direction > 0)
+		    return direction > 0 ? end : start;
-			    ? search_regs.end[0] : search_regs.start[0]);
 		}
 	      else
 		pos_byte += stride_for_teases;
 	    }
 	  }
 static void
 set_search_regs (beg_byte, nbytes)
 int beg_byte, nbytes;
 {
 int i;
+if (!NILP (Vinhibit_changing_match_data))
+return;
 /* Make sure we have registers in which to store
 the match position.  */
 if (search_regs.num_regs == 0)
 {
 Spaces that occur inside character classes or repetition operators
 or other such regexp constructs are not replaced with this.
 A value of nil (which is the normal value) means treat spaces literally.  */);
 Vsearch_spaces_regexp = Qnil;
+DEFVAR_LISP ("inhibit-changing-match-data", &Vinhibit_changing_match_data,
+doc: /* Internal use only.
+If non-nil, the match data will not be changed during call to searching or
+matching functions, such as `looking-at', `string-match', `re-search-forward'
+etc.  */);
+Vinhibit_changing_match_data = Qnil;
 defsubr (&Slooking_at);
 defsubr (&Sposix_looking_at);
 defsubr (&Sstring_match);
 defsubr (&Sposix_string_match);
 defsubr (&Ssearch_forward);

Mercurial > emacs

comparison src/search.c @ 90982:a66921565bcb