#include <config.h>
+#ifdef STDC_HEADERS
+#include <stdlib.h>
+#endif
#include "lisp.h"
#include "syntax.h"
#include "category.h"
#include <sys/types.h>
#include "regex.h"
+#define min(a, b) ((a) < (b) ? (a) : (b))
+#define max(a, b) ((a) > (b) ? (a) : (b))
+
#define REGEXP_CACHE_SIZE 20
/* If the regexp is non-nil, then the buffer contains the compiled form
if (multibyte == STRING_MULTIBYTE (pattern))
{
raw_pattern = (char *) XSTRING (pattern)->data;
- raw_pattern_size = XSTRING (pattern)->size_byte;
+ raw_pattern_size = STRING_BYTES (XSTRING (pattern));
}
else if (multibyte)
{
raw_pattern_size = XSTRING (pattern)->size;
raw_pattern = (char *) alloca (raw_pattern_size + 1);
copy_text (XSTRING (pattern)->data, raw_pattern,
- XSTRING (pattern)->size_byte, 1, 0);
+ STRING_BYTES (XSTRING (pattern)), 1, 0);
}
cp->regexp = Qnil;
- cp->buf.translate = (! NILP (translate) ? translate : 0);
+ cp->buf.translate = (! NILP (translate) ? translate : make_number (0));
cp->posix = posix;
cp->buf.multibyte = multibyte;
BLOCK_INPUT;
cp = *cpp;
if (XSTRING (cp->regexp)->size == XSTRING (pattern)->size
&& !NILP (Fstring_equal (cp->regexp, pattern))
- && cp->buf.translate == (! NILP (translate) ? translate : 0)
+ && EQ (cp->buf.translate, (! NILP (translate) ? translate : make_number (0)))
&& cp->posix == posix
&& cp->buf.multibyte == multibyte)
break;
re_match_object = string;
val = re_search (bufp, (char *) XSTRING (string)->data,
- XSTRING (string)->size_byte, pos_byte,
- XSTRING (string)->size_byte - pos_byte,
+ STRING_BYTES (XSTRING (string)), pos_byte,
+ STRING_BYTES (XSTRING (string)) - pos_byte,
&search_regs);
immediate_quit = 0;
last_thing_searched = Qt;
re_match_object = string;
val = re_search (bufp, (char *) XSTRING (string)->data,
- XSTRING (string)->size_byte, 0, XSTRING (string)->size_byte,
- 0);
+ STRING_BYTES (XSTRING (string)), 0,
+ STRING_BYTES (XSTRING (string)), 0);
immediate_quit = 0;
return val;
}
return val;
}
\f
-/* 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);
-}
-
-\f
/* The newline cache: remembering which sections of text have no newlines. */
/* If the user has requested newline caching, make sure it's on.
If ALLOW_QUIT is non-zero, set immediate_quit. That's good to do
except when inside redisplay. */
+int
scan_buffer (target, start, end, count, shortage, allow_quit)
register int target;
int start, end;
examine. */
int ceiling_byte = CHAR_TO_BYTE (end) - 1;
int start_byte = CHAR_TO_BYTE (start);
+ int tem;
/* If we're looking for a newline, consult the newline cache
to see where we can avoid some scanning. */
bytes. BUFFER_CEILING_OF returns the last character
position that is contiguous, so the ceiling is the
position after that. */
- ceiling_byte = min (BUFFER_CEILING_OF (start_byte), ceiling_byte);
+ tem = BUFFER_CEILING_OF (start_byte);
+ ceiling_byte = min (tem, ceiling_byte);
{
/* The termination address of the dumb loop. */
/* The last character to check before the next obstacle. */
int ceiling_byte = CHAR_TO_BYTE (end);
int start_byte = CHAR_TO_BYTE (start);
+ int tem;
/* Consult the newline cache, if appropriate. */
if (target == '\n' && newline_cache)
}
/* Stop scanning before the gap. */
- ceiling_byte = max (BUFFER_FLOOR_OF (start_byte - 1), ceiling_byte);
+ tem = BUFFER_FLOOR_OF (start_byte - 1);
+ ceiling_byte = max (tem, ceiling_byte);
{
/* The termination address of the dumb loop. */
}
else
{
- int start_byte = CHAR_TO_BYTE (start);
while (start_byte > limit_byte)
{
ceiling = BUFFER_FLOOR_OF (start_byte - 1);
trivial_regexp_p (regexp)
Lisp_Object regexp;
{
- int len = XSTRING (regexp)->size_byte;
+ int len = STRING_BYTES (XSTRING (regexp));
unsigned char *s = XSTRING (regexp)->data;
unsigned char c;
while (--len >= 0)
int posix;
{
int len = XSTRING (string)->size;
- int len_byte = XSTRING (string)->size_byte;
+ int len_byte = STRING_BYTES (XSTRING (string));
register int i;
if (running_asynch_code)
}
if (val >= 0)
{
+ pos_byte = search_regs.start[0] + BEGV_BYTE;
for (i = 0; i < search_regs.num_regs; i++)
if (search_regs.start[i] >= 0)
{
}
if (val >= 0)
{
+ pos_byte = search_regs.end[0] + BEGV_BYTE;
for (i = 0; i < search_regs.num_regs; i++)
if (search_regs.start[i] >= 0)
{
{
raw_pattern = (char *) XSTRING (string)->data;
raw_pattern_size = XSTRING (string)->size;
- raw_pattern_size_byte = XSTRING (string)->size_byte;
+ raw_pattern_size_byte = STRING_BYTES (XSTRING (string));
}
else if (multibyte)
{
raw_pattern_size_byte = XSTRING (string)->size;
raw_pattern = (char *) alloca (raw_pattern_size + 1);
copy_text (XSTRING (string)->data, raw_pattern,
- XSTRING (string)->size_byte, 1, 0);
+ STRING_BYTES (XSTRING (string)), 1, 0);
}
/* Copy and optionally translate the pattern. */
int lim, lim_byte;
{
int multibyte = ! NILP (current_buffer->enable_multibyte_characters);
+ int forward = n > 0;
if (lim > pos && multibyte)
while (n > 0)
while (this_len > 0)
{
int charlen, buf_charlen;
- int pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen);
- int buf_ch;
-
- this_len_byte -= charlen;
- this_len--;
- p += charlen;
+ int pat_ch, buf_ch;
+ pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen);
buf_ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte),
ZV_BYTE - this_pos_byte,
buf_charlen);
- this_pos_byte += buf_charlen;
- this_pos++;
TRANSLATE (buf_ch, trt, buf_ch);
if (buf_ch != pat_ch)
break;
+
+ this_len_byte -= charlen;
+ this_len--;
+ p += charlen;
+
+ this_pos_byte += buf_charlen;
+ this_pos++;
}
if (this_len == 0)
{
int pat_ch = *p++;
int buf_ch = FETCH_BYTE (this_pos);
- this_len--;
- this_pos++;
TRANSLATE (buf_ch, trt, buf_ch);
if (buf_ch != pat_ch)
break;
+
+ this_len--;
+ this_pos++;
}
if (this_len == 0)
while (this_len > 0)
{
int charlen, buf_charlen;
- int pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen);
- int buf_ch;
-
- this_len_byte -= charlen;
- this_len--;
- p += charlen;
+ int pat_ch, buf_ch;
+ pat_ch = STRING_CHAR_AND_LENGTH (p, this_len_byte, charlen);
buf_ch = STRING_CHAR_AND_LENGTH (BYTE_POS_ADDR (this_pos_byte),
ZV_BYTE - this_pos_byte,
buf_charlen);
- this_pos_byte += buf_charlen;
- this_pos++;
TRANSLATE (buf_ch, trt, buf_ch);
if (buf_ch != pat_ch)
break;
+
+ this_len_byte -= charlen;
+ this_len--;
+ p += charlen;
+ this_pos_byte += buf_charlen;
+ this_pos++;
}
if (this_len == 0)
{
int pat_ch = *p++;
int buf_ch = FETCH_BYTE (this_pos);
- this_len--;
- this_pos++;
TRANSLATE (buf_ch, trt, buf_ch);
if (buf_ch != pat_ch)
break;
+ this_len--;
+ this_pos++;
}
if (this_len == 0)
stop:
if (n == 0)
{
- set_search_regs (multibyte ? pos_byte : pos, len_byte);
+ if (forward)
+ set_search_regs ((multibyte ? pos_byte : pos) - len_byte, len_byte);
+ else
+ set_search_regs (multibyte ? pos_byte : pos, len_byte);
return pos;
}
while (! CHAR_HEAD_P (*charstart))
charstart--;
untranslated = STRING_CHAR (charstart, ptr - charstart + 1);
- TRANSLATE (ch, trt, untranslated);
- if (charset_base == (ch & ~0xff))
+ if (charset_base == (untranslated & ~0xff))
{
+ TRANSLATE (ch, trt, untranslated);
if (! CHAR_HEAD_P (*ptr))
{
translate_prev_byte = ptr[-1];
}
}
else
- this_translated = 0;
+ {
+ this_translated = 0;
+ ch = *ptr;
+ }
}
else if (!multibyte)
TRANSLATE (ch, trt, *ptr);
this_translated = 0;
}
- k = j = (unsigned char) ch;
+ if (ch > 0400)
+ j = ((unsigned char) ch) | 0200;
+ else
+ j = (unsigned char) ch;
+
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 */
if (this_translated)
- while (1)
- {
- TRANSLATE (ch, inverse_trt, ch);
- /* For all the characters that map into K,
- set up simple_translate to map them into K. */
- simple_translate[(unsigned char) ch] = k;
- if ((unsigned char) ch == k)
- break;
- BM_tab[(unsigned char) ch] = dirlen - i;
- }
+ {
+ int starting_ch = ch;
+ int starting_j = j;
+ while (1)
+ {
+ TRANSLATE (ch, inverse_trt, ch);
+ if (ch > 0400)
+ j = ((unsigned char) ch) | 0200;
+ else
+ 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] = starting_j;
+ if (ch == starting_ch)
+ break;
+ BM_tab[j] = dirlen - i;
+ }
+ }
}
else
{
QUIT;
pat = base_pat;
limit = pos_byte - dirlen + direction;
- limit = ((direction > 0)
- ? BUFFER_CEILING_OF (limit)
- : BUFFER_FLOOR_OF (limit));
- /* LIMIT is now the last (not beyond-last!) value POS_BYTE
- can take on without hitting edge of buffer or the gap. */
- limit = ((direction > 0)
- ? min (lim_byte - 1, min (limit, pos_byte + 20000))
- : max (lim_byte, max (limit, pos_byte - 20000)));
+ if (direction > 0)
+ {
+ limit = BUFFER_CEILING_OF (limit);
+ /* LIMIT is now the last (not beyond-last!) value POS_BYTE
+ can take on without hitting edge of buffer or the gap. */
+ limit = min (limit, pos_byte + 20000);
+ limit = min (limit, lim_byte - 1);
+ }
+ else
+ {
+ limit = BUFFER_FLOOR_OF (limit);
+ /* LIMIT is now the last (not beyond-last!) value POS_BYTE
+ can take on without hitting edge of buffer or the gap. */
+ limit = max (limit, pos_byte - 20000);
+ limit = max (limit, lim_byte);
+ }
tail_end = BUFFER_CEILING_OF (pos_byte) + 1;
tail_end_ptr = BYTE_POS_ADDR (tail_end);
adjust = - punct_count + 5 * (word_count - 1) + 4;
val = make_uninit_multibyte_string (len + adjust,
- XSTRING (string)->size_byte + adjust);
+ STRING_BYTES (XSTRING (string)) + adjust);
o = XSTRING (val)->data;
*o++ = '\\';
*o++ = 'b';
- for (i = 0; i < XSTRING (val)->size_byte; i++)
+ for (i = 0; i < STRING_BYTES (XSTRING (val)); i++)
if (SYNTAX (p[i]) == Sword)
*o++ = p[i];
else if (i > 0 && SYNTAX (p[i-1]) == Sword && --word_count)
accum = Qnil;
- for (pos_byte = 0, pos = 0; pos_byte < XSTRING (newtext)->size_byte;)
+ for (pos_byte = 0, pos = 0; pos_byte < STRING_BYTES (XSTRING (newtext));)
{
int substart = -1;
int subend;
}
-DEFUN ("store-match-data", Fstore_match_data, Sstore_match_data, 1, 1, 0,
+DEFUN ("set-match-data", Fset_match_data, Sset_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)
CHECK_STRING (string, 0);
- temp = (unsigned char *) alloca (XSTRING (string)->size_byte * 2);
+ temp = (unsigned char *) alloca (STRING_BYTES (XSTRING (string)) * 2);
/* Now copy the data into the new string, inserting escapes. */
in = XSTRING (string)->data;
- end = in + XSTRING (string)->size_byte;
+ end = in + STRING_BYTES (XSTRING (string));
out = temp;
for (; in != end; in++)
*out++ = *in;
}
- return make_multibyte_string (temp,
+ return make_specified_string (temp,
XSTRING (string)->size + backslashes_added,
- out - temp);
+ out - temp,
+ STRING_MULTIBYTE (string));
}
\f
+void
syms_of_search ()
{
register int i;
defsubr (&Smatch_beginning);
defsubr (&Smatch_end);
defsubr (&Smatch_data);
- defsubr (&Sstore_match_data);
+ defsubr (&Sset_match_data);
defsubr (&Sregexp_quote);
}
HCoop / bpt / emacs.git / blobdiff