Github/emacs
2
0
Fork 1
mirror of git://git.sv.gnu.org/emacs.git synced 2026-02-17 10:27:41 +00:00
Code Issues Projects Releases Packages Wiki Activity

A few more naming-convention fixes for getters and setters.

Browse source 
* buffer.c (set_buffer_overlays_before): Move here from buffer.h,
and rename from buffer_overlays_set_before.
(set_buffer_overlays_after): Move here from buffer.h, and rename
from buffer_overlays_set_after.
* buffer.h (buffer_intervals): Rename from buffer_get_intervals.
All uses changed.
(set_buffer_intervals): Rename from buffer_set_intervals.
* intervals.c (set_interval_object): Move here from intervals.h,
and rename from interval_set_object.
(set_interval_left): Move here from intervals.h, and rename from
interval_set_left.
(set_interval_right): Move here from intervals.h, and rename from
interval_set_right.
(copy_interval_parent): Move here from intervals.h, and rename from
interval_copy_parent.
* intervals.h (set_interval_parent): Rename from interval_set_parent.
(set_interval_plist): Rename from interval_set_plist.
Return void, not Lisp_Object, since no caller uses the result.
* lisp.h (string_intervals): Rename from string_get_intervals.
(set_string_intervals): Rename from string_set_intervals.
This commit is contained in:
Paul Eggert 2012-08-17 14:12:11 -07:00
parent ee21815118
commit 0c94c8d603
15 changed files with 223 additions and 205 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
src/ChangeLog
View file

@ -1,5 +1,27 @@
2012-08-17 Paul Eggert <eggert@cs.ucla.edu>
A few more naming-convention fixes for getters and setters.
* buffer.c (set_buffer_overlays_before): Move here from buffer.h,
and rename from buffer_overlays_set_before.
(set_buffer_overlays_after): Move here from buffer.h, and rename
from buffer_overlays_set_after.
* buffer.h (buffer_intervals): Rename from buffer_get_intervals.
All uses changed.
(set_buffer_intervals): Rename from buffer_set_intervals.
* intervals.c (set_interval_object): Move here from intervals.h,
and rename from interval_set_object.
(set_interval_left): Move here from intervals.h, and rename from
interval_set_left.
(set_interval_right): Move here from intervals.h, and rename from
interval_set_right.
(copy_interval_parent): Move here from intervals.h, and rename from
interval_copy_parent.
* intervals.h (set_interval_parent): Rename from interval_set_parent.
(set_interval_plist): Rename from interval_set_plist.
Return void, not Lisp_Object, since no caller uses the result.
* lisp.h (string_intervals): Rename from string_get_intervals.
(set_string_intervals): Rename from string_set_intervals.
* lisp.h (set_char_table_extras): Rename from char_table_set_extras.
(set_char_table_contents): Rename from char_table_set_contents.
(set_sub_char_table_contents): Rename from sub_char_table_set_contents.

6
src/alloc.c
View file

