1992-09-17 02:26:53 +00:00
|
|
|
|
/* Code for doing intervals.
|
1997-04-15 04:56:39 +00:00
|
|
|
|
Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
This file is part of GNU Emacs.
|
|
|
|
|
|
|
|
|
|
GNU Emacs is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
1993-07-31 21:58:03 +00:00
|
|
|
|
the Free Software Foundation; either version 2, or (at your option)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
any later version.
|
|
|
|
|
|
|
|
|
|
GNU Emacs is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with GNU Emacs; see the file COPYING. If not, write to
|
1996-01-15 09:18:04 +00:00
|
|
|
|
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
|
|
|
Boston, MA 02111-1307, USA. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* NOTES:
|
|
|
|
|
|
|
|
|
|
Have to ensure that we can't put symbol nil on a plist, or some
|
|
|
|
|
functions may work incorrectly.
|
|
|
|
|
|
|
|
|
|
An idea: Have the owner of the tree keep count of splits and/or
|
|
|
|
|
insertion lengths (in intervals), and balance after every N.
|
|
|
|
|
|
|
|
|
|
Need to call *_left_hook when buffer is killed.
|
|
|
|
|
|
|
|
|
|
Scan for zero-length, or 0-length to see notes about handling
|
|
|
|
|
zero length interval-markers.
|
|
|
|
|
|
|
|
|
|
There are comments around about freeing intervals. It might be
|
|
|
|
|
faster to explicitly free them (put them on the free list) than
|
|
|
|
|
to GC them.
|
|
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
1993-09-10 06:15:46 +00:00
|
|
|
|
#include <config.h>
|
1992-09-17 02:26:53 +00:00
|
|
|
|
#include "lisp.h"
|
|
|
|
|
#include "intervals.h"
|
|
|
|
|
#include "buffer.h"
|
1993-11-10 20:11:44 +00:00
|
|
|
|
#include "puresize.h"
|
1994-09-19 00:12:39 +00:00
|
|
|
|
#include "keyboard.h"
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* The rest of the file is within this conditional. */
|
1992-10-02 20:02:51 +00:00
|
|
|
|
#ifdef USE_TEXT_PROPERTIES
|
|
|
|
|
|
1994-02-04 01:18:01 +00:00
|
|
|
|
/* Test for membership, allowing for t (actually any non-cons) to mean the
|
|
|
|
|
universal set. */
|
|
|
|
|
|
|
|
|
|
#define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
|
|
|
|
|
|
1994-12-04 21:07:03 +00:00
|
|
|
|
#define min(x, y) ((x) < (y) ? (x) : (y))
|
|
|
|
|
|
1993-11-25 07:47:14 +00:00
|
|
|
|
Lisp_Object merge_properties_sticky ();
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Utility functions for intervals. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Create the root interval of some object, a buffer or string. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
create_root_interval (parent)
|
|
|
|
|
Lisp_Object parent;
|
|
|
|
|
{
|
1993-11-10 20:11:44 +00:00
|
|
|
|
INTERVAL new;
|
|
|
|
|
|
|
|
|
|
CHECK_IMPURE (parent);
|
|
|
|
|
|
|
|
|
|
new = make_interval ();
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1994-09-27 02:30:34 +00:00
|
|
|
|
if (BUFFERP (parent))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1993-07-18 06:24:25 +00:00
|
|
|
|
new->total_length = (BUF_Z (XBUFFER (parent))
|
|
|
|
|
- BUF_BEG (XBUFFER (parent)));
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (XBUFFER (parent)) = new;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
1994-09-27 02:30:34 +00:00
|
|
|
|
else if (STRINGP (parent))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
new->total_length = XSTRING (parent)->size;
|
|
|
|
|
XSTRING (parent)->intervals = new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
new->parent = (INTERVAL) parent;
|
|
|
|
|
new->position = 1;
|
|
|
|
|
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Make the interval TARGET have exactly the properties of SOURCE */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
copy_properties (source, target)
|
|
|
|
|
register INTERVAL source, target;
|
|
|
|
|
{
|
|
|
|
|
if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
COPY_INTERVAL_CACHE (source, target);
|
|
|
|
|
target->plist = Fcopy_sequence (source->plist);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Merge the properties of interval SOURCE into the properties
|
1993-03-01 08:56:22 +00:00
|
|
|
|
of interval TARGET. That is to say, each property in SOURCE
|
|
|
|
|
is added to TARGET if TARGET has no such property as yet. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
merge_properties (source, target)
|
|
|
|
|
register INTERVAL source, target;
|
|
|
|
|
{
|
|
|
|
|
register Lisp_Object o, sym, val;
|
|
|
|
|
|
|
|
|
|
if (DEFAULT_INTERVAL_P (source) && DEFAULT_INTERVAL_P (target))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
MERGE_INTERVAL_CACHE (source, target);
|
|
|
|
|
|
|
|
|
|
o = source->plist;
|
|
|
|
|
while (! EQ (o, Qnil))
|
|
|
|
|
{
|
|
|
|
|
sym = Fcar (o);
|
|
|
|
|
val = Fmemq (sym, target->plist);
|
|
|
|
|
|
|
|
|
|
if (NILP (val))
|
|
|
|
|
{
|
|
|
|
|
o = Fcdr (o);
|
|
|
|
|
val = Fcar (o);
|
|
|
|
|
target->plist = Fcons (sym, Fcons (val, target->plist));
|
|
|
|
|
o = Fcdr (o);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
o = Fcdr (Fcdr (o));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Return 1 if the two intervals have the same properties,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
0 otherwise. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
intervals_equal (i0, i1)
|
|
|
|
|
INTERVAL i0, i1;
|
|
|
|
|
{
|
|
|
|
|
register Lisp_Object i0_cdr, i0_sym, i1_val;
|
|
|
|
|
register i1_len;
|
|
|
|
|
|
|
|
|
|
if (DEFAULT_INTERVAL_P (i0) && DEFAULT_INTERVAL_P (i1))
|
|
|
|
|
return 1;
|
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
if (DEFAULT_INTERVAL_P (i0) || DEFAULT_INTERVAL_P (i1))
|
|
|
|
|
return 0;
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
i1_len = XFASTINT (Flength (i1->plist));
|
|
|
|
|
if (i1_len & 0x1) /* Paranoia -- plists are always even */
|
|
|
|
|
abort ();
|
|
|
|
|
i1_len /= 2;
|
|
|
|
|
i0_cdr = i0->plist;
|
|
|
|
|
while (!NILP (i0_cdr))
|
|
|
|
|
{
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Lengths of the two plists were unequal. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (i1_len == 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
i0_sym = Fcar (i0_cdr);
|
|
|
|
|
i1_val = Fmemq (i0_sym, i1->plist);
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* i0 has something i1 doesn't. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (EQ (i1_val, Qnil))
|
|
|
|
|
return 0;
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* i0 and i1 both have sym, but it has different values in each. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
i0_cdr = Fcdr (i0_cdr);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (! EQ (Fcar (Fcdr (i1_val)), Fcar (i0_cdr)))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
i0_cdr = Fcdr (i0_cdr);
|
|
|
|
|
i1_len--;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Lengths of the two plists were unequal. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (i1_len > 0)
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int icount;
|
|
|
|
|
static int idepth;
|
|
|
|
|
static int zero_length;
|
|
|
|
|
|
|
|
|
|
/* Traverse an interval tree TREE, performing FUNCTION on each node.
|
1993-02-25 20:24:43 +00:00
|
|
|
|
Pass FUNCTION two args: an interval, and ARG. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
void
|
1993-02-25 20:24:43 +00:00
|
|
|
|
traverse_intervals (tree, position, depth, function, arg)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
INTERVAL tree;
|
1992-10-14 23:12:09 +00:00
|
|
|
|
int position, depth;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
void (* function) ();
|
1993-02-25 20:24:43 +00:00
|
|
|
|
Lisp_Object arg;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
if (NULL_INTERVAL_P (tree))
|
|
|
|
|
return;
|
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
traverse_intervals (tree->left, position, depth + 1, function, arg);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
position += LEFT_TOTAL_LENGTH (tree);
|
|
|
|
|
tree->position = position;
|
1993-02-25 20:24:43 +00:00
|
|
|
|
(*function) (tree, arg);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
position += LENGTH (tree);
|
1993-03-01 08:56:22 +00:00
|
|
|
|
traverse_intervals (tree->right, position, depth + 1, function, arg);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* These functions are temporary, for debugging purposes only. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL search_interval, found_interval;
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
check_for_interval (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
if (i == search_interval)
|
|
|
|
|
{
|
|
|
|
|
found_interval = i;
|
|
|
|
|
icount++;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
search_for_interval (i, tree)
|
|
|
|
|
register INTERVAL i, tree;
|
|
|
|
|
{
|
|
|
|
|
icount = 0;
|
|
|
|
|
search_interval = i;
|
|
|
|
|
found_interval = NULL_INTERVAL;
|
1993-02-25 20:24:43 +00:00
|
|
|
|
traverse_intervals (tree, 1, 0, &check_for_interval, Qnil);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return found_interval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
inc_interval_count (i)
|
|
|
|
|
INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
icount++;
|
|
|
|
|
if (LENGTH (i) == 0)
|
|
|
|
|
zero_length++;
|
|
|
|
|
if (depth > idepth)
|
|
|
|
|
idepth = depth;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
count_intervals (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
icount = 0;
|
|
|
|
|
idepth = 0;
|
|
|
|
|
zero_length = 0;
|
1993-02-25 20:24:43 +00:00
|
|
|
|
traverse_intervals (i, 1, 0, &inc_interval_count, Qnil);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
return icount;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
root_interval (interval)
|
|
|
|
|
INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL i = interval;
|
|
|
|
|
|
|
|
|
|
while (! ROOT_INTERVAL_P (i))
|
|
|
|
|
i = i->parent;
|
|
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Assuming that a left child exists, perform the following operation:
|
|
|
|
|
|
|
|
|
|
A B
|
|
|
|
|
/ \ / \
|
|
|
|
|
B => A
|
|
|
|
|
/ \ / \
|
|
|
|
|
c c
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
rotate_right (interval)
|
|
|
|
|
INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
INTERVAL i;
|
|
|
|
|
INTERVAL B = interval->left;
|
1994-01-02 19:01:15 +00:00
|
|
|
|
int old_total = interval->total_length;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Deal with any Parent of A; make it point to B. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (! ROOT_INTERVAL_P (interval))
|
|
|
|
|
if (AM_LEFT_CHILD (interval))
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->parent->left = B;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
else
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->parent->right = B;
|
|
|
|
|
B->parent = interval->parent;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
/* Make B the parent of A */
|
|
|
|
|
i = B->right;
|
|
|
|
|
B->right = interval;
|
|
|
|
|
interval->parent = B;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
/* Make A point to c */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
interval->left = i;
|
|
|
|
|
if (! NULL_INTERVAL_P (i))
|
|
|
|
|
i->parent = interval;
|
1994-01-02 19:01:15 +00:00
|
|
|
|
|
1994-02-03 18:54:04 +00:00
|
|
|
|
/* A's total length is decreased by the length of B and its left child. */
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->total_length -= B->total_length - LEFT_TOTAL_LENGTH (interval);
|
|
|
|
|
|
|
|
|
|
/* B must have the same total length of A. */
|
|
|
|
|
B->total_length = old_total;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
return B;
|
|
|
|
|
}
|
1994-01-02 19:01:15 +00:00
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
/* Assuming that a right child exists, perform the following operation:
|
|
|
|
|
|
|
|
|
|
A B
|
|
|
|
|
/ \ / \
|
|
|
|
|
B => A
|
|
|
|
|
/ \ / \
|
|
|
|
|
c c
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
rotate_left (interval)
|
|
|
|
|
INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
INTERVAL i;
|
|
|
|
|
INTERVAL B = interval->right;
|
1994-01-02 19:01:15 +00:00
|
|
|
|
int old_total = interval->total_length;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
/* Deal with any parent of A; make it point to B. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (! ROOT_INTERVAL_P (interval))
|
|
|
|
|
if (AM_LEFT_CHILD (interval))
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->parent->left = B;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
else
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->parent->right = B;
|
|
|
|
|
B->parent = interval->parent;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
/* Make B the parent of A */
|
1994-01-02 19:01:15 +00:00
|
|
|
|
i = B->left;
|
|
|
|
|
B->left = interval;
|
|
|
|
|
interval->parent = B;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
/* Make A point to c */
|
|
|
|
|
interval->right = i;
|
|
|
|
|
if (! NULL_INTERVAL_P (i))
|
|
|
|
|
i->parent = interval;
|
1994-01-02 19:01:15 +00:00
|
|
|
|
|
1994-02-03 18:54:04 +00:00
|
|
|
|
/* A's total length is decreased by the length of B and its right child. */
|
1994-01-02 19:01:15 +00:00
|
|
|
|
interval->total_length -= B->total_length - RIGHT_TOTAL_LENGTH (interval);
|
|
|
|
|
|
|
|
|
|
/* B must have the same total length of A. */
|
|
|
|
|
B->total_length = old_total;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
return B;
|
|
|
|
|
}
|
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
/* Balance an interval tree with the assumption that the subtrees
|
|
|
|
|
themselves are already balanced. */
|
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
balance_an_interval (i)
|
|
|
|
|
INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
register int old_diff, new_diff;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
old_diff = LEFT_TOTAL_LENGTH (i) - RIGHT_TOTAL_LENGTH (i);
|
|
|
|
|
if (old_diff > 0)
|
|
|
|
|
{
|
|
|
|
|
new_diff = i->total_length - i->left->total_length
|
|
|
|
|
+ RIGHT_TOTAL_LENGTH (i->left) - LEFT_TOTAL_LENGTH (i->left);
|
|
|
|
|
if (abs (new_diff) >= old_diff)
|
|
|
|
|
break;
|
|
|
|
|
i = rotate_right (i);
|
|
|
|
|
balance_an_interval (i->right);
|
|
|
|
|
}
|
|
|
|
|
else if (old_diff < 0)
|
|
|
|
|
{
|
|
|
|
|
new_diff = i->total_length - i->right->total_length
|
|
|
|
|
+ LEFT_TOTAL_LENGTH (i->right) - RIGHT_TOTAL_LENGTH (i->right);
|
|
|
|
|
if (abs (new_diff) >= -old_diff)
|
|
|
|
|
break;
|
|
|
|
|
i = rotate_left (i);
|
|
|
|
|
balance_an_interval (i->left);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Balance INTERVAL, potentially stuffing it back into its parent
|
|
|
|
|
Lisp Object. */
|
|
|
|
|
|
|
|
|
|
static INLINE INTERVAL
|
|
|
|
|
balance_possible_root_interval (interval)
|
|
|
|
|
register INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
Lisp_Object parent;
|
|
|
|
|
|
|
|
|
|
if (interval->parent == NULL_INTERVAL)
|
|
|
|
|
return interval;
|
|
|
|
|
|
|
|
|
|
parent = (Lisp_Object) (interval->parent);
|
|
|
|
|
interval = balance_an_interval (interval);
|
|
|
|
|
|
1994-09-27 02:30:34 +00:00
|
|
|
|
if (BUFFERP (parent))
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (XBUFFER (parent)) = interval;
|
1994-09-27 02:30:34 +00:00
|
|
|
|
else if (STRINGP (parent))
|
1994-01-02 19:01:15 +00:00
|
|
|
|
XSTRING (parent)->intervals = interval;
|
|
|
|
|
|
|
|
|
|
return interval;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Balance the interval tree TREE. Balancing is by weight
|
|
|
|
|
(the amount of text). */
|
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
balance_intervals_internal (tree)
|
|
|
|
|
register INTERVAL tree;
|
|
|
|
|
{
|
|
|
|
|
/* Balance within each side. */
|
|
|
|
|
if (tree->left)
|
1996-07-20 04:44:09 +00:00
|
|
|
|
balance_intervals_internal (tree->left);
|
1994-01-02 19:01:15 +00:00
|
|
|
|
if (tree->right)
|
1996-07-20 04:44:09 +00:00
|
|
|
|
balance_intervals_internal (tree->right);
|
1994-01-02 19:01:15 +00:00
|
|
|
|
return balance_an_interval (tree);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Advertised interface to balance intervals. */
|
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
balance_intervals (tree)
|
|
|
|
|
INTERVAL tree;
|
|
|
|
|
{
|
|
|
|
|
if (tree == NULL_INTERVAL)
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
|
|
|
|
return balance_intervals_internal (tree);
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-18 06:24:25 +00:00
|
|
|
|
/* Split INTERVAL into two pieces, starting the second piece at
|
|
|
|
|
character position OFFSET (counting from 0), relative to INTERVAL.
|
|
|
|
|
INTERVAL becomes the left-hand piece, and the right-hand piece
|
|
|
|
|
(second, lexicographically) is returned.
|
1992-09-19 01:11:21 +00:00
|
|
|
|
|
|
|
|
|
The size and position fields of the two intervals are set based upon
|
|
|
|
|
those of the original interval. The property list of the new interval
|
|
|
|
|
is reset, thus it is up to the caller to do the right thing with the
|
|
|
|
|
result.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
Note that this does not change the position of INTERVAL; if it is a root,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
it is still a root after this operation. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
1992-09-19 01:11:21 +00:00
|
|
|
|
split_interval_right (interval, offset)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
INTERVAL interval;
|
1992-09-19 01:11:21 +00:00
|
|
|
|
int offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
INTERVAL new = make_interval ();
|
|
|
|
|
int position = interval->position;
|
1993-07-18 06:24:25 +00:00
|
|
|
|
int new_length = LENGTH (interval) - offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-18 06:24:25 +00:00
|
|
|
|
new->position = position + offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
new->parent = interval;
|
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
if (NULL_RIGHT_CHILD (interval))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
interval->right = new;
|
|
|
|
|
new->total_length = new_length;
|
|
|
|
|
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Insert the new node between INTERVAL and its right child. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
new->right = interval->right;
|
|
|
|
|
interval->right->parent = new;
|
|
|
|
|
interval->right = new;
|
|
|
|
|
new->total_length = new_length + new->right->total_length;
|
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
balance_an_interval (new);
|
|
|
|
|
balance_possible_root_interval (interval);
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-18 06:24:25 +00:00
|
|
|
|
/* Split INTERVAL into two pieces, starting the second piece at
|
|
|
|
|
character position OFFSET (counting from 0), relative to INTERVAL.
|
|
|
|
|
INTERVAL becomes the right-hand piece, and the left-hand piece
|
|
|
|
|
(first, lexicographically) is returned.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
The size and position fields of the two intervals are set based upon
|
|
|
|
|
those of the original interval. The property list of the new interval
|
|
|
|
|
is reset, thus it is up to the caller to do the right thing with the
|
|
|
|
|
result.
|
|
|
|
|
|
|
|
|
|
Note that this does not change the position of INTERVAL; if it is a root,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
it is still a root after this operation. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
1992-09-19 01:11:21 +00:00
|
|
|
|
split_interval_left (interval, offset)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
INTERVAL interval;
|
1992-09-19 01:11:21 +00:00
|
|
|
|
int offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
INTERVAL new = make_interval ();
|
|
|
|
|
int position = interval->position;
|
1993-07-18 06:24:25 +00:00
|
|
|
|
int new_length = offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
new->position = interval->position;
|
1993-07-18 06:24:25 +00:00
|
|
|
|
interval->position = interval->position + offset;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
new->parent = interval;
|
|
|
|
|
|
|
|
|
|
if (NULL_LEFT_CHILD (interval))
|
|
|
|
|
{
|
|
|
|
|
interval->left = new;
|
|
|
|
|
new->total_length = new_length;
|
|
|
|
|
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Insert the new node between INTERVAL and its left child. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
new->left = interval->left;
|
|
|
|
|
new->left->parent = new;
|
|
|
|
|
interval->left = new;
|
1994-01-02 19:01:15 +00:00
|
|
|
|
new->total_length = new_length + new->left->total_length;
|
|
|
|
|
|
|
|
|
|
balance_an_interval (new);
|
|
|
|
|
balance_possible_root_interval (interval);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
return new;
|
|
|
|
|
}
|
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
/* Find the interval containing text position POSITION in the text
|
1993-07-06 14:53:54 +00:00
|
|
|
|
represented by the interval tree TREE. POSITION is a buffer
|
|
|
|
|
position; the earliest position is 1. If POSITION is at the end of
|
|
|
|
|
the buffer, return the interval containing the last character.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
The `position' field, which is a cache of an interval's position,
|
|
|
|
|
is updated in the interval found. Other functions (e.g., next_interval)
|
1993-07-31 21:58:03 +00:00
|
|
|
|
will update this cache based on the result of find_interval. */
|
1992-09-19 01:11:21 +00:00
|
|
|
|
|
1997-06-02 18:30:21 +00:00
|
|
|
|
INTERVAL
|
1992-09-17 02:26:53 +00:00
|
|
|
|
find_interval (tree, position)
|
|
|
|
|
register INTERVAL tree;
|
|
|
|
|
register int position;
|
|
|
|
|
{
|
1993-07-06 14:53:54 +00:00
|
|
|
|
/* The distance from the left edge of the subtree at TREE
|
|
|
|
|
to POSITION. */
|
|
|
|
|
register int relative_position = position - BEG;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (tree))
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
if (relative_position > TOTAL_LENGTH (tree))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
abort (); /* Paranoia */
|
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
tree = balance_possible_root_interval (tree);
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
while (1)
|
|
|
|
|
{
|
1993-07-06 14:53:54 +00:00
|
|
|
|
if (relative_position < LEFT_TOTAL_LENGTH (tree))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
tree = tree->left;
|
|
|
|
|
}
|
1993-07-06 14:53:54 +00:00
|
|
|
|
else if (! NULL_RIGHT_CHILD (tree)
|
|
|
|
|
&& relative_position >= (TOTAL_LENGTH (tree)
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (tree)))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
relative_position -= (TOTAL_LENGTH (tree)
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (tree));
|
|
|
|
|
tree = tree->right;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
1993-07-06 14:53:54 +00:00
|
|
|
|
tree->position =
|
|
|
|
|
(position - relative_position /* the left edge of *tree */
|
|
|
|
|
+ LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return tree;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Find the succeeding interval (lexicographically) to INTERVAL.
|
1992-09-19 01:11:21 +00:00
|
|
|
|
Sets the `position' field based on that of INTERVAL (see
|
1993-07-31 21:58:03 +00:00
|
|
|
|
find_interval). */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
next_interval (interval)
|
|
|
|
|
register INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL i = interval;
|
|
|
|
|
register int next_position;
|
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (i))
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
next_position = interval->position + LENGTH (interval);
|
|
|
|
|
|
|
|
|
|
if (! NULL_RIGHT_CHILD (i))
|
|
|
|
|
{
|
|
|
|
|
i = i->right;
|
|
|
|
|
while (! NULL_LEFT_CHILD (i))
|
|
|
|
|
i = i->left;
|
|
|
|
|
|
|
|
|
|
i->position = next_position;
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
while (! NULL_PARENT (i))
|
|
|
|
|
{
|
|
|
|
|
if (AM_LEFT_CHILD (i))
|
|
|
|
|
{
|
|
|
|
|
i = i->parent;
|
|
|
|
|
i->position = next_position;
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i = i->parent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Find the preceding interval (lexicographically) to INTERVAL.
|
1992-09-19 01:11:21 +00:00
|
|
|
|
Sets the `position' field based on that of INTERVAL (see
|
1993-07-31 21:58:03 +00:00
|
|
|
|
find_interval). */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
previous_interval (interval)
|
|
|
|
|
register INTERVAL interval;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
register position_of_previous;
|
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (interval))
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
|
|
|
|
if (! NULL_LEFT_CHILD (interval))
|
|
|
|
|
{
|
|
|
|
|
i = interval->left;
|
|
|
|
|
while (! NULL_RIGHT_CHILD (i))
|
|
|
|
|
i = i->right;
|
|
|
|
|
|
|
|
|
|
i->position = interval->position - LENGTH (i);
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
i = interval;
|
|
|
|
|
while (! NULL_PARENT (i))
|
|
|
|
|
{
|
|
|
|
|
if (AM_RIGHT_CHILD (i))
|
|
|
|
|
{
|
|
|
|
|
i = i->parent;
|
|
|
|
|
|
|
|
|
|
i->position = interval->position - LENGTH (i);
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
i = i->parent;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
}
|
1997-04-15 04:45:26 +00:00
|
|
|
|
|
|
|
|
|
/* Find the interval containing POS given some non-NULL INTERVAL
|
|
|
|
|
in the same tree. */
|
|
|
|
|
INTERVAL
|
|
|
|
|
update_interval (i, pos)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
int pos;
|
|
|
|
|
{
|
|
|
|
|
if (NULL_INTERVAL_P (i))
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
if (pos < i->position)
|
|
|
|
|
{
|
|
|
|
|
/* Move left. */
|
|
|
|
|
if (pos >= i->position - TOTAL_LENGTH (i->left))
|
|
|
|
|
i = i->left; /* Move to the left child */
|
|
|
|
|
else if (NULL_PARENT (i))
|
|
|
|
|
error ("Point before start of properties");
|
|
|
|
|
else i = i->parent;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else if (pos >= INTERVAL_LAST_POS (i))
|
|
|
|
|
{
|
|
|
|
|
/* Move right. */
|
|
|
|
|
if (pos < INTERVAL_LAST_POS (i) + TOTAL_LENGTH (i->right))
|
|
|
|
|
i = i->right; /* Move to the right child */
|
|
|
|
|
else if (NULL_PARENT (i))
|
|
|
|
|
error ("Point after end of properties");
|
|
|
|
|
else
|
|
|
|
|
i = i->parent;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
#if 0
|
1992-09-17 02:26:53 +00:00
|
|
|
|
/* Traverse a path down the interval tree TREE to the interval
|
|
|
|
|
containing POSITION, adjusting all nodes on the path for
|
|
|
|
|
an addition of LENGTH characters. Insertion between two intervals
|
|
|
|
|
(i.e., point == i->position, where i is second interval) means
|
|
|
|
|
text goes into second interval.
|
|
|
|
|
|
|
|
|
|
Modifications are needed to handle the hungry bits -- after simply
|
|
|
|
|
finding the interval at position (don't add length going down),
|
|
|
|
|
if it's the beginning of the interval, get the previous interval
|
1996-01-05 10:03:17 +00:00
|
|
|
|
and check the hungry bits of both. Then add the length going back up
|
1993-07-31 21:58:03 +00:00
|
|
|
|
to the root. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
adjust_intervals_for_insertion (tree, position, length)
|
|
|
|
|
INTERVAL tree;
|
|
|
|
|
int position, length;
|
|
|
|
|
{
|
|
|
|
|
register int relative_position;
|
|
|
|
|
register INTERVAL this;
|
|
|
|
|
|
|
|
|
|
if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
/* If inserting at point-max of a buffer, that position
|
|
|
|
|
will be out of range */
|
|
|
|
|
if (position > TOTAL_LENGTH (tree))
|
|
|
|
|
position = TOTAL_LENGTH (tree);
|
|
|
|
|
relative_position = position;
|
|
|
|
|
this = tree;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
if (relative_position <= LEFT_TOTAL_LENGTH (this))
|
|
|
|
|
{
|
|
|
|
|
this->total_length += length;
|
|
|
|
|
this = this->left;
|
|
|
|
|
}
|
|
|
|
|
else if (relative_position > (TOTAL_LENGTH (this)
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (this)))
|
|
|
|
|
{
|
|
|
|
|
relative_position -= (TOTAL_LENGTH (this)
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (this));
|
|
|
|
|
this->total_length += length;
|
|
|
|
|
this = this->right;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* If we are to use zero-length intervals as buffer pointers,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
then this code will have to change. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
this->total_length += length;
|
|
|
|
|
this->position = LEFT_TOTAL_LENGTH (this)
|
|
|
|
|
+ position - relative_position + 1;
|
|
|
|
|
return tree;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
1992-09-19 01:11:21 +00:00
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Effect an adjustment corresponding to the addition of LENGTH characters
|
|
|
|
|
of text. Do this by finding the interval containing POSITION in the
|
1994-02-03 18:54:04 +00:00
|
|
|
|
interval tree TREE, and then adjusting all of its ancestors by adding
|
1992-09-19 01:11:21 +00:00
|
|
|
|
LENGTH to them.
|
|
|
|
|
|
|
|
|
|
If POSITION is the first character of an interval, meaning that point
|
|
|
|
|
is actually between the two intervals, make the new text belong to
|
|
|
|
|
the interval which is "sticky".
|
|
|
|
|
|
1992-09-21 23:57:58 +00:00
|
|
|
|
If both intervals are "sticky", then make them belong to the left-most
|
1992-09-19 01:11:21 +00:00
|
|
|
|
interval. Another possibility would be to create a new interval for
|
1993-07-31 21:58:03 +00:00
|
|
|
|
this text, and make it have the merged properties of both ends. */
|
1992-09-19 01:11:21 +00:00
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
adjust_intervals_for_insertion (tree, position, length)
|
|
|
|
|
INTERVAL tree;
|
|
|
|
|
int position, length;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL i;
|
1993-07-31 21:58:03 +00:00
|
|
|
|
register INTERVAL temp;
|
|
|
|
|
int eobp = 0;
|
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
if (TOTAL_LENGTH (tree) == 0) /* Paranoia */
|
|
|
|
|
abort ();
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
/* If inserting at point-max of a buffer, that position will be out
|
|
|
|
|
of range. Remember that buffer positions are 1-based. */
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (position >= BEG + TOTAL_LENGTH (tree)){
|
1993-07-06 14:53:54 +00:00
|
|
|
|
position = BEG + TOTAL_LENGTH (tree);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
eobp = 1;
|
|
|
|
|
}
|
1992-09-19 01:11:21 +00:00
|
|
|
|
|
|
|
|
|
i = find_interval (tree, position);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
1993-08-15 03:49:28 +00:00
|
|
|
|
/* If in middle of an interval which is not sticky either way,
|
|
|
|
|
we must not just give its properties to the insertion.
|
|
|
|
|
So split this interval at the insertion point. */
|
|
|
|
|
if (! (position == i->position || eobp)
|
|
|
|
|
&& END_NONSTICKY_P (i)
|
1996-12-20 18:15:52 +00:00
|
|
|
|
&& FRONT_NONSTICKY_P (i))
|
1993-08-15 03:49:28 +00:00
|
|
|
|
{
|
1996-12-20 18:15:52 +00:00
|
|
|
|
Lisp_Object tail;
|
|
|
|
|
Lisp_Object front, rear;
|
|
|
|
|
|
|
|
|
|
front = textget (i->plist, Qfront_sticky);
|
|
|
|
|
rear = textget (i->plist, Qrear_nonsticky);
|
|
|
|
|
|
|
|
|
|
/* Does any actual property pose an actual problem? */
|
|
|
|
|
for (tail = i->plist; ! NILP (tail); tail = Fcdr (Fcdr (tail)))
|
|
|
|
|
{
|
|
|
|
|
Lisp_Object prop;
|
|
|
|
|
prop = XCONS (tail)->car;
|
|
|
|
|
|
|
|
|
|
/* Is this particular property rear-sticky?
|
|
|
|
|
Note, if REAR isn't a cons, it must be non-nil,
|
|
|
|
|
which means that all properties are rear-nonsticky. */
|
|
|
|
|
if (CONSP (rear) && NILP (Fmemq (prop, rear)))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* Is this particular property front-sticky?
|
|
|
|
|
Note, if FRONT isn't a cons, it must be nil,
|
|
|
|
|
which means that all properties are front-nonsticky. */
|
|
|
|
|
if (CONSP (front) && ! NILP (Fmemq (prop, front)))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
/* PROP isn't sticky on either side => it is a real problem. */
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If any property is a real problem, split the interval. */
|
|
|
|
|
if (! NILP (tail))
|
|
|
|
|
{
|
|
|
|
|
temp = split_interval_right (i, position - i->position);
|
|
|
|
|
copy_properties (i, temp);
|
|
|
|
|
i = temp;
|
|
|
|
|
}
|
1993-08-15 03:49:28 +00:00
|
|
|
|
}
|
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
/* If we are positioned between intervals, check the stickiness of
|
1993-07-31 21:58:03 +00:00
|
|
|
|
both of them. We have to do this too, if we are at BEG or Z. */
|
|
|
|
|
if (position == i->position || eobp)
|
1992-09-19 01:11:21 +00:00
|
|
|
|
{
|
1993-07-31 21:58:03 +00:00
|
|
|
|
register INTERVAL prev;
|
|
|
|
|
|
|
|
|
|
if (position == BEG)
|
|
|
|
|
prev = 0;
|
|
|
|
|
else if (eobp)
|
|
|
|
|
{
|
|
|
|
|
prev = i;
|
|
|
|
|
i = 0;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
prev = previous_interval (i);
|
1992-09-19 01:11:21 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Even if we are positioned between intervals, we default
|
|
|
|
|
to the left one if it exists. We extend it now and split
|
1996-01-05 10:03:17 +00:00
|
|
|
|
off a part later, if stickiness demands it. */
|
1994-01-02 19:01:15 +00:00
|
|
|
|
for (temp = prev ? prev : i;! NULL_INTERVAL_P (temp); temp = temp->parent)
|
|
|
|
|
{
|
|
|
|
|
temp->total_length += length;
|
|
|
|
|
temp = balance_possible_root_interval (temp);
|
|
|
|
|
}
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
|
|
|
|
/* If at least one interval has sticky properties,
|
1996-01-05 10:03:17 +00:00
|
|
|
|
we check the stickiness property by property. */
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (END_NONSTICKY_P (prev) || FRONT_STICKY_P (i))
|
|
|
|
|
{
|
1994-03-23 22:30:22 +00:00
|
|
|
|
Lisp_Object pleft, pright;
|
1993-07-31 21:58:03 +00:00
|
|
|
|
struct interval newi;
|
|
|
|
|
|
1994-03-23 22:30:22 +00:00
|
|
|
|
pleft = NULL_INTERVAL_P (prev) ? Qnil : prev->plist;
|
|
|
|
|
pright = NULL_INTERVAL_P (i) ? Qnil : i->plist;
|
1993-07-31 21:58:03 +00:00
|
|
|
|
newi.plist = merge_properties_sticky (pleft, pright);
|
|
|
|
|
|
|
|
|
|
if(! prev) /* i.e. position == BEG */
|
|
|
|
|
{
|
|
|
|
|
if (! intervals_equal (i, &newi))
|
|
|
|
|
{
|
|
|
|
|
i = split_interval_left (i, length);
|
|
|
|
|
i->plist = newi.plist;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
else if (! intervals_equal (prev, &newi))
|
|
|
|
|
{
|
|
|
|
|
prev = split_interval_right (prev,
|
|
|
|
|
position - prev->position);
|
|
|
|
|
prev->plist = newi.plist;
|
|
|
|
|
if (! NULL_INTERVAL_P (i)
|
|
|
|
|
&& intervals_equal (prev, i))
|
|
|
|
|
merge_interval_right (prev);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* We will need to update the cache here later. */
|
|
|
|
|
}
|
|
|
|
|
else if (! prev && ! NILP (i->plist))
|
|
|
|
|
{
|
|
|
|
|
/* Just split off a new interval at the left.
|
|
|
|
|
Since I wasn't front-sticky, the empty plist is ok. */
|
|
|
|
|
i = split_interval_left (i, length);
|
|
|
|
|
}
|
1992-09-19 01:11:21 +00:00
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Otherwise just extend the interval. */
|
|
|
|
|
else
|
1992-09-19 01:11:21 +00:00
|
|
|
|
{
|
1993-07-31 21:58:03 +00:00
|
|
|
|
for (temp = i; ! NULL_INTERVAL_P (temp); temp = temp->parent)
|
1994-01-02 19:01:15 +00:00
|
|
|
|
{
|
|
|
|
|
temp->total_length += length;
|
|
|
|
|
temp = balance_possible_root_interval (temp);
|
|
|
|
|
}
|
1992-09-19 01:11:21 +00:00
|
|
|
|
}
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
return tree;
|
|
|
|
|
}
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
1994-02-04 01:18:01 +00:00
|
|
|
|
/* Any property might be front-sticky on the left, rear-sticky on the left,
|
|
|
|
|
front-sticky on the right, or rear-sticky on the right; the 16 combinations
|
|
|
|
|
can be arranged in a matrix with rows denoting the left conditions and
|
|
|
|
|
columns denoting the right conditions:
|
|
|
|
|
_ __ _
|
|
|
|
|
_ FR FR FR FR
|
|
|
|
|
FR__ 0 1 2 3
|
|
|
|
|
_FR 4 5 6 7
|
|
|
|
|
FR 8 9 A B
|
|
|
|
|
FR C D E F
|
|
|
|
|
|
|
|
|
|
left-props = '(front-sticky (p8 p9 pa pb pc pd pe pf)
|
|
|
|
|
rear-nonsticky (p4 p5 p6 p7 p8 p9 pa pb)
|
|
|
|
|
p0 L p1 L p2 L p3 L p4 L p5 L p6 L p7 L
|
|
|
|
|
p8 L p9 L pa L pb L pc L pd L pe L pf L)
|
|
|
|
|
right-props = '(front-sticky (p2 p3 p6 p7 pa pb pe pf)
|
|
|
|
|
rear-nonsticky (p1 p2 p5 p6 p9 pa pd pe)
|
|
|
|
|
p0 R p1 R p2 R p3 R p4 R p5 R p6 R p7 R
|
|
|
|
|
p8 R p9 R pa R pb R pc R pd R pe R pf R)
|
|
|
|
|
|
|
|
|
|
We inherit from whoever has a sticky side facing us. If both sides
|
|
|
|
|
do (cases 2, 3, E, and F), then we inherit from whichever side has a
|
|
|
|
|
non-nil value for the current property. If both sides do, then we take
|
|
|
|
|
from the left.
|
|
|
|
|
|
|
|
|
|
When we inherit a property, we get its stickiness as well as its value.
|
|
|
|
|
So, when we merge the above two lists, we expect to get this:
|
|
|
|
|
|
|
|
|
|
result = '(front-sticky (p6 p7 pa pb pc pd pe pf)
|
|
|
|
|
rear-nonsticky (p6 pa)
|
|
|
|
|
p0 L p1 L p2 L p3 L p6 R p7 R
|
|
|
|
|
pa R pb R pc L pd L pe L pf L)
|
|
|
|
|
|
|
|
|
|
The optimizable special cases are:
|
|
|
|
|
left rear-nonsticky = nil, right front-sticky = nil (inherit left)
|
|
|
|
|
left rear-nonsticky = t, right front-sticky = t (inherit right)
|
|
|
|
|
left rear-nonsticky = t, right front-sticky = nil (inherit none)
|
|
|
|
|
*/
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
Lisp_Object
|
|
|
|
|
merge_properties_sticky (pleft, pright)
|
|
|
|
|
Lisp_Object pleft, pright;
|
|
|
|
|
{
|
1994-03-23 22:30:22 +00:00
|
|
|
|
register Lisp_Object props, front, rear;
|
|
|
|
|
Lisp_Object lfront, lrear, rfront, rrear;
|
1996-12-17 07:25:35 +00:00
|
|
|
|
register Lisp_Object tail1, tail2, sym, lval, rval, cat;
|
1994-02-04 01:18:01 +00:00
|
|
|
|
int use_left, use_right;
|
1996-12-17 07:25:35 +00:00
|
|
|
|
int lpresent;
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
1994-03-23 22:30:22 +00:00
|
|
|
|
props = Qnil;
|
|
|
|
|
front = Qnil;
|
|
|
|
|
rear = Qnil;
|
|
|
|
|
lfront = textget (pleft, Qfront_sticky);
|
|
|
|
|
lrear = textget (pleft, Qrear_nonsticky);
|
|
|
|
|
rfront = textget (pright, Qfront_sticky);
|
|
|
|
|
rrear = textget (pright, Qrear_nonsticky);
|
|
|
|
|
|
1994-02-04 01:18:01 +00:00
|
|
|
|
/* Go through each element of PRIGHT. */
|
|
|
|
|
for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
|
|
|
|
sym = Fcar (tail1);
|
|
|
|
|
|
|
|
|
|
/* Sticky properties get special treatment. */
|
|
|
|
|
if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky))
|
|
|
|
|
continue;
|
1994-02-04 01:18:01 +00:00
|
|
|
|
|
|
|
|
|
rval = Fcar (Fcdr (tail1));
|
|
|
|
|
for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2)))
|
|
|
|
|
if (EQ (sym, Fcar (tail2)))
|
|
|
|
|
break;
|
|
|
|
|
|
1996-12-17 07:25:35 +00:00
|
|
|
|
/* Indicate whether the property is explicitly defined on the left.
|
|
|
|
|
(We know it is defined explicitly on the right
|
|
|
|
|
because otherwise we don't get here.) */
|
|
|
|
|
lpresent = ! NILP (tail2);
|
|
|
|
|
lval = (NILP (tail2) ? Qnil : Fcar (Fcdr (tail2)));
|
|
|
|
|
|
|
|
|
|
use_left = ! TMEM (sym, lrear) && lpresent;
|
1994-02-04 01:18:01 +00:00
|
|
|
|
use_right = TMEM (sym, rfront);
|
|
|
|
|
if (use_left && use_right)
|
|
|
|
|
{
|
1996-12-17 07:25:35 +00:00
|
|
|
|
if (NILP (lval))
|
|
|
|
|
use_left = 0;
|
|
|
|
|
else if (NILP (rval))
|
|
|
|
|
use_right = 0;
|
1994-02-04 01:18:01 +00:00
|
|
|
|
}
|
|
|
|
|
if (use_left)
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
1994-02-04 01:18:01 +00:00
|
|
|
|
/* We build props as (value sym ...) rather than (sym value ...)
|
|
|
|
|
because we plan to nreverse it when we're done. */
|
1996-12-17 07:25:35 +00:00
|
|
|
|
props = Fcons (lval, Fcons (sym, props));
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (TMEM (sym, lfront))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
front = Fcons (sym, front);
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (TMEM (sym, lrear))
|
|
|
|
|
rear = Fcons (sym, rear);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
}
|
1994-02-04 01:18:01 +00:00
|
|
|
|
else if (use_right)
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
1996-12-17 07:25:35 +00:00
|
|
|
|
props = Fcons (rval, Fcons (sym, props));
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (TMEM (sym, rfront))
|
|
|
|
|
front = Fcons (sym, front);
|
|
|
|
|
if (TMEM (sym, rrear))
|
|
|
|
|
rear = Fcons (sym, rear);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
1994-02-04 01:18:01 +00:00
|
|
|
|
|
|
|
|
|
/* Now go through each element of PLEFT. */
|
|
|
|
|
for (tail2 = pleft; ! NILP (tail2); tail2 = Fcdr (Fcdr (tail2)))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
|
|
|
|
sym = Fcar (tail2);
|
|
|
|
|
|
|
|
|
|
/* Sticky properties get special treatment. */
|
|
|
|
|
if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky))
|
|
|
|
|
continue;
|
|
|
|
|
|
1994-02-04 01:18:01 +00:00
|
|
|
|
/* If sym is in PRIGHT, we've already considered it. */
|
|
|
|
|
for (tail1 = pright; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (EQ (sym, Fcar (tail1)))
|
|
|
|
|
break;
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (! NILP (tail1))
|
|
|
|
|
continue;
|
|
|
|
|
|
|
|
|
|
lval = Fcar (Fcdr (tail2));
|
|
|
|
|
|
|
|
|
|
/* Since rval is known to be nil in this loop, the test simplifies. */
|
|
|
|
|
if (! TMEM (sym, lrear))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
1996-12-17 07:25:35 +00:00
|
|
|
|
props = Fcons (lval, Fcons (sym, props));
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (TMEM (sym, lfront))
|
|
|
|
|
front = Fcons (sym, front);
|
|
|
|
|
}
|
|
|
|
|
else if (TMEM (sym, rfront))
|
|
|
|
|
{
|
|
|
|
|
/* The value is nil, but we still inherit the stickiness
|
|
|
|
|
from the right. */
|
1993-07-31 21:58:03 +00:00
|
|
|
|
front = Fcons (sym, front);
|
1994-02-04 01:18:01 +00:00
|
|
|
|
if (TMEM (sym, rrear))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
rear = Fcons (sym, rear);
|
|
|
|
|
}
|
|
|
|
|
}
|
1994-02-03 18:54:04 +00:00
|
|
|
|
props = Fnreverse (props);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (! NILP (rear))
|
1994-02-03 18:54:04 +00:00
|
|
|
|
props = Fcons (Qrear_nonsticky, Fcons (Fnreverse (rear), props));
|
1996-12-17 07:25:35 +00:00
|
|
|
|
|
|
|
|
|
cat = textget (props, Qcategory);
|
|
|
|
|
if (! NILP (front)
|
|
|
|
|
&&
|
|
|
|
|
/* If we have inherited a front-stick category property that is t,
|
|
|
|
|
we don't need to set up a detailed one. */
|
|
|
|
|
! (! NILP (cat) && SYMBOLP (cat)
|
|
|
|
|
&& EQ (Fget (cat, Qfront_sticky), Qt)))
|
1994-02-04 01:18:01 +00:00
|
|
|
|
props = Fcons (Qfront_sticky, Fcons (Fnreverse (front), props));
|
1993-07-31 21:58:03 +00:00
|
|
|
|
return props;
|
|
|
|
|
}
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-19 01:11:21 +00:00
|
|
|
|
/* Delete an node I from its interval tree by merging its subtrees
|
|
|
|
|
into one subtree which is then returned. Caller is responsible for
|
1993-07-31 21:58:03 +00:00
|
|
|
|
storing the resulting subtree into its parent. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
static INTERVAL
|
|
|
|
|
delete_node (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL migrate, this;
|
|
|
|
|
register int migrate_amt;
|
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (i->left))
|
|
|
|
|
return i->right;
|
|
|
|
|
if (NULL_INTERVAL_P (i->right))
|
|
|
|
|
return i->left;
|
|
|
|
|
|
|
|
|
|
migrate = i->left;
|
|
|
|
|
migrate_amt = i->left->total_length;
|
|
|
|
|
this = i->right;
|
|
|
|
|
this->total_length += migrate_amt;
|
|
|
|
|
while (! NULL_INTERVAL_P (this->left))
|
|
|
|
|
{
|
|
|
|
|
this = this->left;
|
|
|
|
|
this->total_length += migrate_amt;
|
|
|
|
|
}
|
|
|
|
|
this->left = migrate;
|
|
|
|
|
migrate->parent = this;
|
|
|
|
|
|
|
|
|
|
return i->right;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Delete interval I from its tree by calling `delete_node'
|
|
|
|
|
and properly connecting the resultant subtree.
|
|
|
|
|
|
|
|
|
|
I is presumed to be empty; that is, no adjustments are made
|
1993-07-31 21:58:03 +00:00
|
|
|
|
for the length of I. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
delete_interval (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL parent;
|
|
|
|
|
int amt = LENGTH (i);
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (amt > 0) /* Only used on zero-length intervals now. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
if (ROOT_INTERVAL_P (i))
|
|
|
|
|
{
|
1994-03-23 22:30:22 +00:00
|
|
|
|
Lisp_Object owner;
|
|
|
|
|
owner = (Lisp_Object) i->parent;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
parent = delete_node (i);
|
|
|
|
|
if (! NULL_INTERVAL_P (parent))
|
|
|
|
|
parent->parent = (INTERVAL) owner;
|
|
|
|
|
|
1994-09-27 02:30:34 +00:00
|
|
|
|
if (BUFFERP (owner))
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (XBUFFER (owner)) = parent;
|
1994-09-27 02:30:34 +00:00
|
|
|
|
else if (STRINGP (owner))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
XSTRING (owner)->intervals = parent;
|
|
|
|
|
else
|
|
|
|
|
abort ();
|
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
parent = i->parent;
|
|
|
|
|
if (AM_LEFT_CHILD (i))
|
|
|
|
|
{
|
|
|
|
|
parent->left = delete_node (i);
|
|
|
|
|
if (! NULL_INTERVAL_P (parent->left))
|
|
|
|
|
parent->left->parent = parent;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
parent->right = delete_node (i);
|
|
|
|
|
if (! NULL_INTERVAL_P (parent->right))
|
|
|
|
|
parent->right->parent = parent;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
/* Find the interval in TREE corresponding to the relative position
|
|
|
|
|
FROM and delete as much as possible of AMOUNT from that interval.
|
|
|
|
|
Return the amount actually deleted, and if the interval was
|
|
|
|
|
zeroed-out, delete that interval node from the tree.
|
|
|
|
|
|
|
|
|
|
Note that FROM is actually origin zero, aka relative to the
|
|
|
|
|
leftmost edge of tree. This is appropriate since we call ourselves
|
|
|
|
|
recursively on subtrees.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-21 23:57:58 +00:00
|
|
|
|
Do this by recursing down TREE to the interval in question, and
|
1993-07-31 21:58:03 +00:00
|
|
|
|
deleting the appropriate amount of text. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
interval_deletion_adjustment (tree, from, amount)
|
|
|
|
|
register INTERVAL tree;
|
|
|
|
|
register int from, amount;
|
|
|
|
|
{
|
|
|
|
|
register int relative_position = from;
|
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (tree))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Left branch */
|
1993-07-06 14:53:54 +00:00
|
|
|
|
if (relative_position < LEFT_TOTAL_LENGTH (tree))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
int subtract = interval_deletion_adjustment (tree->left,
|
|
|
|
|
relative_position,
|
|
|
|
|
amount);
|
|
|
|
|
tree->total_length -= subtract;
|
|
|
|
|
return subtract;
|
|
|
|
|
}
|
|
|
|
|
/* Right branch */
|
1993-07-06 14:53:54 +00:00
|
|
|
|
else if (relative_position >= (TOTAL_LENGTH (tree)
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (tree)))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
int subtract;
|
|
|
|
|
|
|
|
|
|
relative_position -= (tree->total_length
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (tree));
|
|
|
|
|
subtract = interval_deletion_adjustment (tree->right,
|
|
|
|
|
relative_position,
|
|
|
|
|
amount);
|
|
|
|
|
tree->total_length -= subtract;
|
|
|
|
|
return subtract;
|
|
|
|
|
}
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Here -- this node. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
1993-07-06 14:53:54 +00:00
|
|
|
|
/* How much can we delete from this interval? */
|
|
|
|
|
int my_amount = ((tree->total_length
|
|
|
|
|
- RIGHT_TOTAL_LENGTH (tree))
|
|
|
|
|
- relative_position);
|
|
|
|
|
|
|
|
|
|
if (amount > my_amount)
|
|
|
|
|
amount = my_amount;
|
|
|
|
|
|
|
|
|
|
tree->total_length -= amount;
|
|
|
|
|
if (LENGTH (tree) == 0)
|
|
|
|
|
delete_interval (tree);
|
|
|
|
|
|
|
|
|
|
return amount;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Never reach here. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
/* Effect the adjustments necessary to the interval tree of BUFFER to
|
|
|
|
|
correspond to the deletion of LENGTH characters from that buffer
|
|
|
|
|
text. The deletion is effected at position START (which is a
|
1993-07-31 21:58:03 +00:00
|
|
|
|
buffer position, i.e. origin 1). */
|
1992-09-21 23:57:58 +00:00
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
static void
|
|
|
|
|
adjust_intervals_for_deletion (buffer, start, length)
|
|
|
|
|
struct buffer *buffer;
|
|
|
|
|
int start, length;
|
|
|
|
|
{
|
|
|
|
|
register int left_to_delete = length;
|
1995-01-02 21:38:22 +00:00
|
|
|
|
register INTERVAL tree = BUF_INTERVALS (buffer);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
register int deleted;
|
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (tree))
|
|
|
|
|
return;
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
if (start > BEG + TOTAL_LENGTH (tree)
|
|
|
|
|
|| start + length > BEG + TOTAL_LENGTH (tree))
|
|
|
|
|
abort ();
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (length == TOTAL_LENGTH (tree))
|
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (buffer) = NULL_INTERVAL;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (ONLY_INTERVAL_P (tree))
|
|
|
|
|
{
|
|
|
|
|
tree->total_length -= length;
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
if (start > BEG + TOTAL_LENGTH (tree))
|
|
|
|
|
start = BEG + TOTAL_LENGTH (tree);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
while (left_to_delete > 0)
|
|
|
|
|
{
|
1993-07-06 14:53:54 +00:00
|
|
|
|
left_to_delete -= interval_deletion_adjustment (tree, start - 1,
|
1992-09-17 02:26:53 +00:00
|
|
|
|
left_to_delete);
|
1995-01-02 21:38:22 +00:00
|
|
|
|
tree = BUF_INTERVALS (buffer);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if (left_to_delete == tree->total_length)
|
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (buffer) = NULL_INTERVAL;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
1993-06-09 11:59:12 +00:00
|
|
|
|
/* Make the adjustments necessary to the interval tree of BUFFER to
|
1992-09-21 23:57:58 +00:00
|
|
|
|
represent an addition or deletion of LENGTH characters starting
|
|
|
|
|
at position START. Addition or deletion is indicated by the sign
|
1993-07-31 21:58:03 +00:00
|
|
|
|
of LENGTH. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
INLINE void
|
|
|
|
|
offset_intervals (buffer, start, length)
|
|
|
|
|
struct buffer *buffer;
|
|
|
|
|
int start, length;
|
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) || length == 0)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
if (length > 0)
|
1995-01-02 21:38:22 +00:00
|
|
|
|
adjust_intervals_for_insertion (BUF_INTERVALS (buffer), start, length);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
else
|
|
|
|
|
adjust_intervals_for_deletion (buffer, start, -length);
|
|
|
|
|
}
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
|
|
|
|
/* Merge interval I with its lexicographic successor. The resulting
|
|
|
|
|
interval is returned, and has the properties of the original
|
|
|
|
|
successor. The properties of I are lost. I is removed from the
|
|
|
|
|
interval tree.
|
|
|
|
|
|
|
|
|
|
IMPORTANT:
|
|
|
|
|
The caller must verify that this is not the last (rightmost)
|
1993-07-31 21:58:03 +00:00
|
|
|
|
interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
merge_interval_right (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
register int absorb = LENGTH (i);
|
|
|
|
|
register INTERVAL successor;
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Zero out this interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
i->total_length -= absorb;
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Find the succeeding interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
if (! NULL_RIGHT_CHILD (i)) /* It's below us. Add absorb
|
1993-07-31 21:58:03 +00:00
|
|
|
|
as we descend. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
{
|
|
|
|
|
successor = i->right;
|
|
|
|
|
while (! NULL_LEFT_CHILD (successor))
|
|
|
|
|
{
|
|
|
|
|
successor->total_length += absorb;
|
|
|
|
|
successor = successor->left;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
successor->total_length += absorb;
|
|
|
|
|
delete_interval (i);
|
|
|
|
|
return successor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
successor = i;
|
|
|
|
|
while (! NULL_PARENT (successor)) /* It's above us. Subtract as
|
1993-07-31 21:58:03 +00:00
|
|
|
|
we ascend. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
{
|
|
|
|
|
if (AM_LEFT_CHILD (successor))
|
|
|
|
|
{
|
|
|
|
|
successor = successor->parent;
|
|
|
|
|
delete_interval (i);
|
|
|
|
|
return successor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
successor = successor->parent;
|
|
|
|
|
successor->total_length -= absorb;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* This must be the rightmost or last interval and cannot
|
1993-07-31 21:58:03 +00:00
|
|
|
|
be merged right. The caller should have known. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Merge interval I with its lexicographic predecessor. The resulting
|
|
|
|
|
interval is returned, and has the properties of the original predecessor.
|
|
|
|
|
The properties of I are lost. Interval node I is removed from the tree.
|
|
|
|
|
|
|
|
|
|
IMPORTANT:
|
1993-07-31 21:58:03 +00:00
|
|
|
|
The caller must verify that this is not the first (leftmost) interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
|
|
|
|
INTERVAL
|
|
|
|
|
merge_interval_left (i)
|
|
|
|
|
register INTERVAL i;
|
|
|
|
|
{
|
|
|
|
|
register int absorb = LENGTH (i);
|
|
|
|
|
register INTERVAL predecessor;
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Zero out this interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
i->total_length -= absorb;
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Find the preceding interval. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
if (! NULL_LEFT_CHILD (i)) /* It's below us. Go down,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
adding ABSORB as we go. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
{
|
|
|
|
|
predecessor = i->left;
|
|
|
|
|
while (! NULL_RIGHT_CHILD (predecessor))
|
|
|
|
|
{
|
|
|
|
|
predecessor->total_length += absorb;
|
|
|
|
|
predecessor = predecessor->right;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
predecessor->total_length += absorb;
|
|
|
|
|
delete_interval (i);
|
|
|
|
|
return predecessor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
predecessor = i;
|
|
|
|
|
while (! NULL_PARENT (predecessor)) /* It's above us. Go up,
|
1993-07-31 21:58:03 +00:00
|
|
|
|
subtracting ABSORB. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
{
|
|
|
|
|
if (AM_RIGHT_CHILD (predecessor))
|
|
|
|
|
{
|
|
|
|
|
predecessor = predecessor->parent;
|
|
|
|
|
delete_interval (i);
|
|
|
|
|
return predecessor;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
predecessor = predecessor->parent;
|
|
|
|
|
predecessor->total_length -= absorb;
|
|
|
|
|
}
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-24 01:29:22 +00:00
|
|
|
|
/* This must be the leftmost or first interval and cannot
|
1993-07-31 21:58:03 +00:00
|
|
|
|
be merged left. The caller should have known. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
abort ();
|
|
|
|
|
}
|
|
|
|
|
|
1992-09-21 23:57:58 +00:00
|
|
|
|
/* Make an exact copy of interval tree SOURCE which descends from
|
|
|
|
|
PARENT. This is done by recursing through SOURCE, copying
|
|
|
|
|
the current interval and its properties, and then adjusting
|
1993-07-31 21:58:03 +00:00
|
|
|
|
the pointers of the copy. */
|
1992-09-21 23:57:58 +00:00
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
static INTERVAL
|
|
|
|
|
reproduce_tree (source, parent)
|
|
|
|
|
INTERVAL source, parent;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL t = make_interval ();
|
|
|
|
|
|
|
|
|
|
bcopy (source, t, INTERVAL_SIZE);
|
|
|
|
|
copy_properties (source, t);
|
|
|
|
|
t->parent = parent;
|
|
|
|
|
if (! NULL_LEFT_CHILD (source))
|
|
|
|
|
t->left = reproduce_tree (source->left, t);
|
|
|
|
|
if (! NULL_RIGHT_CHILD (source))
|
|
|
|
|
t->right = reproduce_tree (source->right, t);
|
|
|
|
|
|
|
|
|
|
return t;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-06 14:53:54 +00:00
|
|
|
|
#if 0
|
|
|
|
|
/* Nobody calls this. Perhaps it's a vestige of an earlier design. */
|
|
|
|
|
|
1992-09-21 23:57:58 +00:00
|
|
|
|
/* Make a new interval of length LENGTH starting at START in the
|
|
|
|
|
group of intervals INTERVALS, which is actually an interval tree.
|
|
|
|
|
Returns the new interval.
|
|
|
|
|
|
|
|
|
|
Generate an error if the new positions would overlap an existing
|
1993-07-31 21:58:03 +00:00
|
|
|
|
interval. */
|
1992-09-21 23:57:58 +00:00
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
static INTERVAL
|
|
|
|
|
make_new_interval (intervals, start, length)
|
|
|
|
|
INTERVAL intervals;
|
|
|
|
|
int start, length;
|
|
|
|
|
{
|
|
|
|
|
INTERVAL slot;
|
|
|
|
|
|
|
|
|
|
slot = find_interval (intervals, start);
|
|
|
|
|
if (start + length > slot->position + LENGTH (slot))
|
|
|
|
|
error ("Interval would overlap");
|
|
|
|
|
|
|
|
|
|
if (start == slot->position && length == LENGTH (slot))
|
|
|
|
|
return slot;
|
|
|
|
|
|
|
|
|
|
if (slot->position == start)
|
|
|
|
|
{
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* New right node. */
|
1993-07-18 06:24:25 +00:00
|
|
|
|
split_interval_right (slot, length);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return slot;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (slot->position + LENGTH (slot) == start + length)
|
|
|
|
|
{
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* New left node. */
|
1993-07-18 06:24:25 +00:00
|
|
|
|
split_interval_left (slot, LENGTH (slot) - length);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return slot;
|
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Convert interval SLOT into three intervals. */
|
1993-07-18 06:24:25 +00:00
|
|
|
|
split_interval_left (slot, start - slot->position);
|
|
|
|
|
split_interval_right (slot, length);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return slot;
|
|
|
|
|
}
|
1993-07-06 14:53:54 +00:00
|
|
|
|
#endif
|
1993-03-07 09:34:39 +00:00
|
|
|
|
|
1992-09-24 01:29:22 +00:00
|
|
|
|
/* Insert the intervals of SOURCE into BUFFER at POSITION.
|
1993-11-25 06:28:03 +00:00
|
|
|
|
LENGTH is the length of the text in SOURCE.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-18 06:24:25 +00:00
|
|
|
|
This is used in insdel.c when inserting Lisp_Strings into the
|
|
|
|
|
buffer. The text corresponding to SOURCE is already in the buffer
|
|
|
|
|
when this is called. The intervals of new tree are a copy of those
|
|
|
|
|
belonging to the string being inserted; intervals are never
|
|
|
|
|
shared.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-11-25 06:28:03 +00:00
|
|
|
|
If the inserted text had no intervals associated, and we don't
|
|
|
|
|
want to inherit the surrounding text's properties, this function
|
1992-09-17 02:26:53 +00:00
|
|
|
|
simply returns -- offset_intervals should handle placing the
|
1992-09-19 01:11:21 +00:00
|
|
|
|
text in the correct interval, depending on the sticky bits.
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
If the inserted text had properties (intervals), then there are two
|
|
|
|
|
cases -- either insertion happened in the middle of some interval,
|
|
|
|
|
or between two intervals.
|
|
|
|
|
|
|
|
|
|
If the text goes into the middle of an interval, then new
|
|
|
|
|
intervals are created in the middle with only the properties of
|
|
|
|
|
the new text, *unless* the macro MERGE_INSERTIONS is true, in
|
|
|
|
|
which case the new text has the union of its properties and those
|
|
|
|
|
of the text into which it was inserted.
|
|
|
|
|
|
|
|
|
|
If the text goes between two intervals, then if neither interval
|
1992-09-19 01:11:21 +00:00
|
|
|
|
had its appropriate sticky property set (front_sticky, rear_sticky),
|
|
|
|
|
the new text has only its properties. If one of the sticky properties
|
1992-09-17 02:26:53 +00:00
|
|
|
|
is set, then the new text "sticks" to that region and its properties
|
1993-06-09 11:59:12 +00:00
|
|
|
|
depend on merging as above. If both the preceding and succeeding
|
1992-09-19 01:11:21 +00:00
|
|
|
|
intervals to the new text are "sticky", then the new text retains
|
|
|
|
|
only its properties, as if neither sticky property were set. Perhaps
|
1992-09-17 02:26:53 +00:00
|
|
|
|
we should consider merging all three sets of properties onto the new
|
1993-07-31 21:58:03 +00:00
|
|
|
|
text... */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
void
|
1993-11-25 06:28:03 +00:00
|
|
|
|
graft_intervals_into_buffer (source, position, length, buffer, inherit)
|
1992-09-24 01:29:22 +00:00
|
|
|
|
INTERVAL source;
|
1993-11-25 06:28:03 +00:00
|
|
|
|
int position, length;
|
1992-09-24 01:29:22 +00:00
|
|
|
|
struct buffer *buffer;
|
1993-09-14 12:10:53 +00:00
|
|
|
|
int inherit;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1993-03-01 08:56:22 +00:00
|
|
|
|
register INTERVAL under, over, this, prev;
|
1995-01-02 21:38:22 +00:00
|
|
|
|
register INTERVAL tree;
|
1993-03-01 08:56:22 +00:00
|
|
|
|
int middle;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1995-01-02 21:38:22 +00:00
|
|
|
|
tree = BUF_INTERVALS (buffer);
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
/* If the new text has no properties, it becomes part of whatever
|
1993-07-31 21:58:03 +00:00
|
|
|
|
interval it was inserted into. */
|
1992-09-24 01:29:22 +00:00
|
|
|
|
if (NULL_INTERVAL_P (source))
|
1993-11-25 06:28:03 +00:00
|
|
|
|
{
|
|
|
|
|
Lisp_Object buf;
|
1993-12-23 01:58:56 +00:00
|
|
|
|
if (!inherit && ! NULL_INTERVAL_P (tree))
|
1993-11-25 06:28:03 +00:00
|
|
|
|
{
|
1994-10-04 12:10:17 +00:00
|
|
|
|
XSETBUFFER (buf, buffer);
|
1993-11-25 06:28:03 +00:00
|
|
|
|
Fset_text_properties (make_number (position),
|
|
|
|
|
make_number (position + length),
|
|
|
|
|
Qnil, buf);
|
|
|
|
|
}
|
1995-01-02 21:38:22 +00:00
|
|
|
|
if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
|
|
|
|
|
BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
|
1993-11-25 06:28:03 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (tree))
|
|
|
|
|
{
|
|
|
|
|
/* The inserted text constitutes the whole buffer, so
|
1993-07-31 21:58:03 +00:00
|
|
|
|
simply copy over the interval structure. */
|
1993-07-18 06:24:25 +00:00
|
|
|
|
if ((BUF_Z (buffer) - BUF_BEG (buffer)) == TOTAL_LENGTH (source))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1993-07-22 08:06:55 +00:00
|
|
|
|
Lisp_Object buf;
|
1994-10-04 12:10:17 +00:00
|
|
|
|
XSETBUFFER (buf, buffer);
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (buffer) = reproduce_tree (source, buf);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Explicitly free the old tree here. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Create an interval tree in which to place a copy
|
1993-07-31 21:58:03 +00:00
|
|
|
|
of the intervals of the inserted string. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1992-10-02 22:33:18 +00:00
|
|
|
|
Lisp_Object buf;
|
1994-10-04 12:10:17 +00:00
|
|
|
|
XSETBUFFER (buf, buffer);
|
1993-03-01 08:56:22 +00:00
|
|
|
|
tree = create_root_interval (buf);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
}
|
1993-09-14 12:10:53 +00:00
|
|
|
|
else if (TOTAL_LENGTH (tree) == TOTAL_LENGTH (source))
|
|
|
|
|
/* If the buffer contains only the new string, but
|
|
|
|
|
there was already some interval tree there, then it may be
|
|
|
|
|
some zero length intervals. Eventually, do something clever
|
|
|
|
|
about inserting properly. For now, just waste the old intervals. */
|
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_INTERVALS (buffer) = reproduce_tree (source, tree->parent);
|
1993-09-14 12:10:53 +00:00
|
|
|
|
/* Explicitly free the old tree here. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-09-14 12:10:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
/* Paranoia -- the text has already been added, so this buffer
|
|
|
|
|
should be of non-zero length. */
|
|
|
|
|
else if (TOTAL_LENGTH (tree) == 0)
|
|
|
|
|
abort ();
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
this = under = find_interval (tree, position);
|
|
|
|
|
if (NULL_INTERVAL_P (under)) /* Paranoia */
|
|
|
|
|
abort ();
|
1992-09-24 01:29:22 +00:00
|
|
|
|
over = find_interval (source, 1);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
/* Here for insertion in the middle of an interval.
|
|
|
|
|
Split off an equivalent interval to the right,
|
|
|
|
|
then don't bother with it any more. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
if (position > under->position)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
|
|
|
|
INTERVAL end_unchanged
|
1993-07-18 06:24:25 +00:00
|
|
|
|
= split_interval_left (this, position - under->position);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_properties (under, end_unchanged);
|
1993-03-01 08:56:22 +00:00
|
|
|
|
under->position = position;
|
|
|
|
|
prev = 0;
|
|
|
|
|
middle = 1;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
1993-03-01 08:56:22 +00:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
prev = previous_interval (under);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (prev && !END_NONSTICKY_P (prev))
|
1993-03-01 08:56:22 +00:00
|
|
|
|
prev = 0;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Insertion is now at beginning of UNDER. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
/* The inserted text "sticks" to the interval `under',
|
1993-07-31 21:58:03 +00:00
|
|
|
|
which means it gets those properties.
|
|
|
|
|
The properties of under are the result of
|
1996-01-05 10:03:17 +00:00
|
|
|
|
adjust_intervals_for_insertion, so stickiness has
|
1993-07-31 21:58:03 +00:00
|
|
|
|
already been taken care of. */
|
|
|
|
|
|
1992-09-17 02:26:53 +00:00
|
|
|
|
while (! NULL_INTERVAL_P (over))
|
|
|
|
|
{
|
1994-01-24 17:07:28 +00:00
|
|
|
|
if (LENGTH (over) < LENGTH (under))
|
1993-07-31 21:58:03 +00:00
|
|
|
|
{
|
|
|
|
|
this = split_interval_left (under, LENGTH (over));
|
|
|
|
|
copy_properties (under, this);
|
|
|
|
|
}
|
1993-03-01 08:56:22 +00:00
|
|
|
|
else
|
|
|
|
|
this = under;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_properties (over, this);
|
1993-09-14 12:10:53 +00:00
|
|
|
|
if (inherit)
|
1993-07-31 21:58:03 +00:00
|
|
|
|
merge_properties (over, this);
|
|
|
|
|
else
|
|
|
|
|
copy_properties (over, this);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
over = next_interval (over);
|
|
|
|
|
}
|
|
|
|
|
|
1995-01-02 21:38:22 +00:00
|
|
|
|
if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
|
|
|
|
|
BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1993-03-10 05:12:42 +00:00
|
|
|
|
/* Get the value of property PROP from PLIST,
|
|
|
|
|
which is the plist of an interval.
|
1995-03-06 15:43:56 +00:00
|
|
|
|
We check for direct properties, for categories with property PROP,
|
1995-03-27 16:05:57 +00:00
|
|
|
|
and for PROP appearing on the default-text-properties list. */
|
1993-03-10 05:12:42 +00:00
|
|
|
|
|
|
|
|
|
Lisp_Object
|
1993-03-01 08:56:22 +00:00
|
|
|
|
textget (plist, prop)
|
|
|
|
|
Lisp_Object plist;
|
|
|
|
|
register Lisp_Object prop;
|
|
|
|
|
{
|
1993-03-10 05:12:42 +00:00
|
|
|
|
register Lisp_Object tail, fallback;
|
|
|
|
|
fallback = Qnil;
|
1993-03-01 08:56:22 +00:00
|
|
|
|
|
|
|
|
|
for (tail = plist; !NILP (tail); tail = Fcdr (Fcdr (tail)))
|
|
|
|
|
{
|
|
|
|
|
register Lisp_Object tem;
|
|
|
|
|
tem = Fcar (tail);
|
|
|
|
|
if (EQ (prop, tem))
|
|
|
|
|
return Fcar (Fcdr (tail));
|
1993-03-10 05:12:42 +00:00
|
|
|
|
if (EQ (tem, Qcategory))
|
1994-08-24 19:40:44 +00:00
|
|
|
|
{
|
|
|
|
|
tem = Fcar (Fcdr (tail));
|
|
|
|
|
if (SYMBOLP (tem))
|
|
|
|
|
fallback = Fget (tem, prop);
|
|
|
|
|
}
|
1993-03-01 08:56:22 +00:00
|
|
|
|
}
|
1993-03-10 05:12:42 +00:00
|
|
|
|
|
1995-03-06 15:43:56 +00:00
|
|
|
|
if (! NILP (fallback))
|
|
|
|
|
return fallback;
|
1995-03-27 16:05:57 +00:00
|
|
|
|
if (CONSP (Vdefault_text_properties))
|
|
|
|
|
return Fplist_get (Vdefault_text_properties, prop);
|
1995-03-06 15:43:56 +00:00
|
|
|
|
return Qnil;
|
1993-03-01 08:56:22 +00:00
|
|
|
|
}
|
1993-07-31 21:58:03 +00:00
|
|
|
|
|
1993-03-07 09:34:39 +00:00
|
|
|
|
|
1993-03-10 05:12:42 +00:00
|
|
|
|
/* Set point in BUFFER to POSITION. If the target position is
|
1994-04-26 01:18:38 +00:00
|
|
|
|
before an intangible character, move to an ok place. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
set_point (position, buffer)
|
|
|
|
|
register int position;
|
|
|
|
|
register struct buffer *buffer;
|
|
|
|
|
{
|
1993-03-01 08:56:22 +00:00
|
|
|
|
register INTERVAL to, from, toprev, fromprev, target;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
int buffer_point;
|
|
|
|
|
register Lisp_Object obj;
|
1995-01-02 21:38:22 +00:00
|
|
|
|
int old_position = BUF_PT (buffer);
|
1996-12-15 04:58:53 +00:00
|
|
|
|
int backwards = (position < old_position ? 1 : 0);
|
|
|
|
|
int have_overlays;
|
|
|
|
|
int original_position;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1995-01-27 07:19:06 +00:00
|
|
|
|
buffer->point_before_scroll = Qnil;
|
|
|
|
|
|
1995-01-02 21:38:22 +00:00
|
|
|
|
if (position == BUF_PT (buffer))
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
|
1993-05-14 14:40:56 +00:00
|
|
|
|
/* Check this now, before checking if the buffer has any intervals.
|
|
|
|
|
That way, we can catch conditions which break this sanity check
|
|
|
|
|
whether or not there are intervals in the buffer. */
|
1996-12-18 06:30:59 +00:00
|
|
|
|
if (position > BUF_ZV (buffer) || position < BUF_BEGV (buffer))
|
1993-05-14 14:40:56 +00:00
|
|
|
|
abort ();
|
|
|
|
|
|
1996-12-15 04:58:53 +00:00
|
|
|
|
have_overlays = (! NILP (buffer->overlays_before)
|
|
|
|
|
|| ! NILP (buffer->overlays_after));
|
|
|
|
|
|
|
|
|
|
/* If we have no text properties and overlays,
|
|
|
|
|
then we can do it quickly. */
|
|
|
|
|
if (NULL_INTERVAL_P (BUF_INTERVALS (buffer)) && ! have_overlays)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_PT (buffer) = position;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
/* Set TO to the interval containing the char after POSITION,
|
|
|
|
|
and TOPREV to the interval containing the char before POSITION.
|
|
|
|
|
Either one may be null. They may be equal. */
|
1995-01-02 21:38:22 +00:00
|
|
|
|
to = find_interval (BUF_INTERVALS (buffer), position);
|
1993-03-07 09:34:39 +00:00
|
|
|
|
if (position == BUF_BEGV (buffer))
|
|
|
|
|
toprev = 0;
|
1996-12-15 04:58:53 +00:00
|
|
|
|
else if (to && to->position == position)
|
1993-03-01 08:56:22 +00:00
|
|
|
|
toprev = previous_interval (to);
|
|
|
|
|
else
|
|
|
|
|
toprev = to;
|
|
|
|
|
|
1993-03-07 09:34:39 +00:00
|
|
|
|
buffer_point = (BUF_PT (buffer) == BUF_ZV (buffer)
|
|
|
|
|
? BUF_ZV (buffer) - 1
|
1993-03-01 08:56:22 +00:00
|
|
|
|
: BUF_PT (buffer));
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
/* Set FROM to the interval containing the char after PT,
|
|
|
|
|
and FROMPREV to the interval containing the char before PT.
|
|
|
|
|
Either one may be null. They may be equal. */
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* We could cache this and save time. */
|
1995-01-02 21:38:22 +00:00
|
|
|
|
from = find_interval (BUF_INTERVALS (buffer), buffer_point);
|
1993-07-31 21:58:03 +00:00
|
|
|
|
if (buffer_point == BUF_BEGV (buffer))
|
1993-03-07 09:34:39 +00:00
|
|
|
|
fromprev = 0;
|
1996-12-15 04:58:53 +00:00
|
|
|
|
else if (from && from->position == BUF_PT (buffer))
|
1993-03-01 08:56:22 +00:00
|
|
|
|
fromprev = previous_interval (from);
|
|
|
|
|
else if (buffer_point != BUF_PT (buffer))
|
|
|
|
|
fromprev = from, from = 0;
|
|
|
|
|
else
|
|
|
|
|
fromprev = from;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Moving within an interval. */
|
1996-12-15 04:58:53 +00:00
|
|
|
|
if (to == from && toprev == fromprev && INTERVAL_VISIBLE_P (to)
|
|
|
|
|
&& ! have_overlays)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_PT (buffer) = position;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
1996-12-15 04:58:53 +00:00
|
|
|
|
original_position = position;
|
|
|
|
|
|
1995-04-09 09:42:28 +00:00
|
|
|
|
/* If the new position is between two intangible characters
|
|
|
|
|
with the same intangible property value,
|
|
|
|
|
move forward or backward until a change in that property. */
|
1996-12-15 04:58:53 +00:00
|
|
|
|
if (NILP (Vinhibit_point_motion_hooks)
|
|
|
|
|
&& ((! NULL_INTERVAL_P (to) && ! NULL_INTERVAL_P (toprev))
|
1996-12-18 06:30:59 +00:00
|
|
|
|
|| have_overlays)
|
|
|
|
|
/* Intangibility never stops us from positioning at the beginning
|
|
|
|
|
or end of the buffer, so don't bother checking in that case. */
|
|
|
|
|
&& position != BEGV && position != ZV)
|
1992-09-17 02:26:53 +00:00
|
|
|
|
{
|
1996-12-15 04:58:53 +00:00
|
|
|
|
Lisp_Object intangible_propval;
|
|
|
|
|
Lisp_Object pos;
|
|
|
|
|
|
|
|
|
|
XSETINT (pos, position);
|
|
|
|
|
|
1994-09-24 09:13:57 +00:00
|
|
|
|
if (backwards)
|
|
|
|
|
{
|
1996-12-15 04:58:53 +00:00
|
|
|
|
intangible_propval = Fget_char_property (make_number (position),
|
|
|
|
|
Qintangible, Qnil);
|
1995-04-09 09:42:28 +00:00
|
|
|
|
|
|
|
|
|
/* If following char is intangible,
|
|
|
|
|
skip back over all chars with matching intangible property. */
|
|
|
|
|
if (! NILP (intangible_propval))
|
1996-12-15 04:58:53 +00:00
|
|
|
|
while (XINT (pos) > BUF_BEGV (buffer)
|
|
|
|
|
&& EQ (Fget_char_property (make_number (XINT (pos) - 1),
|
|
|
|
|
Qintangible, Qnil),
|
|
|
|
|
intangible_propval))
|
|
|
|
|
pos = Fprevious_char_property_change (pos, Qnil);
|
1994-09-24 09:13:57 +00:00
|
|
|
|
}
|
1993-06-15 05:27:54 +00:00
|
|
|
|
else
|
1994-09-24 09:13:57 +00:00
|
|
|
|
{
|
1996-12-15 04:58:53 +00:00
|
|
|
|
intangible_propval = Fget_char_property (make_number (position - 1),
|
|
|
|
|
Qintangible, Qnil);
|
1995-04-09 09:42:28 +00:00
|
|
|
|
|
1996-12-15 04:58:53 +00:00
|
|
|
|
/* If following char is intangible,
|
|
|
|
|
skip back over all chars with matching intangible property. */
|
1995-04-09 09:42:28 +00:00
|
|
|
|
if (! NILP (intangible_propval))
|
1996-12-15 04:58:53 +00:00
|
|
|
|
while (XINT (pos) < BUF_ZV (buffer)
|
|
|
|
|
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
|
|
|
|
|
intangible_propval))
|
|
|
|
|
pos = Fnext_char_property_change (pos, Qnil);
|
|
|
|
|
|
1994-09-24 09:13:57 +00:00
|
|
|
|
}
|
1996-12-15 04:58:53 +00:00
|
|
|
|
|
|
|
|
|
position = XINT (pos);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (position != original_position)
|
|
|
|
|
{
|
|
|
|
|
/* Set TO to the interval containing the char after POSITION,
|
|
|
|
|
and TOPREV to the interval containing the char before POSITION.
|
|
|
|
|
Either one may be null. They may be equal. */
|
|
|
|
|
to = find_interval (BUF_INTERVALS (buffer), position);
|
|
|
|
|
if (position == BUF_BEGV (buffer))
|
|
|
|
|
toprev = 0;
|
|
|
|
|
else if (to && to->position == position)
|
|
|
|
|
toprev = previous_interval (to);
|
|
|
|
|
else
|
|
|
|
|
toprev = to;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
1993-03-01 08:56:22 +00:00
|
|
|
|
|
1995-04-09 09:42:28 +00:00
|
|
|
|
/* Here TO is the interval after the stopping point
|
|
|
|
|
and TOPREV is the interval before the stopping point.
|
|
|
|
|
One or the other may be null. */
|
|
|
|
|
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_PT (buffer) = position;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-10-01 00:56:11 +00:00
|
|
|
|
/* We run point-left and point-entered hooks here, iff the
|
|
|
|
|
two intervals are not equivalent. These hooks take
|
1993-03-01 08:56:22 +00:00
|
|
|
|
(old_point, new_point) as arguments. */
|
1993-07-23 07:59:08 +00:00
|
|
|
|
if (NILP (Vinhibit_point_motion_hooks)
|
|
|
|
|
&& (! intervals_equal (from, to)
|
|
|
|
|
|| ! intervals_equal (fromprev, toprev)))
|
1992-09-24 01:29:22 +00:00
|
|
|
|
{
|
1993-03-01 08:56:22 +00:00
|
|
|
|
Lisp_Object leave_after, leave_before, enter_after, enter_before;
|
|
|
|
|
|
|
|
|
|
if (fromprev)
|
|
|
|
|
leave_after = textget (fromprev->plist, Qpoint_left);
|
|
|
|
|
else
|
|
|
|
|
leave_after = Qnil;
|
|
|
|
|
if (from)
|
|
|
|
|
leave_before = textget (from->plist, Qpoint_left);
|
|
|
|
|
else
|
|
|
|
|
leave_before = Qnil;
|
|
|
|
|
|
|
|
|
|
if (toprev)
|
|
|
|
|
enter_after = textget (toprev->plist, Qpoint_entered);
|
|
|
|
|
else
|
|
|
|
|
enter_after = Qnil;
|
|
|
|
|
if (to)
|
|
|
|
|
enter_before = textget (to->plist, Qpoint_entered);
|
|
|
|
|
else
|
|
|
|
|
enter_before = Qnil;
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
if (! EQ (leave_before, enter_before) && !NILP (leave_before))
|
|
|
|
|
call2 (leave_before, old_position, position);
|
|
|
|
|
if (! EQ (leave_after, enter_after) && !NILP (leave_after))
|
|
|
|
|
call2 (leave_after, old_position, position);
|
1992-09-24 01:29:22 +00:00
|
|
|
|
|
1993-03-01 08:56:22 +00:00
|
|
|
|
if (! EQ (enter_before, leave_before) && !NILP (enter_before))
|
|
|
|
|
call2 (enter_before, old_position, position);
|
|
|
|
|
if (! EQ (enter_after, leave_after) && !NILP (enter_after))
|
|
|
|
|
call2 (enter_after, old_position, position);
|
1992-09-24 01:29:22 +00:00
|
|
|
|
}
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Set point temporarily, without checking any text properties. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-09-24 01:29:22 +00:00
|
|
|
|
INLINE void
|
|
|
|
|
temp_set_point (position, buffer)
|
|
|
|
|
int position;
|
|
|
|
|
struct buffer *buffer;
|
|
|
|
|
{
|
1995-01-02 21:38:22 +00:00
|
|
|
|
BUF_PT (buffer) = position;
|
1992-09-24 01:29:22 +00:00
|
|
|
|
}
|
1993-03-07 09:34:39 +00:00
|
|
|
|
|
1997-05-31 07:38:44 +00:00
|
|
|
|
/* Move point to POSITION, unless POSITION is inside an intangible
|
|
|
|
|
segment that reaches all the way to point. */
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
move_if_not_intangible (position)
|
|
|
|
|
int position;
|
|
|
|
|
{
|
|
|
|
|
Lisp_Object pos;
|
|
|
|
|
Lisp_Object intangible_propval;
|
|
|
|
|
|
|
|
|
|
XSETINT (pos, position);
|
|
|
|
|
|
|
|
|
|
if (! NILP (Vinhibit_point_motion_hooks))
|
|
|
|
|
/* If intangible is inhibited, always move point to POSITION. */
|
|
|
|
|
;
|
1997-05-31 08:34:13 +00:00
|
|
|
|
else if (PT < position && pos < ZV)
|
1997-05-31 07:38:44 +00:00
|
|
|
|
{
|
|
|
|
|
/* We want to move forward, so check the text before POSITION. */
|
|
|
|
|
|
|
|
|
|
intangible_propval = Fget_char_property (pos,
|
|
|
|
|
Qintangible, Qnil);
|
|
|
|
|
|
|
|
|
|
/* If following char is intangible,
|
|
|
|
|
skip back over all chars with matching intangible property. */
|
|
|
|
|
if (! NILP (intangible_propval))
|
|
|
|
|
while (XINT (pos) > BEGV
|
|
|
|
|
&& EQ (Fget_char_property (make_number (XINT (pos) - 1),
|
|
|
|
|
Qintangible, Qnil),
|
|
|
|
|
intangible_propval))
|
|
|
|
|
pos = Fprevious_char_property_change (pos, Qnil);
|
|
|
|
|
}
|
1997-05-31 08:34:13 +00:00
|
|
|
|
else if (pos > BEGV)
|
1997-05-31 07:38:44 +00:00
|
|
|
|
{
|
|
|
|
|
/* We want to move backward, so check the text after POSITION. */
|
|
|
|
|
|
|
|
|
|
intangible_propval = Fget_char_property (make_number (XINT (pos) - 1),
|
|
|
|
|
Qintangible, Qnil);
|
|
|
|
|
|
|
|
|
|
/* If following char is intangible,
|
|
|
|
|
skip back over all chars with matching intangible property. */
|
|
|
|
|
if (! NILP (intangible_propval))
|
|
|
|
|
while (XINT (pos) < ZV
|
|
|
|
|
&& EQ (Fget_char_property (pos, Qintangible, Qnil),
|
|
|
|
|
intangible_propval))
|
|
|
|
|
pos = Fnext_char_property_change (pos, Qnil);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If the whole stretch between PT and POSITION isn't intangible,
|
|
|
|
|
try moving to POSITION (which means we actually move farther
|
|
|
|
|
if POSITION is inside of intangible text). */
|
|
|
|
|
|
|
|
|
|
if (XINT (pos) != PT)
|
|
|
|
|
SET_PT (position);
|
|
|
|
|
}
|
|
|
|
|
|
1993-03-10 05:12:42 +00:00
|
|
|
|
/* Return the proper local map for position POSITION in BUFFER.
|
|
|
|
|
Use the map specified by the local-map property, if any.
|
|
|
|
|
Otherwise, use BUFFER's local map. */
|
|
|
|
|
|
|
|
|
|
Lisp_Object
|
|
|
|
|
get_local_map (position, buffer)
|
|
|
|
|
register int position;
|
|
|
|
|
register struct buffer *buffer;
|
|
|
|
|
{
|
1995-05-02 23:06:11 +00:00
|
|
|
|
Lisp_Object prop, tem, lispy_position, lispy_buffer;
|
|
|
|
|
int old_begv, old_zv;
|
1993-03-10 05:12:42 +00:00
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Perhaps we should just change `position' to the limit. */
|
1993-03-10 05:12:42 +00:00
|
|
|
|
if (position > BUF_Z (buffer) || position < BUF_BEG (buffer))
|
|
|
|
|
abort ();
|
|
|
|
|
|
1995-05-02 23:06:11 +00:00
|
|
|
|
/* Ignore narrowing, so that a local map continues to be valid even if
|
|
|
|
|
the visible region contains no characters and hence no properties. */
|
|
|
|
|
old_begv = BUF_BEGV (buffer);
|
|
|
|
|
old_zv = BUF_ZV (buffer);
|
|
|
|
|
BUF_BEGV (buffer) = BUF_BEG (buffer);
|
|
|
|
|
BUF_ZV (buffer) = BUF_Z (buffer);
|
|
|
|
|
|
|
|
|
|
/* There are no properties at the end of the buffer, so in that case
|
|
|
|
|
check for a local map on the last character of the buffer instead. */
|
|
|
|
|
if (position == BUF_Z (buffer) && BUF_Z (buffer) > BUF_BEG (buffer))
|
|
|
|
|
--position;
|
|
|
|
|
XSETFASTINT (lispy_position, position);
|
|
|
|
|
XSETBUFFER (lispy_buffer, buffer);
|
|
|
|
|
prop = Fget_char_property (lispy_position, Qlocal_map, lispy_buffer);
|
|
|
|
|
|
|
|
|
|
BUF_BEGV (buffer) = old_begv;
|
|
|
|
|
BUF_ZV (buffer) = old_zv;
|
1993-03-10 05:12:42 +00:00
|
|
|
|
|
|
|
|
|
/* Use the local map only if it is valid. */
|
1996-09-04 15:40:46 +00:00
|
|
|
|
/* Do allow symbols that are defined as keymaps. */
|
|
|
|
|
if (SYMBOLP (prop) && !NILP (prop))
|
|
|
|
|
prop = Findirect_function (prop);
|
1995-05-02 23:06:11 +00:00
|
|
|
|
if (!NILP (prop)
|
|
|
|
|
&& (tem = Fkeymapp (prop), !NILP (tem)))
|
1993-03-10 05:12:42 +00:00
|
|
|
|
return prop;
|
|
|
|
|
|
1995-01-02 21:38:22 +00:00
|
|
|
|
return buffer->keymap;
|
1993-03-10 05:12:42 +00:00
|
|
|
|
}
|
|
|
|
|
|
1992-09-24 01:29:22 +00:00
|
|
|
|
/* Produce an interval tree reflecting the intervals in
|
1993-07-31 21:58:03 +00:00
|
|
|
|
TREE from START to START + LENGTH. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-10-03 00:05:48 +00:00
|
|
|
|
INTERVAL
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_intervals (tree, start, length)
|
|
|
|
|
INTERVAL tree;
|
|
|
|
|
int start, length;
|
|
|
|
|
{
|
|
|
|
|
register INTERVAL i, new, t;
|
1993-06-05 07:57:32 +00:00
|
|
|
|
register int got, prevlen;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
|
|
|
|
if (NULL_INTERVAL_P (tree) || length <= 0)
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
|
|
|
|
i = find_interval (tree, start);
|
|
|
|
|
if (NULL_INTERVAL_P (i) || LENGTH (i) == 0)
|
|
|
|
|
abort ();
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* If there is only one interval and it's the default, return nil. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
if ((start - i->position + 1 + length) < LENGTH (i)
|
|
|
|
|
&& DEFAULT_INTERVAL_P (i))
|
|
|
|
|
return NULL_INTERVAL;
|
|
|
|
|
|
|
|
|
|
new = make_interval ();
|
|
|
|
|
new->position = 1;
|
|
|
|
|
got = (LENGTH (i) - (start - i->position));
|
1992-09-24 01:29:22 +00:00
|
|
|
|
new->total_length = length;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_properties (i, new);
|
|
|
|
|
|
|
|
|
|
t = new;
|
1993-06-05 07:57:32 +00:00
|
|
|
|
prevlen = got;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
while (got < length)
|
|
|
|
|
{
|
|
|
|
|
i = next_interval (i);
|
1993-07-18 06:24:25 +00:00
|
|
|
|
t = split_interval_right (t, prevlen);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_properties (i, t);
|
1993-06-05 07:57:32 +00:00
|
|
|
|
prevlen = LENGTH (i);
|
|
|
|
|
got += prevlen;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1994-01-02 19:01:15 +00:00
|
|
|
|
return balance_an_interval (new);
|
1992-09-17 02:26:53 +00:00
|
|
|
|
}
|
|
|
|
|
|
1993-07-31 21:58:03 +00:00
|
|
|
|
/* Give STRING the properties of BUFFER from POSITION to LENGTH. */
|
1992-09-17 02:26:53 +00:00
|
|
|
|
|
1992-10-01 00:56:11 +00:00
|
|
|
|
INLINE void
|
1992-09-17 02:26:53 +00:00
|
|
|
|
copy_intervals_to_string (string, buffer, position, length)
|
1996-09-04 04:33:40 +00:00
|
|
|
|
Lisp_Object string;
|
|
|
|
|
struct buffer *buffer;
|
1992-09-17 02:26:53 +00:00
|
|
|
|
int position, length;
|
|
|
|
|
{
|
1996-09-04 04:33:40 +00:00
|
|
|
|
INTERVAL interval_copy = copy_intervals (BUF_INTERVALS (buffer),
|
1992-09-17 02:26:53 +00:00
|
|
|
|
position, length);
|
|
|
|
|
if (NULL_INTERVAL_P (interval_copy))
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
interval_copy->parent = (INTERVAL) string;
|
|
|
|
|
XSTRING (string)->intervals = interval_copy;
|
|
|
|
|
}
|
1994-12-04 21:07:03 +00:00
|
|
|
|
|
|
|
|
|
/* Return 1 if string S1 and S2 have identical properties; 0 otherwise.
|
|
|
|
|
Assume they have identical characters. */
|
|
|
|
|
|
|
|
|
|
int
|
|
|
|
|
compare_string_intervals (s1, s2)
|
|
|
|
|
Lisp_Object s1, s2;
|
|
|
|
|
{
|
|
|
|
|
INTERVAL i1, i2;
|
|
|
|
|
int pos = 1;
|
|
|
|
|
int end = XSTRING (s1)->size + 1;
|
|
|
|
|
|
|
|
|
|
/* We specify 1 as position because the interval functions
|
|
|
|
|
always use positions starting at 1. */
|
|
|
|
|
i1 = find_interval (XSTRING (s1)->intervals, 1);
|
|
|
|
|
i2 = find_interval (XSTRING (s2)->intervals, 1);
|
|
|
|
|
|
|
|
|
|
while (pos < end)
|
|
|
|
|
{
|
|
|
|
|
/* Determine how far we can go before we reach the end of I1 or I2. */
|
|
|
|
|
int len1 = (i1 != 0 ? INTERVAL_LAST_POS (i1) : end) - pos;
|
|
|
|
|
int len2 = (i2 != 0 ? INTERVAL_LAST_POS (i2) : end) - pos;
|
|
|
|
|
int distance = min (len1, len2);
|
|
|
|
|
|
|
|
|
|
/* If we ever find a mismatch between the strings,
|
|
|
|
|
they differ. */
|
|
|
|
|
if (! intervals_equal (i1, i2))
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
|
|
/* Advance POS till the end of the shorter interval,
|
|
|
|
|
and advance one or both interval pointers for the new position. */
|
|
|
|
|
pos += distance;
|
|
|
|
|
if (len1 == distance)
|
|
|
|
|
i1 = next_interval (i1);
|
|
|
|
|
if (len2 == distance)
|
|
|
|
|
i2 = next_interval (i2);
|
|
|
|
|
}
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
1992-10-02 20:02:51 +00:00
|
|
|
|
|
|
|
|
|
#endif /* USE_TEXT_PROPERTIES */
|