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.

15 files changed, 223 insertions, 205 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 1b2a6412896..7b8bf5e52ad 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -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.
diff --git a/src/alloc.c b/src/alloc.c
index 1d484d4a322..522f33f5379 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -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++;
               }
diff --git a/src/buffer.c b/src/buffer.c
index 56d6231f5f8..75377abb758 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;
-  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);
diff --git a/src/buffer.h b/src/buffer.h
index 7a6bddee5ec..507b15e8b4a 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -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
diff --git a/src/editfns.c b/src/editfns.c
index b7feb733782..5445561fad3 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -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);
diff --git a/src/fileio.c b/src/fileio.c
index 5991a238ffc..5d3ba6a14ae 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -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.  */
diff --git a/src/fns.c b/src/fns.c
index 6b6da59a7b8..443e98b2f04 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -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;
 }
diff --git a/src/indent.c b/src/indent.c
index 881e5d7ddaf..d4b15e876f3 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 (buffer_get_intervals (current_buffer)
+  if (buffer_intervals (current_buffer)
       || buffer_has_overlays ()
       || Z != Z_BYTE)
     return current_column_1 ();
diff --git a/src/insdel.c b/src/insdel.c
index 14d2dab084d..fe10879b9f8 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 (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)
         {
diff --git a/src/intervals.c b/src/intervals.c
index b0ef7c8d3b9..2dcf208a676 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -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);
diff --git a/src/intervals.h b/src/intervals.h
index a5166c6376f..01e72d7c9db 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -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.  */
diff --git a/src/lisp.h b/src/lisp.h
index 44a757f19c7..4a6edcda53c 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -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;
 }
diff --git a/src/lread.c b/src/lread.c
index 94ae4dd4282..e2ad03b349f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -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));
 }
 
 
diff --git a/src/print.c b/src/print.c
index 23ad6c0a256..9d633ecce51 100644
--- a/src/print.c
+++ b/src/print.c
@@ -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 (')');
             }
diff --git a/src/textprop.c b/src/textprop.c
index ac1980fde78..20d98b0e6f3 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 = 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;