@ -5836,7 +5836,7 @@ mark_buffer (struct buffer *buffer)
/* ...but there are some buffer-specific things. */
MARK_INTERVAL_TREE (buffer_get_intervals (buffer));
MARK_INTERVAL_TREE (buffer_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
@ -6090,7 +6090,7 @@ mark_object (Lisp_Object arg)
}
if (!PURE_POINTER_P (XSTRING (ptr->name)))
MARK_STRING (XSTRING (ptr->name));
MARK_INTERVAL_TREE (string_get_intervals (ptr->name));
MARK_INTERVAL_TREE (string_intervals (ptr->name));
ptr = ptr->next;
if (ptr)
@ -6405,7 +6405,7 @@ gc_sweep (void)
{
if (!iblk->intervals[i].gcmarkbit)
{
interval_set_parent (&iblk->intervals[i], interval_free_list);
set_interval_parent (&iblk->intervals[i], interval_free_list);
interval_free_list = &iblk->intervals[i];
this_free++;
}

71
src/buffer.c
View file

@ -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;
buffer_set_intervals (b, NULL);
set_buffer_intervals (b, NULL);
BUF_UNCHANGED_MODIFIED (b) = 1;
BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
BUF_END_UNCHANGED (b) = 0;
@ -384,7 +384,7 @@ even if it is dead. The return value is never nil. */)
BSET (b, zv_marker, Qnil);
name = Fcopy_sequence (buffer_or_name);
string_set_intervals (name, NULL);
set_string_intervals (name, NULL);
BSET (b, name, name);
BSET (b, undo_list, (SREF (name, 0) != ' ') ? Qnil : Qt);
@ -439,6 +439,19 @@ copy_overlays (struct buffer *b, struct Lisp_Overlay *list)
return result;
}
/* Set an appropriate overlay of B. */
static inline void
set_buffer_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
{
b->overlays_before = o;
}
static inline void
set_buffer_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
{
b->overlays_after = o;
}
/* Clone per-buffer values of buffer FROM.
@ -474,8 +487,8 @@ clone_per_buffer_values (struct buffer *from, struct buffer *to)
memcpy (to->local_flags, from->local_flags, sizeof to->local_flags);
buffer_set_overlays_before (to, copy_overlays (to, from->overlays_before));
buffer_set_overlays_after (to, copy_overlays (to, from->overlays_after));
set_buffer_overlays_before (to, copy_overlays (to, from->overlays_before));
set_buffer_overlays_after (to, copy_overlays (to, from->overlays_after));
/* Get (a copy of) the alist of Lisp-level local variables of FROM
and install that in TO. */
@ -589,7 +602,7 @@ CLONE nil means the indirect buffer's state is reset to default values. */)
all_buffers = b;
name = Fcopy_sequence (name);
string_set_intervals (name, NULL);
set_string_intervals (name, NULL);
BSET (b, name, name);
reset_buffer (b);
@ -688,8 +701,8 @@ delete_all_overlays (struct buffer *b)
ov->next = NULL;
}
buffer_set_overlays_before (b, NULL);
buffer_set_overlays_after (b, NULL);
set_buffer_overlays_before (b, NULL);
set_buffer_overlays_after (b, NULL);
}
/* Reinitialize everything about a buffer except its name and contents
@ -718,8 +731,8 @@ reset_buffer (register struct buffer *b)
b->auto_save_failure_time = 0;
BSET (b, auto_save_file_name, Qnil);
BSET (b, read_only, Qnil);
buffer_set_overlays_before (b, NULL);
buffer_set_overlays_after (b, NULL);
set_buffer_overlays_before (b, NULL);
set_buffer_overlays_after (b, NULL);
b->overlay_center = BEG;
BSET (b, mark_active, Qnil);
BSET (b, point_before_scroll, Qnil);
@ -1691,7 +1704,7 @@ cleaning up all windows currently displaying the buffer to be killed. */)
m = next;
}
BUF_MARKERS (b) = NULL;
buffer_set_intervals (b, NULL);
set_buffer_intervals (b, NULL);
/* Perhaps we should explicitly free the interval tree here... */
}
@ -3238,7 +3251,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
if (prev)
prev->next = next;
else
buffer_set_overlays_before (buf, next);
set_buffer_overlays_before (buf, next);
/* Search thru overlays_after for where to put it. */
other_prev = NULL;
@ -3260,7 +3273,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
if (other_prev)
other_prev->next = tail;
else
buffer_set_overlays_after (buf, tail);
set_buffer_overlays_after (buf, tail);
tail = prev;
}
else
@ -3296,7 +3309,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
if (prev)
prev->next = next;
else
buffer_set_overlays_after (buf, next);
set_buffer_overlays_after (buf, next);
/* Search thru overlays_before for where to put it. */
other_prev = NULL;
@ -3318,7 +3331,7 @@ recenter_overlay_lists (struct buffer *buf, ptrdiff_t pos)
if (other_prev)
other_prev->next = tail;
else
buffer_set_overlays_before (buf, tail);
set_buffer_overlays_before (buf, tail);
tail = prev;
}
}
@ -3423,7 +3436,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
beforep = tail;
}
if (!parent)
buffer_set_overlays_before (current_buffer, tail->next);
set_buffer_overlays_before (current_buffer, tail->next);
else
parent->next = tail->next;
tail = tail->next;
@ -3469,7 +3482,7 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
beforep = tail;
}
if (!parent)
buffer_set_overlays_after (current_buffer, tail->next);
set_buffer_overlays_after (current_buffer, tail->next);
else
parent->next = tail->next;
tail = tail->next;
@ -3483,14 +3496,14 @@ fix_start_end_in_overlays (register ptrdiff_t start, register ptrdiff_t end)
if (beforep)
{
beforep->next = current_buffer->overlays_before;
buffer_set_overlays_before (current_buffer, before_list);
set_buffer_overlays_before (current_buffer, before_list);
}
recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
if (afterp)
{
afterp->next = current_buffer->overlays_after;
buffer_set_overlays_after (current_buffer, after_list);
set_buffer_overlays_after (current_buffer, after_list);
}
recenter_overlay_lists (current_buffer, current_buffer->overlay_center);
}
@ -3567,7 +3580,7 @@ fix_overlays_before (struct buffer *bp, ptrdiff_t prev, ptrdiff_t pos)
if (!right_pair)
{
found->next = bp->overlays_before;
buffer_set_overlays_before (bp, found);
set_buffer_overlays_before (bp, found);
}
else
{
@ -3645,13 +3658,13 @@ for the rear of the overlay advance when text is inserted there
{
if (b->overlays_after)
XOVERLAY (overlay)->next = b->overlays_after;
buffer_set_overlays_after (b, XOVERLAY (overlay));
set_buffer_overlays_after (b, XOVERLAY (overlay));
}
else
{
if (b->overlays_before)
XOVERLAY (overlay)->next = b->overlays_before;
buffer_set_overlays_before (b, XOVERLAY (overlay));
set_buffer_overlays_before (b, XOVERLAY (overlay));
}
/* This puts it in the right list, and in the right order. */
@ -3716,8 +3729,8 @@ unchain_both (struct buffer *b, Lisp_Object overlay)
{
struct Lisp_Overlay *ov = XOVERLAY (overlay);
buffer_set_overlays_before (b, unchain_overlay (b->overlays_before, ov));
buffer_set_overlays_after (b, unchain_overlay (b->overlays_after, ov));
set_buffer_overlays_before (b, unchain_overlay (b->overlays_before, ov));
set_buffer_overlays_after (b, unchain_overlay (b->overlays_after, ov));
eassert (XOVERLAY (overlay)->next == NULL);
}
@ -3812,12 +3825,12 @@ buffer. */)
if (n_end < b->overlay_center)
{
XOVERLAY (overlay)->next = b->overlays_after;
buffer_set_overlays_after (b, XOVERLAY (overlay));
set_buffer_overlays_after (b, XOVERLAY (overlay));
}
else
{
XOVERLAY (overlay)->next = b->overlays_before;
buffer_set_overlays_before (b, XOVERLAY (overlay));
set_buffer_overlays_before (b, XOVERLAY (overlay));
}
/* This puts it in the right list, and in the right order. */
@ -4913,8 +4926,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;
buffer_set_intervals (&buffer_defaults, NULL);
buffer_set_intervals (&buffer_local_symbols, NULL);
set_buffer_intervals (&buffer_defaults, NULL);
set_buffer_intervals (&buffer_local_symbols, NULL);
XSETPVECTYPESIZE (&buffer_defaults, PVEC_BUFFER, pvecsize);
XSETBUFFER (Vbuffer_defaults, &buffer_defaults);
XSETPVECTYPESIZE (&buffer_local_symbols, PVEC_BUFFER, pvecsize);
@ -4938,8 +4951,8 @@ init_buffer_once (void)
BSET (&buffer_defaults, mark_active, Qnil);
BSET (&buffer_defaults, file_format, Qnil);
BSET (&buffer_defaults, auto_save_file_format, Qt);
buffer_set_overlays_before (&buffer_defaults, NULL);
buffer_set_overlays_after (&buffer_defaults, NULL);
set_buffer_overlays_before (&buffer_defaults, NULL);
set_buffer_overlays_after (&buffer_defaults, NULL);
buffer_defaults.overlay_center = BEG;
XSETFASTINT (BVAR (&buffer_defaults, tab_width), 8);

