xemacs-beta: src/search.c comparison

comparison src/search.c @ 1468:0f42689481f0

[xemacs-hg @ 2003-05-09 14:52:37 by stephent] revert clobber match data <873cjoi38t.fsf@tleepslib.sk.tsukuba.ac.jp>

author	stephent
date	Fri, 09 May 2003 14:52:43 +0000
parents	74cb069b8417
children	4af49f9a7a5c

comparison

equal deleted inserted replaced

-:e5da225ea2ca
+:0f42689481f0
 that gets real ugly real fast since the buffer might have changed and
 the positions might be out of sync or out of range.
 */
 static struct re_registers search_regs;
-/* Every function that _may_ set the match data _must_ clear the search
+/* Every function that sets the match data _must_ clear unused search
-registers on entry.  An unsuccessful search should leave the search
+registers on success.  An unsuccessful search or match _must_ preserve
-registers cleared.  Applications that are no-ops by definition (eg,
+the search registers.  The traditional documentation implied that
-searches with a repetition count of 0) _must not_ clear the search
+any match operation might trash the registers, but in fact failures
+have always preserved the match data (in GNU Emacs as well).  Some
+plausible code depends on this behavior (cf. `w3-configuration-data'
+in library "w3-cfg").
+Ordinary string searchs use set_search_regs to set the whole-string
+match.  That function takes care of clearing the unused subexpression
 registers.
-XEmacs 21.5 up to beta 11 may have permitted the following idiom to
-"win" in the sense that the match data was set to the last successful
-match's match data, and not cleared as the current implemenation does:
-(while (search_forward "string"))
-(use-match-data-of-last-successful-search)
-This no longer can work.  You must use save-match-data to preserve the
-match data:
-(let (md)
-(while (when (search-forward "string") (setq md (match-data))))
-(set-match-data md))
-(use-match-data-of-last-successful-search)
 */
 static void set_search_regs (struct buffer *buf, Charbpos beg, Charcount len);
-static void clear_search_regs (struct re_registers *regp);
+static void clear_search_regs (void);
 /* The buffer in which the last search was performed, or
 Qt if the last search was done in a string;
 Qnil if no searching has been done yet.  */
 static Lisp_Object last_thing_searched;
 REGISTER int i;
 struct re_pattern_buffer *bufp;
 struct syntax_cache scache_struct;
 struct syntax_cache *scache = &scache_struct;
