/* Buffer insertion/deletion and gap motion for GNU Emacs. -*- coding: utf-8 -*-

Foundation, Inc.

This file is part of GNU Emacs.

#include "buffer.h"

#include "window.h"

#include "region-cache.h"

static void insert_from_string_1 (Lisp_Object, ptrdiff_t, ptrdiff_t, ptrdiff_t,

ptrdiff_t, bool, bool);

i = GPT_BYTE;

to = GAP_END_ADDR;

from = GPT_ADDR;

/* Now copy the characters. To move the gap down,

copy characters up. */

make_gap_smaller set inhibit-quit. */

if (QUITP)

{

bytepos = new_s1;

charpos = BYTE_TO_CHAR (bytepos);

break;

}

/* Move at most 32000 chars before checking again for a quit. */

if (i > 32000)

i = 32000;

new_s1 -= i;

{

register unsigned char *to, *from;

register ptrdiff_t i;

BUF_COMPUTE_UNCHANGED (current_buffer, charpos, GPT);

make_gap_smaller set inhibit-quit. */

if (QUITP)

{

bytepos = new_s1;

charpos = BYTE_TO_CHAR (bytepos);

break;

if (pos <= endpos)

for ( ; pos < endpos; pos++)

else

for ( ; pos > endpos; pos--)

return bytepos;

}

while (bytes_left > 0)

{

if (! ASCII_CHAR_P (c))

c &= 0xFF;

*to_addr++ = c;

the insertion. This, together with recording the insertion,

will add up to the right stuff in the undo list. */

record_insert (PT, nchars);

CHARS_MODIFF = MODIFF;

memcpy (GPT_ADDR, string, nbytes);

offset_intervals (current_buffer, PT, nchars);

if (!inherit && buffer_intervals (current_buffer))

Qnil, Qnil, Qnil);

adjust_point (nchars, nbytes);

#endif

record_insert (PT, nchars);

CHARS_MODIFF = MODIFF;

GAP_SIZE -= outgoing_nbytes;



/* Insert a sequence of NCHARS chars which occupy NBYTES bytes

starting at GAP_END_ADDR - NBYTES (if text_at_gap_tail) and at

GPT_ADDR (if not text_at_gap_tail). */

void

of this dance. */

invalidate_buffer_caches (current_buffer, GPT, GPT);

record_insert (GPT, nchars);

adjust_overlays_for_insert (ins_charpos, nchars);

adjust_markers_for_insert (ins_charpos, ins_bytepos,

#endif

record_insert (PT, nchars);

CHARS_MODIFF = MODIFF;

GAP_SIZE -= outgoing_nbytes;

if (len == 0)

evaporate_overlays (from);

CHARS_MODIFF = MODIFF;

}

void

replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,

bool prepare, bool inherit, bool markers,

{

ptrdiff_t inschars = SCHARS (new);

ptrdiff_t insbytes = SBYTES (new);

check_markers ();

CHARS_MODIFF = MODIFF;

if (adjust_match_data)

update_search_regs (from, to, from + SCHARS (new));

}



/* Replace the text from character positions FROM to TO with

check_markers ();

CHARS_MODIFF = MODIFF;

}



at the end of the text before the gap. */

adjust_markers_for_delete (from, from_byte, to, to_byte);

CHARS_MODIFF = MODIFF;

/* Relocate point as if it were a marker. */

BUF_COMPUTE_UNCHANGED (current_buffer, start - 1, end);

if (MODIFF <= SAVE_MODIFF)

record_first_change ();

CHARS_MODIFF = MODIFF;

bset_point_before_scroll (current_buffer, Qnil);

if (!NILP (BVAR (current_buffer, read_only)))

Fbarf_if_buffer_read_only (temp);

run_undoable_change();

bset_redisplay (current_buffer);

if (preserve_ptr)

{

Lisp_Object preserve_marker;

verify_interval_modification (current_buffer, start, end);

*preserve_ptr = marker_position (preserve_marker);

unchain_marker (XMARKER (preserve_marker));

/* Make binding buffer-file-name to nil effective. */

&& !NILP (BVAR (base_buffer, filename))

&& SAVE_MODIFF >= MODIFF)

/* If `select-active-regions' is non-nil, save the region text. */

/* FIXME: Move this to Elisp (via before-change-functions). */

: (!NILP (Vselect_active_regions)

&& !NILP (Vtransient_mark_mode))))

Vsaved_region_selection

signal_before_change (start, end, preserve_ptr);

Fset (Qdeactivate_mark, Qt);

#define PRESERVE_VALUE \

if (preserve_ptr && NILP (preserve_marker)) \

#define RESTORE_VALUE \

if (! NILP (preserve_marker)) \

Lisp_Object start, end;

Lisp_Object start_marker, end_marker;

Lisp_Object preserve_marker;

struct rvoe_arg rvoe_arg;

preserve_marker = Qnil;

start_marker = Qnil;

end_marker = Qnil;

}

if (! NILP (start_marker))

if (! NILP (end_marker))

RESTORE_VALUE;

unbind_to (count, Qnil);

void

signal_after_change (ptrdiff_t charpos, ptrdiff_t lendel, ptrdiff_t lenins)

{

struct rvoe_arg rvoe_arg;

if (inhibit_modification_hooks)

return;

and there are no before-change functions,

just record the args that we were going to use. */

if (! NILP (Vcombine_after_change_calls)

&& !buffer_has_overlays ())

{

Lisp_Object elt;

return;

}

if (!NILP (combine_after_change_list))

Fcombine_after_change_execute ();

/* Actually run the hook functions. */

CALLN (Frun_hook_with_args, Qafter_change_functions,

/* There was no error: unarm the reset_on_error. */

rvoe_arg.errorp = 0;

}

if (buffer_has_overlays ())

1,

/* After an insertion, call the text properties

insert-behind-hooks or insert-in-front-hooks. */

if (lendel == 0)

unbind_to (count, Qnil);

}

doc: /* This function is for use internally in the function `combine-after-change-calls'. */)

(void)

{

ptrdiff_t beg, end, change;

ptrdiff_t begpos, endpos;

Lisp_Object tail;

/* It is rare for combine_after_change_buffer to be invalid, but

possible. It can happen when combine-after-change-calls is

lock_file) which scribbles into a temp file -- cyd */

if (!BUFFERP (combine_after_change_buffer)

|| !BUFFER_LIVE_P (XBUFFER (combine_after_change_buffer)))

elt = XCAR (tail);

if (! CONSP (elt))

continue;

elt = XCDR (elt);

if (! CONSP (elt))

continue;

elt = XCDR (elt);

if (! CONSP (elt))

continue;

/* Merge this range into the accumulated range. */

change += thischange;

combine_after_change_buffer = Qnil;

DEFSYM (Qundo_auto__undoable_change, "undo-auto--undoable-change");

DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls,

doc: /* Used internally by the function `combine-after-change-calls' macro. */);

DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks,

doc: /* Non-nil means don't run any of the hooks that respond to buffer changes.

This affects `before-change-functions' and `after-change-functions',

inhibit_modification_hooks = 0;

DEFSYM (Qinhibit_modification_hooks, "inhibit-modification-hooks");

defsubr (&Scombine_after_change_execute);

}