18
src/buffer.h
View file

@ -953,7 +953,7 @@ extern Lisp_Object Qfirst_change_hook;
/* Get text properties of B. */
BUFFER_INLINE INTERVAL
buffer_get_intervals (struct buffer *b)
buffer_intervals (struct buffer *b)
{
eassert (b->text != NULL);
return b->text->intervals;
@ -962,26 +962,12 @@ buffer_get_intervals (struct buffer *b)
/* Set text properties of B to I. */
BUFFER_INLINE void
buffer_set_intervals (struct buffer *b, INTERVAL i)
set_buffer_intervals (struct buffer *b, INTERVAL i)
{
eassert (b->text != NULL);
b->text->intervals = i;
}
/* Set an appropriate overlay of B. */
BUFFER_INLINE void
buffer_set_overlays_before (struct buffer *b, struct Lisp_Overlay *o)
{
b->overlays_before = o;
}
BUFFER_INLINE void
buffer_set_overlays_after (struct buffer *b, struct Lisp_Overlay *o)
{
b->overlays_after = o;
}
/* Non-zero if current buffer has overlays. */
BUFFER_INLINE int

6
src/editfns.c
View file

@ -3936,7 +3936,7 @@ usage: (format STRING &rest OBJECTS) */)
/* If this argument has text properties, record where
in the result string it appears. */
if (string_get_intervals (args[n]))
if (string_intervals (args[n]))
info[n].intervals = arg_intervals = 1;
continue;
@ -4280,7 +4280,7 @@ usage: (format STRING &rest OBJECTS) */)
arguments has text properties, set up text properties of the
result string. */
if (string_get_intervals (args[0]) || arg_intervals)
if (string_intervals (args[0]) || arg_intervals)
{
Lisp_Object len, new_len, props;
struct gcpro gcpro1;
@ -4530,7 +4530,7 @@ Transposing beyond buffer boundaries is an error. */)
Lisp_Object buf;
XSETBUFFER (buf, current_buffer);
cur_intv = buffer_get_intervals (current_buffer);
cur_intv = buffer_intervals (current_buffer);
validate_region (&startr1, &endr1);
validate_region (&startr2, &endr2);

2
src/fileio.c
View file

@ -3146,7 +3146,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);
buffer_set_intervals (current_buffer, NULL);
set_buffer_intervals (current_buffer, NULL);
TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
/* Now we are safe to change the buffer's multibyteness directly. */

6
src/fns.c
View file

