[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Emacs-diffs] /srv/bzr/emacs/trunk r109666: A few more naming-convention
|
From: |
Paul Eggert |
|
Subject: |
[Emacs-diffs] /srv/bzr/emacs/trunk r109666: A few more naming-convention fixes for getters and setters. |
|
Date: |
Fri, 17 Aug 2012 14:12:11 -0700 |
|
User-agent: |
Bazaar (2.5.0) |
------------------------------------------------------------
revno: 109666
committer: Paul Eggert <address@hidden>
branch nick: trunk
timestamp: Fri 2012-08-17 14:12:11 -0700
message:
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.
modified:
src/ChangeLog
src/alloc.c
src/buffer.c
src/buffer.h
src/editfns.c
src/fileio.c
src/fns.c
src/indent.c
src/insdel.c
src/intervals.c
src/intervals.h
src/lisp.h
src/lread.c
src/print.c
src/textprop.c
=== modified file 'src/ChangeLog'
--- a/src/ChangeLog 2012-08-17 17:09:45 +0000
+++ b/src/ChangeLog 2012-08-17 21:12:11 +0000
@@ -1,5 +1,27 @@
2012-08-17 Paul Eggert <address@hidden>
+ 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.
=== modified file 'src/alloc.c'
--- a/src/alloc.c 2012-08-14 21:38:06 +0000
+++ b/src/alloc.c 2012-08-17 21:12:11 +0000
@@ -5836,7 +5836,7 @@
/* ...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 @@
}
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 @@
{
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++;
}
=== modified file 'src/buffer.c'
--- a/src/buffer.c 2012-08-14 04:49:18 +0000
+++ b/src/buffer.c 2012-08-17 21:12:11 +0000
@@ -360,7 +360,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
{
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 @@
{
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 @@
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 @@
/* 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 @@
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);
=== modified file 'src/buffer.h'
--- a/src/buffer.h 2012-08-14 04:49:18 +0000
+++ b/src/buffer.h 2012-08-17 21:12:11 +0000
@@ -953,7 +953,7 @@
/* 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 @@
/* 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
=== modified file 'src/editfns.c'
--- a/src/editfns.c 2012-08-16 21:58:44 +0000
+++ b/src/editfns.c 2012-08-17 21:12:11 +0000
@@ -3936,7 +3936,7 @@
/* 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 @@
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 @@
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);
=== modified file 'src/fileio.c'
--- a/src/fileio.c 2012-08-16 21:58:44 +0000
+++ b/src/fileio.c 2012-08-17 21:12:11 +0000
@@ -3146,7 +3146,7 @@
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. */
=== modified file 'src/fns.c'
--- a/src/fns.c 2012-08-17 17:08:30 +0000
+++ b/src/fns.c 2012-08-17 21:12:11 +0000
@@ -628,7 +628,7 @@
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 @@
/* 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 @@
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;
}
=== modified file 'src/indent.c'
--- a/src/indent.c 2012-08-13 03:39:07 +0000
+++ b/src/indent.c 2012-08-17 21:12:11 +0000
@@ -336,7 +336,7 @@
/* 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 ();
=== modified file 'src/insdel.c'
--- a/src/insdel.c 2012-08-13 03:39:07 +0000
+++ b/src/insdel.c 2012-08-17 21:12:11 +0000
@@ -844,10 +844,10 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 @@
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)
{
=== modified file 'src/intervals.c'
--- a/src/intervals.c 2012-08-17 05:35:39 +0000
+++ b/src/intervals.c 2012-08-17 21:12:11 +0000
@@ -62,6 +62,38 @@
/* 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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
if (length == TOTAL_LENGTH (tree))
{
- buffer_set_intervals (buffer, NULL);
+ set_buffer_intervals (buffer, NULL);
return;
}
@@ -1353,10 +1385,10 @@
{
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
/* 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 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 @@
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 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 @@
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 @@
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 @@
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 @@
{
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 @@
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);
=== modified file 'src/intervals.h'
--- a/src/intervals.h 2012-08-10 09:37:43 +0000
+++ b/src/intervals.h 2012-08-17 21:12:11 +0000
@@ -137,47 +137,16 @@
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 @@
{ \
(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. */
=== modified file 'src/lisp.h'
--- a/src/lisp.h 2012-08-17 17:08:30 +0000
+++ b/src/lisp.h 2012-08-17 21:12:11 +0000
@@ -2458,7 +2458,7 @@
/* 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 @@
/* 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;
}
=== modified file 'src/lread.c'
--- a/src/lread.c 2012-08-16 01:18:07 +0000
+++ b/src/lread.c 2012-08-17 21:12:11 +0000
@@ -3189,8 +3189,8 @@
/* 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 @@
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));
}
=== modified file 'src/print.c'
--- a/src/print.c 2012-08-14 04:49:18 +0000
+++ b/src/print.c 2012-08-17 21:12:11 +0000
@@ -1194,7 +1194,7 @@
{
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 @@
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 @@
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 @@
}
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 (')');
}
=== modified file 'src/textprop.c'
--- a/src/textprop.c 2012-08-08 12:12:40 +0000
+++ b/src/textprop.c 2012-08-17 21:12:11 +0000
@@ -143,7 +143,7 @@
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 @@
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 @@
}
/* 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 @@
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 @@
}
if (changed)
- interval_set_plist (i, current_plist);
+ set_interval_plist (i, current_plist);
return changed;
}
@@ -510,13 +510,13 @@
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 @@
&& 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 @@
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 @@
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;
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [Emacs-diffs] /srv/bzr/emacs/trunk r109666: A few more naming-convention fixes for getters and setters.,
Paul Eggert <=