view src/search.c @ 12096:cdc859dd813b

Declare sbrk.

+
鐃緒申��申鐃緒申/* String search routines for GNU Emacs.
+
鐃緒申��申鐃緒申   Copyright (C) 1985, 1986, 1987, 1993, 1994 Free Software Foundation, Inc.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申This file is part of GNU Emacs.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申GNU Emacs is free software; you can redistribute it and/or modify
+
鐃緒申��申鐃緒申it under the terms of the GNU General Public License as published by
+
鐃緒申��申鐃緒申the Free Software Foundation; either version 1, or (at your option)
+
鐃緒申��申鐃緒申any later version.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申GNU Emacs is distributed in the hope that it will be useful,
+
鐃緒申��申鐃緒申but WITHOUT ANY WARRANTY; without even the implied warranty of
+
鐃緒申��申鐃緒申MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+
鐃緒申��申鐃緒申GNU General Public License for more details.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申You should have received a copy of the GNU General Public License
+
鐃緒申��申鐃緒申along with GNU Emacs; see the file COPYING.  If not, write to
+
鐃緒申��申鐃緒申the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include <config.h>
+
鐃緒申��申鐃緒申#include "lisp.h"
+
鐃緒申��申鐃緒申#include "syntax.h"
+
鐃緒申��申鐃緒申#include "buffer.h"
+
鐃緒申��申鐃緒申#include "region-cache.h"
+
鐃緒申��申鐃緒申#include "commands.h"
+
鐃緒申��申鐃緒申#include "blockinput.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#include <sys/types.h>
+
鐃緒申��申鐃緒申#include "regex.h"
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#define REGEXP_CACHE_SIZE 5
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* If the regexp is non-nil, then the buffer contains the compiled form
+
鐃緒申��申鐃緒申   of that regexp, suitable for searching.  */
+
鐃緒申��申鐃緒申struct regexp_cache {
+
鐃緒申��申鐃緒申  struct regexp_cache *next;
+
鐃緒申��申鐃緒申  Lisp_Object regexp;
+
鐃緒申��申鐃緒申  struct re_pattern_buffer buf;
+
鐃緒申��申鐃緒申  char fastmap[0400];
+
鐃緒申��申鐃緒申  /* Nonzero means regexp was compiled to do full POSIX backtracking.  */
+
鐃緒申��申鐃緒申  char posix;
+
鐃緒申��申鐃緒申};
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The instances of that struct.  */
+
鐃緒申��申鐃緒申struct regexp_cache searchbufs[REGEXP_CACHE_SIZE];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The head of the linked list; points to the most recently used buffer.  */
+
鐃緒申��申鐃緒申struct regexp_cache *searchbuf_head;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Every call to re_match, etc., must pass &search_regs as the regs
+
鐃緒申��申鐃緒申   argument unless you can show it is unnecessary (i.e., if re_match
+
鐃緒申��申鐃緒申   is certainly going to be called again before region-around-match
+
鐃緒申��申鐃緒申   can be called).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Since the registers are now dynamically allocated, we need to make
+
鐃緒申��申鐃緒申   sure not to refer to the Nth register before checking that it has
+
鐃緒申��申鐃緒申   been allocated by checking search_regs.num_regs.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   The regex code keeps track of whether it has allocated the search
+
鐃緒申��申鐃緒申   buffer using bits in the re_pattern_buffer.  This means that whenever
+
鐃緒申��申鐃緒申   you compile a new pattern, it completely forgets whether it has
+
鐃緒申��申鐃緒申   allocated any registers, and will allocate new registers the next
+
鐃緒申��申鐃緒申   time you call a searching or matching function.  Therefore, we need
+
鐃緒申��申鐃緒申   to call re_set_registers after compiling a new pattern or after
+
鐃緒申��申鐃緒申   setting the match registers, so that the regex functions will be
+
鐃緒申��申鐃緒申   able to free or re-allocate it properly.  */
+
鐃緒申��申鐃緒申static struct re_registers search_regs;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* 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;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* error condition signalled when regexp compile_pattern fails */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object Qinvalid_regexp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void set_search_regs ();
+
鐃緒申��申鐃緒申static void save_search_regs ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int search_buffer ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申matcher_overflow ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  error ("Stack overflow in regexp matcher");
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申#ifdef __STDC__
+
鐃緒申��申鐃緒申#define CONST const
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申#define CONST
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Compile a regexp and signal a Lisp error if anything goes wrong.
+
鐃緒申��申鐃緒申   PATTERN is the pattern to compile.
+
鐃緒申��申鐃緒申   CP is the place to put the result.
+
鐃緒申��申鐃緒申   TRANSLATE is a translation table for ignoring case, or NULL for none.
+
鐃緒申��申鐃緒申   REGP is the structure that says where to store the "register"
+
鐃緒申��申鐃緒申   values that will result from matching this pattern.
+
鐃緒申��申鐃緒申   If it is 0, we should compile the pattern not to record any
+
鐃緒申��申鐃緒申   subexpression bounds.
+
鐃緒申��申鐃緒申   POSIX is nonzero if we want full backtracking (POSIX style)
+
鐃緒申��申鐃緒申   for this pattern.  0 means backtrack only enough to get a valid match.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申compile_pattern_1 (cp, pattern, translate, regp, posix)
+
鐃緒申��申鐃緒申     struct regexp_cache *cp;
+
鐃緒申��申鐃緒申     Lisp_Object pattern;
+
鐃緒申��申鐃緒申     char *translate;
+
鐃緒申��申鐃緒申     struct re_registers *regp;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  CONST char *val;
+
鐃緒申��申鐃緒申  reg_syntax_t old;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  cp->regexp = Qnil;
+
鐃緒申��申鐃緒申  cp->buf.translate = translate;
+
鐃緒申��申鐃緒申  cp->posix = posix;
+
鐃緒申��申鐃緒申  BLOCK_INPUT;
+
鐃緒申��申鐃緒申  old = re_set_syntax (RE_SYNTAX_EMACS
+
鐃緒申��申鐃緒申		       | (posix ? 0 : RE_NO_POSIX_BACKTRACKING));
+
鐃緒申��申鐃緒申  val = (CONST char *) re_compile_pattern ((char *) XSTRING (pattern)->data,
+
鐃緒申��申鐃緒申					   XSTRING (pattern)->size, &cp->buf);
+
鐃緒申��申鐃緒申  re_set_syntax (old);
+
鐃緒申��申鐃緒申  UNBLOCK_INPUT;
+
鐃緒申��申鐃緒申  if (val)
+
鐃緒申��申鐃緒申    Fsignal (Qinvalid_regexp, Fcons (build_string (val), Qnil));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  cp->regexp = Fcopy_sequence (pattern);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Compile a regexp if necessary, but first check to see if there's one in
+
鐃緒申��申鐃緒申   the cache.
+
鐃緒申��申鐃緒申   PATTERN is the pattern to compile.
+
鐃緒申��申鐃緒申   TRANSLATE is a translation table for ignoring case, or NULL for none.
+
鐃緒申��申鐃緒申   REGP is the structure that says where to store the "register"
+
鐃緒申��申鐃緒申   values that will result from matching this pattern.
+
鐃緒申��申鐃緒申   If it is 0, we should compile the pattern not to record any
+
鐃緒申��申鐃緒申   subexpression bounds.
+
鐃緒申��申鐃緒申   POSIX is nonzero if we want full backtracking (POSIX style)
+
鐃緒申��申鐃緒申   for this pattern.  0 means backtrack only enough to get a valid match.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申struct re_pattern_buffer *
+
鐃緒申��申鐃緒申compile_pattern (pattern, regp, translate, posix)
+
鐃緒申��申鐃緒申     Lisp_Object pattern;
+
鐃緒申��申鐃緒申     struct re_registers *regp;
+
鐃緒申��申鐃緒申     char *translate;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct regexp_cache *cp, **cpp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (cpp = &searchbuf_head; ; cpp = &cp->next)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      cp = *cpp;
+
鐃緒申��申鐃緒申      if (!NILP (Fstring_equal (cp->regexp, pattern))
+
鐃緒申��申鐃緒申	  && cp->buf.translate == translate
+
鐃緒申��申鐃緒申	  && cp->posix == posix)
+
鐃緒申��申鐃緒申	break;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* If we're at the end of the cache, compile into the last cell.  */
+
鐃緒申��申鐃緒申      if (cp->next == 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  compile_pattern_1 (cp, pattern, translate, regp, posix);
+
鐃緒申��申鐃緒申	  break;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* When we get here, cp (aka *cpp) contains the compiled pattern,
+
鐃緒申��申鐃緒申     either because we found it in the cache or because we just compiled it.
+
鐃緒申��申鐃緒申     Move it to the front of the queue to mark it as most recently used.  */
+
鐃緒申��申鐃緒申  *cpp = cp->next;
+
鐃緒申��申鐃緒申  cp->next = searchbuf_head;
+
鐃緒申��申鐃緒申  searchbuf_head = cp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Advise the searching functions about the space we have allocated
+
鐃緒申��申鐃緒申     for register data.  */
+
鐃緒申��申鐃緒申  if (regp)
+
鐃緒申��申鐃緒申    re_set_registers (&cp->buf, regp, regp->num_regs, regp->start, regp->end);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return &cp->buf;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Error condition used for failing searches */
+
鐃緒申��申鐃緒申Lisp_Object Qsearch_failed;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object
+
鐃緒申��申鐃緒申signal_failure (arg)
+
鐃緒申��申鐃緒申     Lisp_Object arg;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Fsignal (Qsearch_failed, Fcons (arg, Qnil));
+
鐃緒申��申鐃緒申  return Qnil;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申looking_at_1 (string, posix)
+
鐃緒申��申鐃緒申     Lisp_Object string;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object val;
+
鐃緒申��申鐃緒申  unsigned char *p1, *p2;
+
鐃緒申��申鐃緒申  int s1, s2;
+
鐃緒申��申鐃緒申  register int i;
+
鐃緒申��申鐃緒申  struct re_pattern_buffer *bufp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (running_asynch_code)
+
鐃緒申��申鐃緒申    save_search_regs ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (string, 0);
+
鐃緒申��申鐃緒申  bufp = compile_pattern (string, &search_regs,
+
鐃緒申��申鐃緒申			  (!NILP (current_buffer->case_fold_search)
+
鐃緒申��申鐃緒申			   ? DOWNCASE_TABLE : 0),
+
鐃緒申��申鐃緒申			  posix);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  immediate_quit = 1;
+
鐃緒申��申鐃緒申  QUIT;			/* Do a pending quit right away, to avoid paradoxical behavior */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Get pointers and sizes of the two strings
+
鐃緒申��申鐃緒申     that make up the visible portion of the buffer. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  p1 = BEGV_ADDR;
+
鐃緒申��申鐃緒申  s1 = GPT - BEGV;
+
鐃緒申��申鐃緒申  p2 = GAP_END_ADDR;
+
鐃緒申��申鐃緒申  s2 = ZV - GPT;
+
鐃緒申��申鐃緒申  if (s1 < 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      p2 = p1;
+
鐃緒申��申鐃緒申      s2 = ZV - BEGV;
+
鐃緒申��申鐃緒申      s1 = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  if (s2 < 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      s1 = ZV - BEGV;
+
鐃緒申��申鐃緒申      s2 = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2,
+
鐃緒申��申鐃緒申		  point - BEGV, &search_regs,
+
鐃緒申��申鐃緒申		  ZV - BEGV);
+
鐃緒申��申鐃緒申  if (i == -2)
+
鐃緒申��申鐃緒申    matcher_overflow ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  val = (0 <= i ? Qt : Qnil);
+
鐃緒申��申鐃緒申  for (i = 0; i < search_regs.num_regs; i++)
+
鐃緒申��申鐃緒申    if (search_regs.start[i] >= 0)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	search_regs.start[i] += BEGV;
+
鐃緒申��申鐃緒申	search_regs.end[i] += BEGV;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  XSETBUFFER (last_thing_searched, current_buffer);
+
鐃緒申��申鐃緒申  immediate_quit = 0;
+
鐃緒申��申鐃緒申  return val;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("looking-at", Flooking_at, Slooking_at, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Return t if text after point matches regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申This function modifies the match data that `match-beginning',\n\
+
鐃緒申��申鐃緒申`match-end' and `match-data' access; save and restore the match\n\
+
鐃緒申��申鐃緒申data if you want to preserve them.")
+
鐃緒申��申鐃緒申  (regexp)
+
鐃緒申��申鐃緒申     Lisp_Object regexp;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return looking_at_1 (regexp, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("posix-looking-at", Fposix_looking_at, Sposix_looking_at, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Return t if text after point matches regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申Find the longest match, in accord with Posix regular expression rules.\n\
+
鐃緒申��申鐃緒申This function modifies the match data that `match-beginning',\n\
+
鐃緒申��申鐃緒申`match-end' and `match-data' access; save and restore the match\n\
+
鐃緒申��申鐃緒申data if you want to preserve them.")
+
鐃緒申��申鐃緒申  (regexp)
+
鐃緒申��申鐃緒申     Lisp_Object regexp;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return looking_at_1 (regexp, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申string_match_1 (regexp, string, start, posix)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, string, start;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int val;
+
鐃緒申��申鐃緒申  int s;
+
鐃緒申��申鐃緒申  struct re_pattern_buffer *bufp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (running_asynch_code)
+
鐃緒申��申鐃緒申    save_search_regs ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (regexp, 0);
+
鐃緒申��申鐃緒申  CHECK_STRING (string, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (NILP (start))
+
鐃緒申��申鐃緒申    s = 0;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int len = XSTRING (string)->size;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      CHECK_NUMBER (start, 2);
+
鐃緒申��申鐃緒申      s = XINT (start);
+
鐃緒申��申鐃緒申      if (s < 0 && -s <= len)
+
鐃緒申��申鐃緒申	s = len + s;
+
鐃緒申��申鐃緒申      else if (0 > s || s > len)
+
鐃緒申��申鐃緒申	args_out_of_range (string, start);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  bufp = compile_pattern (regexp, &search_regs,
+
鐃緒申��申鐃緒申			  (!NILP (current_buffer->case_fold_search)
+
鐃緒申��申鐃緒申			   ? DOWNCASE_TABLE : 0),
+
鐃緒申��申鐃緒申			  0);
+
鐃緒申��申鐃緒申  immediate_quit = 1;
+
鐃緒申��申鐃緒申  val = re_search (bufp, (char *) XSTRING (string)->data,
+
鐃緒申��申鐃緒申		   XSTRING (string)->size, s, XSTRING (string)->size - s,
+
鐃緒申��申鐃緒申		   &search_regs);
+
鐃緒申��申鐃緒申  immediate_quit = 0;
+
鐃緒申��申鐃緒申  last_thing_searched = Qt;
+
鐃緒申��申鐃緒申  if (val == -2)
+
鐃緒申��申鐃緒申    matcher_overflow ();
+
鐃緒申��申鐃緒申  if (val < 0) return Qnil;
+
鐃緒申��申鐃緒申  return make_number (val);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("string-match", Fstring_match, Sstring_match, 2, 3, 0,
+
鐃緒申��申鐃緒申  "Return index of start of first match for REGEXP in STRING, or nil.\n\
+
鐃緒申��申鐃緒申If third arg START is non-nil, start search at that index in STRING.\n\
+
鐃緒申��申鐃緒申For index of first char beyond the match, do (match-end 0).\n\
+
鐃緒申��申鐃緒申`match-end' and `match-beginning' also give indices of substrings\n\
+
鐃緒申��申鐃緒申matched by parenthesis constructs in the pattern.")
+
鐃緒申��申鐃緒申  (regexp, string, start)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, string, start;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return string_match_1 (regexp, string, start, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("posix-string-match", Fposix_string_match, Sposix_string_match, 2, 3, 0,
+
鐃緒申��申鐃緒申  "Return index of start of first match for REGEXP in STRING, or nil.\n\
+
鐃緒申��申鐃緒申Find the longest match, in accord with Posix regular expression rules.\n\
+
鐃緒申��申鐃緒申If third arg START is non-nil, start search at that index in STRING.\n\
+
鐃緒申��申鐃緒申For index of first char beyond the match, do (match-end 0).\n\
+
鐃緒申��申鐃緒申`match-end' and `match-beginning' also give indices of substrings\n\
+
鐃緒申��申鐃緒申matched by parenthesis constructs in the pattern.")
+
鐃緒申��申鐃緒申  (regexp, string, start)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, string, start;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return string_match_1 (regexp, string, start, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Match REGEXP against STRING, searching all of STRING,
+
鐃緒申��申鐃緒申   and return the index of the match, or negative on failure.
+
鐃緒申��申鐃緒申   This does not clobber the match data.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申fast_string_match (regexp, string)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, string;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int val;
+
鐃緒申��申鐃緒申  struct re_pattern_buffer *bufp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  bufp = compile_pattern (regexp, 0, 0, 0);
+
鐃緒申��申鐃緒申  immediate_quit = 1;
+
鐃緒申��申鐃緒申  val = re_search (bufp, (char *) XSTRING (string)->data,
+
鐃緒申��申鐃緒申		   XSTRING (string)->size, 0, XSTRING (string)->size,
+
鐃緒申��申鐃緒申		   0);
+
鐃緒申��申鐃緒申  immediate_quit = 0;
+
鐃緒申��申鐃緒申  return val;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* max and min.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申max (a, b)
+
鐃緒申��申鐃緒申     int a, b;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return ((a > b) ? a : b);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申min (a, b)
+
鐃緒申��申鐃緒申     int a, b;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return ((a < b) ? a : b);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* The newline cache: remembering which sections of text have no newlines.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* If the user has requested newline caching, make sure it's on.
+
鐃緒申��申鐃緒申   Otherwise, make sure it's off.
+
鐃緒申��申鐃緒申   This is our cheezy way of associating an action with the change of
+
鐃緒申��申鐃緒申   state of a buffer-local variable.  */
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申newline_cache_on_off (buf)
+
鐃緒申��申鐃緒申     struct buffer *buf;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (NILP (buf->cache_long_line_scans))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* It should be off.  */
+
鐃緒申��申鐃緒申      if (buf->newline_cache)
+
鐃緒申��申鐃緒申        {
+
鐃緒申��申鐃緒申          free_region_cache (buf->newline_cache);
+
鐃緒申��申鐃緒申          buf->newline_cache = 0;
+
鐃緒申��申鐃緒申        }
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* It should be on.  */
+
鐃緒申��申鐃緒申      if (buf->newline_cache == 0)
+
鐃緒申��申鐃緒申        buf->newline_cache = new_region_cache ();
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Search for COUNT instances of the character TARGET between START and END.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If COUNT is positive, search forwards; END must be >= START.
+
鐃緒申��申鐃緒申   If COUNT is negative, search backwards for the -COUNTth instance;
+
鐃緒申��申鐃緒申      END must be <= START.
+
鐃緒申��申鐃緒申   If COUNT is zero, do anything you please; run rogue, for all I care.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If END is zero, use BEGV or ZV instead, as appropriate for the
+
鐃緒申��申鐃緒申   direction indicated by COUNT.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If we find COUNT instances, set *SHORTAGE to zero, and return the
+
鐃緒申��申鐃緒申   position after the COUNTth match.  Note that for reverse motion
+
鐃緒申��申鐃緒申   this is not the same as the usual convention for Emacs motion commands.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If we don't find COUNT instances before reaching END, set *SHORTAGE
+
鐃緒申��申鐃緒申   to the number of TARGETs left unfound, and return END.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If ALLOW_QUIT is non-zero, set immediate_quit.  That's good to do
+
鐃緒申��申鐃緒申   except when inside redisplay.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申scan_buffer (target, start, end, count, shortage, allow_quit)
+
鐃緒申��申鐃緒申     register int target;
+
鐃緒申��申鐃緒申     int start, end;
+
鐃緒申��申鐃緒申     int count;
+
鐃緒申��申鐃緒申     int *shortage;
+
鐃緒申��申鐃緒申     int allow_quit;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  struct region_cache *newline_cache;
+
鐃緒申��申鐃緒申  int direction; 
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (count > 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      direction = 1;
+
鐃緒申��申鐃緒申      if (! end) end = ZV;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      direction = -1;
+
鐃緒申��申鐃緒申      if (! end) end = BEGV;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  newline_cache_on_off (current_buffer);
+
鐃緒申��申鐃緒申  newline_cache = current_buffer->newline_cache;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (shortage != 0)
+
鐃緒申��申鐃緒申    *shortage = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  immediate_quit = allow_quit;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (count > 0)
+
鐃緒申��申鐃緒申    while (start != end)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申        /* Our innermost scanning loop is very simple; it doesn't know
+
鐃緒申��申鐃緒申           about gaps, buffer ends, or the newline cache.  ceiling is
+
鐃緒申��申鐃緒申           the position of the last character before the next such
+
鐃緒申��申鐃緒申           obstacle --- the last character the dumb search loop should
+
鐃緒申��申鐃緒申           examine.  */
+
鐃緒申��申鐃緒申        register int ceiling = end - 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        /* If we're looking for a newline, consult the newline cache
+
鐃緒申��申鐃緒申           to see where we can avoid some scanning.  */
+
鐃緒申��申鐃緒申        if (target == '\n' && newline_cache)
+
鐃緒申��申鐃緒申          {
+
鐃緒申��申鐃緒申            int next_change;
+
鐃緒申��申鐃緒申            immediate_quit = 0;
+
鐃緒申��申鐃緒申            while (region_cache_forward
+
鐃緒申��申鐃緒申                   (current_buffer, newline_cache, start, &next_change))
+
鐃緒申��申鐃緒申              start = next_change;
+
鐃緒申��申鐃緒申            immediate_quit = allow_quit;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申            /* start should never be after end.  */
+
鐃緒申��申鐃緒申            if (start >= end)
+
鐃緒申��申鐃緒申              start = end - 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申            /* Now the text after start is an unknown region, and
+
鐃緒申��申鐃緒申               next_change is the position of the next known region. */
+
鐃緒申��申鐃緒申            ceiling = min (next_change - 1, ceiling);
+
鐃緒申��申鐃緒申          }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        /* The dumb loop can only scan text stored in contiguous
+
鐃緒申��申鐃緒申           bytes. BUFFER_CEILING_OF returns the last character
+
鐃緒申��申鐃緒申           position that is contiguous, so the ceiling is the
+
鐃緒申��申鐃緒申           position after that.  */
+
鐃緒申��申鐃緒申        ceiling = min (BUFFER_CEILING_OF (start), ceiling);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        {
+
鐃緒申��申鐃緒申          /* The termination address of the dumb loop.  */ 
+
鐃緒申��申鐃緒申          register unsigned char *ceiling_addr = &FETCH_CHAR (ceiling) + 1;
+
鐃緒申��申鐃緒申          register unsigned char *cursor = &FETCH_CHAR (start);
+
鐃緒申��申鐃緒申          unsigned char *base = cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申          while (cursor < ceiling_addr)
+
鐃緒申��申鐃緒申            {
+
鐃緒申��申鐃緒申              unsigned char *scan_start = cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              /* The dumb loop.  */
+
鐃緒申��申鐃緒申              while (*cursor != target && ++cursor < ceiling_addr)
+
鐃緒申��申鐃緒申                ;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              /* If we're looking for newlines, cache the fact that
+
鐃緒申��申鐃緒申                 the region from start to cursor is free of them. */
+
鐃緒申��申鐃緒申              if (target == '\n' && newline_cache)
+
鐃緒申��申鐃緒申                know_region_cache (current_buffer, newline_cache,
+
鐃緒申��申鐃緒申                                   start + scan_start - base,
+
鐃緒申��申鐃緒申                                   start + cursor - base);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              /* Did we find the target character?  */
+
鐃緒申��申鐃緒申              if (cursor < ceiling_addr)
+
鐃緒申��申鐃緒申                {
+
鐃緒申��申鐃緒申                  if (--count == 0)
+
鐃緒申��申鐃緒申                    {
+
鐃緒申��申鐃緒申                      immediate_quit = 0;
+
鐃緒申��申鐃緒申                      return (start + cursor - base + 1);
+
鐃緒申��申鐃緒申                    }
+
鐃緒申��申鐃緒申                  cursor++;
+
鐃緒申��申鐃緒申                }
+
鐃緒申��申鐃緒申            }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申          start += cursor - base;
+
鐃緒申��申鐃緒申        }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    while (start > end)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申        /* The last character to check before the next obstacle.  */
+
鐃緒申��申鐃緒申        register int ceiling = end;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        /* Consult the newline cache, if appropriate.  */
+
鐃緒申��申鐃緒申        if (target == '\n' && newline_cache)
+
鐃緒申��申鐃緒申          {
+
鐃緒申��申鐃緒申            int next_change;
+
鐃緒申��申鐃緒申            immediate_quit = 0;
+
鐃緒申��申鐃緒申            while (region_cache_backward
+
鐃緒申��申鐃緒申                   (current_buffer, newline_cache, start, &next_change))
+
鐃緒申��申鐃緒申              start = next_change;
+
鐃緒申��申鐃緒申            immediate_quit = allow_quit;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申            /* Start should never be at or before end.  */
+
鐃緒申��申鐃緒申            if (start <= end)
+
鐃緒申��申鐃緒申              start = end + 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申            /* Now the text before start is an unknown region, and
+
鐃緒申��申鐃緒申               next_change is the position of the next known region. */
+
鐃緒申��申鐃緒申            ceiling = max (next_change, ceiling);
+
鐃緒申��申鐃緒申          }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        /* Stop scanning before the gap.  */
+
鐃緒申��申鐃緒申        ceiling = max (BUFFER_FLOOR_OF (start - 1), ceiling);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申        {
+
鐃緒申��申鐃緒申          /* The termination address of the dumb loop.  */
+
鐃緒申��申鐃緒申          register unsigned char *ceiling_addr = &FETCH_CHAR (ceiling);
+
鐃緒申��申鐃緒申          register unsigned char *cursor = &FETCH_CHAR (start - 1);
+
鐃緒申��申鐃緒申          unsigned char *base = cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申          while (cursor >= ceiling_addr)
+
鐃緒申��申鐃緒申            {
+
鐃緒申��申鐃緒申              unsigned char *scan_start = cursor;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              while (*cursor != target && --cursor >= ceiling_addr)
+
鐃緒申��申鐃緒申                ;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              /* If we're looking for newlines, cache the fact that
+
鐃緒申��申鐃緒申                 the region from after the cursor to start is free of them.  */
+
鐃緒申��申鐃緒申              if (target == '\n' && newline_cache)
+
鐃緒申��申鐃緒申                know_region_cache (current_buffer, newline_cache,
+
鐃緒申��申鐃緒申                                   start + cursor - base,
+
鐃緒申��申鐃緒申                                   start + scan_start - base);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申              /* Did we find the target character?  */
+
鐃緒申��申鐃緒申              if (cursor >= ceiling_addr)
+
鐃緒申��申鐃緒申                {
+
鐃緒申��申鐃緒申                  if (++count >= 0)
+
鐃緒申��申鐃緒申                    {
+
鐃緒申��申鐃緒申                      immediate_quit = 0;
+
鐃緒申��申鐃緒申                      return (start + cursor - base);
+
鐃緒申��申鐃緒申                    }
+
鐃緒申��申鐃緒申                  cursor--;
+
鐃緒申��申鐃緒申                }
+
鐃緒申��申鐃緒申            }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申          start += cursor - base;
+
鐃緒申��申鐃緒申        }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  immediate_quit = 0;
+
鐃緒申��申鐃緒申  if (shortage != 0)
+
鐃緒申��申鐃緒申    *shortage = count * direction;
+
鐃緒申��申鐃緒申  return start;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申find_next_newline_no_quit (from, cnt)
+
鐃緒申��申鐃緒申     register int from, cnt;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return scan_buffer ('\n', from, 0, cnt, (int *) 0, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申find_next_newline (from, cnt)
+
鐃緒申��申鐃緒申     register int from, cnt;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return scan_buffer ('\n', from, 0, cnt, (int *) 0, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Like find_next_newline, but returns position before the newline,
+
鐃緒申��申鐃緒申   not after, and only search up to TO.  This isn't just
+
鐃緒申��申鐃緒申   find_next_newline (...)-1, because you might hit TO.  */
+
鐃緒申��申鐃緒申int
+
鐃緒申��申鐃緒申find_before_next_newline (from, to, cnt)
+
鐃緒申��申鐃緒申     int from, to, cnt;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int shortage;
+
鐃緒申��申鐃緒申  int pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (shortage == 0)
+
鐃緒申��申鐃緒申    pos--;
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申  return pos;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object skip_chars ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("skip-chars-forward", Fskip_chars_forward, Sskip_chars_forward, 1, 2, 0,
+
鐃緒申��申鐃緒申  "Move point forward, stopping before a char not in STRING, or at pos LIM.\n\
+
鐃緒申��申鐃緒申STRING is like the inside of a `[...]' in a regular expression\n\
+
鐃緒申��申鐃緒申except that `]' is never special and `\\' quotes `^', `-' or `\\'.\n\
+
鐃緒申��申鐃緒申Thus, with arg \"a-zA-Z\", this skips letters stopping before first nonletter.\n\
+
鐃緒申��申鐃緒申With arg \"^a-zA-Z\", skips nonletters stopping before first letter.\n\
+
鐃緒申��申鐃緒申Returns the distance traveled, either zero or positive.")
+
鐃緒申��申鐃緒申  (string, lim)
+
鐃緒申��申鐃緒申     Lisp_Object string, lim;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return skip_chars (1, 0, string, lim);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("skip-chars-backward", Fskip_chars_backward, Sskip_chars_backward, 1, 2, 0,
+
鐃緒申��申鐃緒申  "Move point backward, stopping after a char not in STRING, or at pos LIM.\n\
+
鐃緒申��申鐃緒申See `skip-chars-forward' for details.\n\
+
鐃緒申��申鐃緒申Returns the distance traveled, either zero or negative.")
+
鐃緒申��申鐃緒申  (string, lim)
+
鐃緒申��申鐃緒申     Lisp_Object string, lim;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return skip_chars (0, 0, string, lim);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("skip-syntax-forward", Fskip_syntax_forward, Sskip_syntax_forward, 1, 2, 0,
+
鐃緒申��申鐃緒申  "Move point forward across chars in specified syntax classes.\n\
+
鐃緒申��申鐃緒申SYNTAX is a string of syntax code characters.\n\
+
鐃緒申��申鐃緒申Stop before a char whose syntax is not in SYNTAX, or at position LIM.\n\
+
鐃緒申��申鐃緒申If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
+
鐃緒申��申鐃緒申This function returns the distance traveled, either zero or positive.")
+
鐃緒申��申鐃緒申  (syntax, lim)
+
鐃緒申��申鐃緒申     Lisp_Object syntax, lim;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return skip_chars (1, 1, syntax, lim);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("skip-syntax-backward", Fskip_syntax_backward, Sskip_syntax_backward, 1, 2, 0,
+
鐃緒申��申鐃緒申  "Move point backward across chars in specified syntax classes.\n\
+
鐃緒申��申鐃緒申SYNTAX is a string of syntax code characters.\n\
+
鐃緒申��申鐃緒申Stop on reaching a char whose syntax is not in SYNTAX, or at position LIM.\n\
+
鐃緒申��申鐃緒申If SYNTAX starts with ^, skip characters whose syntax is NOT in SYNTAX.\n\
+
鐃緒申��申鐃緒申This function returns the distance traveled, either zero or negative.")
+
鐃緒申��申鐃緒申  (syntax, lim)
+
鐃緒申��申鐃緒申     Lisp_Object syntax, lim;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return skip_chars (0, 1, syntax, lim);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申Lisp_Object
+
鐃緒申��申鐃緒申skip_chars (forwardp, syntaxp, string, lim)
+
鐃緒申��申鐃緒申     int forwardp, syntaxp;
+
鐃緒申��申鐃緒申     Lisp_Object string, lim;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register unsigned char *p, *pend;
+
鐃緒申��申鐃緒申  register unsigned char c;
+
鐃緒申��申鐃緒申  unsigned char fastmap[0400];
+
鐃緒申��申鐃緒申  int negate = 0;
+
鐃緒申��申鐃緒申  register int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (string, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (NILP (lim))
+
鐃緒申��申鐃緒申    XSETINT (lim, forwardp ? ZV : BEGV);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    CHECK_NUMBER_COERCE_MARKER (lim, 1);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* In any case, don't allow scan outside bounds of buffer.  */
+
鐃緒申��申鐃緒申  /* jla turned this off, for no known reason.
+
鐃緒申��申鐃緒申     bfox turned the ZV part on, and rms turned the
+
鐃緒申��申鐃緒申     BEGV part back on.  */
+
鐃緒申��申鐃緒申  if (XINT (lim) > ZV)
+
鐃緒申��申鐃緒申    XSETFASTINT (lim, ZV);
+
鐃緒申��申鐃緒申  if (XINT (lim) < BEGV)
+
鐃緒申��申鐃緒申    XSETFASTINT (lim, BEGV);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  p = XSTRING (string)->data;
+
鐃緒申��申鐃緒申  pend = p + XSTRING (string)->size;
+
鐃緒申��申鐃緒申  bzero (fastmap, sizeof fastmap);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (p != pend && *p == '^')
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      negate = 1; p++;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Find the characters specified and set their elements of fastmap.
+
鐃緒申��申鐃緒申     If syntaxp, each character counts as itself.
+
鐃緒申��申鐃緒申     Otherwise, handle backslashes and ranges specially  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  while (p != pend)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      c = *p++;
+
鐃緒申��申鐃緒申      if (syntaxp)
+
鐃緒申��申鐃緒申	fastmap[c] = 1;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (c == '\\')
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      if (p == pend) break;
+
鐃緒申��申鐃緒申	      c = *p++;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  if (p != pend && *p == '-')
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      p++;
+
鐃緒申��申鐃緒申	      if (p == pend) break;
+
鐃緒申��申鐃緒申	      while (c <= *p)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  fastmap[c] = 1;
+
鐃緒申��申鐃緒申		  c++;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      p++;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    fastmap[c] = 1;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (syntaxp && fastmap['-'] != 0)
+
鐃緒申��申鐃緒申    fastmap[' '] = 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* If ^ was the first character, complement the fastmap. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (negate)
+
鐃緒申��申鐃緒申    for (i = 0; i < sizeof fastmap; i++)
+
鐃緒申��申鐃緒申      fastmap[i] ^= 1;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int start_point = point;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    immediate_quit = 1;
+
鐃緒申��申鐃緒申    if (syntaxp)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	if (forwardp)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    while (point < XINT (lim)
+
鐃緒申��申鐃緒申		   && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (point))]])
+
鐃緒申��申鐃緒申	      SET_PT (point + 1);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    while (point > XINT (lim)
+
鐃緒申��申鐃緒申		   && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (point - 1))]])
+
鐃緒申��申鐃緒申	      SET_PT (point - 1);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    else
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	if (forwardp)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    while (point < XINT (lim) && fastmap[FETCH_CHAR (point)])
+
鐃緒申��申鐃緒申	      SET_PT (point + 1);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    while (point > XINT (lim) && fastmap[FETCH_CHAR (point - 1)])
+
鐃緒申��申鐃緒申	      SET_PT (point - 1);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申    immediate_quit = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    return make_number (point - start_point);
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Subroutines of Lisp buffer search functions. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申search_command (string, bound, noerror, count, direction, RE, posix)
+
鐃緒申��申鐃緒申     Lisp_Object string, bound, noerror, count;
+
鐃緒申��申鐃緒申     int direction;
+
鐃緒申��申鐃緒申     int RE;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register int np;
+
鐃緒申��申鐃緒申  int lim;
+
鐃緒申��申鐃緒申  int n = direction;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (!NILP (count))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      CHECK_NUMBER (count, 3);
+
鐃緒申��申鐃緒申      n *= XINT (count);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (string, 0);
+
鐃緒申��申鐃緒申  if (NILP (bound))
+
鐃緒申��申鐃緒申    lim = n > 0 ? ZV : BEGV;
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      CHECK_NUMBER_COERCE_MARKER (bound, 1);
+
鐃緒申��申鐃緒申      lim = XINT (bound);
+
鐃緒申��申鐃緒申      if (n > 0 ? lim < point : lim > point)
+
鐃緒申��申鐃緒申	error ("Invalid search bound (wrong side of point)");
+
鐃緒申��申鐃緒申      if (lim > ZV)
+
鐃緒申��申鐃緒申	lim = ZV;
+
鐃緒申��申鐃緒申      if (lim < BEGV)
+
鐃緒申��申鐃緒申	lim = BEGV;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  np = search_buffer (string, point, lim, n, RE,
+
鐃緒申��申鐃緒申		      (!NILP (current_buffer->case_fold_search)
+
鐃緒申��申鐃緒申		       ? XSTRING (current_buffer->case_canon_table)->data : 0),
+
鐃緒申��申鐃緒申		      (!NILP (current_buffer->case_fold_search)
+
鐃緒申��申鐃緒申		       ? XSTRING (current_buffer->case_eqv_table)->data : 0),
+
鐃緒申��申鐃緒申		      posix);
+
鐃緒申��申鐃緒申  if (np <= 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (NILP (noerror))
+
鐃緒申��申鐃緒申	return signal_failure (string);
+
鐃緒申��申鐃緒申      if (!EQ (noerror, Qt))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (lim < BEGV || lim > ZV)
+
鐃緒申��申鐃緒申	    abort ();
+
鐃緒申��申鐃緒申	  SET_PT (lim);
+
鐃緒申��申鐃緒申	  return Qnil;
+
鐃緒申��申鐃緒申#if 0 /* This would be clean, but maybe programs depend on
+
鐃緒申��申鐃緒申	 a value of nil here.  */
+
鐃緒申��申鐃緒申	  np = lim;
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	return Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (np < BEGV || np > ZV)
+
鐃緒申��申鐃緒申    abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  SET_PT (np);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return make_number (np);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申trivial_regexp_p (regexp)
+
鐃緒申��申鐃緒申     Lisp_Object regexp;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int len = XSTRING (regexp)->size;
+
鐃緒申��申鐃緒申  unsigned char *s = XSTRING (regexp)->data;
+
鐃緒申��申鐃緒申  unsigned char c;
+
鐃緒申��申鐃緒申  while (--len >= 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      switch (*s++)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	case '.': case '*': case '+': case '?': case '[': case '^': case '$':
+
鐃緒申��申鐃緒申	  return 0;
+
鐃緒申��申鐃緒申	case '\\':
+
鐃緒申��申鐃緒申	  if (--len < 0)
+
鐃緒申��申鐃緒申	    return 0;
+
鐃緒申��申鐃緒申	  switch (*s++)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	    case '|': case '(': case ')': case '`': case '\'': case 'b':
+
鐃緒申��申鐃緒申	    case 'B': case '<': case '>': case 'w': case 'W': case 's':
+
鐃緒申��申鐃緒申	    case 'S': case '=':
+
鐃緒申��申鐃緒申	    case '1': case '2': case '3': case '4': case '5':
+
鐃緒申��申鐃緒申	    case '6': case '7': case '8': case '9':
+
鐃緒申��申鐃緒申	      return 0;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  return 1;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Search for the n'th occurrence of STRING in the current buffer,
+
鐃緒申��申鐃緒申   starting at position POS and stopping at position LIM,
+
鐃緒申��申鐃緒申   treating STRING as a literal string if RE is false or as
+
鐃緒申��申鐃緒申   a regular expression if RE is true.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   If N is positive, searching is forward and LIM must be greater than POS.
+
鐃緒申��申鐃緒申   If N is negative, searching is backward and LIM must be less than POS.
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   Returns -x if only N-x occurrences found (x > 0),
+
鐃緒申��申鐃緒申   or else the position at the beginning of the Nth occurrence
+
鐃緒申��申鐃緒申   (if searching backward) or the end (if searching forward).
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申   POSIX is nonzero if we want full backtracking (POSIX style)
+
鐃緒申��申鐃緒申   for this pattern.  0 means backtrack only enough to get a valid match.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static int
+
鐃緒申��申鐃緒申search_buffer (string, pos, lim, n, RE, trt, inverse_trt, posix)
+
鐃緒申��申鐃緒申     Lisp_Object string;
+
鐃緒申��申鐃緒申     int pos;
+
鐃緒申��申鐃緒申     int lim;
+
鐃緒申��申鐃緒申     int n;
+
鐃緒申��申鐃緒申     int RE;
+
鐃緒申��申鐃緒申     register unsigned char *trt;
+
鐃緒申��申鐃緒申     register unsigned char *inverse_trt;
+
鐃緒申��申鐃緒申     int posix;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  int len = XSTRING (string)->size;
+
鐃緒申��申鐃緒申  unsigned char *base_pat = XSTRING (string)->data;
+
鐃緒申��申鐃緒申  register int *BM_tab;
+
鐃緒申��申鐃緒申  int *BM_tab_base;
+
鐃緒申��申鐃緒申  register int direction = ((n > 0) ? 1 : -1);
+
鐃緒申��申鐃緒申  register int dirlen;
+
鐃緒申��申鐃緒申  int infinity, limit, k, stride_for_teases;
+
鐃緒申��申鐃緒申  register unsigned char *pat, *cursor, *p_limit;  
+
鐃緒申��申鐃緒申  register int i, j;
+
鐃緒申��申鐃緒申  unsigned char *p1, *p2;
+
鐃緒申��申鐃緒申  int s1, s2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (running_asynch_code)
+
鐃緒申��申鐃緒申    save_search_regs ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Null string is found at starting position.  */
+
鐃緒申��申鐃緒申  if (len == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      set_search_regs (pos, 0);
+
鐃緒申��申鐃緒申      return pos;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Searching 0 times means don't move.  */
+
鐃緒申��申鐃緒申  if (n == 0)
+
鐃緒申��申鐃緒申    return pos;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (RE && !trivial_regexp_p (string))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct re_pattern_buffer *bufp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      bufp = compile_pattern (string, &search_regs, (char *) trt, posix);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      immediate_quit = 1;	/* Quit immediately if user types ^G,
+
鐃緒申��申鐃緒申				   because letting this function finish
+
鐃緒申��申鐃緒申				   can take too long. */
+
鐃緒申��申鐃緒申      QUIT;			/* Do a pending quit right away,
+
鐃緒申��申鐃緒申				   to avoid paradoxical behavior */
+
鐃緒申��申鐃緒申      /* Get pointers and sizes of the two strings
+
鐃緒申��申鐃緒申	 that make up the visible portion of the buffer. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      p1 = BEGV_ADDR;
+
鐃緒申��申鐃緒申      s1 = GPT - BEGV;
+
鐃緒申��申鐃緒申      p2 = GAP_END_ADDR;
+
鐃緒申��申鐃緒申      s2 = ZV - GPT;
+
鐃緒申��申鐃緒申      if (s1 < 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  p2 = p1;
+
鐃緒申��申鐃緒申	  s2 = ZV - BEGV;
+
鐃緒申��申鐃緒申	  s1 = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      if (s2 < 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  s1 = ZV - BEGV;
+
鐃緒申��申鐃緒申	  s2 = 0;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      while (n < 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int val;
+
鐃緒申��申鐃緒申	  val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
+
鐃緒申��申鐃緒申			     pos - BEGV, lim - pos, &search_regs,
+
鐃緒申��申鐃緒申			     /* Don't allow match past current point */
+
鐃緒申��申鐃緒申			     pos - BEGV);
+
鐃緒申��申鐃緒申	  if (val == -2)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      matcher_overflow ();
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  if (val >= 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      j = BEGV;
+
鐃緒申��申鐃緒申	      for (i = 0; i < search_regs.num_regs; i++)
+
鐃緒申��申鐃緒申		if (search_regs.start[i] >= 0)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    search_regs.start[i] += j;
+
鐃緒申��申鐃緒申		    search_regs.end[i] += j;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      XSETBUFFER (last_thing_searched, current_buffer);
+
鐃緒申��申鐃緒申	      /* Set pos to the new position. */
+
鐃緒申��申鐃緒申	      pos = search_regs.start[0];
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      immediate_quit = 0;
+
鐃緒申��申鐃緒申	      return (n);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  n++;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      while (n > 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int val;
+
鐃緒申��申鐃緒申	  val = re_search_2 (bufp, (char *) p1, s1, (char *) p2, s2,
+
鐃緒申��申鐃緒申			     pos - BEGV, lim - pos, &search_regs,
+
鐃緒申��申鐃緒申			     lim - BEGV);
+
鐃緒申��申鐃緒申	  if (val == -2)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      matcher_overflow ();
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  if (val >= 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      j = BEGV;
+
鐃緒申��申鐃緒申	      for (i = 0; i < search_regs.num_regs; i++)
+
鐃緒申��申鐃緒申		if (search_regs.start[i] >= 0)
+
鐃緒申��申鐃緒申		  {
+
鐃緒申��申鐃緒申		    search_regs.start[i] += j;
+
鐃緒申��申鐃緒申		    search_regs.end[i] += j;
+
鐃緒申��申鐃緒申		  }
+
鐃緒申��申鐃緒申	      XSETBUFFER (last_thing_searched, current_buffer);
+
鐃緒申��申鐃緒申	      pos = search_regs.end[0];
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      immediate_quit = 0;
+
鐃緒申��申鐃緒申	      return (0 - n);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  n--;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      immediate_quit = 0;
+
鐃緒申��申鐃緒申      return (pos);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else				/* non-RE case */
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申#ifdef C_ALLOCA
+
鐃緒申��申鐃緒申      int BM_tab_space[0400];
+
鐃緒申��申鐃緒申      BM_tab = &BM_tab_space[0];
+
鐃緒申��申鐃緒申#else
+
鐃緒申��申鐃緒申      BM_tab = (int *) alloca (0400 * sizeof (int));
+
鐃緒申��申鐃緒申#endif
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	unsigned char *patbuf = (unsigned char *) alloca (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
+
鐃緒申��申鐃緒申	       just quotes the next character.  */
+
鐃緒申��申鐃緒申	    if (RE && *base_pat == '\\')
+
鐃緒申��申鐃緒申	      {
+
鐃緒申��申鐃緒申		len--;
+
鐃緒申��申鐃緒申		base_pat++;
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	    *pat++ = (trt ? trt[*base_pat++] : *base_pat++);
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	len = pat - patbuf;
+
鐃緒申��申鐃緒申	pat = base_pat = patbuf;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申      /* The general approach is that we are going to maintain that we know */
+
鐃緒申��申鐃緒申      /* the first (closest to the present position, in whatever direction */
+
鐃緒申��申鐃緒申      /* we're searching) character that could possibly be the last */
+
鐃緒申��申鐃緒申      /* (furthest from present position) character of a valid match.  We */
+
鐃緒申��申鐃緒申      /* advance the state of our knowledge by looking at that character */
+
鐃緒申��申鐃緒申      /* and seeing whether it indeed matches the last character of the */
+
鐃緒申��申鐃緒申      /* pattern.  If it does, we take a closer look.  If it does not, we */
+
鐃緒申��申鐃緒申      /* move our pointer (to putative last characters) as far as is */
+
鐃緒申��申鐃緒申      /* logically possible.  This amount of movement, which I call a */
+
鐃緒申��申鐃緒申      /* stride, will be the length of the pattern if the actual character */
+
鐃緒申��申鐃緒申      /* appears nowhere in the pattern, otherwise it will be the distance */
+
鐃緒申��申鐃緒申      /* from the last occurrence of that character to the end of the */
+
鐃緒申��申鐃緒申      /* pattern. */
+
鐃緒申��申鐃緒申      /* 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);
+
鐃緒申��申鐃緒申      BM_tab_base = BM_tab;
+
鐃緒申��申鐃緒申      BM_tab += 0400;
+
鐃緒申��申鐃緒申      j = dirlen;		/* to get it in a register */
+
鐃緒申��申鐃緒申      /* A character that does not appear in the pattern induces a */
+
鐃緒申��申鐃緒申      /* stride equal to the pattern length. */
+
鐃緒申��申鐃緒申      while (BM_tab_base != BM_tab)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  *--BM_tab = j;
+
鐃緒申��申鐃緒申	  *--BM_tab = j;
+
鐃緒申��申鐃緒申	  *--BM_tab = j;
+
鐃緒申��申鐃緒申	  *--BM_tab = j;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      i = 0;
+
鐃緒申��申鐃緒申      while (i != infinity)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  j = pat[i]; i += direction;
+
鐃緒申��申鐃緒申	  if (i == dirlen) i = infinity;
+
鐃緒申��申鐃緒申	  if (trt != 0)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      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
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      if (i == infinity)
+
鐃緒申��申鐃緒申		stride_for_teases = BM_tab[j];
+
鐃緒申��申鐃緒申	      BM_tab[j] = dirlen - i;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  /* stride_for_teases tells how much to stride if we get a */
+
鐃緒申��申鐃緒申	  /* match on the far character but are subsequently */
+
鐃緒申��申鐃緒申	  /* disappointed, by recording what the stride would have been */
+
鐃緒申��申鐃緒申	  /* for that character if the last character had been */
+
鐃緒申��申鐃緒申	  /* different. */
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      infinity = dirlen - infinity;
+
鐃緒申��申鐃緒申      pos += dirlen - ((direction > 0) ? direction : 0);
+
鐃緒申��申鐃緒申      /* loop invariant - pos points at where last char (first char if reverse)
+
鐃緒申��申鐃緒申	 of pattern would align in a possible match.  */
+
鐃緒申��申鐃緒申      while (n != 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  /* It's been reported that some (broken) compiler thinks that
+
鐃緒申��申鐃緒申	     Boolean expressions in an arithmetic context are unsigned.
+
鐃緒申��申鐃緒申	     Using an explicit ?1:0 prevents this.  */
+
鐃緒申��申鐃緒申	  if ((lim - pos - ((direction > 0) ? 1 : 0)) * direction < 0)
+
鐃緒申��申鐃緒申	    return (n * (0 - direction));
+
鐃緒申��申鐃緒申	  /* First we do the part we can by pointers (maybe nothing) */
+
鐃緒申��申鐃緒申	  QUIT;
+
鐃緒申��申鐃緒申	  pat = base_pat;
+
鐃緒申��申鐃緒申	  limit = pos - dirlen + direction;
+
鐃緒申��申鐃緒申	  limit = ((direction > 0)
+
鐃緒申��申鐃緒申		   ? BUFFER_CEILING_OF (limit)
+
鐃緒申��申鐃緒申		   : BUFFER_FLOOR_OF (limit));
+
鐃緒申��申鐃緒申	  /* LIMIT is now the last (not beyond-last!) value
+
鐃緒申��申鐃緒申	     POS can take on without hitting edge of buffer or the gap.  */
+
鐃緒申��申鐃緒申	  limit = ((direction > 0)
+
鐃緒申��申鐃緒申		   ? min (lim - 1, min (limit, pos + 20000))
+
鐃緒申��申鐃緒申		   : max (lim, max (limit, pos - 20000)));
+
鐃緒申��申鐃緒申	  if ((limit - pos) * direction > 20)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      p_limit = &FETCH_CHAR (limit);
+
鐃緒申��申鐃緒申	      p2 = (cursor = &FETCH_CHAR (pos));
+
鐃緒申��申鐃緒申	      /* In this loop, pos + cursor - p2 is the surrogate for pos */
+
鐃緒申��申鐃緒申	      while (1)		/* use one cursor setting as long as i can */
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (direction > 0) /* worth duplicating */
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      /* Use signed comparison if appropriate
+
鐃緒申��申鐃緒申			 to make cursor+infinity sure to be > p_limit.
+
鐃緒申��申鐃緒申			 Assuming that the buffer lies in a range of addresses
+
鐃緒申��申鐃緒申			 that are all "positive" (as ints) or all "negative",
+
鐃緒申��申鐃緒申			 either kind of comparison will work as long
+
鐃緒申��申鐃緒申			 as we don't step by infinity.  So pick the kind
+
鐃緒申��申鐃緒申			 that works when we do step by infinity.  */
+
鐃緒申��申鐃緒申		      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 <= (unsigned EMACS_INT) 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 >= (unsigned EMACS_INT) 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 */
+
鐃緒申��申鐃緒申 /* to throw you well beyond the end of the search.  It can also */
+
鐃緒申��申鐃緒申 /* happen if you fail to match within the permitted region and would */
+
鐃緒申��申鐃緒申 /* otherwise try a character beyond that region */
+
鐃緒申��申鐃緒申		  if ((cursor - p_limit) * direction <= len)
+
鐃緒申��申鐃緒申		    break;	/* a small overrun is genuine */
+
鐃緒申��申鐃緒申		  cursor -= infinity; /* large overrun = hit */
+
鐃緒申��申鐃緒申		  i = dirlen - direction;
+
鐃緒申��申鐃緒申		  if (trt != 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      while ((i -= direction) + direction != 0)
+
鐃緒申��申鐃緒申			if (pat[i] != trt[*(cursor -= direction)])
+
鐃緒申��申鐃緒申			  break;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      while ((i -= direction) + direction != 0)
+
鐃緒申��申鐃緒申			if (pat[i] != *(cursor -= direction))
+
鐃緒申��申鐃緒申			  break;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  cursor += dirlen - i - direction;	/* fix cursor */
+
鐃緒申��申鐃緒申		  if (i + direction == 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      cursor -= direction;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      set_search_regs (pos + cursor - p2 + ((direction > 0)
+
鐃緒申��申鐃緒申							    ? 1 - len : 0),
+
鐃緒申��申鐃緒申				       len);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      if ((n -= direction) != 0)
+
鐃緒申��申鐃緒申			cursor += dirlen; /* to resume search */
+
鐃緒申��申鐃緒申		      else
+
鐃緒申��申鐃緒申			return ((direction > 0)
+
鐃緒申��申鐃緒申				? search_regs.end[0] : search_regs.start[0]);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    cursor += stride_for_teases; /* <sigh> we lose -  */
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      pos += cursor - p2;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    /* Now we'll pick up a clump that has to be done the hard */
+
鐃緒申��申鐃緒申	    /* way because it covers a discontinuity */
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      limit = ((direction > 0)
+
鐃緒申��申鐃緒申		       ? BUFFER_CEILING_OF (pos - dirlen + 1)
+
鐃緒申��申鐃緒申		       : BUFFER_FLOOR_OF (pos - dirlen - 1));
+
鐃緒申��申鐃緒申	      limit = ((direction > 0)
+
鐃緒申��申鐃緒申		       ? min (limit + len, lim - 1)
+
鐃緒申��申鐃緒申		       : max (limit - len, lim));
+
鐃緒申��申鐃緒申	      /* LIMIT is now the last value POS can have
+
鐃緒申��申鐃緒申		 and still be valid for a possible match.  */
+
鐃緒申��申鐃緒申	      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)
+
鐃緒申��申鐃緒申		    pos += BM_tab[FETCH_CHAR(pos)];
+
鐃緒申��申鐃緒申		  /* now run the same tests to distinguish going off the */
+
鐃緒申��申鐃緒申		  /* end, a match or a phony match. */
+
鐃緒申��申鐃緒申		  if ((pos - limit) * direction <= len)
+
鐃緒申��申鐃緒申		    break;	/* ran off the end */
+
鐃緒申��申鐃緒申		  /* Found what might be a match.
+
鐃緒申��申鐃緒申		     Set POS back to last (first if reverse) char pos.  */
+
鐃緒申��申鐃緒申		  pos -= infinity;
+
鐃緒申��申鐃緒申		  i = dirlen - direction;
+
鐃緒申��申鐃緒申		  while ((i -= direction) + direction != 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      pos -= direction;
+
鐃緒申��申鐃緒申		      if (pat[i] != (trt != 0
+
鐃緒申��申鐃緒申				     ? trt[FETCH_CHAR(pos)]
+
鐃緒申��申鐃緒申				     : FETCH_CHAR (pos)))
+
鐃緒申��申鐃緒申			break;
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  /* Above loop has moved POS part or all the way
+
鐃緒申��申鐃緒申		     back to the first char pos (last char pos if reverse).
+
鐃緒申��申鐃緒申		     Set it once again at the last (first if reverse) char.  */
+
鐃緒申��申鐃緒申		  pos += dirlen - i- direction;
+
鐃緒申��申鐃緒申		  if (i + direction == 0)
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      pos -= direction;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      set_search_regs (pos + ((direction > 0) ? 1 - len : 0),
+
鐃緒申��申鐃緒申				       len);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申		      if ((n -= direction) != 0)
+
鐃緒申��申鐃緒申			pos += dirlen; /* to resume search */
+
鐃緒申��申鐃緒申		      else
+
鐃緒申��申鐃緒申			return ((direction > 0)
+
鐃緒申��申鐃緒申				? search_regs.end[0] : search_regs.start[0]);
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    pos += stride_for_teases;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      }
+
鐃緒申��申鐃緒申	  /* We have done one clump.  Can we continue? */
+
鐃緒申��申鐃緒申	  if ((lim - pos) * direction < 0)
+
鐃緒申��申鐃緒申	    return ((0 - n) * direction);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      return pos;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Record beginning BEG and end BEG + LEN
+
鐃緒申��申鐃緒申   for a match just found in the current buffer.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申set_search_regs (beg, len)
+
鐃緒申��申鐃緒申     int beg, len;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  /* Make sure we have registers in which to store
+
鐃緒申��申鐃緒申     the match position.  */
+
鐃緒申��申鐃緒申  if (search_regs.num_regs == 0)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      search_regs.start = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
+
鐃緒申��申鐃緒申      search_regs.end = (regoff_t *) xmalloc (2 * sizeof (regoff_t));
+
鐃緒申��申鐃緒申      search_regs.num_regs = 2;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  search_regs.start[0] = beg;
+
鐃緒申��申鐃緒申  search_regs.end[0] = beg + len;
+
鐃緒申��申鐃緒申  XSETBUFFER (last_thing_searched, current_buffer);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Given a string of words separated by word delimiters,
+
鐃緒申��申鐃緒申  compute a regexp that matches those exact words
+
鐃緒申��申鐃緒申  separated by arbitrary punctuation.  */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申wordify (string)
+
鐃緒申��申鐃緒申     Lisp_Object string;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register unsigned char *p, *o;
+
鐃緒申��申鐃緒申  register int i, len, punct_count = 0, word_count = 0;
+
鐃緒申��申鐃緒申  Lisp_Object val;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (string, 0);
+
鐃緒申��申鐃緒申  p = XSTRING (string)->data;
+
鐃緒申��申鐃緒申  len = XSTRING (string)->size;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < len; i++)
+
鐃緒申��申鐃緒申    if (SYNTAX (p[i]) != Sword)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	punct_count++;
+
鐃緒申��申鐃緒申	if (i > 0 && SYNTAX (p[i-1]) == Sword) word_count++;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  if (SYNTAX (p[len-1]) == Sword) word_count++;
+
鐃緒申��申鐃緒申  if (!word_count) return build_string ("");
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  val = make_string (p, len - punct_count + 5 * (word_count - 1) + 4);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  o = XSTRING (val)->data;
+
鐃緒申��申鐃緒申  *o++ = '\\';
+
鐃緒申��申鐃緒申  *o++ = 'b';
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < len; i++)
+
鐃緒申��申鐃緒申    if (SYNTAX (p[i]) == Sword)
+
鐃緒申��申鐃緒申      *o++ = p[i];
+
鐃緒申��申鐃緒申    else if (i > 0 && SYNTAX (p[i-1]) == Sword && --word_count)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	*o++ = '\\';
+
鐃緒申��申鐃緒申	*o++ = 'W';
+
鐃緒申��申鐃緒申	*o++ = '\\';
+
鐃緒申��申鐃緒申	*o++ = 'W';
+
鐃緒申��申鐃緒申	*o++ = '*';
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  *o++ = '\\';
+
鐃緒申��申鐃緒申  *o++ = 'b';
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return val;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("search-backward", Fsearch_backward, Ssearch_backward, 1, 4,
+
鐃緒申��申鐃緒申  "sSearch backward: ",
+
鐃緒申��申鐃緒申  "Search backward from point for STRING.\n\
+
鐃緒申��申鐃緒申Set point to the beginning of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend before that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申 If not nil and not t, position at limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (string, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object string, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (string, bound, noerror, count, -1, 0, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("search-forward", Fsearch_forward, Ssearch_forward, 1, 4, "sSearch: ",
+
鐃緒申��申鐃緒申  "Search forward from point for STRING.\n\
+
鐃緒申��申鐃緒申Set point to the end of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend after that position.  nil is equivalent\n\
+
鐃緒申��申鐃緒申  to (point-max).\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (string, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object string, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (string, bound, noerror, count, 1, 0, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("word-search-backward", Fword_search_backward, Sword_search_backward, 1, 4,
+
鐃緒申��申鐃緒申  "sWord search backward: ",
+
鐃緒申��申鐃緒申  "Search backward from point for STRING, ignoring differences in punctuation.\n\
+
鐃緒申��申鐃緒申Set point to the beginning of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend before that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.")
+
鐃緒申��申鐃緒申  (string, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object string, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (wordify (string), bound, noerror, count, -1, 1, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("word-search-forward", Fword_search_forward, Sword_search_forward, 1, 4,
+
鐃緒申��申鐃緒申  "sWord search: ",
+
鐃緒申��申鐃緒申  "Search forward from point for STRING, ignoring differences in punctuation.\n\
+
鐃緒申��申鐃緒申Set point to the end of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend after that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.")
+
鐃緒申��申鐃緒申  (string, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object string, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (wordify (string), bound, noerror, count, 1, 1, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4,
+
鐃緒申��申鐃緒申  "sRE search backward: ",
+
鐃緒申��申鐃緒申  "Search backward from point for match for regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申Set point to the beginning of the match, and return point.\n\
+
鐃緒申��申鐃緒申The match found is the one starting last in the buffer\n\
+
鐃緒申��申鐃緒申and yet ending before the origin of the search.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must start at or after that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (regexp, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (regexp, bound, noerror, count, -1, 1, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("re-search-forward", Fre_search_forward, Sre_search_forward, 1, 4,
+
鐃緒申��申鐃緒申  "sRE search: ",
+
鐃緒申��申鐃緒申  "Search forward from point for regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申Set point to the end of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend after that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (regexp, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (regexp, bound, noerror, count, 1, 1, 0);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("posix-search-backward", Fposix_search_backward, Sposix_search_backward, 1, 4,
+
鐃緒申��申鐃緒申  "sPosix search backward: ",
+
鐃緒申��申鐃緒申  "Search backward from point for match for regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申Find the longest match in accord with Posix regular expression rules.\n\
+
鐃緒申��申鐃緒申Set point to the beginning of the match, and return point.\n\
+
鐃緒申��申鐃緒申The match found is the one starting last in the buffer\n\
+
鐃緒申��申鐃緒申and yet ending before the origin of the search.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must start at or after that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (regexp, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (regexp, bound, noerror, count, -1, 1, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("posix-search-forward", Fposix_search_forward, Sposix_search_forward, 1, 4,
+
鐃緒申��申鐃緒申  "sPosix search: ",
+
鐃緒申��申鐃緒申  "Search forward from point for regular expression REGEXP.\n\
+
鐃緒申��申鐃緒申Find the longest match in accord with Posix regular expression rules.\n\
+
鐃緒申��申鐃緒申Set point to the end of the occurrence found, and return point.\n\
+
鐃緒申��申鐃緒申An optional second argument bounds the search; it is a buffer position.\n\
+
鐃緒申��申鐃緒申The match found must not extend after that position.\n\
+
鐃緒申��申鐃緒申Optional third argument, if t, means if fail just return nil (no error).\n\
+
鐃緒申��申鐃緒申  If not nil and not t, move to limit of search and return nil.\n\
+
鐃緒申��申鐃緒申Optional fourth argument is repeat count--search for successive occurrences.\n\
+
鐃緒申��申鐃緒申See also the functions `match-beginning', `match-end' and `replace-match'.")
+
鐃緒申��申鐃緒申  (regexp, bound, noerror, count)
+
鐃緒申��申鐃緒申     Lisp_Object regexp, bound, noerror, count;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return search_command (regexp, bound, noerror, count, 1, 1, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("replace-match", Freplace_match, Sreplace_match, 1, 4, 0,
+
鐃緒申��申鐃緒申  "Replace text matched by last search with NEWTEXT.\n\
+
鐃緒申��申鐃緒申If second arg FIXEDCASE is non-nil, do not alter case of replacement text.\n\
+
鐃緒申��申鐃緒申Otherwise maybe capitalize the whole text, or maybe just word initials,\n\
+
鐃緒申��申鐃緒申based on the replaced text.\n\
+
鐃緒申��申鐃緒申If the replaced text has only capital letters\n\
+
鐃緒申��申鐃緒申and has at least one multiletter word, convert NEWTEXT to all caps.\n\
+
鐃緒申��申鐃緒申If the replaced text has at least one word starting with a capital letter,\n\
+
鐃緒申��申鐃緒申then capitalize each word in NEWTEXT.\n\n\
+
鐃緒申��申鐃緒申If third arg LITERAL is non-nil, insert NEWTEXT literally.\n\
+
鐃緒申��申鐃緒申Otherwise treat `\\' as special:\n\
+
鐃緒申��申鐃緒申  `\\&' in NEWTEXT means substitute original matched text.\n\
+
鐃緒申��申鐃緒申  `\\N' means substitute what matched the Nth `\\(...\\)'.\n\
+
鐃緒申��申鐃緒申       If Nth parens didn't match, substitute nothing.\n\
+
鐃緒申��申鐃緒申  `\\\\' means insert one `\\'.\n\
+
鐃緒申��申鐃緒申FIXEDCASE and LITERAL are optional arguments.\n\
+
鐃緒申��申鐃緒申Leaves point at end of replacement text.\n\
+
鐃緒申��申鐃緒申\n\
+
鐃緒申��申鐃緒申The optional fourth argument STRING can be a string to modify.\n\
+
鐃緒申��申鐃緒申In that case, this function creates and returns a new string\n\
+
鐃緒申��申鐃緒申which is made by replacing the part of STRING that was matched.")
+
鐃緒申��申鐃緒申  (newtext, fixedcase, literal, string)
+
鐃緒申��申鐃緒申     Lisp_Object newtext, fixedcase, literal, string;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  enum { nochange, all_caps, cap_initial } case_action;
+
鐃緒申��申鐃緒申  register int pos, last;
+
鐃緒申��申鐃緒申  int some_multiletter_word;
+
鐃緒申��申鐃緒申  int some_lowercase;
+
鐃緒申��申鐃緒申  int some_uppercase;
+
鐃緒申��申鐃緒申  int some_nonuppercase_initial;
+
鐃緒申��申鐃緒申  register int c, prevc;
+
鐃緒申��申鐃緒申  int inslen;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (newtext, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (! NILP (string))
+
鐃緒申��申鐃緒申    CHECK_STRING (string, 4);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  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");
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (NILP (string))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (search_regs.start[0] < BEGV
+
鐃緒申��申鐃緒申	  || search_regs.start[0] > search_regs.end[0]
+
鐃緒申��申鐃緒申	  || search_regs.end[0] > ZV)
+
鐃緒申��申鐃緒申	args_out_of_range (make_number (search_regs.start[0]),
+
鐃緒申��申鐃緒申			   make_number (search_regs.end[0]));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (search_regs.start[0] < 0
+
鐃緒申��申鐃緒申	  || search_regs.start[0] > search_regs.end[0]
+
鐃緒申��申鐃緒申	  || search_regs.end[0] > XSTRING (string)->size)
+
鐃緒申��申鐃緒申	args_out_of_range (make_number (search_regs.start[0]),
+
鐃緒申��申鐃緒申			   make_number (search_regs.end[0]));
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (NILP (fixedcase))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      /* Decide how to casify by examining the matched text. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      last = search_regs.end[0];
+
鐃緒申��申鐃緒申      prevc = '\n';
+
鐃緒申��申鐃緒申      case_action = all_caps;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* some_multiletter_word is set nonzero if any original word
+
鐃緒申��申鐃緒申	 is more than one letter long. */
+
鐃緒申��申鐃緒申      some_multiletter_word = 0;
+
鐃緒申��申鐃緒申      some_lowercase = 0;
+
鐃緒申��申鐃緒申      some_nonuppercase_initial = 0;
+
鐃緒申��申鐃緒申      some_uppercase = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (pos = search_regs.start[0]; pos < last; pos++)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (NILP (string))
+
鐃緒申��申鐃緒申	    c = FETCH_CHAR (pos);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    c = XSTRING (string)->data[pos];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (LOWERCASEP (c))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* Cannot be all caps if any original char is lower case */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      some_lowercase = 1;
+
鐃緒申��申鐃緒申	      if (SYNTAX (prevc) != Sword)
+
鐃緒申��申鐃緒申		some_nonuppercase_initial = 1;
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		some_multiletter_word = 1;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else if (!NOCASEP (c))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      some_uppercase = 1;
+
鐃緒申��申鐃緒申	      if (SYNTAX (prevc) != Sword)
+
鐃緒申��申鐃緒申		;
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		some_multiletter_word = 1;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      /* If the initial is a caseless word constituent,
+
鐃緒申��申鐃緒申		 treat that like a lowercase initial.  */
+
鐃緒申��申鐃緒申	      if (SYNTAX (prevc) != Sword)
+
鐃緒申��申鐃緒申		some_nonuppercase_initial = 1;
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  prevc = c;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Convert to all caps if the old text is all caps
+
鐃緒申��申鐃緒申	 and has at least one multiletter word.  */
+
鐃緒申��申鐃緒申      if (! some_lowercase && some_multiletter_word)
+
鐃緒申��申鐃緒申	case_action = all_caps;
+
鐃緒申��申鐃緒申      /* Capitalize each word, if the old text has all capitalized words.  */
+
鐃緒申��申鐃緒申      else if (!some_nonuppercase_initial && some_multiletter_word)
+
鐃緒申��申鐃緒申	case_action = cap_initial;
+
鐃緒申��申鐃緒申      else if (!some_nonuppercase_initial && some_uppercase)
+
鐃緒申��申鐃緒申	/* Should x -> yz, operating on X, give Yz or YZ?
+
鐃緒申��申鐃緒申	   We'll assume the latter.  */
+
鐃緒申��申鐃緒申	case_action = all_caps;
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	case_action = nochange;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Do replacement in a string.  */
+
鐃緒申��申鐃緒申  if (!NILP (string))
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      Lisp_Object before, after;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      before = Fsubstring (string, make_number (0),
+
鐃緒申��申鐃緒申			   make_number (search_regs.start[0]));
+
鐃緒申��申鐃緒申      after = Fsubstring (string, make_number (search_regs.end[0]), Qnil);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      /* Do case substitution into NEWTEXT if desired.  */
+
鐃緒申��申鐃緒申      if (NILP (literal))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int lastpos = -1;
+
鐃緒申��申鐃緒申	  /* We build up the substituted string in ACCUM.  */
+
鐃緒申��申鐃緒申	  Lisp_Object accum;
+
鐃緒申��申鐃緒申	  Lisp_Object middle;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  accum = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  for (pos = 0; pos < XSTRING (newtext)->size; pos++)
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      int substart = -1;
+
鐃緒申��申鐃緒申	      int subend;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	      c = XSTRING (newtext)->data[pos];
+
鐃緒申��申鐃緒申	      if (c == '\\')
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  c = XSTRING (newtext)->data[++pos];
+
鐃緒申��申鐃緒申		  if (c == '&')
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      substart = search_regs.start[0];
+
鐃緒申��申鐃緒申		      subend = search_regs.end[0];
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		  else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0')
+
鐃緒申��申鐃緒申		    {
+
鐃緒申��申鐃緒申		      if (search_regs.start[c - '0'] >= 1)
+
鐃緒申��申鐃緒申			{
+
鐃緒申��申鐃緒申			  substart = search_regs.start[c - '0'];
+
鐃緒申��申鐃緒申			  subend = search_regs.end[c - '0'];
+
鐃緒申��申鐃緒申			}
+
鐃緒申��申鐃緒申		    }
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      if (substart >= 0)
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (pos - 1 != lastpos + 1)
+
鐃緒申��申鐃緒申		    middle = Fsubstring (newtext, lastpos + 1, pos - 1);
+
鐃緒申��申鐃緒申		  else
+
鐃緒申��申鐃緒申		    middle = Qnil;
+
鐃緒申��申鐃緒申		  accum = concat3 (accum, middle,
+
鐃緒申��申鐃緒申				   Fsubstring (string, make_number (substart),
+
鐃緒申��申鐃緒申					       make_number (subend)));
+
鐃緒申��申鐃緒申		  lastpos = pos;
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  if (pos != lastpos + 1)
+
鐃緒申��申鐃緒申	    middle = Fsubstring (newtext, lastpos + 1, pos);
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    middle = Qnil;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  newtext = concat2 (accum, middle);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      if (case_action == all_caps)
+
鐃緒申��申鐃緒申	newtext = Fupcase (newtext);
+
鐃緒申��申鐃緒申      else if (case_action == cap_initial)
+
鐃緒申��申鐃緒申	newtext = Fupcase_initials (newtext);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      return concat3 (before, newtext, after);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* 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.  */
+
鐃緒申��申鐃緒申  SET_PT (search_regs.start[0]);
+
鐃緒申��申鐃緒申  if (!NILP (literal))
+
鐃緒申��申鐃緒申    Finsert_and_inherit (1, &newtext);
+
鐃緒申��申鐃緒申  else
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      struct gcpro gcpro1;
+
鐃緒申��申鐃緒申      GCPRO1 (newtext);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      for (pos = 0; pos < XSTRING (newtext)->size; pos++)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  int offset = point - search_regs.start[0];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  c = XSTRING (newtext)->data[pos];
+
鐃緒申��申鐃緒申	  if (c == '\\')
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      c = XSTRING (newtext)->data[++pos];
+
鐃緒申��申鐃緒申	      if (c == '&')
+
鐃緒申��申鐃緒申		Finsert_buffer_substring
+
鐃緒申��申鐃緒申		  (Fcurrent_buffer (),
+
鐃緒申��申鐃緒申		   make_number (search_regs.start[0] + offset),
+
鐃緒申��申鐃緒申		   make_number (search_regs.end[0] + offset));
+
鐃緒申��申鐃緒申	      else if (c >= '1' && c <= '9' && c <= search_regs.num_regs + '0')
+
鐃緒申��申鐃緒申		{
+
鐃緒申��申鐃緒申		  if (search_regs.start[c - '0'] >= 1)
+
鐃緒申��申鐃緒申		    Finsert_buffer_substring
+
鐃緒申��申鐃緒申		      (Fcurrent_buffer (),
+
鐃緒申��申鐃緒申		       make_number (search_regs.start[c - '0'] + offset),
+
鐃緒申��申鐃緒申		       make_number (search_regs.end[c - '0'] + offset));
+
鐃緒申��申鐃緒申		}
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		insert_char (c);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    insert_char (c);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      UNGCPRO;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  inslen = point - (search_regs.start[0]);
+
鐃緒申��申鐃緒申  del_range (search_regs.start[0] + inslen, search_regs.end[0] + inslen);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (case_action == all_caps)
+
鐃緒申��申鐃緒申    Fupcase_region (make_number (point - inslen), make_number (point));
+
鐃緒申��申鐃緒申  else if (case_action == cap_initial)
+
鐃緒申��申鐃緒申    Fupcase_initials_region (make_number (point - inslen), make_number (point));
+
鐃緒申��申鐃緒申  return Qnil;
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申static Lisp_Object
+
鐃緒申��申鐃緒申match_limit (num, beginningp)
+
鐃緒申��申鐃緒申     Lisp_Object num;
+
鐃緒申��申鐃緒申     int beginningp;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register int n;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_NUMBER (num, 0);
+
鐃緒申��申鐃緒申  n = XINT (num);
+
鐃緒申��申鐃緒申  if (n < 0 || n >= search_regs.num_regs)
+
鐃緒申��申鐃緒申    args_out_of_range (num, make_number (search_regs.num_regs));
+
鐃緒申��申鐃緒申  if (search_regs.num_regs <= 0
+
鐃緒申��申鐃緒申      || search_regs.start[n] < 0)
+
鐃緒申��申鐃緒申    return Qnil;
+
鐃緒申��申鐃緒申  return (make_number ((beginningp) ? search_regs.start[n]
+
鐃緒申��申鐃緒申		                    : search_regs.end[n]));
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("match-beginning", Fmatch_beginning, Smatch_beginning, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Return position of start of text matched by last search.\n\
+
鐃緒申��申鐃緒申NUM specifies which parenthesized expression in the last regexp.\n\
+
鐃緒申��申鐃緒申 Value is nil if NUMth pair didn't match, or there were less than NUM pairs.\n\
+
鐃緒申��申鐃緒申Zero means the entire text matched by the whole regexp or whole string.")
+
鐃緒申��申鐃緒申  (num)
+
鐃緒申��申鐃緒申     Lisp_Object num;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return match_limit (num, 1);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("match-end", Fmatch_end, Smatch_end, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Return position of end of text matched by last search.\n\
+
鐃緒申��申鐃緒申ARG, a number, specifies which parenthesized expression in the last regexp.\n\
+
鐃緒申��申鐃緒申 Value is nil if ARGth pair didn't match, or there were less than ARG pairs.\n\
+
鐃緒申��申鐃緒申Zero means the entire text matched by the whole regexp or whole string.")
+
鐃緒申��申鐃緒申  (num)
+
鐃緒申��申鐃緒申     Lisp_Object num;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  return match_limit (num, 0);
+
鐃緒申��申鐃緒申} 
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("match-data", Fmatch_data, Smatch_data, 0, 0, 0,
+
鐃緒申��申鐃緒申  "Return a list containing all info on what the last search matched.\n\
+
鐃緒申��申鐃緒申Element 2N is `(match-beginning N)'; element 2N + 1 is `(match-end N)'.\n\
+
鐃緒申��申鐃緒申All the elements are markers or nil (nil if the Nth pair didn't match)\n\
+
鐃緒申��申鐃緒申if the last match was on a buffer; integers or nil if a string was matched.\n\
+
鐃緒申��申鐃緒申Use `store-match-data' to reinstate the data in this list.")
+
鐃緒申��申鐃緒申  ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  Lisp_Object *data;
+
鐃緒申��申鐃緒申  int i, len;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (NILP (last_thing_searched))
+
鐃緒申��申鐃緒申    error ("match-data called before any match found");
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  data = (Lisp_Object *) alloca ((2 * search_regs.num_regs)
+
鐃緒申��申鐃緒申				 * sizeof (Lisp_Object));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  len = -1;
+
鐃緒申��申鐃緒申  for (i = 0; i < search_regs.num_regs; i++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      int start = search_regs.start[i];
+
鐃緒申��申鐃緒申      if (start >= 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (EQ (last_thing_searched, Qt))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      XSETFASTINT (data[2 * i], start);
+
鐃緒申��申鐃緒申	      XSETFASTINT (data[2 * i + 1], search_regs.end[i]);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else if (BUFFERP (last_thing_searched))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      data[2 * i] = Fmake_marker ();
+
鐃緒申��申鐃緒申	      Fset_marker (data[2 * i],
+
鐃緒申��申鐃緒申			   make_number (start),
+
鐃緒申��申鐃緒申			   last_thing_searched);
+
鐃緒申��申鐃緒申	      data[2 * i + 1] = Fmake_marker ();
+
鐃緒申��申鐃緒申	      Fset_marker (data[2 * i + 1],
+
鐃緒申��申鐃緒申			   make_number (search_regs.end[i]), 
+
鐃緒申��申鐃緒申			   last_thing_searched);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申	  else
+
鐃緒申��申鐃緒申	    /* last_thing_searched must always be Qt, a buffer, or Qnil.  */
+
鐃緒申��申鐃緒申	    abort ();
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  len = i;
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	data[2 * i] = data [2 * i + 1] = Qnil;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  return Flist (2 * len + 2, data);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("store-match-data", Fstore_match_data, Sstore_match_data, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Set internal data on last search match from elements of LIST.\n\
+
鐃緒申��申鐃緒申LIST should have been created by calling `match-data' previously.")
+
鐃緒申��申鐃緒申  (list)
+
鐃緒申��申鐃緒申     register Lisp_Object list;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register int i;
+
鐃緒申��申鐃緒申  register Lisp_Object marker;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  if (running_asynch_code)
+
鐃緒申��申鐃緒申    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.  */
+
鐃緒申��申鐃緒申  {
+
鐃緒申��申鐃緒申    int length = XFASTINT (Flength (list)) / 2;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申    if (length > search_regs.num_regs)
+
鐃緒申��申鐃緒申      {
+
鐃緒申��申鐃緒申	if (search_regs.num_regs == 0)
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    search_regs.start
+
鐃緒申��申鐃緒申	      = (regoff_t *) xmalloc (length * sizeof (regoff_t));
+
鐃緒申��申鐃緒申	    search_regs.end
+
鐃緒申��申鐃緒申	      = (regoff_t *) xmalloc (length * sizeof (regoff_t));
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申	else
+
鐃緒申��申鐃緒申	  {
+
鐃緒申��申鐃緒申	    search_regs.start
+
鐃緒申��申鐃緒申	      = (regoff_t *) xrealloc (search_regs.start,
+
鐃緒申��申鐃緒申				       length * sizeof (regoff_t));
+
鐃緒申��申鐃緒申	    search_regs.end
+
鐃緒申��申鐃緒申	      = (regoff_t *) xrealloc (search_regs.end,
+
鐃緒申��申鐃緒申				       length * sizeof (regoff_t));
+
鐃緒申��申鐃緒申	  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	search_regs.num_regs = length;
+
鐃緒申��申鐃緒申      }
+
鐃緒申��申鐃緒申  }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < search_regs.num_regs; i++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      marker = Fcar (list);
+
鐃緒申��申鐃緒申      if (NILP (marker))
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  search_regs.start[i] = -1;
+
鐃緒申��申鐃緒申	  list = Fcdr (list);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      else
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  if (MARKERP (marker))
+
鐃緒申��申鐃緒申	    {
+
鐃緒申��申鐃緒申	      if (XMARKER (marker)->buffer == 0)
+
鐃緒申��申鐃緒申		XSETFASTINT (marker, 0);
+
鐃緒申��申鐃緒申	      else
+
鐃緒申��申鐃緒申		XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer);
+
鐃緒申��申鐃緒申	    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  CHECK_NUMBER_COERCE_MARKER (marker, 0);
+
鐃緒申��申鐃緒申	  search_regs.start[i] = XINT (marker);
+
鐃緒申��申鐃緒申	  list = Fcdr (list);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  marker = Fcar (list);
+
鐃緒申��申鐃緒申	  if (MARKERP (marker) && XMARKER (marker)->buffer == 0)
+
鐃緒申��申鐃緒申	    XSETFASTINT (marker, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申	  CHECK_NUMBER_COERCE_MARKER (marker, 0);
+
鐃緒申��申鐃緒申	  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;
+
鐃緒申��申鐃緒申static struct re_registers saved_search_regs;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Called from Flooking_at, Fstring_match, search_buffer, Fstore_match_data
+
鐃緒申��申鐃緒申   if asynchronous code (filter or sentinel) is running. */
+
鐃緒申��申鐃緒申static void
+
鐃緒申��申鐃緒申save_search_regs ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (!search_regs_saved)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      saved_search_regs.num_regs = search_regs.num_regs;
+
鐃緒申��申鐃緒申      saved_search_regs.start = search_regs.start;
+
鐃緒申��申鐃緒申      saved_search_regs.end = search_regs.end;
+
鐃緒申��申鐃緒申      search_regs.num_regs = 0;
+
鐃緒申��申鐃緒申      search_regs.start = 0;
+
鐃緒申��申鐃緒申      search_regs.end = 0;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      search_regs_saved = 1;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Called upon exit from filters and sentinels. */
+
鐃緒申��申鐃緒申void
+
鐃緒申��申鐃緒申restore_match_data ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  if (search_regs_saved)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (search_regs.num_regs > 0)
+
鐃緒申��申鐃緒申	{
+
鐃緒申��申鐃緒申	  xfree (search_regs.start);
+
鐃緒申��申鐃緒申	  xfree (search_regs.end);
+
鐃緒申��申鐃緒申	}
+
鐃緒申��申鐃緒申      search_regs.num_regs = saved_search_regs.num_regs;
+
鐃緒申��申鐃緒申      search_regs.start = saved_search_regs.start;
+
鐃緒申��申鐃緒申      search_regs.end = saved_search_regs.end;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申      search_regs_saved = 0;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申/* Quote a string to inactivate reg-expr chars */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申DEFUN ("regexp-quote", Fregexp_quote, Sregexp_quote, 1, 1, 0,
+
鐃緒申��申鐃緒申  "Return a regexp string which matches exactly STRING and nothing else.")
+
鐃緒申��申鐃緒申  (str)
+
鐃緒申��申鐃緒申     Lisp_Object str;
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register unsigned char *in, *out, *end;
+
鐃緒申��申鐃緒申  register unsigned char *temp;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  CHECK_STRING (str, 0);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  temp = (unsigned char *) alloca (XSTRING (str)->size * 2);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  /* Now copy the data into the new string, inserting escapes. */
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  in = XSTRING (str)->data;
+
鐃緒申��申鐃緒申  end = in + XSTRING (str)->size;
+
鐃緒申��申鐃緒申  out = temp; 
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (; in != end; in++)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      if (*in == '[' || *in == ']'
+
鐃緒申��申鐃緒申	  || *in == '*' || *in == '.' || *in == '\\'
+
鐃緒申��申鐃緒申	  || *in == '?' || *in == '+'
+
鐃緒申��申鐃緒申	  || *in == '^' || *in == '$')
+
鐃緒申��申鐃緒申	*out++ = '\\';
+
鐃緒申��申鐃緒申      *out++ = *in;
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  return make_string (temp, out - temp);
+
鐃緒申��申鐃緒申}
+
鐃緒申��申鐃緒申  
+
鐃緒申��申鐃緒申syms_of_search ()
+
鐃緒申��申鐃緒申{
+
鐃緒申��申鐃緒申  register int i;
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  for (i = 0; i < REGEXP_CACHE_SIZE; ++i)
+
鐃緒申��申鐃緒申    {
+
鐃緒申��申鐃緒申      searchbufs[i].buf.allocated = 100;
+
鐃緒申��申鐃緒申      searchbufs[i].buf.buffer = (unsigned char *) malloc (100);
+
鐃緒申��申鐃緒申      searchbufs[i].buf.fastmap = searchbufs[i].fastmap;
+
鐃緒申��申鐃緒申      searchbufs[i].regexp = Qnil;
+
鐃緒申��申鐃緒申      staticpro (&searchbufs[i].regexp);
+
鐃緒申��申鐃緒申      searchbufs[i].next = (i == REGEXP_CACHE_SIZE-1 ? 0 : &searchbufs[i+1]);
+
鐃緒申��申鐃緒申    }
+
鐃緒申��申鐃緒申  searchbuf_head = &searchbufs[0];
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Qsearch_failed = intern ("search-failed");
+
鐃緒申��申鐃緒申  staticpro (&Qsearch_failed);
+
鐃緒申��申鐃緒申  Qinvalid_regexp = intern ("invalid-regexp");
+
鐃緒申��申鐃緒申  staticpro (&Qinvalid_regexp);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Fput (Qsearch_failed, Qerror_conditions,
+
鐃緒申��申鐃緒申	Fcons (Qsearch_failed, Fcons (Qerror, Qnil)));
+
鐃緒申��申鐃緒申  Fput (Qsearch_failed, Qerror_message,
+
鐃緒申��申鐃緒申	build_string ("Search failed"));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  Fput (Qinvalid_regexp, Qerror_conditions,
+
鐃緒申��申鐃緒申	Fcons (Qinvalid_regexp, Fcons (Qerror, Qnil)));
+
鐃緒申��申鐃緒申  Fput (Qinvalid_regexp, Qerror_message,
+
鐃緒申��申鐃緒申	build_string ("Invalid regexp"));
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  last_thing_searched = Qnil;
+
鐃緒申��申鐃緒申  staticpro (&last_thing_searched);
+
鐃緒申��申鐃緒申
+
鐃緒申��申鐃緒申  defsubr (&Slooking_at);
+
鐃緒申��申鐃緒申  defsubr (&Sposix_looking_at);
+
鐃緒申��申鐃緒申  defsubr (&Sstring_match);
+
鐃緒申��申鐃緒申  defsubr (&Sposix_string_match);
+
鐃緒申��申鐃緒申  defsubr (&Sskip_chars_forward);
+
鐃緒申��申鐃緒申  defsubr (&Sskip_chars_backward);
+
鐃緒申��申鐃緒申  defsubr (&Sskip_syntax_forward);
+
鐃緒申��申鐃緒申  defsubr (&Sskip_syntax_backward);
+
鐃緒申��申鐃緒申  defsubr (&Ssearch_forward);
+
鐃緒申��申鐃緒申  defsubr (&Ssearch_backward);
+
鐃緒申��申鐃緒申  defsubr (&Sword_search_forward);
+
鐃緒申��申鐃緒申  defsubr (&Sword_search_backward);
+
鐃緒申��申鐃緒申  defsubr (&Sre_search_forward);
+
鐃緒申��申鐃緒申  defsubr (&Sre_search_backward);
+
鐃緒申��申鐃緒申  defsubr (&Sposix_search_forward);
+
鐃緒申��申鐃緒申  defsubr (&Sposix_search_backward);
+
鐃緒申��申鐃緒申  defsubr (&Sreplace_match);
+
鐃緒申��申鐃緒申  defsubr (&Smatch_beginning);
+
鐃緒申��申鐃緒申  defsubr (&Smatch_end);
+
鐃緒申��申鐃緒申  defsubr (&Smatch_data);
+
鐃緒申��申鐃緒申  defsubr (&Sstore_match_data);
+
鐃緒申��申鐃緒申  defsubr (&Sregexp_quote);
+
鐃緒申��申鐃緒申}