From: Dmitry Antipov Date: Wed, 8 Aug 2012 12:12:40 +0000 (+0400) Subject: Inline functions to examine and change buffer intervals. X-Git-Tag: emacs-24.2.90~779 X-Git-Url: http://git.eshelyaron.com/gitweb/?a=commitdiff_plain;h=8707c1e56ca83a0a34785e451dcef428c60242fe;p=emacs.git Inline functions to examine and change buffer intervals. * alloc.c (mark_interval_tree): Remove. (MARK_INTERVAL_TREE): Simplify. (UNMARK_BALANCE_INTERVALS): Remove. Adjust users. * intervals.c (buffer_balance_intervals): New function. (graft_intervals_into_buffer): Adjust indentation. (set_intervals_multibyte): Simplify. * buffer.h (BUF_INTERVALS): Remove. (buffer_get_intervals, buffer_set_intervals): New function. * alloc.c, buffer.c, editfns.c, fileio.c, indent.c, insdel.c: * intervals.c, textprop.c: Adjust users. --- diff --git a/src/ChangeLog b/src/ChangeLog index 20bb917f1a1..9c6d4b4458d 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,17 @@ +2012-08-08 Dmitry Antipov + + Inline functions to examine and change buffer intervals. + * alloc.c (mark_interval_tree): Remove. + (MARK_INTERVAL_TREE): Simplify. + (UNMARK_BALANCE_INTERVALS): Remove. Adjust users. + * intervals.c (buffer_balance_intervals): New function. + (graft_intervals_into_buffer): Adjust indentation. + (set_intervals_multibyte): Simplify. + * buffer.h (BUF_INTERVALS): Remove. + (buffer_get_intervals, buffer_set_intervals): New function. + * alloc.c, buffer.c, editfns.c, fileio.c, indent.c, insdel.c: + * intervals.c, textprop.c: Adjust users. + 2012-08-08 Dmitry Antipov Inline functions to examine and change string intervals. diff --git a/src/alloc.c b/src/alloc.c index 95309f076d4..c93fcb564c7 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -1542,35 +1542,12 @@ mark_interval (register INTERVAL i, Lisp_Object dummy) mark_object (i->plist); } - -/* Mark the interval tree rooted in TREE. Don't call this directly; - use the macro MARK_INTERVAL_TREE instead. */ - -static void -mark_interval_tree (register INTERVAL tree) -{ - /* No need to test if this tree has been marked already; this - function is always called through the MARK_INTERVAL_TREE macro, - which takes care of that. */ - - traverse_intervals_noorder (tree, mark_interval, Qnil); -} - - /* Mark the interval tree rooted in I. */ -#define MARK_INTERVAL_TREE(i) \ - do { \ - if (i && !i->gcmarkbit) \ - mark_interval_tree (i); \ - } while (0) - -/* Unmark and rebalance interval tree rooted in I. */ - -#define UNMARK_BALANCE_INTERVALS(i) \ - do { \ - if (i) \ - (i) = balance_intervals (i); \ +#define MARK_INTERVAL_TREE(i) \ + do { \ + if (i && !i->gcmarkbit) \ + traverse_intervals_noorder (i, mark_interval, Qnil); \ } while (0) /*********************************************************************** @@ -2101,8 +2078,8 @@ sweep_strings (void) /* String is live; unmark it and its intervals. */ UNMARK_STRING (s); - if (s->intervals) - UNMARK_BALANCE_INTERVALS (s->intervals); + /* Do not use string_(set|get)_intervals here. */ + s->intervals = balance_intervals (s->intervals); ++total_strings; total_string_bytes += STRING_BYTES (s); @@ -5848,7 +5825,7 @@ mark_buffer (struct buffer *buffer) /* ...but there are some buffer-specific things. */ - MARK_INTERVAL_TREE (BUF_INTERVALS (buffer)); + MARK_INTERVAL_TREE (buffer_get_intervals (buffer)); /* For now, we just don't mark the undo_list. It's done later in a special way just before the sweep phase, and after stripping @@ -6587,7 +6564,8 @@ gc_sweep (void) else { VECTOR_UNMARK (buffer); - UNMARK_BALANCE_INTERVALS (BUF_INTERVALS (buffer)); + /* Do not use buffer_(set|get)_intervals here. */ + buffer->text->intervals = balance_intervals (buffer->text->intervals); total_buffers++; prev = buffer, buffer = buffer->header.next.buffer; } diff --git a/src/buffer.c b/src/buffer.c index 395ca48680f..fab7330b195 100644 --- a/src/buffer.c +++ b/src/buffer.c @@ -360,7 +360,7 @@ even if it is dead. The return value is never nil. */) BUF_CHARS_MODIFF (b) = 1; BUF_OVERLAY_MODIFF (b) = 1; BUF_SAVE_MODIFF (b) = 1; - BUF_INTERVALS (b) = NULL; + buffer_set_intervals (b, NULL); BUF_UNCHANGED_MODIFIED (b) = 1; BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1; BUF_END_UNCHANGED (b) = 0; @@ -1688,7 +1688,7 @@ cleaning up all windows currently displaying the buffer to be killed. */) m = next; } BUF_MARKERS (b) = NULL; - BUF_INTERVALS (b) = NULL; + buffer_set_intervals (b, NULL); /* Perhaps we should explicitly free the interval tree here... */ } @@ -4904,8 +4904,8 @@ init_buffer_once (void) /* No one will share the text with these buffers, but let's play it safe. */ buffer_defaults.indirections = 0; buffer_local_symbols.indirections = 0; - BUF_INTERVALS (&buffer_defaults) = NULL; - BUF_INTERVALS (&buffer_local_symbols) = NULL; + buffer_set_intervals (&buffer_defaults, NULL); + buffer_set_intervals (&buffer_local_symbols, NULL); XSETPVECTYPESIZE (&buffer_defaults, PVEC_BUFFER, pvecsize); XSETBUFFER (Vbuffer_defaults, &buffer_defaults); XSETPVECTYPESIZE (&buffer_local_symbols, PVEC_BUFFER, pvecsize); diff --git a/src/buffer.h b/src/buffer.h index 9618fc6ded1..986df8e6d32 100644 --- a/src/buffer.h +++ b/src/buffer.h @@ -193,9 +193,6 @@ INLINE_HEADER_BEGIN /* FIXME: should we move this into ->text->auto_save_modiff? */ #define BUF_AUTOSAVE_MODIFF(buf) ((buf)->auto_save_modified) -/* Interval tree of buffer. */ -#define BUF_INTERVALS(buf) ((buf)->text->intervals) - /* Marker chain of buffer. */ #define BUF_MARKERS(buf) ((buf)->text->markers) @@ -951,7 +948,25 @@ extern void mmap_set_vars (int); extern Lisp_Object Qbefore_change_functions; extern Lisp_Object Qafter_change_functions; extern Lisp_Object Qfirst_change_hook; - + +/* Get text properties of B. */ + +BUFFER_INLINE INTERVAL +buffer_get_intervals (struct buffer *b) +{ + eassert (b->text != NULL); + return b->text->intervals; +} + +/* Set text properties of B to I. */ + +BUFFER_INLINE void +buffer_set_intervals (struct buffer *b, INTERVAL i) +{ + eassert (b->text != NULL); + b->text->intervals = i; +} + /* Return character code of multi-byte form at byte position POS. If POS doesn't point the head of valid multi-byte form, only the byte at POS is returned. No range checking. diff --git a/src/editfns.c b/src/editfns.c index 3bcc1a57a7e..aca34482fb2 100644 --- a/src/editfns.c +++ b/src/editfns.c @@ -4527,7 +4527,7 @@ Transposing beyond buffer boundaries is an error. */) Lisp_Object buf; XSETBUFFER (buf, current_buffer); - cur_intv = BUF_INTERVALS (current_buffer); + cur_intv = buffer_get_intervals (current_buffer); validate_region (&startr1, &endr1); validate_region (&startr2, &endr2); diff --git a/src/fileio.c b/src/fileio.c index 7639c2f0b33..9fe7437669c 100644 --- a/src/fileio.c +++ b/src/fileio.c @@ -3145,7 +3145,7 @@ decide_coding_unwind (Lisp_Object unwind_data) set_buffer_internal (XBUFFER (buffer)); adjust_markers_for_delete (BEG, BEG_BYTE, Z, Z_BYTE); adjust_overlays_for_delete (BEG, Z - BEG); - BUF_INTERVALS (current_buffer) = NULL; + buffer_set_intervals (current_buffer, NULL); TEMP_SET_PT_BOTH (BEG, BEG_BYTE); /* Now we are safe to change the buffer's multibyteness directly. */ diff --git a/src/indent.c b/src/indent.c index 928d61196a5..6b7e79fb7a5 100644 --- a/src/indent.c +++ b/src/indent.c @@ -336,7 +336,7 @@ current_column (void) /* If the buffer has overlays, text properties, or multibyte characters, use a more general algorithm. */ - if (BUF_INTERVALS (current_buffer) + if (buffer_get_intervals (current_buffer) || current_buffer->overlays_before || current_buffer->overlays_after || Z != Z_BYTE) diff --git a/src/insdel.c b/src/insdel.c index 1a66cfc6080..ec0d3b31f70 100644 --- a/src/insdel.c +++ b/src/insdel.c @@ -844,10 +844,10 @@ insert_1_both (const char *string, PT + nchars, PT_BYTE + nbytes, before_markers); - if (BUF_INTERVALS (current_buffer)) + if (buffer_get_intervals (current_buffer)) offset_intervals (current_buffer, PT, nchars); - if (!inherit && BUF_INTERVALS (current_buffer)) + if (!inherit && buffer_get_intervals (current_buffer)) set_text_properties (make_number (PT), make_number (PT + nchars), Qnil, Qnil, Qnil); @@ -1017,7 +1017,7 @@ insert_from_gap (ptrdiff_t nchars, ptrdiff_t nbytes) adjust_markers_for_insert (GPT - nchars, GPT_BYTE - nbytes, GPT, GPT_BYTE, 0); - if (BUF_INTERVALS (current_buffer)) + if (buffer_get_intervals (current_buffer)) { offset_intervals (current_buffer, GPT - nchars, nchars); graft_intervals_into_buffer (NULL, GPT - nchars, nchars, @@ -1157,11 +1157,11 @@ insert_from_buffer_1 (struct buffer *buf, PT_BYTE + outgoing_nbytes, 0); - if (BUF_INTERVALS (current_buffer)) + if (buffer_get_intervals (current_buffer)) offset_intervals (current_buffer, PT, nchars); /* Get the intervals for the part of the string we are inserting. */ - intervals = BUF_INTERVALS (buf); + intervals = buffer_get_intervals (buf); if (nchars < BUF_Z (buf) - BUF_BEG (buf)) { if (buf == current_buffer && PT <= from) @@ -1225,10 +1225,9 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte, adjust_overlays_for_insert (from, len - nchars_del); else if (len < nchars_del) adjust_overlays_for_delete (from, nchars_del - len); - if (BUF_INTERVALS (current_buffer)) - { - offset_intervals (current_buffer, from, len - nchars_del); - } + + if (buffer_get_intervals (current_buffer)) + offset_intervals (current_buffer, from, len - nchars_del); if (from < PT) adjust_point (len - nchars_del, len_byte - nbytes_del); @@ -1823,7 +1822,7 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end, if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer) ++windows_or_buffers_changed; - if (BUF_INTERVALS (current_buffer)) + if (buffer_get_intervals (current_buffer)) { if (preserve_ptr) { diff --git a/src/intervals.c b/src/intervals.c index 64e54eb7b43..e9c3929670e 100644 --- a/src/intervals.c +++ b/src/intervals.c @@ -77,7 +77,7 @@ create_root_interval (Lisp_Object parent) new->total_length = (BUF_Z (XBUFFER (parent)) - BUF_BEG (XBUFFER (parent))); eassert (0 <= TOTAL_LENGTH (new)); - BUF_INTERVALS (XBUFFER (parent)) = new; + buffer_set_intervals (XBUFFER (parent), new); new->position = BEG; } else if (STRINGP (parent)) @@ -453,7 +453,7 @@ balance_possible_root_interval (register INTERVAL interval) if (have_parent) { if (BUFFERP (parent)) - BUF_INTERVALS (XBUFFER (parent)) = interval; + buffer_set_intervals (XBUFFER (parent), interval); else if (STRINGP (parent)) string_set_intervals (parent, interval); } @@ -483,6 +483,19 @@ balance_intervals (INTERVAL tree) return tree ? balance_intervals_internal (tree) : NULL; } +/* Rebalance text properties of B. */ + +static void +buffer_balance_intervals (struct buffer *b) +{ + INTERVAL i; + + eassert (b != NULL); + i = buffer_get_intervals (b); + if (i) + buffer_set_intervals (b, balance_an_interval (i)); +} + /* Split INTERVAL into two pieces, starting the second piece at character position OFFSET (counting from 0), relative to INTERVAL. INTERVAL becomes the left-hand piece, and the right-hand piece @@ -1204,7 +1217,7 @@ delete_interval (register INTERVAL i) interval_set_object (parent, owner); if (BUFFERP (owner)) - BUF_INTERVALS (XBUFFER (owner)) = parent; + buffer_set_intervals (XBUFFER (owner), parent); else if (STRINGP (owner)) string_set_intervals (owner, parent); else @@ -1306,7 +1319,7 @@ adjust_intervals_for_deletion (struct buffer *buffer, ptrdiff_t start, ptrdiff_t length) { register ptrdiff_t left_to_delete = length; - register INTERVAL tree = BUF_INTERVALS (buffer); + register INTERVAL tree = buffer_get_intervals (buffer); Lisp_Object parent; ptrdiff_t offset; @@ -1321,7 +1334,7 @@ adjust_intervals_for_deletion (struct buffer *buffer, if (length == TOTAL_LENGTH (tree)) { - BUF_INTERVALS (buffer) = NULL; + buffer_set_intervals (buffer, NULL); return; } @@ -1338,10 +1351,10 @@ adjust_intervals_for_deletion (struct buffer *buffer, { left_to_delete -= interval_deletion_adjustment (tree, start - offset, left_to_delete); - tree = BUF_INTERVALS (buffer); + tree = buffer_get_intervals (buffer); if (left_to_delete == tree->total_length) { - BUF_INTERVALS (buffer) = NULL; + buffer_set_intervals (buffer, NULL); return; } } @@ -1359,11 +1372,12 @@ adjust_intervals_for_deletion (struct buffer *buffer, void offset_intervals (struct buffer *buffer, ptrdiff_t start, ptrdiff_t length) { - if (!BUF_INTERVALS (buffer) || length == 0) + if (!buffer_get_intervals (buffer) || length == 0) return; if (length > 0) - adjust_intervals_for_insertion (BUF_INTERVALS (buffer), start, length); + adjust_intervals_for_insertion (buffer_get_intervals (buffer), + start, length); else { IF_LINT (if (length < - TYPE_MAXIMUM (ptrdiff_t)) abort ();) @@ -1570,7 +1584,7 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position, register INTERVAL tree; ptrdiff_t over_used; - tree = BUF_INTERVALS (buffer); + tree = buffer_get_intervals (buffer); /* If the new text has no properties, then with inheritance it becomes part of whatever interval it was inserted into. @@ -1586,31 +1600,34 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position, make_number (position + length), Qnil, buf, 0); } - if (BUF_INTERVALS (buffer)) - /* Shouldn't be necessary. --Stef */ - BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer)); + /* Shouldn't be necessary. --Stef */ + buffer_balance_intervals (buffer); return; } eassert (length == TOTAL_LENGTH (source)); if ((BUF_Z (buffer) - BUF_BEG (buffer)) == length) - { /* The inserted text constitutes the whole buffer, so + { + /* The inserted text constitutes the whole buffer, so simply copy over the interval structure. */ - Lisp_Object buf; - XSETBUFFER (buf, buffer); - BUF_INTERVALS (buffer) = reproduce_tree_obj (source, buf); - BUF_INTERVALS (buffer)->position = BUF_BEG (buffer); - eassert (BUF_INTERVALS (buffer)->up_obj == 1); - return; - } + Lisp_Object buf; + + XSETBUFFER (buf, buffer); + buffer_set_intervals (buffer, reproduce_tree_obj (source, buf)); + buffer_get_intervals (buffer)->position = BUF_BEG (buffer); + eassert (buffer_get_intervals (buffer)->up_obj == 1); + return; + } else if (!tree) - { /* Create an interval tree in which to place a copy + { + /* Create an interval tree in which to place a copy of the intervals of the inserted string. */ Lisp_Object buf; + XSETBUFFER (buf, buffer); tree = create_root_interval (buf); - } + } /* Paranoia -- the text has already been added, so this buffer should be of non-zero length. */ eassert (TOTAL_LENGTH (tree) > 0); @@ -1691,9 +1708,7 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position, under = next_interval (this); } - if (BUF_INTERVALS (buffer)) - BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer)); - return; + buffer_balance_intervals (buffer); } /* Get the value of property PROP from PLIST, @@ -1860,7 +1875,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos) /* If we have no text properties and overlays, then we can do it quickly. */ - if (!BUF_INTERVALS (current_buffer) && ! have_overlays) + if (!buffer_get_intervals (current_buffer) && ! have_overlays) { temp_set_point_both (current_buffer, charpos, bytepos); return; @@ -1869,7 +1884,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos) /* Set TO to the interval containing the char after CHARPOS, and TOPREV to the interval containing the char before CHARPOS. Either one may be null. They may be equal. */ - to = find_interval (BUF_INTERVALS (current_buffer), charpos); + to = find_interval (buffer_get_intervals (current_buffer), charpos); if (charpos == BEGV) toprev = 0; else if (to && to->position == charpos) @@ -1883,7 +1898,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos) and FROMPREV to the interval containing the char before PT. Either one may be null. They may be equal. */ /* We could cache this and save time. */ - from = find_interval (BUF_INTERVALS (current_buffer), buffer_point); + from = find_interval (buffer_get_intervals (current_buffer), buffer_point); if (buffer_point == BEGV) fromprev = 0; else if (from && from->position == PT) @@ -1989,7 +2004,7 @@ set_point_both (ptrdiff_t charpos, ptrdiff_t bytepos) /* Set TO to the interval containing the char after CHARPOS, and TOPREV to the interval containing the char before CHARPOS. Either one may be null. They may be equal. */ - to = find_interval (BUF_INTERVALS (current_buffer), charpos); + to = find_interval (buffer_get_intervals (current_buffer), charpos); if (charpos == BEGV) toprev = 0; else if (to && to->position == charpos) @@ -2122,9 +2137,9 @@ get_property_and_range (ptrdiff_t pos, Lisp_Object prop, Lisp_Object *val, INTERVAL i, prev, next; if (NILP (object)) - i = find_interval (BUF_INTERVALS (current_buffer), pos); + i = find_interval (buffer_get_intervals (current_buffer), pos); else if (BUFFERP (object)) - i = find_interval (BUF_INTERVALS (XBUFFER (object)), pos); + i = find_interval (buffer_get_intervals (XBUFFER (object)), pos); else if (STRINGP (object)) i = find_interval (string_get_intervals (object), pos); else @@ -2253,7 +2268,7 @@ void copy_intervals_to_string (Lisp_Object string, struct buffer *buffer, ptrdiff_t position, ptrdiff_t length) { - INTERVAL interval_copy = copy_intervals (BUF_INTERVALS (buffer), + INTERVAL interval_copy = copy_intervals (buffer_get_intervals (buffer), position, length); if (!interval_copy) return; @@ -2418,7 +2433,8 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag, void set_intervals_multibyte (int multi_flag) { - if (BUF_INTERVALS (current_buffer)) - set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag, - BEG, BEG_BYTE, Z, Z_BYTE); + INTERVAL i = buffer_get_intervals (current_buffer); + + if (i) + set_intervals_multibyte_1 (i, multi_flag, BEG, BEG_BYTE, Z, Z_BYTE); } diff --git a/src/textprop.c b/src/textprop.c index 5366249be89..ac1980fde78 100644 --- a/src/textprop.c +++ b/src/textprop.c @@ -143,7 +143,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *en if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end) && XINT (*end) <= BUF_ZV (b))) args_out_of_range (*begin, *end); - i = BUF_INTERVALS (b); + i = buffer_get_intervals (b); /* If there's no text, there are no properties. */ if (BUF_BEGV (b) == BUF_ZV (b)) @@ -510,7 +510,7 @@ interval_of (ptrdiff_t position, Lisp_Object object) beg = BUF_BEGV (b); end = BUF_ZV (b); - i = BUF_INTERVALS (b); + i = buffer_get_intervals (b); } else { @@ -1338,8 +1338,8 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie else return; - if (i == 0) - i = find_interval (BUF_INTERVALS (XBUFFER (buffer)), s); + if (i == NULL) + i = find_interval (buffer_get_intervals (XBUFFER (buffer)), s); if (i->position != s) { @@ -1993,7 +1993,7 @@ void verify_interval_modification (struct buffer *buf, ptrdiff_t start, ptrdiff_t end) { - register INTERVAL intervals = BUF_INTERVALS (buf); + register INTERVAL intervals = buffer_get_intervals (buf); register INTERVAL i; Lisp_Object hooks; register Lisp_Object prev_mod_hooks;