adjust_markers (struct buffer *buf, Memind from, Memind to,
Bytecount amount)
{
- Lisp_Marker *m;
+ struct Lisp_Marker *m;
for (m = BUF_MARKERS (buf); m; m = marker_next (m))
m->memind = do_marker_adjustment (m->memind, from, to, amount);
static void
adjust_markers_for_insert (struct buffer *buf, Memind ind, Bytecount amount)
{
- Lisp_Marker *m;
+ struct Lisp_Marker *m;
for (m = BUF_MARKERS (buf); m; m = marker_next (m))
{
/* Routines for dealing with the gap */
/************************************************************************/
+/* XEmacs requires an ANSI C compiler, and it damn well better have a
+ working memmove() */
+#define GAP_USE_BCOPY
+#ifdef BCOPY_UPWARD_SAFE
+# undef BCOPY_UPWARD_SAFE
+#endif
+#ifdef BCOPY_DOWNWARD_SAFE
+# undef BCOPY_DOWNWARD_SAFE
+#endif
+#define BCOPY_UPWARD_SAFE 1
+#define BCOPY_DOWNWARD_SAFE 1
+
/* maximum amount of memory moved in a single chunk. Increasing this
value improves gap-motion efficiency but decreases QUIT responsiveness
time. Was 32000 but today's processors are faster and files are
Bufbyte *to, *from;
Bytecount i;
Bytind new_s1;
- struct buffer *mbuf;
- Lisp_Object bufcons;
from = BUF_GPT_ADDR (buf);
to = from + BUF_GAP_SIZE (buf);
/* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
if (i > GAP_MOVE_CHUNK)
i = GAP_MOVE_CHUNK;
-
- if (i >= 128)
+#ifdef GAP_USE_BCOPY
+ if (i >= 128
+ /* bcopy is safe if the two areas of memory do not overlap
+ or on systems where bcopy is always safe for moving upward. */
+ && (BCOPY_UPWARD_SAFE
+ || to - from >= 128))
{
+ /* If overlap is not safe, avoid it by not moving too many
+ characters at once. */
+ if (!BCOPY_UPWARD_SAFE && i > to - from)
+ i = to - from;
new_s1 -= i;
- from -= i;
- to -= i;
+ from -= i, to -= i;
memmove (to, from, i);
}
else
+#endif
{
new_s1 -= i;
while (--i >= 0)
/* Adjust markers, and buffer data structure, to put the gap at POS.
POS is where the loop above stopped, which may be what was specified
or may be where a quit was detected. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_markers (mbuf, pos, BI_BUF_GPT (mbuf), BUF_GAP_SIZE (mbuf));
- }
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_extents (make_buffer (mbuf), pos, BI_BUF_GPT (mbuf),
- BUF_GAP_SIZE (mbuf));
- }
+ adjust_markers (buf, pos, BI_BUF_GPT (buf), BUF_GAP_SIZE (buf));
+ adjust_extents (make_buffer (buf), pos, BI_BUF_GPT (buf),
+ BUF_GAP_SIZE (buf));
SET_BI_BUF_GPT (buf, pos);
SET_GAP_SENTINEL (buf);
#ifdef ERROR_CHECK_EXTENTS
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- sledgehammer_extent_check (make_buffer (mbuf));
- }
+ sledgehammer_extent_check (make_buffer (buf));
#endif
QUIT;
}
Bufbyte *to, *from;
Bytecount i;
Bytind new_s1;
- struct buffer *mbuf;
- Lisp_Object bufcons;
to = BUF_GPT_ADDR (buf);
from = to + BUF_GAP_SIZE (buf);
/* Move at most GAP_MOVE_CHUNK chars before checking again for a quit. */
if (i > GAP_MOVE_CHUNK)
i = GAP_MOVE_CHUNK;
-
- if (i >= 128)
+#ifdef GAP_USE_BCOPY
+ if (i >= 128
+ /* bcopy is safe if the two areas of memory do not overlap
+ or on systems where bcopy is always safe for moving downward. */
+ && (BCOPY_DOWNWARD_SAFE
+ || from - to >= 128))
{
+ /* If overlap is not safe, avoid it by not moving too many
+ characters at once. */
+ if (!BCOPY_DOWNWARD_SAFE && i > from - to)
+ i = from - to;
new_s1 += i;
memmove (to, from, i);
- from += i;
- to += i;
+ from += i, to += i;
}
else
+#endif
{
new_s1 += i;
while (--i >= 0)
{
int gsize = BUF_GAP_SIZE (buf);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_markers (mbuf, BI_BUF_GPT (mbuf) + gsize, pos + gsize, - gsize);
- }
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_extents (make_buffer (mbuf), BI_BUF_GPT (mbuf) + gsize,
- pos + gsize, - gsize);
- }
+ adjust_markers (buf, BI_BUF_GPT (buf) + gsize, pos + gsize, - gsize);
+ adjust_extents (make_buffer (buf), BI_BUF_GPT (buf) + gsize, pos + gsize,
+ - gsize);
SET_BI_BUF_GPT (buf, pos);
SET_GAP_SENTINEL (buf);
#ifdef ERROR_CHECK_EXTENTS
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- sledgehammer_extent_check (make_buffer (mbuf));
- }
+ sledgehammer_extent_check (make_buffer (buf));
#endif
}
if (pos == BI_BUF_Z (buf))
Bytecount old_gap_size;
/* If we have to get more space, get enough to last a while. We use
- a geometric progression that saves on realloc space. */
+ a geometric progession that saves on realloc space. */
increment += 2000 + ((BI_BUF_Z (buf) - BI_BUF_BEG (buf)) / 8);
if (increment > BUF_END_GAP_SIZE (buf))
of the specified region, that will also be handled correctly.
begin_multiple_change() returns a number (actually a specpdl depth)
- that you must pass to end_multiple_change() when you are done.
-
- FSF Emacs 20 implements a similar feature, accessible from Lisp
- through a `combine-after-change-calls' special form, which is
- essentially equivalent to this function. We should consider
- whether we want to introduce a similar Lisp form. */
+ that you must pass to end_multiple_change() when you are done. */
int
begin_multiple_change (struct buffer *buf, Bufpos start, Bufpos end)
static Lisp_Object
change_function_restore (Lisp_Object buffer)
{
- /* We should first reset the variable and then change the buffer,
- because Fset_buffer() can throw. */
+ Fset_buffer (buffer);
inside_change_hook = 0;
- if (XBUFFER (buffer) != current_buffer)
- Fset_buffer (buffer);
return Qnil;
}
static Lisp_Object
first_change_hook_restore (Lisp_Object buffer)
{
- in_first_change = 0;
Fset_buffer (buffer);
+ in_first_change = 0;
return Qnil;
}
if (!in_first_change)
{
- if (!NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
+ if (!preparing_for_armageddon &&
+ !NILP (symbol_value_in_buffer (Qfirst_change_hook, buffer)))
{
int speccount = specpdl_depth ();
record_unwind_protect (first_change_hook_restore, buffer);
signal_before_change (struct buffer *buf, Bufpos start, Bufpos end)
{
/* This function can GC */
- struct buffer *mbuf;
- Lisp_Object bufcons;
+ Lisp_Object buffer;
+ XSETBUFFER (buffer, buf);
if (!inside_change_hook)
{
- Lisp_Object buffer;
- int speccount;
-
/* Are we in a multiple-change session? */
if (buf->text->changes->in_multiple_change &&
buf->text->changes->mc_begin != 0)
/* If buffer is unmodified, run a special hook for that case. */
if (BUF_SAVE_MODIFF (buf) >= BUF_MODIFF (buf))
- {
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- signal_first_change (mbuf);
- }
- }
+ signal_first_change (buf);
/* Now in any case run the before-change-functions if any. */
- speccount = specpdl_depth ();
- record_unwind_protect (change_function_restore, Fcurrent_buffer ());
- inside_change_hook = 1;
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ if (!preparing_for_armageddon &&
+ (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer)) ||
+ /* Obsolete, for compatibility */
+ !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer))))
{
- XSETBUFFER (buffer, mbuf);
- if (!NILP (symbol_value_in_buffer (Qbefore_change_functions, buffer))
- /* Obsolete, for compatibility */
- || !NILP (symbol_value_in_buffer (Qbefore_change_function, buffer)))
- {
- set_buffer_internal (buf);
- va_run_hook_with_args (Qbefore_change_functions, 2,
- make_int (start), make_int (end));
- /* Obsolete, for compatibility */
- va_run_hook_with_args (Qbefore_change_function, 2,
- make_int (start), make_int (end));
- }
- }
-
- /* Make sure endpoints remain valid. before-change-functions
- might have modified the buffer. */
- if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
- if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
- if (end < BUF_BEGV (buf)) end = BUF_BEGV (buf);
- if (end > BUF_ZV (buf)) end = BUF_ZV (buf);
-
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- XSETBUFFER (buffer, mbuf);
- report_extent_modification (buffer, start, end, 0);
+ int speccount = specpdl_depth ();
+ record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ set_buffer_internal (buf);
+ inside_change_hook = 1;
+ va_run_hook_with_args (Qbefore_change_functions, 2,
+ make_int (start), make_int (end));
+ /* Obsolete, for compatibility */
+ va_run_hook_with_args (Qbefore_change_function, 2,
+ make_int (start), make_int (end));
+ unbind_to (speccount, Qnil);
}
- unbind_to (speccount, Qnil);
/* Only now do we indicate that the before-change-functions have
been called, in case some function throws out. */
buf->text->changes->mc_begin_signaled = 1;
}
+
+ /* #### At this point we should map over extents calling
+ modification-hooks, insert-before-hooks and insert-after-hooks
+ of relevant extents */
}
/* Signal a change immediately after it happens.
Bufpos new_end)
{
/* This function can GC */
- struct buffer *mbuf;
- Lisp_Object bufcons;
+ Lisp_Object buffer;
+ XSETBUFFER (buffer, buf);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- /* always do this. */
- buffer_signal_changed_region (mbuf, start, new_end);
- }
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- /* #### This seems inefficient. Wouldn't it be better to just
- keep one cache per base buffer? */
- font_lock_maybe_update_syntactic_caches (mbuf, start, orig_end, new_end);
- }
+ /* always do this. */
+ buffer_signal_changed_region (buf, start, new_end);
+ font_lock_maybe_update_syntactic_caches (buf, start, orig_end, new_end);
if (!inside_change_hook)
{
- Lisp_Object buffer;
- int speccount;
-
if (buf->text->changes->in_multiple_change &&
buf->text->changes->mc_begin != 0)
{
return; /* after-change-functions signalled when all changes done */
}
- speccount = specpdl_depth ();
- record_unwind_protect (change_function_restore, Fcurrent_buffer ());
- inside_change_hook = 1;
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ if (!preparing_for_armageddon &&
+ (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer)) ||
+ /* Obsolete, for compatibility */
+ !NILP (symbol_value_in_buffer (Qafter_change_function, buffer))))
{
- XSETBUFFER (buffer, mbuf);
-
- if (!NILP (symbol_value_in_buffer (Qafter_change_functions, buffer))
- /* Obsolete, for compatibility */
- || !NILP (symbol_value_in_buffer (Qafter_change_function, buffer)))
- {
- set_buffer_internal (buf);
- /* The actual after-change functions take slightly
- different arguments than what we were passed. */
- va_run_hook_with_args (Qafter_change_functions, 3,
- make_int (start), make_int (new_end),
- make_int (orig_end - start));
- /* Obsolete, for compatibility */
- va_run_hook_with_args (Qafter_change_function, 3,
- make_int (start), make_int (new_end),
- make_int (orig_end - start));
- }
- }
-
- /* Make sure endpoints remain valid. after-change-functions
- might have modified the buffer. */
- if (start < BUF_BEGV (buf)) start = BUF_BEGV (buf);
- if (start > BUF_ZV (buf)) start = BUF_ZV (buf);
- if (new_end < BUF_BEGV (buf)) new_end = BUF_BEGV (buf);
- if (new_end > BUF_ZV (buf)) new_end = BUF_ZV (buf);
- if (orig_end < BUF_BEGV (buf)) orig_end = BUF_BEGV (buf);
- if (orig_end > BUF_ZV (buf)) orig_end = BUF_ZV (buf);
-
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- XSETBUFFER (buffer, mbuf);
- report_extent_modification (buffer, start, new_end, 1);
+ int speccount = specpdl_depth ();
+ record_unwind_protect (change_function_restore, Fcurrent_buffer ());
+ set_buffer_internal (buf);
+ inside_change_hook = 1;
+ /* The actual after-change functions take slightly
+ different arguments than what we were passed. */
+ va_run_hook_with_args (Qafter_change_functions, 3,
+ make_int (start), make_int (new_end),
+ make_int (orig_end - start));
+ /* Obsolete, for compatibility */
+ va_run_hook_with_args (Qafter_change_function, 3,
+ make_int (start), make_int (new_end),
+ make_int (orig_end - start));
+ unbind_to (speccount, Qnil);
}
- unbind_to (speccount, Qnil); /* sets inside_change_hook back to 0 */
}
+
+ /* #### At this point we should map over extents calling
+ some sort of modification hooks of relevant extents */
}
/* Call this if you're about to change the region of BUFFER from START
/* dmoore - This function can also kill the buffer buf, the current
buffer, and do anything it pleases. So if you call it, be
careful. */
- struct buffer *mbuf;
- Lisp_Object buffer, bufcons;
+ Lisp_Object buffer;
struct gcpro gcpro1;
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- barf_if_buffer_read_only (mbuf, start, end);
- }
+ barf_if_buffer_read_only (buf, start, end);
/* if this is the first modification, see about locking the buffer's
file */
Vdeactivate_mark = Qt;
#endif
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- mbuf->point_before_scroll = Qnil;
- }
+ buf->point_before_scroll = Qnil;
}
\f
Bytind ind;
Charcount cclen;
int move_point = 0;
- struct buffer *mbuf;
- Lisp_Object bufcons;
/* Defensive steps just in case a buffer gets deleted and a calling
function doesn't notice it. */
if ((length + BUF_Z (buf)) > EMACS_INT_MAX)
error ("Maximum buffer size exceeded");
- /* theoretically not necessary -- caller should GCPRO.
- #### buffer_insert_from_buffer_1() doesn't! */
+ /* theoretically not necessary -- caller should GCPRO */
GCPRO1 (reloc);
prepare_to_modify_buffer (buf, pos, pos, !(flags & INSDEL_NO_LOCKING));
insert_invalidate_line_number_cache (buf, pos, nonreloc + offset, length);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- record_insert (mbuf, pos, cclen);
- }
-
+ record_insert (buf, pos, cclen);
BUF_MODIFF (buf)++;
MARK_BUFFERS_CHANGED;
SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) - length);
SET_BI_BUF_GPT (buf, BI_BUF_GPT (buf) + length);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) + cclen, BI_BUF_ZV (mbuf) + length);
- }
+ SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) + cclen, BI_BUF_ZV (buf) + length);
SET_BOTH_BUF_Z (buf, BUF_Z (buf) + cclen, BI_BUF_Z (buf) + length);
SET_GAP_SENTINEL (buf);
buffer_mule_signal_inserted_region (buf, pos, length, cclen);
#endif
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- process_extents_for_insertion (make_buffer (mbuf), ind, length);
- }
-
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- /* We know the gap is at IND so the cast is OK. */
- adjust_markers_for_insert (mbuf, (Memind) ind, length);
- }
+ process_extents_for_insertion (make_buffer (buf), ind, length);
+ /* We know the gap is at IND so the cast is OK. */
+ adjust_markers_for_insert (buf, (Memind) ind, length);
/* Point logically doesn't move, but may need to be adjusted because
it's a byte index. point-marker doesn't change because it's a
memory index. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- if (BI_BUF_PT (mbuf) > ind)
- JUST_SET_POINT (mbuf, BUF_PT (mbuf) + cclen,
- BI_BUF_PT (mbuf) + length);
- }
+ if (BI_BUF_PT (buf) > ind)
+ JUST_SET_POINT (buf, BUF_PT (buf) + cclen, BI_BUF_PT (buf) + length);
/* Well, point might move. */
if (move_point)
BI_BUF_SET_PT (buf, ind + length);
if (STRINGP (reloc))
- {
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- splice_in_string_extents (reloc, mbuf, ind, length, offset);
- }
- }
+ splice_in_string_extents (reloc, buf, ind, length, offset);
if (flags & INSDEL_BEFORE_MARKERS)
{
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- /* ind - 1 is correct because the FROM argument is exclusive.
- I formerly used DEC_BYTIND() but that caused problems at the
- beginning of the buffer. */
- adjust_markers (mbuf, ind - 1, ind, length);
- }
+ /* ind - 1 is correct because the FROM argument is exclusive.
+ I formerly used DEC_BYTIND() but that caused problems at the
+ beginning of the buffer. */
+ adjust_markers (buf, ind - 1, ind, length);
}
signal_after_change (buf, pos, pos, pos + cclen);
int flags)
{
/* This function can GC */
-#ifdef ERROR_CHECK_TYPECHECK
assert (STRINGP (str));
-#endif
return buffer_insert_string_1 (buf, pos, 0, str, 0,
XSTRING_LENGTH (str),
flags);
int flags)
{
/* This function can GC */
+
CONST char *translated = GETTEXT (s);
return buffer_insert_string_1 (buf, pos, (CONST Bufbyte *) translated, Qnil,
0, strlen (translated), flags);
{
/* This function can GC */
Bufbyte str[MAX_EMCHAR_LEN];
- Bytecount len = set_charptr_emchar (str, ch);
+ Bytecount len;
+
+ len = set_charptr_emchar (str, ch);
return buffer_insert_string_1 (buf, pos, str, Qnil, 0, len, flags);
}
Bytind bi_from, bi_to;
Bytecount bc_numdel;
EMACS_INT shortage;
- struct buffer *mbuf;
- Lisp_Object bufcons;
+ Lisp_Object bufobj;
/* Defensive steps just in case a buffer gets deleted and a calling
function doesn't notice it. */
if ((numdel = to - from) <= 0)
return;
+ XSETBUFFER (bufobj, buf);
+
/* Redisplay needs to know if a newline was in the deleted region.
If we've already marked the changed region as having a deleted
newline there is no use in performing the check. */
{
scan_buffer (buf, '\n', from, to, 1, &shortage, 1);
if (!shortage)
- {
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- mbuf->changes->newline_was_deleted = 1;
- }
- }
+ buf->changes->newline_was_deleted = 1;
}
bi_from = bufpos_to_bytind (buf, from);
{
/* avoid moving the gap just to delete from the bottom. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- record_delete (mbuf, from, numdel);
- }
+ record_delete (buf, from, numdel);
BUF_MODIFF (buf)++;
MARK_BUFFERS_CHANGED;
- /* #### Point used to be modified here, but this causes problems
- with MULE, as point is used to calculate bytinds, and if the
- offset in bc_numdel causes point to move to a non first-byte
- location, causing some other function to throw an assertion
- in ASSERT_VALID_BYTIND. I've moved the code to right after
- the other movements and adjustments, but before the gap is
- moved. -- jh 970813 */
+ /* ### Point used to be modified here, but this causes problems with MULE,
+ as point is used to calculate bytinds, and if the offset in bc_numdel causes
+ point to move to a non first-byte location, causing some other function to
+ throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
+ the other movements and adjustments, but before the gap is moved.
+ -- jh 970813 */
/* Detach any extents that are completely within the range [FROM, TO],
if the extents are detachable.
- This must come AFTER record_delete(), so that the appropriate
- extents will be present to be recorded, and BEFORE the gap
- size is increased, as otherwise we will be confused about
- where the extents end. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
- }
+ This must come AFTER record_delete(), so that the appropriate extents
+ will be present to be recorded, and BEFORE the gap size is increased,
+ as otherwise we will be confused about where the extents end. */
+ process_extents_for_deletion (bufobj, bi_from, bi_to, 0);
- /* Relocate all markers pointing into the new, larger gap to
- point at the end of the text before the gap. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_markers (mbuf,
- (bi_to + BUF_GAP_SIZE (mbuf)),
- (bi_to + BUF_GAP_SIZE (mbuf)),
- (- bc_numdel));
- }
+ /* Relocate all markers pointing into the new, larger gap
+ to point at the end of the text before the gap. */
+ adjust_markers (buf,
+ (bi_to + BUF_GAP_SIZE (buf)),
+ (bi_to + BUF_GAP_SIZE (buf)),
+ (- bc_numdel));
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- /* Relocate any extent endpoints just like markers. */
- adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
- BUF_GAP_SIZE (mbuf), bc_numdel, 0);
- }
+ /* Relocate any extent endpoints just like markers. */
+ adjust_extents_for_deletion (bufobj, bi_from, bi_to,
+ BUF_GAP_SIZE (buf), bc_numdel, 0);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ /* Relocate point as if it were a marker. */
+ if (bi_from < BI_BUF_PT (buf))
{
- /* Relocate point as if it were a marker. */
- if (bi_from < BI_BUF_PT (mbuf))
- {
- if (BI_BUF_PT (mbuf) < bi_to)
- JUST_SET_POINT (mbuf, from, bi_from);
- else
- JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
- BI_BUF_PT (mbuf) - bc_numdel);
- }
+ if (BI_BUF_PT (buf) < bi_to)
+ JUST_SET_POINT (buf, from, bi_from);
+ else
+ JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
+ BI_BUF_PT (buf) - bc_numdel);
}
SET_BUF_END_GAP_SIZE (buf, BUF_END_GAP_SIZE (buf) + bc_numdel);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
- BI_BUF_ZV (mbuf) - bc_numdel);
- }
+ SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) - numdel, BI_BUF_ZV (buf) - bc_numdel);
SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
SET_GAP_SENTINEL (buf);
}
if (bi_from > BI_BUF_GPT (buf))
gap_right (buf, bi_from);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- record_delete (mbuf, from, numdel);
- }
+ record_delete (buf, from, numdel);
BUF_MODIFF (buf)++;
MARK_BUFFERS_CHANGED;
- /* #### Point used to be modified here, but this causes problems
- with MULE, as point is used to calculate bytinds, and if the
- offset in bc_numdel causes point to move to a non first-byte
- location, causing some other function to throw an assertion
- in ASSERT_VALID_BYTIND. I've moved the code to right after
- the other movements and adjustments, but before the gap is
- moved. -- jh 970813 */
+ /* ### Point used to be modified here, but this causes problems with MULE,
+ as point is used to calculate bytinds, and if the offset in bc_numdel causes
+ point to move to a non first-byte location, causing some other function to
+ throw an assertion in ASSERT_VALID_BYTIND. I've moved the code to right after
+ the other movements and adjustments, but before the gap is moved.
+ -- jh 970813 */
/* Detach any extents that are completely within the range [FROM, TO],
if the extents are detachable.
This must come AFTER record_delete(), so that the appropriate extents
will be present to be recorded, and BEFORE the gap size is increased,
as otherwise we will be confused about where the extents end. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- process_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to, 0);
- }
+ process_extents_for_deletion (bufobj, bi_from, bi_to, 0);
- /* Relocate all markers pointing into the new, larger gap to
- point at the end of the text before the gap. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_markers (mbuf,
- (bi_to + BUF_GAP_SIZE (mbuf)),
- (bi_to + BUF_GAP_SIZE (mbuf)),
- (- bc_numdel - BUF_GAP_SIZE (mbuf)));
- }
+ /* Relocate all markers pointing into the new, larger gap
+ to point at the end of the text before the gap. */
+ adjust_markers (buf,
+ (bi_to + BUF_GAP_SIZE (buf)),
+ (bi_to + BUF_GAP_SIZE (buf)),
+ (- bc_numdel - BUF_GAP_SIZE (buf)));
/* Relocate any extent endpoints just like markers. */
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- adjust_extents_for_deletion (make_buffer (mbuf), bi_from, bi_to,
- BUF_GAP_SIZE (mbuf),
- bc_numdel, BUF_GAP_SIZE (mbuf));
- }
+ adjust_extents_for_deletion (bufobj, bi_from, bi_to, BUF_GAP_SIZE (buf),
+ bc_numdel, BUF_GAP_SIZE (buf));
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
+ /* Relocate point as if it were a marker. */
+ if (bi_from < BI_BUF_PT (buf))
{
- /* Relocate point as if it were a marker. */
- if (bi_from < BI_BUF_PT (mbuf))
- {
- if (BI_BUF_PT (mbuf) < bi_to)
- JUST_SET_POINT (mbuf, from, bi_from);
- else
- JUST_SET_POINT (mbuf, BUF_PT (mbuf) - numdel,
- BI_BUF_PT (mbuf) - bc_numdel);
- }
+ if (BI_BUF_PT (buf) < bi_to)
+ JUST_SET_POINT (buf, from, bi_from);
+ else
+ JUST_SET_POINT (buf, BUF_PT (buf) - numdel,
+ BI_BUF_PT (buf) - bc_numdel);
}
SET_BUF_GAP_SIZE (buf, BUF_GAP_SIZE (buf) + bc_numdel);
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- SET_BOTH_BUF_ZV (mbuf, BUF_ZV (mbuf) - numdel,
- BI_BUF_ZV (mbuf) - bc_numdel);
- }
+ SET_BOTH_BUF_ZV (buf, BUF_ZV (buf) - numdel, BI_BUF_ZV (buf) - bc_numdel);
SET_BOTH_BUF_Z (buf, BUF_Z (buf) - numdel, BI_BUF_Z (buf) - bc_numdel);
SET_BI_BUF_GPT (buf, bi_from);
SET_GAP_SENTINEL (buf);
#endif
#ifdef ERROR_CHECK_EXTENTS
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- sledgehammer_extent_check (make_buffer (mbuf));
- }
+ sledgehammer_extent_check (bufobj);
#endif
signal_after_change (buf, from, to, from);
/* Replace the character at POS in buffer B with CH. */
void
-buffer_replace_char (struct buffer *buf, Bufpos pos, Emchar ch,
+buffer_replace_char (struct buffer *b, Bufpos pos, Emchar ch,
int not_real_change, int force_lock_check)
{
/* This function can GC */
/* Defensive steps just in case a buffer gets deleted and a calling
function doesn't notice it. */
- if (!BUFFER_LIVE_P (buf))
+ if (!BUFFER_LIVE_P (b))
return;
- curlen = BUF_CHARPTR_COPY_CHAR (buf, pos, curstr);
+ curlen = BUF_CHARPTR_COPY_CHAR (b, pos, curstr);
newlen = set_charptr_emchar (newstr, ch);
if (curlen == newlen)
{
- struct buffer *mbuf;
- Lisp_Object bufcons;
-
/* then we can just replace the text. */
- prepare_to_modify_buffer (buf, pos, pos + 1,
+ prepare_to_modify_buffer (b, pos, pos + 1,
!not_real_change || force_lock_check);
/* Defensive steps in case the before-change-functions fuck around */
- if (!BUFFER_LIVE_P (buf))
+ if (!BUFFER_LIVE_P (b))
/* Bad bad pre-change function. */
return;
/* Make args be valid again. prepare_to_modify_buffer() might have
modified the buffer. */
- if (pos < BUF_BEGV (buf))
- pos = BUF_BEGV (buf);
- if (pos >= BUF_ZV (buf))
- pos = BUF_ZV (buf) - 1;
- if (pos < BUF_BEGV (buf))
+ if (pos < BUF_BEGV (b))
+ pos = BUF_BEGV (b);
+ if (pos >= BUF_ZV (b))
+ pos = BUF_ZV (b) - 1;
+ if (pos < BUF_BEGV (b))
/* no more characters in buffer! */
return;
- if (BUF_FETCH_CHAR (buf, pos) == '\n')
- {
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- mbuf->changes->newline_was_deleted = 1;
- }
- }
+ if (BUF_FETCH_CHAR (b, pos) == '\n')
+ b->changes->newline_was_deleted = 1;
MARK_BUFFERS_CHANGED;
if (!not_real_change)
{
- MAP_INDIRECT_BUFFERS (buf, mbuf, bufcons)
- {
- record_change (mbuf, pos, 1);
- }
- BUF_MODIFF (buf)++;
+ record_change (b, pos, 1);
+ BUF_MODIFF (b)++;
}
- memcpy (BUF_BYTE_ADDRESS (buf, pos), newstr, newlen);
-
- signal_after_change (buf, pos, pos + 1, pos + 1);
+ memcpy (BUF_BYTE_ADDRESS (b, pos), newstr, newlen);
+ signal_after_change (b, pos, pos + 1, pos + 1);
/* We do not have to adjust the Mule data; we just replaced a
character with another of the same number of bytes. */
* point. Point will drift backward by one position and stay
* there otherwise.
*/
- int movepoint = (pos == BUF_PT (buf) - 1);
+ int movepoint = (pos == BUF_PT (b) - 1);
- buffer_delete_range (buf, pos, pos + 1, 0);
+ buffer_delete_range (b, pos, pos + 1, 0);
/* Defensive steps in case the before-change-functions fuck around */
- if (!BUFFER_LIVE_P (buf))
+ if (!BUFFER_LIVE_P (b))
/* Bad bad pre-change function. */
return;
/* Make args be valid again. prepare_to_modify_buffer() might have
modified the buffer. */
- if (pos < BUF_BEGV (buf))
- pos = BUF_BEGV (buf);
- if (pos >= BUF_ZV (buf))
- pos = BUF_ZV (buf) - 1;
- if (pos < BUF_BEGV (buf))
+ if (pos < BUF_BEGV (b))
+ pos = BUF_BEGV (b);
+ if (pos >= BUF_ZV (b))
+ pos = BUF_ZV (b) - 1;
+ if (pos < BUF_BEGV (b))
/* no more characters in buffer! */
return;
/*
* insertion, which we must do if the deletion moved point
* backward so that it now equals the insertion point.
*/
- buffer_insert_string_1 (buf, (movepoint ? -1 : pos),
+ buffer_insert_string_1 (b, (movepoint ? -1 : pos),
newstr, Qnil, 0, newlen, 0);
}
}
/* Make a string from a buffer. This needs to take into account the gap,
and add any necessary extents from the buffer. */
-static Lisp_Object
-make_string_from_buffer_1 (struct buffer *buf, Bufpos pos, Charcount length,
- int no_extents)
+Lisp_Object
+make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
{
/* This function can GC */
- Bytind bi_ind = bufpos_to_bytind (buf, pos);
- Bytecount bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
- Lisp_Object val = make_uninit_string (bi_len);
-
+ Lisp_Object val;
struct gcpro gcpro1;
+ Bytind bi_ind;
+ Bytecount bi_len;
+
+ bi_ind = bufpos_to_bytind (buf, pos);
+ bi_len = bufpos_to_bytind (buf, pos + length) - bi_ind;
+
+ val = make_uninit_string (bi_len);
GCPRO1 (val);
- if (!no_extents)
- add_string_extents (val, buf, bi_ind, bi_len);
+ add_string_extents (val, buf, bi_ind, bi_len);
{
Bytecount len1 = BI_BUF_GPT (buf) - bi_ind;
return val;
}
-Lisp_Object
-make_string_from_buffer (struct buffer *buf, Bufpos pos, Charcount length)
-{
- return make_string_from_buffer_1 (buf, pos, length, 0);
-}
-
-Lisp_Object
-make_string_from_buffer_no_extents (struct buffer *buf, Bufpos pos,
- Charcount length)
-{
- return make_string_from_buffer_1 (buf, pos, length, 1);
-}
-
void
barf_if_buffer_read_only (struct buffer *buf, Bufpos from, Bufpos to)
{
}
}
-Charcount
+int
convert_bufbyte_string_into_emchar_string (CONST Bufbyte *str, Bytecount len,
Emchar *arr)
{
/************************************************************************/
void
-reinit_vars_of_insdel (void)
+vars_of_insdel (void)
{
int i;
}
void
-vars_of_insdel (void)
-{
- reinit_vars_of_insdel ();
-}
-
-void
-init_buffer_text (struct buffer *b)
+init_buffer_text (struct buffer *b, int indirect_p)
{
- if (!b->base_buffer)
+ if (!indirect_p)
{
SET_BUF_GAP_SIZE (b, 20);
BUFFER_ALLOC (b->text->beg, BUF_GAP_SIZE (b) + BUF_END_SENTINEL_SIZE);
}
}
#endif /* MULE */
- b->text->line_number_cache = Qnil;
BUF_MODIFF (b) = 1;
BUF_SAVE_MODIFF (b) = 1;
}
void
-uninit_buffer_text (struct buffer *b)
+uninit_buffer_text (struct buffer *b, int indirect_p)
{
- if (!b->base_buffer)
+ if (!indirect_p)
{
BUFFER_FREE (b->text->beg);
xfree (b->text->changes);