From 0c94c8d603031f6b665ae7f3136ca77fb573fd7e Mon Sep 17 00:00:00 2001 From: Paul Eggert Date: Fri, 17 Aug 2012 14:12:11 -0700 Subject: [PATCH] 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. --- src/ChangeLog | 22 ++++++ src/alloc.c | 6 +- src/buffer.c | 71 ++++++++++-------- src/buffer.h | 18 +---- src/editfns.c | 6 +- src/fileio.c | 2 +- src/fns.c | 6 +- src/indent.c | 2 +- src/insdel.c | 18 ++--- src/intervals.c | 192 +++++++++++++++++++++++++++--------------------- src/intervals.h | 39 +--------- src/lisp.h | 4 +- src/lread.c | 6 +- src/print.c | 10 +-- src/textprop.c | 26 +++---- 15 files changed, 223 insertions(+), 205 deletions(-) diff --git a/src/ChangeLog b/src/ChangeLog index 1b2a641289..7b8bf5e52a 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,5 +1,27 @@ 2012-08-17 Paul Eggert + 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 1d484d4a32..522f33f537 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 56d6231f5f..75377abb75 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 7a6bddee5e..507b15e8b4 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 b7feb73378..5445561fad 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 5991a238ff..5d3ba6a14a 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 6b6da59a7b..443e98b2f0 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 881e5d7dda..d4b15e876f 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 14d2dab084..fe10879b9f 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 b0ef7c8d3b..2dcf208a67 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 a5166c6376..01e72d7c9d 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 44a757f19c..4a6edcda53 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 94ae4dd428..e2ad03b349 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 23ad6c0a25..9d633ecce5 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 ac1980fde7..20d98b0e6f 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; -- 2.20.1