while (boyer_moore_ok)
{
- if (ASCII_BYTE_P (inverse))
+ if (ASCII_CHAR_P (inverse))
{
if (this_char_base > 0)
boyer_moore_ok = 0;
matching with CHAR_BASE are to be checked. */
int ch = -1;
- if (ASCII_BYTE_P (*ptr) || ! multibyte)
+ if (ASCII_CHAR_P (*ptr) || ! multibyte)
ch = *ptr;
else if (char_base
&& ((pat_end - ptr) == 1 || CHAR_HEAD_P (ptr[1])))
substed_alloc_size = (length <= (STRING_BYTES_BOUND - 100) / 2
? length * 2 + 100
: STRING_BYTES_BOUND);
- substed = xmalloc (substed_alloc_size);
+ substed = xmalloc_atomic (substed_alloc_size);
substed_len = 0;
/* Go thru NEWTEXT, producing the actual text to insert in
{
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext, pos, pos_byte);
if (!buf_multibyte)
- c = multibyte_char_to_unibyte (c);
+ c = CHAR_TO_BYTE8 (c);
}
else
{
FETCH_STRING_CHAR_ADVANCE_NO_CHECK (c, newtext,
pos, pos_byte);
if (!buf_multibyte && !ASCII_CHAR_P (c))
- c = multibyte_char_to_unibyte (c);
+ c = CHAR_TO_BYTE8 (c);
}
else
{
}
if (really_changed)
- {
- if (buf_multibyte)
- {
- ptrdiff_t nchars =
- multibyte_chars_in_text (substed, substed_len);
-
- newtext = make_multibyte_string ((char *) substed, nchars,
- substed_len);
- }
- else
- newtext = make_unibyte_string ((char *) substed, substed_len);
- }
+ newtext = make_specified_string ((const char *) substed, -1,
+ substed_len, buf_multibyte);
xfree (substed);
}
the buffer. If the buffer doesn't have a cache, the value is nil. */)
(Lisp_Object buffer)
{
- struct buffer *buf;
- struct region_cache *nlcache;
+ struct buffer *buf, *old = NULL;
ptrdiff_t shortage, nl_count_cache, nl_count_buf;
Lisp_Object cache_newlines, buf_newlines, val;
- ptrdiff_t from, from_byte, found, i;
+ ptrdiff_t from, found, i;
if (NILP (buffer))
buf = current_buffer;
{
CHECK_BUFFER (buffer);
buf = XBUFFER (buffer);
+ old = current_buffer;
}
if (buf->base_buffer)
buf = buf->base_buffer;
|| buf->newline_cache == NULL)
return Qnil;
+ /* find_newline can only work on the current buffer. */
+ if (old != NULL)
+ set_buffer_internal_1 (buf);
+
/* How many newlines are there according to the cache? */
- find_newline (BUF_BEG (buf), BUF_BEG_BYTE (buf),
- BUF_Z (buf), BUF_Z_BYTE (buf),
+ find_newline (BEGV, BEGV_BYTE, ZV, ZV_BYTE,
TYPE_MAXIMUM (ptrdiff_t), &shortage, NULL, true);
nl_count_cache = TYPE_MAXIMUM (ptrdiff_t) - shortage;
/* Create vector and populate it. */
cache_newlines = make_uninit_vector (nl_count_cache);
- for (from = BUF_BEG( buf), found = from, i = 0;
- from < BUF_Z (buf);
- from = found, i++)
+
+ if (nl_count_cache)
{
- ptrdiff_t from_byte = CHAR_TO_BYTE (from);
+ for (from = BEGV, found = from, i = 0; from < ZV; from = found, i++)
+ {
+ ptrdiff_t from_byte = CHAR_TO_BYTE (from);
- found = find_newline (from, from_byte, 0, -1, 1, &shortage, NULL, true);
- if (shortage == 0)
- ASET (cache_newlines, i, make_number (found - 1));
+ found = find_newline (from, from_byte, 0, -1, 1, &shortage,
+ NULL, true);
+ if (shortage != 0 || i >= nl_count_cache)
+ break;
+ ASET (cache_newlines, i, make_number (found - 1));
+ }
+ /* Fill the rest of slots with an invalid position. */
+ for ( ; i < nl_count_cache; i++)
+ ASET (cache_newlines, i, make_number (-1));
}
/* Now do the same, but without using the cache. */
- find_newline1 (BUF_BEG (buf), BUF_BEG_BYTE (buf),
- BUF_Z (buf), BUF_Z_BYTE (buf),
+ find_newline1 (BEGV, BEGV_BYTE, ZV, ZV_BYTE,
TYPE_MAXIMUM (ptrdiff_t), &shortage, NULL, true);
nl_count_buf = TYPE_MAXIMUM (ptrdiff_t) - shortage;
buf_newlines = make_uninit_vector (nl_count_buf);
- for (from = BUF_BEG( buf), found = from, i = 0;
- from < BUF_Z (buf);
- from = found, i++)
+ if (nl_count_buf)
{
- ptrdiff_t from_byte = CHAR_TO_BYTE (from);
+ for (from = BEGV, found = from, i = 0; from < ZV; from = found, i++)
+ {
+ ptrdiff_t from_byte = CHAR_TO_BYTE (from);
- found = find_newline1 (from, from_byte, 0, -1, 1, &shortage, NULL, true);
- if (shortage == 0)
- ASET (buf_newlines, i, make_number (found - 1));
+ found = find_newline1 (from, from_byte, 0, -1, 1, &shortage,
+ NULL, true);
+ if (shortage != 0 || i >= nl_count_buf)
+ break;
+ ASET (buf_newlines, i, make_number (found - 1));
+ }
+ for ( ; i < nl_count_buf; i++)
+ ASET (buf_newlines, i, make_number (-1));
}
/* Construct the value and return it. */
val = make_uninit_vector (2);
ASET (val, 0, cache_newlines);
ASET (val, 1, buf_newlines);
+
+ if (old != NULL)
+ set_buffer_internal_1 (old);
return val;
}
\f
void
syms_of_search (void)
{
+#include "search.x"
+
register int i;
for (i = 0; i < REGEXP_CACHE_SIZE; ++i)
{
searchbufs[i].buf.allocated = 100;
- searchbufs[i].buf.buffer = xmalloc (100);
+ searchbufs[i].buf.buffer = xmalloc_atomic (100);
searchbufs[i].buf.fastmap = searchbufs[i].fastmap;
searchbufs[i].regexp = Qnil;
searchbufs[i].whitespace_regexp = Qnil;
do not set the match data. The proper way to use this variable
is to bind it with `let' around a small expression. */);
Vinhibit_changing_match_data = Qnil;
-
- defsubr (&Slooking_at);
- defsubr (&Sposix_looking_at);
- defsubr (&Sstring_match);
- defsubr (&Sposix_string_match);
- defsubr (&Ssearch_forward);
- defsubr (&Ssearch_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 (&Sset_match_data);
- defsubr (&Sregexp_quote);
- defsubr (&Snewline_cache_check);
}
HCoop / bpt / emacs.git / blobdiff