@ -628,7 +628,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
ptrdiff_t thislen_byte = SBYTES (this);
memcpy (SDATA (val) + toindex_byte, SDATA (this), SBYTES (this));
if (string_get_intervals (this))
if (string_intervals (this))
{
textprops[num_textprops].argnum = argnum;
textprops[num_textprops].from = 0;
@ -640,7 +640,7 @@ concat (ptrdiff_t nargs, Lisp_Object *args,
/* Copy a single-byte string to a multibyte string. */
else if (STRINGP (this) && STRINGP (val))
{
if (string_get_intervals (this))
if (string_intervals (this))
{
textprops[num_textprops].argnum = argnum;
textprops[num_textprops].from = 0;
@ -1060,7 +1060,7 @@ If you're not sure, whether to use `string-as-multibyte' or
str_as_multibyte (SDATA (new_string), nbytes,
SBYTES (string), NULL);
string = new_string;
string_set_intervals (string, NULL);
set_string_intervals (string, NULL);
}
return string;
}

2
src/indent.c
View file

@ -336,7 +336,7 @@ current_column (void)
/* If the buffer has overlays, text properties,
or multibyte characters, use a more general algorithm. */
if (buffer_get_intervals (current_buffer)
if (buffer_intervals (current_buffer)
|| buffer_has_overlays ()
|| Z != Z_BYTE)
return current_column_1 ();

18
src/insdel.c
View file

@ -844,10 +844,10 @@ insert_1_both (const char *string,
PT + nchars, PT_BYTE + nbytes,
before_markers);
if (buffer_get_intervals (current_buffer))
if (buffer_intervals (current_buffer))
offset_intervals (current_buffer, PT, nchars);
if (!inherit && buffer_get_intervals (current_buffer))
if (!inherit && buffer_intervals (current_buffer))
set_text_properties (make_number (PT), make_number (PT + nchars),
Qnil, Qnil, Qnil);
@ -976,7 +976,7 @@ insert_from_string_1 (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
offset_intervals (current_buffer, PT, nchars);
intervals = string_get_intervals (string);
intervals = string_intervals (string);
/* Get the intervals for the part of the string we are inserting. */
if (nbytes < SBYTES (string))
intervals = copy_intervals (intervals, pos, nchars);
@ -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 (buffer_get_intervals (current_buffer))
if (buffer_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 (buffer_get_intervals (current_buffer))
if (buffer_intervals (current_buffer))
offset_intervals (current_buffer, PT, nchars);
/* Get the intervals for the part of the string we are inserting. */
intervals = buffer_get_intervals (buf);
intervals = buffer_intervals (buf);
if (nchars < BUF_Z (buf) - BUF_BEG (buf))
{
if (buf == current_buffer && PT <= from)
@ -1226,7 +1226,7 @@ adjust_after_replace (ptrdiff_t from, ptrdiff_t from_byte,
else if (len < nchars_del)
adjust_overlays_for_delete (from, nchars_del - len);
if (buffer_get_intervals (current_buffer))
if (buffer_intervals (current_buffer))
offset_intervals (current_buffer, from, len - nchars_del);
if (from < PT)
@ -1412,7 +1412,7 @@ replace_range (ptrdiff_t from, ptrdiff_t to, Lisp_Object new,
/* Get the intervals for the part of the string we are inserting--
not including the combined-before bytes. */
intervals = string_get_intervals (new);
intervals = string_intervals (new);
/* Insert those intervals. */
graft_intervals_into_buffer (intervals, from, inschars,
current_buffer, inherit);
@ -1822,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 (buffer_get_intervals (current_buffer))
if (buffer_intervals (current_buffer))
{
if (preserve_ptr)
{

192
src/intervals.c
View file

@ -62,6 +62,38 @@ static INTERVAL reproduce_tree (INTERVAL, INTERVAL);
/* Utility functions for intervals. */
/* Use these functions to set Lisp_Object
or pointer slots of struct interval. */
static inline void
set_interval_object (INTERVAL i, Lisp_Object obj)
{
eassert (BUFFERP (obj) || STRINGP (obj));
i->up_obj = 1;
i->up.obj = obj;
}
static inline void
set_interval_left (INTERVAL i, INTERVAL left)
{
i->left = left;
}
static inline void
set_interval_right (INTERVAL i, INTERVAL right)
{
i->right = right;
}
/* Make the parent of D be whatever the parent of S is, regardless
of the type. This is used when balancing an interval tree. */
static inline void
copy_interval_parent (INTERVAL d, INTERVAL s)
{
d->up = s->up;
d->up_obj = s->up_obj;
}
/* Create the root interval of some object, a buffer or string. */
@ -79,18 +111,18 @@ create_root_interval (Lisp_Object parent)
new->total_length = (BUF_Z (XBUFFER (parent))
- BUF_BEG (XBUFFER (parent)));
eassert (0 <= TOTAL_LENGTH (new));
buffer_set_intervals (XBUFFER (parent), new);
set_buffer_intervals (XBUFFER (parent), new);
new->position = BEG;
}
else if (STRINGP (parent))
{
new->total_length = SCHARS (parent);
eassert (0 <= TOTAL_LENGTH (new));
string_set_intervals (parent, new);
set_string_intervals (parent, new);
new->position = 0;
}
interval_set_object (new, parent);
set_interval_object (new, parent);
return new;
}
@ -104,7 +136,7 @@ copy_properties (register INTERVAL source, register INTERVAL target)
return;
COPY_INTERVAL_CACHE (source, target);
interval_set_plist (target, Fcopy_sequence (source->plist));
set_interval_plist (target, Fcopy_sequence (source->plist));
}
/* Merge the properties of interval SOURCE into the properties
@ -140,7 +172,7 @@ merge_properties (register INTERVAL source, register INTERVAL target)
if (NILP (val))
{
val = XCAR (o);
interval_set_plist (target, Fcons (sym, Fcons (val, target->plist)));
set_interval_plist (target, Fcons (sym, Fcons (val, target->plist)));
}
o = XCDR (o);
}
@ -322,21 +354,21 @@ rotate_right (INTERVAL interval)
if (! ROOT_INTERVAL_P (interval))
{
if (AM_LEFT_CHILD (interval))
interval_set_left (INTERVAL_PARENT (interval), B);
set_interval_left (INTERVAL_PARENT (interval), B);
else
interval_set_right (INTERVAL_PARENT (interval), B);
set_interval_right (INTERVAL_PARENT (interval), B);
}
interval_copy_parent (B, interval);
copy_interval_parent (B, interval);
/* Make B the parent of A */
i = B->right;
interval_set_right (B, interval);
interval_set_parent (interval, B);
set_interval_right (B, interval);
set_interval_parent (interval, B);
/* Make A point to c */
interval_set_left (interval, i);
set_interval_left (interval, i);
if (i)
interval_set_parent (i, interval);
set_interval_parent (i, interval);
/* A's total length is decreased by the length of B and its left child. */
interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
@ -369,21 +401,21 @@ rotate_left (INTERVAL interval)
if (! ROOT_INTERVAL_P (interval))
{
if (AM_LEFT_CHILD (interval))
interval_set_left (INTERVAL_PARENT (interval), B);
set_interval_left (INTERVAL_PARENT (interval), B);
else
interval_set_right (INTERVAL_PARENT (interval), B);
set_interval_right (INTERVAL_PARENT (interval), B);
}
interval_copy_parent (B, interval);
copy_interval_parent (B, interval);
/* Make B the parent of A */
i = B->left;
interval_set_left (B, interval);
interval_set_parent (interval, B);
set_interval_left (B, interval);
set_interval_parent (interval, B);
/* Make A point to c */
interval_set_right (interval, i);
set_interval_right (interval, i);
if (i)
interval_set_parent (i, interval);
set_interval_parent (i, interval);
/* A's total length is decreased by the length of B and its right child. */
interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
@ -455,9 +487,9 @@ balance_possible_root_interval (register INTERVAL interval)
if (have_parent)
{
if (BUFFERP (parent))
buffer_set_intervals (XBUFFER (parent), interval);
set_buffer_intervals (XBUFFER (parent), interval);
else if (STRINGP (parent))
string_set_intervals (parent, interval);
set_string_intervals (parent, interval);
}
return interval;
@ -493,9 +525,9 @@ buffer_balance_intervals (struct buffer *b)
INTERVAL i;
eassert (b != NULL);
i = buffer_get_intervals (b);
i = buffer_intervals (b);
if (i)
buffer_set_intervals (b, balance_an_interval (i));
set_buffer_intervals (b, balance_an_interval (i));
}
/* Split INTERVAL into two pieces, starting the second piece at
@ -519,20 +551,20 @@ split_interval_right (INTERVAL interval, ptrdiff_t offset)
ptrdiff_t new_length = LENGTH (interval) - offset;
new->position = position + offset;
interval_set_parent (new, interval);
set_interval_parent (new, interval);
if (NULL_RIGHT_CHILD (interval))
{
interval_set_right (interval, new);
set_interval_right (interval, new);
new->total_length = new_length;
eassert (0 <= TOTAL_LENGTH (new));
}
else
{
/* Insert the new node between INTERVAL and its right child. */
interval_set_right (new, interval->right);
interval_set_parent (interval->right, new);
interval_set_right (interval, new);
set_interval_right (new, interval->right);
set_interval_parent (interval->right, new);
set_interval_right (interval, new);
new->total_length = new_length + new->right->total_length;
eassert (0 <= TOTAL_LENGTH (new));
balance_an_interval (new);
@ -564,20 +596,20 @@ split_interval_left (INTERVAL interval, ptrdiff_t offset)
new->position = interval->position;
interval->position = interval->position + offset;
interval_set_parent (new, interval);
set_interval_parent (new, interval);
if (NULL_LEFT_CHILD (interval))
{
interval_set_left (interval, new);
set_interval_left (interval, new);
new->total_length = new_length;
eassert (0 <= TOTAL_LENGTH (new));
}
else
{
/* Insert the new node between INTERVAL and its left child. */
interval_set_left (new, interval->left);
interval_set_parent (new->left, new);
interval_set_left (interval, new);
set_interval_left (new, interval->left);
set_interval_parent (new->left, new);
set_interval_left (interval, new);
new->total_length = new_length + new->left->total_length;
eassert (0 <= TOTAL_LENGTH (new));
balance_an_interval (new);
@ -952,20 +984,20 @@ adjust_intervals_for_insertion (INTERVAL tree,
RESET_INTERVAL (&newi);
pleft = prev ? prev->plist : Qnil;
pright = i ? i->plist : Qnil;
interval_set_plist (&newi, merge_properties_sticky (pleft, pright));
set_interval_plist (&newi, merge_properties_sticky (pleft, pright));
if (! prev) /* i.e. position == BEG */
{
if (! intervals_equal (i, &newi))
{
i = split_interval_left (i, length);
interval_set_plist (i, newi.plist);
set_interval_plist (i, newi.plist);
}
}
else if (! intervals_equal (prev, &newi))
{
prev = split_interval_right (prev, position - prev->position);
interval_set_plist (prev, newi.plist);
set_interval_plist (prev, newi.plist);
if (i && intervals_equal (prev, i))
merge_interval_right (prev);
}
@ -1190,8 +1222,8 @@ delete_node (register INTERVAL i)
this->total_length += migrate_amt;
}
eassert (0 <= TOTAL_LENGTH (this));
interval_set_left (this, migrate);
interval_set_parent (migrate, this);
set_interval_left (this, migrate);
set_interval_parent (migrate, this);
return i->right;
}
@ -1216,12 +1248,12 @@ delete_interval (register INTERVAL i)
GET_INTERVAL_OBJECT (owner, i);
parent = delete_node (i);
if (parent)
interval_set_object (parent, owner);
set_interval_object (parent, owner);
if (BUFFERP (owner))
buffer_set_intervals (XBUFFER (owner), parent);
set_buffer_intervals (XBUFFER (owner), parent);
else if (STRINGP (owner))
string_set_intervals (owner, parent);
set_string_intervals (owner, parent);
else
abort ();
@ -1231,15 +1263,15 @@ delete_interval (register INTERVAL i)
parent = INTERVAL_PARENT (i);
if (AM_LEFT_CHILD (i))
{
interval_set_left (parent, delete_node (i));
set_interval_left (parent, delete_node (i));
if (parent->left)
interval_set_parent (parent->left, parent);
set_interval_parent (parent->left, parent);
}
else
{
interval_set_right (parent, delete_node (i));
set_interval_right (parent, delete_node (i));
if (parent->right)
interval_set_parent (parent->right, parent);
set_interval_parent (parent->right, parent);
}
}
@ -1320,8 +1352,8 @@ static void
adjust_intervals_for_deletion (struct buffer *buffer,
ptrdiff_t start, ptrdiff_t length)
{
register ptrdiff_t left_to_delete = length;
register INTERVAL tree = buffer_get_intervals (buffer);
ptrdiff_t left_to_delete = length;
INTERVAL tree = buffer_intervals (buffer);
Lisp_Object parent;
ptrdiff_t offset;
@ -1336,7 +1368,7 @@ adjust_intervals_for_deletion (struct buffer *buffer,
if (length == TOTAL_LENGTH (tree))
{
buffer_set_intervals (buffer, NULL);
set_buffer_intervals (buffer, NULL);
return;
}
@ -1353,10 +1385,10 @@ adjust_intervals_for_deletion (struct buffer *buffer,
{
left_to_delete -= interval_deletion_adjustment (tree, start - offset,
left_to_delete);
tree = buffer_get_intervals (buffer);
tree = buffer_intervals (buffer);
if (left_to_delete == tree->total_length)
{
buffer_set_intervals (buffer, NULL);
set_buffer_intervals (buffer, NULL);
return;
}
}
@ -1370,11 +1402,11 @@ adjust_intervals_for_deletion (struct buffer *buffer,
void
offset_intervals (struct buffer *buffer, ptrdiff_t start, ptrdiff_t length)
{
if (!buffer_get_intervals (buffer) || length == 0)
if (!buffer_intervals (buffer) || length == 0)
return;
if (length > 0)
adjust_intervals_for_insertion (buffer_get_intervals (buffer),
adjust_intervals_for_insertion (buffer_intervals (buffer),
start, length);
else
{
@ -1510,9 +1542,9 @@ reproduce_interval (INTERVAL source)
copy_properties (source, target);
if (! NULL_LEFT_CHILD (source))
interval_set_left (target, reproduce_tree (source->left, target));
set_interval_left (target, reproduce_tree (source->left, target));
if (! NULL_RIGHT_CHILD (source))
interval_set_right (target, reproduce_tree (source->right, target));
set_interval_right (target, reproduce_tree (source->right, target));
return target;
}
@ -1525,18 +1557,16 @@ reproduce_interval (INTERVAL source)
static INTERVAL
reproduce_tree (INTERVAL source, INTERVAL parent)
{
register INTERVAL target = reproduce_interval (source);
interval_set_parent (target, parent);
INTERVAL target = reproduce_interval (source);
set_interval_parent (target, parent);
return target;
}
static INTERVAL
reproduce_tree_obj (INTERVAL source, Lisp_Object parent)
{
register INTERVAL target = reproduce_interval (source);
interval_set_object (target, parent);
INTERVAL target = reproduce_interval (source);
set_interval_object (target, parent);
return target;
}
@ -1582,12 +1612,10 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
ptrdiff_t length, struct buffer *buffer,
int inherit)
{
register INTERVAL under, over, this;
register INTERVAL tree;
INTERVAL tree = buffer_intervals (buffer);
INTERVAL under, over, this;
ptrdiff_t over_used;
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.
To prevent inheritance, we must clear out the properties
@ -1616,9 +1644,9 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
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);
set_buffer_intervals (buffer, reproduce_tree_obj (source, buf));
buffer_intervals (buffer)->position = BUF_BEG (buffer);
eassert (buffer_intervals (buffer)->up_obj == 1);
return;
}
else if (!tree)
@ -1876,7 +1904,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 (!buffer_get_intervals (current_buffer) && ! have_overlays)
if (!buffer_intervals (current_buffer) && ! have_overlays)
{
temp_set_point_both (current_buffer, charpos, bytepos);
return;
@ -1885,7 +1913,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 (buffer_get_intervals (current_buffer), charpos);
to = find_interval (buffer_intervals (current_buffer), charpos);
if (charpos == BEGV)
toprev = 0;
else if (to && to->position == charpos)
@ -1899,7 +1927,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 (buffer_get_intervals (current_buffer), buffer_point);
from = find_interval (buffer_intervals (current_buffer), buffer_point);
if (buffer_point == BEGV)
fromprev = 0;
else if (from && from->position == PT)
@ -2005,7 +2033,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 (buffer_get_intervals (current_buffer), charpos);
to = find_interval (buffer_intervals (current_buffer), charpos);
if (charpos == BEGV)
toprev = 0;
else if (to && to->position == charpos)
@ -2138,11 +2166,11 @@ get_property_and_range (ptrdiff_t pos, Lisp_Object prop, Lisp_Object *val,
INTERVAL i, prev, next;
if (NILP (object))
i = find_interval (buffer_get_intervals (current_buffer), pos);
i = find_interval (buffer_intervals (current_buffer), pos);
else if (BUFFERP (object))
i = find_interval (buffer_get_intervals (XBUFFER (object)), pos);
i = find_interval (buffer_intervals (XBUFFER (object)), pos);
else if (STRINGP (object))
i = find_interval (string_get_intervals (object), pos);
i = find_interval (string_intervals (object), pos);
else
abort ();
@ -2269,13 +2297,13 @@ void
copy_intervals_to_string (Lisp_Object string, struct buffer *buffer,
ptrdiff_t position, ptrdiff_t length)
{
INTERVAL interval_copy = copy_intervals (buffer_get_intervals (buffer),
INTERVAL interval_copy = copy_intervals (buffer_intervals (buffer),
position, length);
if (!interval_copy)
return;
interval_set_object (interval_copy, string);
string_set_intervals (string, interval_copy);
set_interval_object (interval_copy, string);
set_string_intervals (string, interval_copy);
}
/* Return 1 if strings S1 and S2 have identical properties; 0 otherwise.
@ -2288,8 +2316,8 @@ compare_string_intervals (Lisp_Object s1, Lisp_Object s2)
ptrdiff_t pos = 0;
ptrdiff_t end = SCHARS (s1);
i1 = find_interval (string_get_intervals (s1), 0);
i2 = find_interval (string_get_intervals (s2), 0);
i1 = find_interval (string_intervals (s1), 0);
i2 = find_interval (string_intervals (s2), 0);
while (pos < end)
{
@ -2414,13 +2442,13 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag,
{
if ((i)->left)
{
interval_set_plist (i, i->left->plist);
set_interval_plist (i, i->left->plist);
(i)->left->total_length = 0;
delete_interval ((i)->left);
}
else
{
interval_set_plist (i, i->right->plist);
set_interval_plist (i, i->right->plist);
(i)->right->total_length = 0;
delete_interval ((i)->right);
}
@ -2434,7 +2462,7 @@ set_intervals_multibyte_1 (INTERVAL i, int multi_flag,
void
set_intervals_multibyte (int multi_flag)
{
INTERVAL i = buffer_get_intervals (current_buffer);
INTERVAL i = buffer_intervals (current_buffer);
if (i)
set_intervals_multibyte_1 (i, multi_flag, BEG, BEG_BYTE, Z, Z_BYTE);

39
src/intervals.h
View file

@ -137,47 +137,16 @@ struct interval
or pointer slots of struct interval. */
INTERVALS_INLINE void
interval_set_parent (INTERVAL i, INTERVAL parent)
set_interval_parent (INTERVAL i, INTERVAL parent)
{
i->up_obj = 0;
i->up.interval = parent;
}
INTERVALS_INLINE void
interval_set_object (INTERVAL i, Lisp_Object obj)
{
eassert (BUFFERP (obj) || STRINGP (obj));
i->up_obj = 1;
i->up.obj = obj;
}
INTERVALS_INLINE void
interval_set_left (INTERVAL i, INTERVAL left)
{
i->left = left;
}
INTERVALS_INLINE void
interval_set_right (INTERVAL i, INTERVAL right)
{
i->right = right;
}
INTERVALS_INLINE Lisp_Object
interval_set_plist (INTERVAL i, Lisp_Object plist)
set_interval_plist (INTERVAL i, Lisp_Object plist)
{
i->plist = plist;
return plist;
}
/* Make the parent of D be whatever the parent of S is, regardless
of the type. This is used when balancing an interval tree. */
INTERVALS_INLINE void
interval_copy_parent (INTERVAL d, INTERVAL s)
{
d->up = s->up;
d->up_obj = s->up_obj;
}
/* Get the parent interval, if any, otherwise a null pointer. Useful
@ -191,11 +160,11 @@ interval_copy_parent (INTERVAL d, INTERVAL s)
{ \
(i)->total_length = (i)->position = 0; \
(i)->left = (i)->right = NULL; \
interval_set_parent (i, NULL); \
set_interval_parent (i, NULL); \
(i)->write_protect = 0; \
(i)->visible = 0; \
(i)->front_sticky = (i)->rear_sticky = 0; \
interval_set_plist (i, Qnil); \
set_interval_plist (i, Qnil); \
}
/* Copy the cached property values of interval FROM to interval TO. */

4
src/lisp.h
View file

@ -2458,7 +2458,7 @@ set_overlay_plist (Lisp_Object overlay, Lisp_Object plist)
/* Get text properties of S. */
LISP_INLINE INTERVAL
string_get_intervals (Lisp_Object s)
string_intervals (Lisp_Object s)
{
return XSTRING (s)->intervals;
}
@ -2466,7 +2466,7 @@ string_get_intervals (Lisp_Object s)
/* Set text properties of S to I. */
LISP_INLINE void
string_set_intervals (Lisp_Object s, INTERVAL i)
set_string_intervals (Lisp_Object s, INTERVAL i)
{
XSTRING (s)->intervals = i;
}

6
src/lread.c
View file

@ -3189,8 +3189,8 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
/* Check for text properties in each interval.
substitute_in_interval contains part of the logic. */
INTERVAL root_interval = string_get_intervals (subtree);
Lisp_Object arg = Fcons (object, placeholder);
INTERVAL root_interval = string_intervals (subtree);
Lisp_Object arg = Fcons (object, placeholder);
traverse_intervals_noorder (root_interval,
&substitute_in_interval, arg);
@ -3211,7 +3211,7 @@ substitute_in_interval (INTERVAL interval, Lisp_Object arg)
Lisp_Object object = Fcar (arg);
Lisp_Object placeholder = Fcdr (arg);
SUBSTITUTE (interval->plist, interval_set_plist (interval, true_value));
SUBSTITUTE (interval->plist, set_interval_plist (interval, true_value));
}

10
src/print.c
View file

@ -1194,7 +1194,7 @@ print_preprocess (Lisp_Object obj)
{
case Lisp_String:
/* A string may have text properties, which can be circular. */
traverse_intervals_noorder (string_get_intervals (obj),
traverse_intervals_noorder (string_intervals (obj),
print_preprocess_string, Qnil);
break;
@ -1297,7 +1297,7 @@ static Lisp_Object
print_prune_string_charset (Lisp_Object string)
{
print_check_string_result = 0;
traverse_intervals (string_get_intervals (string), 0,
traverse_intervals (string_intervals (string), 0,
print_check_string_charset_prop, string);
if (! (print_check_string_result & PRINT_STRING_UNSAFE_CHARSET_FOUND))
{
@ -1408,7 +1408,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
if (! EQ (Vprint_charset_text_property, Qt))
obj = print_prune_string_charset (obj);
if (string_get_intervals (obj))
if (string_intervals (obj))
{
PRINTCHAR ('#');
PRINTCHAR ('(');
@ -1499,9 +1499,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
}
PRINTCHAR ('\"');
if (string_get_intervals (obj))
if (string_intervals (obj))
{
traverse_intervals (string_get_intervals (obj),
traverse_intervals (string_intervals (obj),
0, print_interval, printcharfun);
PRINTCHAR (')');
}

26
src/textprop.c
View file

@ -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 = buffer_get_intervals (b);
i = buffer_intervals (b);
/* If there's no text, there are no properties. */
if (BUF_BEGV (b) == BUF_ZV (b))
@ -161,7 +161,7 @@ validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *en
XSETFASTINT (*begin, XFASTINT (*begin));
if (begin != end)
XSETFASTINT (*end, XFASTINT (*end));
i = string_get_intervals (object);
i = string_intervals (object);
if (len == 0)
return NULL;
@ -338,7 +338,7 @@ set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object)
}
/* Store new properties. */
interval_set_plist (interval, Fcopy_sequence (properties));
set_interval_plist (interval, Fcopy_sequence (properties));
}
/* Add the properties of PLIST to the interval I, or set
@ -411,7 +411,7 @@ add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object)
record_property_change (i->position, LENGTH (i),
sym1, Qnil, object);
}
interval_set_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
changed++;
}
}
@ -484,7 +484,7 @@ remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object
}
if (changed)
interval_set_plist (i, current_plist);
set_interval_plist (i, current_plist);
return changed;
}
@ -510,13 +510,13 @@ interval_of (ptrdiff_t position, Lisp_Object object)
beg = BUF_BEGV (b);
end = BUF_ZV (b);
i = buffer_get_intervals (b);
i = buffer_intervals (b);
}
else
{
beg = 0;
end = SCHARS (object);
i = string_get_intervals (object);
i = string_intervals (object);
}
if (!(beg <= position && position <= end))
@ -1274,10 +1274,10 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
&& XFASTINT (start) == 0
&& XFASTINT (end) == SCHARS (object))
{
if (!string_get_intervals (object))
if (!string_intervals (object))
return Qnil;
string_set_intervals (object, NULL);
set_string_intervals (object, NULL);
return Qt;
}
@ -1339,7 +1339,7 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
return;
if (i == NULL)
i = find_interval (buffer_get_intervals (XBUFFER (buffer)), s);
i = find_interval (buffer_intervals (XBUFFER (buffer)), s);
if (i->position != s)
{
@ -1993,10 +1993,10 @@ void
verify_interval_modification (struct buffer *buf,
ptrdiff_t start, ptrdiff_t end)
{
register INTERVAL intervals = buffer_get_intervals (buf);
register INTERVAL i;
INTERVAL intervals = buffer_intervals (buf);
INTERVAL i;
Lisp_Object hooks;
register Lisp_Object prev_mod_hooks;
Lisp_Object prev_mod_hooks;
Lisp_Object mod_hooks;
struct gcpro gcpro1;