-/* clear search registers *now*.  no mercy, not even for errors */
-clear_search_regs (&search_regs);
 CHECK_STRING (string);
 bufp = compile_pattern (string, &search_regs,
 			  (!NILP (buf->case_fold_search)
 			   ? XCASE_TABLE_DOWNCASE (buf->case_table) : Qnil),
 			  wrap_buffer (buf), buf, posix, ERROR_ME);
 return val;
 }
 DEFUN ("looking-at", Flooking_at, 1, 2, 0, /*
 Return t if text after point matches regular expression REGEXP.
-This function modifies the match data that `match-beginning',
+When the match is successful, this function modifies the match data
-`match-end' and `match-data' access; save and restore the match
+that `match-beginning', `match-end' and `match-data' access; save the
-data if you want to preserve them.
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
 Optional argument BUFFER defaults to the current buffer.
 */
 (regexp, buffer))
 {
 }
 DEFUN ("posix-looking-at", Fposix_looking_at, 1, 2, 0, /*
 Return t if text after point matches regular expression REGEXP.
 Find the longest match, in accord with Posix regular expression rules.
-This function modifies the match data that `match-beginning',
+When the match is successful, this function modifies the match data
-`match-end' and `match-data' access; save and restore the match
+that `match-beginning', `match-end' and `match-data' access; save the
-data if you want to preserve them.
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
 Optional argument BUFFER defaults to the current buffer.
 */
 (regexp, buffer))
 {
 struct re_pattern_buffer *bufp;
 /* Some FSF junk with running_asynch_code, to preserve the match
 data.  Not necessary because we don't call process filters
 asynchronously (i.e. from within QUIT). */
-/* clear search registers *now*.  no mercy, not even for errors */
-clear_search_regs (&search_regs);
 CHECK_STRING (regexp);
 CHECK_STRING (string);
 if (NILP (start))
 (let ((case-fold-search nil))
 (string-match "^foo.*bar" string))
 but the case, syntax, and category tables come from the standard tables,
-which are accessed through functions `default-{case,syntax,category}-table' and serve as the parents of the
+which are accessed through functions `default-{case,syntax,category}-table'
-tables in particular buffer
+and serve as the parents of the tables in particular buffer.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
 */
 (regexp, string, start, buffer))
 {
 /* &&#### implement new interp for buffer arg; check code to see if it
 makes more sense than prev */
 matched by parenthesis constructs in the pattern.
 Optional arg BUFFER controls how case folding is done (according to
 the value of `case-fold-search' in that buffer and that buffer's case
 tables) and defaults to the current buffer.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
 */
 (regexp, string, start, buffer))
 {
 return string_match_1 (regexp, string, start, decode_buffer (buffer, 0), 1);
 }
 /* Searching 0 times means noop---don't move, don't touch registers.  */
 if (n == 0)
 return charbpos;
-/* clear the search regs now */
-clear_search_regs (&search_regs);
 /* Null string is found at starting position.  */
 if (len == 0)
 {
 set_search_regs (buf, charbpos, 0);
 return charbpos;
 in the pattern.  Others don't matter anyway!  */
 xzero (simple_translate);
 for (i = 0; i < 0400; i++)
 simple_translate[i] = (Ibyte) i;
 i = 0;
-/* clear search regs now */
-clear_search_regs (&search_regs);
 while (i != infinity)
 {
 Ibyte *ptr = base_pat + i;
 i += direction;
 search_regs.start = xnew (regoff_t);
 search_regs.end   = xnew (regoff_t);
 search_regs.num_regs = 1;
 }
+clear_search_regs ();
 search_regs.start[0] = beg;
 search_regs.end[0] = beg + len;
 last_thing_searched = wrap_buffer (buf);
 }
-/* Clear search registers so match data will be null.
+/* Clear search registers so match data will be null. */
-REGP is a pointer to the register structure to clear, usually the global
-search_regs. */
 static void
-clear_search_regs (struct re_registers *regp)
+clear_search_regs (void)
 {
 /* This function has been Mule-ized. */
 int i;
-for (i = 0; i < regp->num_regs; i++)
+for (i = 0; i < search_regs.num_regs; i++)
-regp->start[i] = regp->end[i] = -1;
+search_regs.start[i] = search_regs.end[i] = -1;
 }
 /* Given a string of words separated by word delimiters,
 compute a regexp that matches those exact words
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (string, limit, noerror, count, buffer))
 {
 return search_command (string, limit, noerror, count, buffer, -1, 0, 0);
 }
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (string, limit, noerror, count, buffer))
 {
 return search_command (string, limit, noerror, count, buffer, 1, 0, 0);
 }
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (string, limit, noerror, count, buffer))
 {
 return search_command (wordify (buffer, string), limit, noerror, count,
 			 buffer, -1, 1, 0);
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (string, limit, noerror, count, buffer))
 {
 return search_command (wordify (buffer, string), limit, noerror, count,
 			 buffer, 1, 1, 0);
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (regexp, limit, noerror, count, buffer))
 {
 return search_command (regexp, limit, noerror, count, buffer, -1, 1, 0);
 }
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (regexp, limit, noerror, count, buffer))
 {
 return search_command (regexp, limit, noerror, count, buffer, 1, 1, 0);
 }
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (regexp, limit, noerror, count, buffer))
 {
 return search_command (regexp, limit, noerror, count, buffer, -1, 1, 1);
 }
 successive occurrences.
 Optional fifth argument BUFFER specifies the buffer to search in and
 defaults to the current buffer.
-See also the functions `match-beginning', `match-end' and `replace-match'.
+When the match is successful, this function modifies the match data
+that `match-beginning', `match-end' and `match-data' access; save the
+match data with `match-data' and restore it with `store-match-data' if
+you want to preserve them.  If the match fails, the match data from the
+previous success match is preserved.
+See also the function `replace-match'.
 */
 (regexp, limit, noerror, count, buffer))
 {
 return search_command (regexp, limit, noerror, count, buffer, 1, 1, 1);
 }
 When fourth argument is nil, STRBUFFER specifies a subexpression of
 the match.  It says to replace just that subexpression instead of the
 whole match.  This is useful only after a regular expression search or
 match since only regular expressions have distinguished subexpressions.
-If no match (including searches) has been conducted, the last match
+If no match (including searches) has been conducted or the requested
-operation failed, or the requested subexpression was not matched, an
+subexpression was not matched, an `args-out-of-range' error will be
-`args-out-of-range' error will be signaled.  (If no match has ever been
+signaled.  (If no match has ever been conducted in this instance of
-conducted in this instance of XEmacs, an `invalid-operation' error will
+XEmacs, an `invalid-operation' error will be signaled.  This is very
-be signaled.  This is very rare.)
+rare.)
 */
 (replacement, fixedcase, literal, string, strbuffer))
 {
 /* This function can GC */
 enum { nochange, all_caps, cap_initial } case_action;
 }
 DEFUN ("store-match-data", Fstore_match_data, 1, 1, 0, /*
 Set internal data on last search match from elements of LIST.
-LIST should have been created by calling `match-data' previously.
+LIST should have been created by calling `match-data' previously,
+or be nil, to clear the internal match data.
 */
 (list))
 {
 REGISTER int i;
 REGISTER Lisp_Object marker;

Mercurial > hg > xemacs-beta

comparison src/search.c @ 1468:0f42689481f0