/* Code for doing intervals.
- Copyright (C) 1993, 1994, 1995, 1997, 1998, 2002 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1997, 1998, 2002, 2003, 2004,
+ 2005 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
/* NOTES:
- BUF_BEG (XBUFFER (parent)));
CHECK_TOTAL_LENGTH (new);
BUF_INTERVALS (XBUFFER (parent)) = new;
- new->position = 1;
+ new->position = BEG;
}
else if (STRINGP (parent))
{
MERGE_INTERVAL_CACHE (source, target);
o = source->plist;
- while (! EQ (o, Qnil))
+ while (CONSP (o))
{
- sym = Fcar (o);
+ sym = XCAR (o);
val = Fmemq (sym, target->plist);
if (NILP (val))
{
- o = Fcdr (o);
- val = Fcar (o);
+ o = XCDR (o);
+ CHECK_CONS (o);
+ val = XCAR (o);
target->plist = Fcons (sym, Fcons (val, target->plist));
- o = Fcdr (o);
+ o = XCDR (o);
}
else
- o = Fcdr (Fcdr (o));
+ o = Fcdr (XCDR (o));
}
}
abort ();
i1_len /= 2;
i0_cdr = i0->plist;
- while (!NILP (i0_cdr))
+ while (CONSP (i0_cdr))
{
/* Lengths of the two plists were unequal. */
if (i1_len == 0)
return 0;
- i0_sym = Fcar (i0_cdr);
+ i0_sym = XCAR (i0_cdr);
i1_val = Fmemq (i0_sym, i1->plist);
/* i0 has something i1 doesn't. */
return 0;
/* i0 and i1 both have sym, but it has different values in each. */
- i0_cdr = Fcdr (i0_cdr);
- if (! EQ (Fcar (Fcdr (i1_val)), Fcar (i0_cdr)))
+ i0_cdr = XCDR (i0_cdr);
+ CHECK_CONS (i0_cdr);
+ if (!EQ (Fcar (Fcdr (i1_val)), XCAR (i0_cdr)))
return 0;
- i0_cdr = Fcdr (i0_cdr);
+ i0_cdr = XCDR (i0_cdr);
i1_len--;
}
else
{
tree->position
- = (position - relative_position /* the left edge of *tree */
- + LEFT_TOTAL_LENGTH (tree)); /* the left edge of this interval */
+ = (position - relative_position /* left edge of *tree. */
+ + LEFT_TOTAL_LENGTH (tree)); /* left edge of this interval. */
return tree;
}
rrear = textget (pright, Qrear_nonsticky);
/* Go through each element of PRIGHT. */
- for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (Fcdr (tail1)))
+ for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
{
Lisp_Object tmp;
- sym = Fcar (tail1);
+ sym = XCAR (tail1);
/* Sticky properties get special treatment. */
if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky))
continue;
- rval = Fcar (Fcdr (tail1));
- for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (Fcdr (tail2)))
- if (EQ (sym, Fcar (tail2)))
+ rval = Fcar (XCDR (tail1));
+ for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
+ if (EQ (sym, XCAR (tail2)))
break;
/* Indicate whether the property is explicitly defined on the left.
}
/* Now go through each element of PLEFT. */
- for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (Fcdr (tail2)))
+ for (tail2 = pleft; CONSP (tail2); tail2 = Fcdr (XCDR (tail2)))
{
Lisp_Object tmp;
- sym = Fcar (tail2);
+ sym = XCAR (tail2);
/* Sticky properties get special treatment. */
if (EQ (sym, Qrear_nonsticky) || EQ (sym, Qfront_sticky))
continue;
/* If sym is in PRIGHT, we've already considered it. */
- for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (Fcdr (tail1)))
- if (EQ (sym, Fcar (tail1)))
+ for (tail1 = pright; CONSP (tail1); tail1 = Fcdr (XCDR (tail1)))
+ if (EQ (sym, XCAR (tail1)))
break;
if (! NILP (tail1))
continue;
- lval = Fcar (Fcdr (tail2));
+ lval = Fcar (XCDR (tail2));
/* Even if lrear or rfront say nothing about the stickiness of
SYM, Vtext_property_default_nonsticky may give default
{
register INTERVAL under, over, this, prev;
register INTERVAL tree;
+ int over_used;
tree = BUF_INTERVALS (buffer);
Qnil, buf, 0);
}
if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
+ /* Shouldn't be necessary. -stef */
BUF_INTERVALS (buffer) = balance_an_interval (BUF_INTERVALS (buffer));
return;
}
Lisp_Object buf;
XSETBUFFER (buf, buffer);
BUF_INTERVALS (buffer) = reproduce_tree_obj (source, buf);
- BUF_INTERVALS (buffer)->position = 1;
+ BUF_INTERVALS (buffer)->position = BEG;
+ BUF_INTERVALS (buffer)->up_obj = 1;
/* Explicitly free the old tree here? */
about inserting properly. For now, just waste the old intervals. */
{
BUF_INTERVALS (buffer) = reproduce_tree (source, INTERVAL_PARENT (tree));
- BUF_INTERVALS (buffer)->position = 1;
+ BUF_INTERVALS (buffer)->position = BEG;
+ BUF_INTERVALS (buffer)->up_obj = 1;
/* Explicitly free the old tree here. */
return;
adjust_intervals_for_insertion, so stickiness has
already been taken care of. */
+ /* OVER is the interval we are copying from next.
+ OVER_USED says how many characters' worth of OVER
+ have already been copied into target intervals.
+ UNDER is the next interval in the target. */
+ over_used = 0;
while (! NULL_INTERVAL_P (over))
{
- if (LENGTH (over) < LENGTH (under))
+ /* If UNDER is longer than OVER, split it. */
+ if (LENGTH (over) - over_used < LENGTH (under))
{
- this = split_interval_left (under, LENGTH (over));
+ this = split_interval_left (under, LENGTH (over) - over_used);
copy_properties (under, this);
}
else
this = under;
- copy_properties (over, this);
+
+ /* THIS is now the interval to copy or merge into.
+ OVER covers all of it. */
if (inherit)
merge_properties (over, this);
else
copy_properties (over, this);
- over = next_interval (over);
+
+ /* If THIS and OVER end at the same place,
+ advance OVER to a new source interval. */
+ if (LENGTH (this) == LENGTH (over) - over_used)
+ {
+ over = next_interval (over);
+ over_used = 0;
+ }
+ else
+ /* Otherwise just record that more of OVER has been used. */
+ over_used += LENGTH (this);
+
+ /* Always advance to a new target interval. */
+ under = next_interval (this);
}
if (! NULL_INTERVAL_P (BUF_INTERVALS (buffer)))
return fallback;
/* Check for alternative properties */
tail = Fassq (prop, Vchar_property_alias_alist);
- if (NILP (tail))
- return tail;
- tail = XCDR (tail);
- for (; NILP (fallback) && CONSP (tail); tail = XCDR (tail))
- fallback = Fplist_get (plist, XCAR (tail));
+ if (! NILP (tail))
+ {
+ tail = XCDR (tail);
+ for (; NILP (fallback) && CONSP (tail); tail = XCDR (tail))
+ fallback = Fplist_get (plist, XCAR (tail));
+ }
+
if (textprop && NILP (fallback) && CONSP (Vdefault_text_properties))
fallback = Fplist_get (Vdefault_text_properties, prop);
return fallback;
such that an insertion at POS would inherit it. */
&& (NILP (invis_overlay)
/* Invisible property is from a text-property. */
- ? (text_property_stickiness (Qinvisible, make_number (pos))
+ ? (text_property_stickiness (Qinvisible, make_number (pos), Qnil)
== (test_offs == 0 ? 1 : -1))
/* Invisible property is from an overlay. */
: (test_offs == 0
if (charpos > BUF_ZV (buffer) || charpos < BUF_BEGV (buffer))
abort ();
- have_overlays = (! NILP (buffer->overlays_before)
- || ! NILP (buffer->overlays_after));
+ have_overlays = (buffer->overlays_before || buffer->overlays_after);
/* If we have no text properties and overlays,
then we can do it quickly. */
if (backwards)
{
- /* If the preceeding character is both intangible and invisible,
+ /* If the preceding character is both intangible and invisible,
and the invisible property is `rear-sticky', perturb it so
that the search starts one character earlier -- this ensures
that point can never move to the end of an invisible/
pos = Fnext_char_property_change (pos, Qnil);
}
+ else if (position < BEGV)
+ position = BEGV;
+ else if (position > ZV)
+ position = ZV;
/* If the whole stretch between PT and POSITION isn't intangible,
try moving to POSITION (which means we actually move farther
BUF_BEGV_BYTE (buffer) = BUF_BEG_BYTE (buffer);
BUF_ZV_BYTE (buffer) = BUF_Z_BYTE (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);
+ /* First check if the CHAR has any property. This is because when
+ we click with the mouse, the mouse pointer is really pointing
+ to the CHAR after POS. */
prop = Fget_char_property (lispy_position, type, lispy_buffer);
+ /* If not, look at the POS's properties. This is necessary because when
+ editing a field with a `local-map' property, we want insertion at the end
+ to obey the `local-map' property. */
+ if (NILP (prop))
+ prop = get_pos_property (lispy_position, type, lispy_buffer);
BUF_BEGV (buffer) = old_begv;
BUF_ZV (buffer) = old_zv;
set_intervals_multibyte_1 (BUF_INTERVALS (current_buffer), multi_flag,
BEG, BEG_BYTE, Z, Z_BYTE);
}
+
+/* arch-tag: 3d402b60-083c-4271-b4a3-ebd9a74bfe27
+ (do not change this comment) */