xemacs-beta: src/search.c comparison

comparison src/search.c @ 867:804517e16990

[xemacs-hg @ 2002-06-05 09:54:39 by ben] Textual renaming: text/char names abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, charset.h, chartab.c, chartab.h, cmds.c, console-gtk.h, console-msw.c, console-msw.h, console-stream.c, console-tty.c, console-x.c, console-x.h, console.h, data.c, device-msw.c, device-x.c, dialog-msw.c, dired-msw.c, dired.c, doc.c, doprnt.c, editfns.c, eldap.c, emodules.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, event-unixoid.c, events.c, events.h, file-coding.c, file-coding.h, fileio.c, filelock.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, glyphs-eimage.c, glyphs-msw.c, glyphs-x.c, glyphs.c, glyphs.h, gpmevent.c, gui-x.c, gui-x.h, gui.c, gui.h, hpplay.c, indent.c, insdel.c, insdel.h, intl-win32.c, keymap.c, line-number.c, line-number.h, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, md5.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, ndir.h, nt.c, objects-gtk.c, objects-gtk.h, objects-msw.c, objects-tty.c, objects-x.c, objects.c, objects.h, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, procimpl.h, realpath.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-tty.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, search.c, select-common.h, select-gtk.c, select-x.c, sound.h, symbols.c, syntax.c, syntax.h, sysdep.c, sysdep.h, sysdir.h, sysfile.h, sysproc.h, syspwd.h, systime.h, syswindows.h, termcap.c, tests.c, text.c, text.h, toolbar-common.c, tooltalk.c, ui-gtk.c, unexnt.c, unicode.c, win32.c: Text/char naming rationalization. [a] distinguish between "charptr" when it refers to operations on the pointer itself and when it refers to operations on text; and [b] use consistent naming for everything referring to internal format, i.e. Itext == text in internal format Ibyte == a byte in such text Ichar == a char as represented in internal character format thus e.g. set_charptr_emchar -> set_itext_ichar The pre and post tags on either side of this change are: pre-internal-format-textual-renaming post-internal-format-textual-renaming See the Internals Manual for details of exactly how this was done, how to handle the change in your workspace, etc.

author	ben
date	Wed, 05 Jun 2002 09:58:45 +0000
parents	2b6fa2618f76
children	79c6ff3eef26

comparison

equal deleted inserted replaced

-:613552a02607
+:804517e16990
 #include "regex.h"
 #include "casetab.h"
 #include "chartab.h"
 #define TRANSLATE(table, pos)	\
-(!NILP (table) ? TRT_TABLE_OF (table, (Emchar) pos) : pos)
+(!NILP (table) ? TRT_TABLE_OF (table, (Ichar) pos) : pos)
 #define REGEXP_CACHE_SIZE 20
 /* If the regexp is non-nil, then the buffer contains the compiled form
 of that regexp, suitable for searching.  */
 /* range table for use with skip_chars.  Only needed for Mule. */
 Lisp_Object Vskip_chars_range_table;
 static void set_search_regs (struct buffer *buf, Charbpos beg, Charcount len);
 static void save_search_regs (void);
