xemacs-beta: src/search.c comparison

comparison src/search.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	8eaf7971accc
children	b405438285a2

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 We could get a potential speedup by not converting the search registers
 until it's really necessary, e.g. when match-data or replace-match is
 called.  However, this complexifies the code a lot (e.g. the buffer
 could have changed and the Bytinds stored might be invalid) and is
 probably not a great time-saver. */
 static void
 fixup_search_regs_for_buffer (struct buffer *buf)
 {
 int i;
 /* This function has been Mule-ized. */
 Bytind lim = en > 0 ? en :
 ((count > 0) ? BI_BUF_ZV (buf) : BI_BUF_BEGV (buf));
 /* #### newline cache stuff in this function not yet ported */
 assert (count != 0);
 if (shortage)
 *shortage = 0;
 if (count > 0)
 {
 #ifdef MULE
 /* Due to the Mule representation of characters in a buffer,
 	 we can simply search for characters in the range 0 - 127
 	{
 	  while (st < lim && count > 0)
 	    {
 	      Bytind ceil;
 	      Bufbyte *bufptr;
 	      ceil = BI_BUF_CEILING_OF (buf, st);
 	      ceil = min (lim, ceil);
 	      bufptr = (Bufbyte *) memchr (BI_BUF_BYTE_ADDRESS (buf, st),
 					   (int) target, ceil - st);
 	      if (bufptr)
 	  while (st > lim && count < 0)
 	    {
 	      Bytind floor;
 	      Bufbyte *bufptr;
 	      Bufbyte *floorptr;
 	      floor = BI_BUF_FLOOR_OF (buf, st);
 	      floor = max (lim, floor);
 	      /* No memrchr() ... */
 	      bufptr = BI_BUF_BYTE_ADDRESS_BEFORE (buf, st);
 	      floorptr = BI_BUF_BYTE_ADDRESS (buf, floor);
 int shortage;
 Bufpos pos = scan_buffer (buf, '\n', from, to, cnt, &shortage, 1);
 if (shortage == 0)
 pos--;
 return pos;
 }
 static Lisp_Object
 skip_chars (struct buffer *buf, int forwardp, int syntaxp,
 p = XSTRING_DATA (string);
 pend = p + XSTRING_LENGTH (string);
 memset (fastmap, 0, sizeof (fastmap));
 Fclear_range_table (Vskip_chars_range_table);
 if (p != pend && *p == '^')
 {
 negate = 1;
 p++;
 }
 	      INC_CHARPTR (p);
 	    }
 	  if (p != pend && *p == '-')
 	    {
 	      Emchar cend;
 	      p++;
 	      if (p == pend) break;
 	      cend = charptr_emchar (p);
 	      while (c <= cend && c < 0400)
 		{
 	      BUF_SET_PT (buf, BUF_PT (buf) + 1);
 	  }
 	else
 	  {
 	    while (BUF_PT (buf) > XINT (lim)
 		   && fastmap[(unsigned char)
 syntax_code_spec
 			      [(int) SYNTAX (syntax_table,
 					     BUF_FETCH_CHAR
 					     (buf, BUF_PT (buf) - 1))]])
 	      BUF_SET_PT (buf, BUF_PT (buf) - 1);
 	  }
 	else
 	  {
 	    while (BUF_PT (buf) > XINT (lim))
 	      {
 		Emchar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1);
 		if ((ch < 0400) ? fastmap[ch] :
 		    (NILP (Fget_range_table (make_int (ch),
 					     Vskip_chars_range_table,
 					     Qnil))
 		     == negate))
 DEFUN ("skip-chars-forward", Fskip_chars_forward, 1, 3, 0, /*
 Move point forward, stopping before a char not in STRING, or at pos LIM.
 STRING is like the inside of a `[...]' in a regular expression
 except that `]' is never special and `\\' quotes `^', `-' or `\\'.
-Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.
+Thus, with arg "a-zA-Z", this skips letters stopping before first nonletter.
-With arg \"^a-zA-Z\", skips nonletters stopping before first letter.
+With arg "^a-zA-Z", skips nonletters stopping before first letter.
 Returns the distance traveled, either zero or positive.
 Optional argument BUFFER defaults to the current buffer.
 */
 (string, lim, buffer))
 EMACS_INT infinity;
 Bytind limit;
 EMACS_INT k;
 Bytecount stride_for_teases = 0;
 register Bufbyte *pat = 0;
 register Bufbyte *cursor, *p_limit, *ptr2;
 register EMACS_INT i, j;
 Bytind p1, p2;
 Bytecount s1, s2;
 Bytind pos, lim;
 p1 = BI_BUF_BEGV (buf);
 p2 = BI_BUF_CEILING_OF (buf, p1);
 s1 = p2 - p1;
 s2 = BI_BUF_ZV (buf) - p2;
 while (n < 0)
 	{
 	  Bytecount val;
 	  QUIT;
 regex_emacs_buffer = buf;
 {
 #ifdef C_ALLOCA
 EMACS_INT BM_tab_space[0400];
 BM_tab = &BM_tab_space[0];
 #else
-BM_tab = (EMACS_INT *) alloca (0400 * sizeof (EMACS_INT));
+BM_tab = alloca_array (EMACS_INT, 256);
 #endif
 {
-	Bufbyte *patbuf = (Bufbyte *) alloca (len);
+	Bufbyte *patbuf = alloca_array (Bufbyte, len);
 	pat = patbuf;
 	while (--len >= 0)
 	  {
 	    /* If we got here and the RE flag is set, it's because we're
 	       dealing with a regexp known to be trivial, so the backslash
 /* As a coding trick, an enormous stride is coded into the table for */
 /* characters that match the last character.  This allows use of only */
 /* a single test, a test for having gone past the end of the */
 /* permissible match region, to test for both possible matches (when */
 /* the stride goes past the end immediately) and failure to */
 /* match (where you get nudged past the end one stride at a time). */
 /* Here we make a "mickey mouse" BM table.  The stride of the search */
 /* is determined only by the last character of the putative match. */
 /* If that character does not match, we will stride the proper */
 /* distance to propose a match that superimposes it on the last */
 /* instance of a character that matches it (per trt), or misses */
 /* it entirely if there is none. */
 dirlen = len * direction;
 infinity = dirlen - (lim + pos + len + len) * direction;
 if (direction < 0)
 	pat = (base_pat += len - 1);
 	      k = (j = trt[j]);
 	      if (i == infinity)
 		stride_for_teases = BM_tab[j];
 	      BM_tab[j] = dirlen - i;
 	      /* A translation table is accompanied by its inverse -- see */
 	      /* comment following downcase_table for details */
 	      while ((j = inverse_trt[j]) != k)
 		BM_tab[j] = dirlen - i;
 	    }
 	  else
 			Bytind bytstart = (pos + cursor - ptr2 +
 					   ((direction > 0)
 					    ? 1 - len : 0));
 			Bufpos bufstart = bytind_to_bufpos (buf, bytstart);
 			Bufpos bufend = bytind_to_bufpos (buf, bytstart + len);
 			set_search_regs (buf, bufstart, bufend - bufstart);
 		      }
 		      if ((n -= direction) != 0)
 			cursor += dirlen; /* to resume search */
 	      while (1)
 		{
 		  /* This loop can be coded for space rather than */
 		  /* speed because it will usually run only once. */
 		  /* (the reach is at most len + 21, and typically */
 		  /* does not exceed len) */
 		  while ((limit - pos) * direction >= 0)
 		    /* *not* BI_BUF_FETCH_CHAR.  We are working here
 		       with bytes, not characters. */
 		    pos += BM_tab[*BI_BUF_BYTE_ADDRESS (buf, pos)];
 		  /* now run the same tests to distinguish going off the */
 			Bytind bytstart = (pos +
 					   ((direction > 0)
 					    ? 1 - len : 0));
 			Bufpos bufstart = bytind_to_bufpos (buf, bytstart);
 			Bufpos bufend = bytind_to_bufpos (buf, bytstart + len);
 			set_search_regs (buf, bufstart, bufend - bufstart);
 		      }
 		      if ((n -= direction) != 0)
 			pos += dirlen; /* to resume search */
 /* This function has been Mule-ized. */
 /* Make sure we have registers in which to store
 the match position.  */
 if (search_regs.num_regs == 0)
 {
-/* #### XEmacs: the ones were twos before, which is surely broken. */
+search_regs.start = xnew (regoff_t);
-search_regs.start = (regoff_t *) xmalloc (1 * sizeof (regoff_t));
+search_regs.end   = xnew (regoff_t);
-search_regs.end = (regoff_t *) xmalloc (1 * sizeof (regoff_t));
 search_regs.num_regs = 1;
 }
 search_regs.start[0] = beg;
 search_regs.end[0] = beg + len;
 *o++ = 'b';
 for (i = 0; i < len; i++)
 {
 	Emchar ch = string_char (XSTRING (string), i);
 	if (WORD_SYNTAX_P (syntax_table, ch))
 	  o += set_charptr_emchar (o, ch);
 	else if (i > 0
 		 && WORD_SYNTAX_P (syntax_table,
 				   string_char (XSTRING (string), i - 1))
 buffer = last_thing_searched;
 buf = XBUFFER (buffer);
 }
 syntax_table = XCHAR_TABLE (buf->mirror_syntax_table);
 case_action = nochange;	/* We tried an initialization */
 				/* but some C compilers blew it */
 if (search_regs.num_regs <= 0)
 error ("replace-match called before any match found");
 	{
 	  int i = 0;
 	  int cur_action = 'E';
 	  Charcount stlen = string_char_length (XSTRING (newtext));
 	  Charcount strpos;
 	  for (strpos = 0; strpos < stlen; strpos++)
 	    {
 	      Emchar curchar = string_char (XSTRING (newtext), strpos);
 	      Emchar newchar = -1;
 	      if (i < Dynarr_length (ul_pos_dynarr) &&
 				    search_regs.end[0]);
 /* begin_multiple_change() records an unwind-protect, so we need to
 record this value now. */
 speccount = specpdl_depth ();
 /* We insert the replacement text before the old text, and then
 delete the original text.  This means that markers at the
 beginning or end of the original will float to the corresponding
 position in the replacement.  */
 BUF_SET_PT (buf, search_regs.start[0]);
 	  c = string_char (XSTRING (newtext), strpos);
 	  if (c == '\\')
 	    {
 	      c = string_char (XSTRING (newtext), ++strpos);
 	      if (c == '&')
 		Finsert_buffer_substring
 (buffer,
 make_int (search_regs.start[0] + offset),
 make_int (search_regs.end[0] + offset));
 	      else if (c >= '1' && c <= '9' &&
 		       c <= search_regs.num_regs + '0')
 Zero means the entire text matched by the whole regexp or whole string.
 */
 (num))
 {
 return match_limit (num, 0);
 }
 DEFUN ("match-data", Fmatch_data, 0, 0, 0, /*
 Return a list containing all info on what the last regexp search matched.
 Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.
 All the elements are markers or nil (nil if the Nth pair didn't match)
 Charcount len;
 if (NILP (last_thing_searched))
 error ("match-data called before any match found");
-data = (Lisp_Object *) alloca ((2 * search_regs.num_regs)
+data = alloca_array (Lisp_Object, 2 * search_regs.num_regs);
-				 * sizeof (Lisp_Object));
 len = -1;
 for (i = 0; i < search_regs.num_regs; i++)
 {
 Bufpos start = search_regs.start[i];
 	      Fset_marker (data[2 * i],
 			   make_int (start),
 			   last_thing_searched);
 	      data[2 * i + 1] = Fmake_marker ();
 	      Fset_marker (data[2 * i + 1],
 			   make_int (search_regs.end[i]),
 			   last_thing_searched);
 	    }
 	  else
 	    /* last_thing_searched must always be Qt, a buffer, or Qnil.  */
 	    abort ();
 save_search_regs ();
 if (!CONSP (list) && !NILP (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.  */
 {
 if (length > search_regs.num_regs)
 {
 	if (search_regs.num_regs == 0)
 	  {
-	    search_regs.start
+	    search_regs.start = xnew_array (regoff_t, length);
-	      = (regoff_t *) xmalloc (length * sizeof (regoff_t));
+	    search_regs.end   = xnew_array (regoff_t, length);
-	    search_regs.end
-	      = (regoff_t *) xmalloc (length * sizeof (regoff_t));
 	  }
 	else
 	  {
-	    search_regs.start
+	    XREALLOC_ARRAY (search_regs.start, regoff_t, length);
-	      = (regoff_t *) xrealloc (search_regs.start,
+	    XREALLOC_ARRAY (search_regs.end,   regoff_t, length);
-				       length * sizeof (regoff_t));
-	    search_regs.end
-	      = (regoff_t *) xrealloc (search_regs.end,
-				       length * sizeof (regoff_t));
 	  }
 	search_regs.num_regs = length;
 }
 }
 	  search_regs.end[i] = XINT (marker);
 	}
 list = Fcdr (list);
 }
 return Qnil;
 }
 /* If non-zero the match data have been saved in saved_search_regs
 during the execution of a sentinel or filter. */
 static int search_regs_saved;
 /* Now copy the data into the new string, inserting escapes. */
 in = XSTRING_DATA (str);
 end = in + XSTRING_LENGTH (str);
 out = temp;
 for (; in != end; in++)
 {
 if (*in == '[' || *in == ']'
 	  || *in == '*' || *in == '.' || *in == '\\'

Mercurial > hg > xemacs-beta

comparison src/search.c @ 185:3d6bfa290dbd r20-3b19