-static Charbpos simple_search (struct buffer *buf, Intbyte *base_pat,
+static Charbpos simple_search (struct buffer *buf, Ibyte *base_pat,
 			       Bytecount len, Bytebpos pos, Bytebpos lim,
 			       EMACS_INT n, Lisp_Object trt);
-static Charbpos boyer_moore (struct buffer *buf, Intbyte *base_pat,
+static Charbpos boyer_moore (struct buffer *buf, Ibyte *base_pat,
 			     Bytecount len, Bytebpos pos, Bytebpos lim,
 			     EMACS_INT n, Lisp_Object trt,
 			     Lisp_Object inverse_trt, int charset_base);
 static Charbpos search_buffer (struct buffer *buf, Lisp_Object str,
 			       Charbpos charbpos, Charbpos buflim, EMACS_INT n,
 {
 int i;
 int num_regs = search_regs.num_regs;
 /* #### bytecount_to_charcount() is not that efficient.  This function
-could be faster if it did its own conversion (using INC_CHARPTR()
+could be faster if it did its own conversion (using INC_IBYTEPTR()
 and such), because the register ends are likely to be somewhat ordered.
 (Even if not, you could sort them.)
 Think about this if this function is a time hog, which it's probably
 not. */
 /* 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. */
 Bytecount
-fast_string_match (Lisp_Object regexp,  const Intbyte *nonreloc,
+fast_string_match (Lisp_Object regexp,  const Ibyte *nonreloc,
 		   Lisp_Object reloc, Bytecount offset,
 		   Bytecount length, int case_fold_search,
 		   Error_Behavior errb, int no_quit)
 {
 Bytecount val;
-Intbyte *newnonreloc = (Intbyte *) nonreloc;
+Ibyte *newnonreloc = (Ibyte *) nonreloc;
 struct re_pattern_buffer *bufp;
 struct syntax_cache scache_struct;
 struct syntax_cache *scache = &scache_struct;
 bufp = compile_pattern (regexp, 0,
 to the number of TARGETs left unfound, and return END.
 If ALLOW_QUIT is non-zero, call QUIT periodically. */
 static Bytebpos
-byte_scan_buffer (struct buffer *buf, Emchar target, Bytebpos st, Bytebpos en,
+byte_scan_buffer (struct buffer *buf, Ichar target, Bytebpos st, Bytebpos en,
 		EMACS_INT count, EMACS_INT *shortage, int allow_quit)
 {
 Bytebpos lim = en > 0 ? en :
 ((count > 0) ? BYTE_BUF_ZV (buf) : BYTE_BUF_BEGV (buf));
 {
 #ifdef MULE
 Internal_Format fmt = buf->text->format;
 /* Check for char that's unrepresentable in the buffer -- it
 certainly can't be there. */
-if (!emchar_fits_in_format (target, fmt, wrap_buffer (buf)))
+if (!ichar_fits_in_format (target, fmt, wrap_buffer (buf)))
 	{
 	  *shortage = count;
 	  return lim;
 	}
 /* Due to the Mule representation of characters in a buffer, we can
 	 simply search for characters in the range 0 - 127 directly; for
 	 8-bit-fixed, we can do this for all characters.  In other cases,
 	 we do it the "hard" way.  Note that this way works for all
 	 characters and all formats, but the other way is faster. */
 else if (! (fmt == FORMAT_8_BIT_FIXED ||
-		  (fmt == FORMAT_DEFAULT && emchar_ascii_p (target))))
+		  (fmt == FORMAT_DEFAULT && ichar_ascii_p (target))))
 	{
-	  Raw_Emchar raw = emchar_to_raw (target, fmt, wrap_buffer (buf));
+	  Raw_Ichar raw = ichar_to_raw (target, fmt, wrap_buffer (buf));
 	  while (st < lim && count > 0)
 	    {
 	      if (BYTE_BUF_FETCH_CHAR_RAW (buf, st) == raw)
 		count--;
 	      INC_BYTEBPOS (buf, st);
 	    }
 	}
 else
 #endif
 	{
-	  Raw_Emchar raw = emchar_to_raw (target, fmt, wrap_buffer (buf));
+	  Raw_Ichar raw = ichar_to_raw (target, fmt, wrap_buffer (buf));
 	  while (st < lim && count > 0)
 	    {
 	      Bytebpos ceil;
-	      Intbyte *bufptr;
+	      Ibyte *bufptr;
 	      ceil = BYTE_BUF_CEILING_OF (buf, st);
 	      ceil = min (lim, ceil);
-	      bufptr = (Intbyte *) memchr (BYTE_BUF_BYTE_ADDRESS (buf, st),
+	      bufptr = (Ibyte *) memchr (BYTE_BUF_BYTE_ADDRESS (buf, st),
 					   raw, ceil - st);
 	      if (bufptr)
 		{
 		  count--;
 		  st = BYTE_BUF_PTR_BYTE_POS (buf, bufptr) + 1;
 {
 #ifdef MULE
 Internal_Format fmt = buf->text->format;
 /* Check for char that's unrepresentable in the buffer -- it
 certainly can't be there. */
-if (!emchar_fits_in_format (target, fmt, wrap_buffer (buf)))
+if (!ichar_fits_in_format (target, fmt, wrap_buffer (buf)))
 	{
 	  *shortage = -count;
 	  return lim;
 	}
 else if (! (fmt == FORMAT_8_BIT_FIXED ||
-		  (fmt == FORMAT_DEFAULT && emchar_ascii_p (target))))
+		  (fmt == FORMAT_DEFAULT && ichar_ascii_p (target))))
 	{
-	  Raw_Emchar raw = emchar_to_raw (target, fmt, wrap_buffer (buf));
+	  Raw_Ichar raw = ichar_to_raw (target, fmt, wrap_buffer (buf));
 	  while (st > lim && count < 0)
 	    {
 	      DEC_BYTEBPOS (buf, st);
 	      if (BYTE_BUF_FETCH_CHAR_RAW (buf, st) == raw)
 		count++;
 	    }
 	}
 else
 #endif
 	{
-	  Raw_Emchar raw = emchar_to_raw (target, fmt, wrap_buffer (buf));
+	  Raw_Ichar raw = ichar_to_raw (target, fmt, wrap_buffer (buf));
 	  while (st > lim && count < 0)
 	    {
 	      Bytebpos floor;
-	      Intbyte *bufptr;
+	      Ibyte *bufptr;
-	      Intbyte *floorptr;
+	      Ibyte *floorptr;
 	      floor = BYTE_BUF_FLOOR_OF (buf, st);
 	      floor = max (lim, floor);
 	      /* No memrchr() ... */
 	      bufptr = BYTE_BUF_BYTE_ADDRESS_BEFORE (buf, st);
 		{
 		  st--;
 		  /* At this point, both ST and BUFPTR refer to the same
 		     character.  When the loop terminates, ST will
 		     always point to the last character we tried. */
-		  if (*bufptr == (Intbyte) raw)
+		  if (*bufptr == (Ibyte) raw)
 		    {
 		      count++;
 		      break;
 		    }
 		  bufptr--;
 	}
 }
 }
 Charbpos
-scan_buffer (struct buffer *buf, Emchar target, Charbpos start, Charbpos end,
+scan_buffer (struct buffer *buf, Ichar target, Charbpos start, Charbpos end,
 	     EMACS_INT count, EMACS_INT *shortage, int allow_quit)
 {
 Bytebpos byte_retval;
 Bytebpos byte_start, byte_end;
 {
 return scan_buffer (buf, '\n', from, 0, count, 0, 1);
 }
 Bytecount
-byte_find_next_emchar_in_string (Lisp_Object str, Emchar target, Bytecount st,
+byte_find_next_ichar_in_string (Lisp_Object str, Ichar target, Bytecount st,
 			       EMACS_INT count)
 {
 Bytebpos lim = XSTRING_LENGTH (str) -1;
-Intbyte *s = XSTRING_DATA (str);
+Ibyte *s = XSTRING_DATA (str);
 assert (count >= 0);
 #ifdef MULE
 /* Due to the Mule representation of characters in a buffer,
 way is faster. */
 if (target >= 0200)
 {
 while (st < lim && count > 0)
 	{
-	  if (string_emchar (str, st) == target)
+	  if (string_ichar (str, st) == target)
 	    count--;
 	  INC_BYTECOUNT (s, st);
 	}
 }
 else
 #endif
 {
 while (st < lim && count > 0)
 	{
-	  Intbyte *bufptr = (Intbyte *) memchr (charptr_n_addr (s, st),
+	  Ibyte *bufptr = (Ibyte *) memchr (itext_n_addr (s, st),
 						(int) target, lim - st);
 	  if (bufptr)
 	    {
 	      count--;
 	      st =  (Bytebpos) (bufptr - s) + 1;
 static Lisp_Object
 skip_chars (struct buffer *buf, int forwardp, int syntaxp,
 	    Lisp_Object string, Lisp_Object lim)
 {
-REGISTER Intbyte *p, *pend;
+REGISTER Ibyte *p, *pend;
-REGISTER Emchar c;
+REGISTER Ichar c;
 /* We store the first 256 chars in an array here and the rest in
 a range table. */
 unsigned char fastmap[0400];
 int negate = 0;
 REGISTER int i;
 If syntaxp, each character counts as itself.
 Otherwise, handle backslashes and ranges specially  */
 while (p != pend)
 {
-c = charptr_emchar (p);
+c = itext_ichar (p);
-INC_CHARPTR (p);
+INC_IBYTEPTR (p);
 if (syntaxp)
 	{
 	  if (c < 0400 && syntax_spec_code[c] < (unsigned char) Smax)
 	    fastmap[c] = 1;
 	  else
 else
 	{
 	  if (c == '\\')
 	    {
 	      if (p == pend) break;
-	      c = charptr_emchar (p);
+	      c = itext_ichar (p);
-	      INC_CHARPTR (p);
+	      INC_IBYTEPTR (p);
 	    }
 	  if (p != pend && *p == '-')
 	    {
-	      Emchar cend;
+	      Ichar cend;
 	      p++;
 	      if (p == pend) break;
-	      cend = charptr_emchar (p);
+	      cend = itext_ichar (p);
 	      while (c <= cend && c < 0400)
 		{
 		  fastmap[c] = 1;
 		  c++;
 		}
 	      if (c <= cend)
 		Fput_range_table (make_int (c), make_int (cend), Qt,
 				  Vskip_chars_range_table);
-	      INC_CHARPTR (p);
+	      INC_IBYTEPTR (p);
 	    }
 	  else
 	    {
 	      if (c < 0400)
 		fastmap[c] = 1;
 {
 	if (forwardp)
 	  {
 	    while (BUF_PT (buf) < limit)
 	      {
-		Emchar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf));
+		Ichar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf));
 		if ((ch < 0400) ? fastmap[ch] :
 		    (NILP (Fget_range_table (make_int (ch),
 					     Vskip_chars_range_table,
 					     Qnil))
 		     == negate))
 	  }
 	else
 	  {
 	    while (BUF_PT (buf) > limit)
 	      {
-		Emchar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1);
+		Ichar ch = BUF_FETCH_CHAR (buf, BUF_PT (buf) - 1);
 		if ((ch < 0400) ? fastmap[ch] :
 		    (NILP (Fget_range_table (make_int (ch),
 					     Vskip_chars_range_table,
 					     Qnil))
 		     == negate))
 static int
 trivial_regexp_p (Lisp_Object regexp)
 {
 Bytecount len = XSTRING_LENGTH (regexp);
-Intbyte *s = XSTRING_DATA (regexp);
+Ibyte *s = XSTRING_DATA (regexp);
 while (--len >= 0)
 {
 switch (*s++)
 	{
 	case '.': case '*': case '+': case '?': case '[': case '^': case '$':
 search_buffer (struct buffer *buf, Lisp_Object string, Charbpos charbpos,
 	       Charbpos buflim, EMACS_INT n, int RE, Lisp_Object trt,
 	       Lisp_Object inverse_trt, int posix)
 {
 Bytecount len = XSTRING_LENGTH (string);
-Intbyte *base_pat = XSTRING_DATA (string);
+Ibyte *base_pat = XSTRING_DATA (string);
 REGISTER EMACS_INT i, j;
 Bytebpos p1, p2;
 Bytecount s1, s2;
 Bytebpos pos, lim;
 }
 else				/* non-RE case */
 {
 int charset_base = -1;
 int boyer_moore_ok = 1;
-Intbyte *pat = 0;
+Ibyte *pat = 0;
-Intbyte *patbuf = alloca_array (Intbyte, len * MAX_EMCHAR_LEN);
+Ibyte *patbuf = alloca_array (Ibyte, len * MAX_ICHAR_LEN);
 pat = patbuf;
 #ifdef MULE
 /* &&#### needs some 8-bit work here */
 while (len > 0)
 	{
-	  Intbyte tmp_str[MAX_EMCHAR_LEN];
+	  Ibyte tmp_str[MAX_ICHAR_LEN];
-	  Emchar c, translated, inverse;
+	  Ichar c, translated, inverse;
 	  Bytecount orig_bytelen, new_bytelen, inv_bytelen;
 	  /* 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++;
 	    }
-	  c = charptr_emchar (base_pat);
+	  c = itext_ichar (base_pat);
 	  translated = TRANSLATE (trt, c);
 	  inverse = TRANSLATE (inverse_trt, c);
-	  orig_bytelen = charptr_emchar_len (base_pat);
+	  orig_bytelen = itext_ichar_len (base_pat);
-	  inv_bytelen = set_charptr_emchar (tmp_str, inverse);
+	  inv_bytelen = set_itext_ichar (tmp_str, inverse);
-	  new_bytelen = set_charptr_emchar (tmp_str, translated);
+	  new_bytelen = set_itext_ichar (tmp_str, translated);
 	  if (new_bytelen != orig_bytelen || inv_bytelen != orig_bytelen)
 	    boyer_moore_ok = 0;
 	  if (translated != c || inverse != c)
 	    {
 	      /* Keep track of which character set row
 		 contains the characters that need translation.  */
-	      int charset_base_code = c & ~EMCHAR_FIELD3_MASK;
+	      int charset_base_code = c & ~ICHAR_FIELD3_MASK;
 	      if (charset_base == -1)
 		charset_base = charset_base_code;
 	      else if (charset_base != charset_base_code)
 		/* If two different rows appear, needing translation,
 		   then we cannot use boyer_moore search.  */
 This kind of search works regardless of what is in PAT and
 regardless of what is in TRT.  It is used in cases where
 boyer_moore cannot work.  */
 static Charbpos
-simple_search (struct buffer *buf, Intbyte *base_pat, Bytecount len,
+simple_search (struct buffer *buf, Ibyte *base_pat, Bytecount len,
 	       Bytebpos pos, Bytebpos lim, EMACS_INT n, Lisp_Object trt)
 {
 int forward = n > 0;
 Bytecount buf_len = 0; /* Shut up compiler. */
 {
 	while (1)
 	  {
 	    Bytecount this_len = len;
 	    Bytebpos this_pos = pos;
-	    Intbyte *p = base_pat;
+	    Ibyte *p = base_pat;
 	    if (pos >= lim)
 	      goto stop;
 	    while (this_len > 0)
 	      {
-		Emchar pat_ch, buf_ch;
+		Ichar pat_ch, buf_ch;
 		Bytecount pat_len;
-		pat_ch = charptr_emchar (p);
+		pat_ch = itext_ichar (p);
 		buf_ch = BYTE_BUF_FETCH_CHAR (buf, this_pos);
 		buf_ch = TRANSLATE (trt, buf_ch);
 		if (buf_ch != pat_ch)
 		  break;
-		pat_len = charptr_emchar_len (p);
+		pat_len = itext_ichar_len (p);
 		p += pat_len;
 		this_len -= pat_len;
 		INC_BYTEBPOS (buf, this_pos);
 	      }
 	    if (this_len == 0)
 {
 	while (1)
 	  {
 	    Bytecount this_len = len;
 	    Bytebpos this_pos = pos;
-	    Intbyte *p;
+	    Ibyte *p;
 	    if (pos <= lim)
 	      goto stop;
 	    p = base_pat + len;
 	    while (this_len > 0)
 	      {
-		Emchar pat_ch, buf_ch;
+		Ichar pat_ch, buf_ch;
-		DEC_CHARPTR (p);
+		DEC_IBYTEPTR (p);
 		DEC_BYTEBPOS (buf, this_pos);
-		pat_ch = charptr_emchar (p);
+		pat_ch = itext_ichar (p);
 		buf_ch = BYTE_BUF_FETCH_CHAR (buf, this_pos);
 		buf_ch = TRANSLATE (trt, buf_ch);
 		if (buf_ch != pat_ch)
 		  break;
-		this_len -= charptr_emchar_len (p);
+		this_len -= itext_ichar_len (p);
 	      }
 	    if (this_len == 0)
 	      {
 		buf_len = pos - this_pos;
 		pos = this_pos;
 and do so after just a simple test of the context.
 If that criterion is not satisfied, do not call this function.  */
 static Charbpos
-boyer_moore (struct buffer *buf, Intbyte *base_pat, Bytecount len,
+boyer_moore (struct buffer *buf, Ibyte *base_pat, Bytecount len,
 	     Bytebpos pos, Bytebpos lim, EMACS_INT n, Lisp_Object trt,
 	     Lisp_Object inverse_trt, int charset_base)
 {
 /* &&#### needs some 8-bit work here */
 /* #### Someone really really really needs to comment the workings
 REGISTER Bytecount dirlen;
 EMACS_INT infinity;
 Bytebpos limit;
 Bytecount stride_for_teases = 0;
 REGISTER EMACS_INT i, j;
-Intbyte *pat, *pat_end;
+Ibyte *pat, *pat_end;
-REGISTER Intbyte *cursor, *p_limit, *ptr2;
+REGISTER Ibyte *cursor, *p_limit, *ptr2;
-Intbyte simple_translate[0400];
+Ibyte simple_translate[0400];
 REGISTER int direction = ((n > 0) ? 1 : -1);
 #ifdef MULE
-Intbyte translate_prev_byte = 0;
+Ibyte translate_prev_byte = 0;
-Intbyte translate_anteprev_byte = 0;
+Ibyte translate_anteprev_byte = 0;
 #endif
 #ifdef C_ALLOCA
 EMACS_INT BM_tab_space[0400];
 BM_tab = &BM_tab_space[0];
 #else
 /* We use this for translation, instead of TRT itself.  We
 fill this in to handle the characters that actually occur
 in the pattern.  Others don't matter anyway!  */
 xzero (simple_translate);
 for (i = 0; i < 0400; i++)
-simple_translate[i] = (Intbyte) i;
+simple_translate[i] = (Ibyte) i;
 i = 0;
 while (i != infinity)
 {
-Intbyte *ptr = base_pat + i;
+Ibyte *ptr = base_pat + i;
 i += direction;
 if (i == dirlen)
 	i = infinity;
 if (!NILP (trt))
 	{
 #ifdef MULE
-	  Emchar ch, untranslated;
+	  Ichar ch, untranslated;
 	  int this_translated = 1;
 	  /* Is *PTR the last byte of a character?  */
-	  if (pat_end - ptr == 1 || intbyte_first_byte_p (ptr[1]))
+	  if (pat_end - ptr == 1 || ibyte_first_byte_p (ptr[1]))
 	    {
-	      Intbyte *charstart = ptr;
+	      Ibyte *charstart = ptr;
-	      while (!intbyte_first_byte_p (*charstart))
+	      while (!ibyte_first_byte_p (*charstart))
 		charstart--;
-	      untranslated = charptr_emchar (charstart);
+	      untranslated = itext_ichar (charstart);
-	      if (charset_base == (untranslated & ~EMCHAR_FIELD3_MASK))
+	      if (charset_base == (untranslated & ~ICHAR_FIELD3_MASK))
 		{
 		  ch = TRANSLATE (trt, untranslated);
-		  if (!intbyte_first_byte_p (*ptr))
+		  if (!ibyte_first_byte_p (*ptr))
 		    {
 		      translate_prev_byte = ptr[-1];
-		      if (!intbyte_first_byte_p (translate_prev_byte))
+		      if (!ibyte_first_byte_p (translate_prev_byte))
 			translate_anteprev_byte = ptr[-2];
 		    }
 		}
 	      else
 		{
 	  BM_tab[j] = dirlen - i;
 	  /* A translation table is accompanied by its inverse --
 	     see comment in casetab.c. */
 	  if (this_translated)
 	    {
-	      Emchar starting_ch = ch;
+	      Ichar starting_ch = ch;
 	      EMACS_INT starting_j = j;
 	      while (1)
 		{
 		  ch = TRANSLATE (inverse_trt, ch);
 		  if (ch > 0400)
 		    j = (unsigned char) ch;
 		  /* For all the characters that map into CH,
 		     set up simple_translate to map the last byte
 		     into STARTING_J.  */
-		  simple_translate[j] = (Intbyte) starting_j;
+		  simple_translate[j] = (Ibyte) starting_j;
 		  if (ch == starting_ch)
 		    break;
 		  BM_tab[j] = dirlen - i;
 		}
 	    }
 	  BM_tab[j] = dirlen - i;
 	  /* A translation table is accompanied by its inverse --
 	     see comment in casetab.c. */
 	  while ((j = TRANSLATE (inverse_trt, j)) != k)
 	    {
-	      simple_translate[j] = (Intbyte) k;
+	      simple_translate[j] = (Ibyte) k;
 	      BM_tab[j] = dirlen - i;
 	    }
 #endif
 	}
 else
 /* loop invariant - pos points at where last char (first char if
 reverse) of pattern would align in a possible match.  */
 while (n != 0)
 {
 Bytebpos tail_end;
-Intbyte *tail_end_ptr;
+Ibyte *tail_end_ptr;
 /* 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);
 	      if (!NILP (trt))
 		{
 		  while ((i -= direction) + direction != 0)
 		    {
 #ifdef MULE
-		      Emchar ch;
+		      Ichar ch;
 		      cursor -= direction;
 		      /* Translate only the last byte of a character.  */
 		      if ((cursor == tail_end_ptr
-			   || intbyte_first_byte_p (cursor[1]))
+			   || ibyte_first_byte_p (cursor[1]))
-			  && (intbyte_first_byte_p (cursor[0])
+			  && (ibyte_first_byte_p (cursor[0])
 			      || (translate_prev_byte == cursor[-1]
-				  && (intbyte_first_byte_p (translate_prev_byte)
+				  && (ibyte_first_byte_p (translate_prev_byte)
 				      || translate_anteprev_byte == cursor[-2]))))
 			ch = simple_translate[*cursor];
 		      else
 			ch = *cursor;
 		      if (pat[i] != ch)
 	      pos -= infinity;
 	      i = dirlen - direction;
 	      while ((i -= direction) + direction != 0)
 		{
 #ifdef MULE
-		  Emchar ch;
+		  Ichar ch;
-		  Intbyte *ptr;
+		  Ibyte *ptr;
 #endif
 		  pos -= direction;
 #ifdef MULE
 		  ptr = BYTE_BUF_BYTE_ADDRESS_NO_VERIFY (buf, pos);
 		  if ((ptr == tail_end_ptr
-		       || intbyte_first_byte_p (ptr[1]))
+		       || ibyte_first_byte_p (ptr[1]))
-		      && (intbyte_first_byte_p (ptr[0])
+		      && (ibyte_first_byte_p (ptr[0])
 			  || (translate_prev_byte == ptr[-1]
-			      && (intbyte_first_byte_p (translate_prev_byte)
+			      && (ibyte_first_byte_p (translate_prev_byte)
 				  || translate_anteprev_byte == ptr[-2]))))
 		    ch = simple_translate[*ptr];
 		  else
 		    ch = *ptr;
 		  if (pat[i] != ch)
 CHECK_STRING (string);
 len = string_char_length (string);
 for (i = 0; i < len; i++)
-if (!WORD_SYNTAX_P (syntax_table, string_emchar (string, i)))
+if (!WORD_SYNTAX_P (syntax_table, string_ichar (string, i)))
 {
 	punct_count++;
 	if (i > 0 && WORD_SYNTAX_P (syntax_table,
-				    string_emchar (string, i - 1)))
+				    string_ichar (string, i - 1)))
 word_count++;
 }
-if (WORD_SYNTAX_P (syntax_table, string_emchar (string, len - 1)))
+if (WORD_SYNTAX_P (syntax_table, string_ichar (string, len - 1)))
 word_count++;
 if (!word_count) return build_string ("");
 {
 /* The following value is an upper bound on the amount of storage we
 need.  In non-Mule, it is exact. */
-Intbyte *storage =
+Ibyte *storage =
-(Intbyte *) ALLOCA (XSTRING_LENGTH (string) - punct_count +
+(Ibyte *) ALLOCA (XSTRING_LENGTH (string) - punct_count +
 5 * (word_count - 1) + 4);
-Intbyte *o = storage;
+Ibyte *o = storage;
 *o++ = '\\';
 *o++ = 'b';
 for (i = 0; i < len; i++)
 {
-	Emchar ch = string_emchar (string, i);
+	Ichar ch = string_ichar (string, i);
 	if (WORD_SYNTAX_P (syntax_table, ch))
-	  o += set_charptr_emchar (o, ch);
+	  o += set_itext_ichar (o, ch);
 	else if (i > 0
 		 && WORD_SYNTAX_P (syntax_table,
-				   string_emchar (string, i - 1))
+				   string_ichar (string, i - 1))
 		 && --word_count)
 	  {
 	    *o++ = '\\';
 	    *o++ = 'W';
 	    *o++ = '\\';
 Charbpos pos, last;
 int some_multiletter_word;
 int some_lowercase;
 int some_uppercase;
 int some_nonuppercase_initial;
-Emchar c, prevc;
+Ichar c, prevc;
 Charcount inslen;
 struct buffer *buf;
 Lisp_Object syntax_table;
 int mc_count;
 Lisp_Object buffer;
 for (pos = search_regs.start[sub]; pos < last; pos++)
 	{
 	  if (NILP (string))
 	    c = BUF_FETCH_CHAR (buf, pos);
 	  else
-	    c = string_emchar (string, pos);
+	    c = string_ichar (string, pos);
 	  if (LOWERCASEP (buf, c))
 	    {
 	      /* Cannot be all caps if any original char is lower case */
 	      /* If SUBSTART is set, we need to also insert the
 		 text from SUBSTART to SUBEND in the original string. */
 	      Charcount substart = -1;
 	      Charcount subend   = -1;
-	      c = string_emchar (replacement, strpos);
+	      c = string_ichar (replacement, strpos);
 	      if (c == '\\' && strpos < stlen - 1)
 		{
-		  c = string_emchar (replacement, ++strpos);
+		  c = string_ichar (replacement, ++strpos);
 		  if (c == '&')
 		    {
 		      literal_end = strpos - 1;
 		      substart = search_regs.start[0];
 		      subend = search_regs.end[0];
 	  Charcount stlen = string_char_length (replacement);
 	  Charcount strpos;
 	  for (strpos = 0; strpos < stlen; strpos++)
 	    {
-	      Emchar curchar = string_emchar (replacement, strpos);
+	      Ichar curchar = string_ichar (replacement, strpos);
-	      Emchar newchar = -1;
+	      Ichar newchar = -1;
 	      if (i < Dynarr_length (ul_pos_dynarr) &&
 		  strpos == Dynarr_at (ul_pos_dynarr, i))
 		{
 		  int new_action = Dynarr_at (ul_action_dynarr, i);
 		  i++;
 	     exactly complementing BUF_SET_PT() above.
 	     During the loop, it keeps track of the amount inserted.
 	   */
 	  Charcount offset = BUF_PT (buf) - search_regs.start[sub];
-	  c = string_emchar (replacement, strpos);
+	  c = string_ichar (replacement, strpos);
 	  if (c == '\\' && strpos < stlen - 1)
 	    {
 	      /* XXX FIXME: replacing just a substring non-literally
 		 using backslash refs to the match looks dangerous.  But
 		 <15366.18513.698042.156573@ns.caldera.de> from Torsten Duwe
 		 <duwe@caldera.de> claims Finsert_buffer_substring already
 		 handles this correctly.
 	      */
-	      c = string_emchar (replacement, ++strpos);
+	      c = string_ichar (replacement, ++strpos);
 	      if (c == '&')
 		Finsert_buffer_substring
 (buffer,
 make_int (search_regs.start[0] + offset),
 make_int (search_regs.end[0] + offset));
 int i = 0;
 int cur_action = 'E';
 for (pos = BUF_PT (buf) - inslen; pos < eend; pos++)
 	{
-	  Emchar curchar = BUF_FETCH_CHAR (buf, pos);
+	  Ichar curchar = BUF_FETCH_CHAR (buf, pos);
-	  Emchar newchar = -1;
+	  Ichar newchar = -1;
 	  if (i < Dynarr_length (ul_pos_dynarr) &&
 	      pos == Dynarr_at (ul_pos_dynarr, i))
 	    {
 	      int new_action = Dynarr_at (ul_action_dynarr, i);
 	      i++;
 DEFUN ("regexp-quote", Fregexp_quote, 1, 1, 0, /*
 Return a regexp string which matches exactly STRING and nothing else.
 */
 (string))
 {
-REGISTER Intbyte *in, *out, *end;
+REGISTER Ibyte *in, *out, *end;
-REGISTER Intbyte *temp;
+REGISTER Ibyte *temp;
 CHECK_STRING (string);
-temp = (Intbyte *) ALLOCA (XSTRING_LENGTH (string) * 2);
+temp = (Ibyte *) ALLOCA (XSTRING_LENGTH (string) * 2);
 /* Now copy the data into the new string, inserting escapes. */
 in = XSTRING_DATA (string);
 end = in + XSTRING_LENGTH (string);
 out = temp;
 while (in < end)
 {
-Emchar c = charptr_emchar (in);
+Ichar c = itext_ichar (in);
 if (c == '[' || c == ']'
 	  || c == '*' || c == '.' || c == '\\'
 	  || c == '?' || c == '+'
 	  || c == '^' || c == '$')
 	*out++ = '\\';
-out += set_charptr_emchar (out, c);
+out += set_itext_ichar (out, c);
-INC_CHARPTR (in);
+INC_IBYTEPTR (in);
 }
 return make_string (temp, out - temp);
 }

Mercurial > hg > xemacs-beta

comparison src/search.c @ 867:804517e16990