/* Interface code for dealing with text properties.
- Copyright (C) 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1993, 1994, 1995, 1997, 1999, 2000 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, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
#include <config.h>
#include "lisp.h"
only once on the list. Although some code i.e., remove_properties,
handles the more general case, the uniqueness of properties is
necessary for the system to remain consistent. This requirement
- is enforced by the subrs installing properties onto the intervals. */
+ is enforced by the subrs installing properties onto the intervals. */
-/* The rest of the file is within this conditional */
-#ifdef USE_TEXT_PROPERTIES
\f
-/* Types of hooks. */
+/* Types of hooks. */
Lisp_Object Qmouse_left;
Lisp_Object Qmouse_entered;
Lisp_Object Qpoint_left;
Lisp_Object Qcategory;
Lisp_Object Qlocal_map;
-/* Visual properties text (including strings) may have. */
+/* Visual properties text (including strings) may have. */
Lisp_Object Qforeground, Qbackground, Qfont, Qunderline, Qstipple;
-Lisp_Object Qinvisible, Qread_only, Qintangible;
+Lisp_Object Qinvisible, Qread_only, Qintangible, Qmouse_face;
/* Sticky properties */
Lisp_Object Qfront_sticky, Qrear_nonsticky;
/* If o1 is a cons whose cdr is a cons, return non-zero and set o2 to
the o1's cdr. Otherwise, return zero. This is handy for
traversing plists. */
-#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCONS (o1)->cdr, CONSP (o2)))
+#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCDR (o1), CONSP (o2)))
Lisp_Object Vinhibit_point_motion_hooks;
Lisp_Object Vdefault_text_properties;
+Lisp_Object Vtext_property_default_nonsticky;
/* verify_interval_modification saves insertion hooks here
to be run later by report_interval_modification. */
Lisp_Object interval_insert_behind_hooks;
Lisp_Object interval_insert_in_front_hooks;
+
+
+/* Signal a `text-read-only' error. This function makes it easier
+ to capture that error in GDB by putting a breakpoint on it. */
+
+static void
+text_read_only ()
+{
+ Fsignal (Qtext_read_only, Qnil);
+}
+
+
\f
/* Extract the interval at the position pointed to by BEGIN from
OBJECT, a string or buffer. Additionally, check that the positions
#define soft 0
#define hard 1
-static INTERVAL
+INTERVAL
validate_interval_range (object, begin, end, force)
Lisp_Object object, *begin, *end;
int force;
CHECK_NUMBER_COERCE_MARKER (*end, 0);
/* If we are asked for a point, but from a subr which operates
- on a range, then return nothing. */
+ on a range, then return nothing. */
if (EQ (*begin, *end) && begin != end)
return NULL_INTERVAL;
args_out_of_range (*begin, *end);
i = BUF_INTERVALS (b);
- /* If there's no text, there are no properties. */
+ /* If there's no text, there are no properties. */
if (BUF_BEGV (b) == BUF_ZV (b))
return NULL_INTERVAL;
if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= s->size))
args_out_of_range (*begin, *end);
- /* User-level Positions in strings start with 0,
- but the interval code always wants positions starting with 1. */
- XSETFASTINT (*begin, XFASTINT (*begin) + 1);
+ XSETFASTINT (*begin, XFASTINT (*begin));
if (begin != end)
- XSETFASTINT (*end, XFASTINT (*end) + 1);
+ XSETFASTINT (*end, XFASTINT (*end));
i = s->intervals;
if (s->size == 0)
/* Validate LIST as a property list. If LIST is not a list, then
make one consisting of (LIST nil). Otherwise, verify that LIST
- is even numbered and thus suitable as a plist. */
+ is even numbered and thus suitable as a plist. */
static Lisp_Object
validate_plist (list)
}
/* Return nonzero if interval I has all the properties,
- with the same values, of list PLIST. */
+ with the same values, of list PLIST. */
static int
interval_has_all_properties (plist, i)
Lisp_Object plist;
INTERVAL i;
{
- register Lisp_Object tail1, tail2, sym1, sym2;
+ register Lisp_Object tail1, tail2, sym1;
register int found;
- /* Go through each element of PLIST. */
+ /* Go through each element of PLIST. */
for (tail1 = plist; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
{
sym1 = Fcar (tail1);
if (EQ (sym1, Fcar (tail2)))
{
/* Found the same property on both lists. If the
- values are unequal, return zero. */
+ values are unequal, return zero. */
if (! EQ (Fcar (Fcdr (tail1)), Fcar (Fcdr (tail2))))
return 0;
- /* Property has same value on both lists; go to next one. */
+ /* Property has same value on both lists; go to next one. */
found = 1;
break;
}
}
/* Return nonzero if the plist of interval I has any of the
- properties of PLIST, regardless of their values. */
+ properties of PLIST, regardless of their values. */
static INLINE int
interval_has_some_properties (plist, i)
{
register Lisp_Object tail1, tail2, sym;
- /* Go through each element of PLIST. */
+ /* Go through each element of PLIST. */
for (tail1 = plist; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
{
sym = Fcar (tail1);
Lisp_Object value;
while (PLIST_ELT_P (plist, value))
- if (EQ (XCONS (plist)->car, prop))
- return XCONS (value)->car;
+ if (EQ (XCAR (plist), prop))
+ return XCAR (value);
else
- plist = XCONS (value)->cdr;
+ plist = XCDR (value);
return Qunbound;
}
or has a different value in PROPERTIES, make an undo record. */
for (sym = interval->plist;
PLIST_ELT_P (sym, value);
- sym = XCONS (value)->cdr)
- if (! EQ (property_value (properties, XCONS (sym)->car),
- XCONS (value)->car))
+ sym = XCDR (value))
+ if (! EQ (property_value (properties, XCAR (sym)),
+ XCAR (value)))
{
- modify_region (XBUFFER (object),
- make_number (interval->position),
- make_number (interval->position + LENGTH (interval)));
record_property_change (interval->position, LENGTH (interval),
- XCONS (sym)->car, XCONS (value)->car,
+ XCAR (sym), XCAR (value),
object);
- signal_after_change (interval->position, LENGTH (interval),
- LENGTH (interval));
}
/* For each new property that has no value at all in the old plist,
make an undo record binding it to nil, so it will be removed. */
for (sym = properties;
PLIST_ELT_P (sym, value);
- sym = XCONS (value)->cdr)
- if (EQ (property_value (interval->plist, XCONS (sym)->car), Qunbound))
+ sym = XCDR (value))
+ if (EQ (property_value (interval->plist, XCAR (sym)), Qunbound))
{
- modify_region (XBUFFER (object),
- make_number (interval->position),
- make_number (interval->position + LENGTH (interval)));
record_property_change (interval->position, LENGTH (interval),
- XCONS (sym)->car, Qnil,
+ XCAR (sym), Qnil,
object);
- signal_after_change (interval->position, LENGTH (interval),
- LENGTH (interval));
}
}
I and its plist are also protected, via OBJECT. */
GCPRO3 (tail1, sym1, val1);
- /* Go through each element of PLIST. */
+ /* Go through each element of PLIST. */
for (tail1 = plist; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
{
sym1 = Fcar (tail1);
register Lisp_Object this_cdr;
this_cdr = Fcdr (tail2);
- /* Found the property. Now check its value. */
+ /* Found the property. Now check its value. */
found = 1;
/* The properties have the same value on both lists.
- Continue to the next property. */
+ Continue to the next property. */
if (EQ (val1, Fcar (this_cdr)))
break;
/* Record this change in the buffer, for undo purposes. */
if (BUFFERP (object))
{
- modify_region (XBUFFER (object),
- make_number (i->position),
- make_number (i->position + LENGTH (i)));
record_property_change (i->position, LENGTH (i),
sym1, Fcar (this_cdr), object);
- signal_after_change (i->position, LENGTH (i), LENGTH (i));
}
/* I's property has a different value -- change it */
/* Record this change in the buffer, for undo purposes. */
if (BUFFERP (object))
{
- modify_region (XBUFFER (object),
- make_number (i->position),
- make_number (i->position + LENGTH (i)));
record_property_change (i->position, LENGTH (i),
sym1, Qnil, object);
- signal_after_change (i->position, LENGTH (i), LENGTH (i));
}
i->plist = Fcons (sym1, Fcons (val1, i->plist));
changed++;
register int changed = 0;
current_plist = i->plist;
- /* Go through each element of plist. */
+ /* Go through each element of plist. */
for (tail1 = plist; ! NILP (tail1); tail1 = Fcdr (Fcdr (tail1)))
{
sym = Fcar (tail1);
{
if (BUFFERP (object))
{
- modify_region (XBUFFER (object),
- make_number (i->position),
- make_number (i->position + LENGTH (i)));
record_property_change (i->position, LENGTH (i),
sym, Fcar (Fcdr (current_plist)),
object);
- signal_after_change (i->position, LENGTH (i), LENGTH (i));
}
current_plist = Fcdr (Fcdr (current_plist));
{
if (BUFFERP (object))
{
- modify_region (XBUFFER (object),
- make_number (i->position),
- make_number (i->position + LENGTH (i)));
record_property_change (i->position, LENGTH (i),
sym, Fcar (Fcdr (this)), object);
- signal_after_change (i->position, LENGTH (i), LENGTH (i));
}
Fsetcdr (Fcdr (tail2), Fcdr (Fcdr (this)));
#if 0
/* Remove all properties from interval I. Return non-zero
- if this changes the interval. */
+ if this changes the interval. */
static INLINE int
erase_properties (i)
}
#endif
\f
+/* Returns the interval of POSITION in OBJECT.
+ POSITION is BEG-based. */
+
+INTERVAL
+interval_of (position, object)
+ int position;
+ Lisp_Object object;
+{
+ register INTERVAL i;
+ int beg, end;
+
+ if (NILP (object))
+ XSETBUFFER (object, current_buffer);
+ else if (EQ (object, Qt))
+ return NULL_INTERVAL;
+
+ CHECK_STRING_OR_BUFFER (object, 0);
+
+ if (BUFFERP (object))
+ {
+ register struct buffer *b = XBUFFER (object);
+
+ beg = BUF_BEGV (b);
+ end = BUF_ZV (b);
+ i = BUF_INTERVALS (b);
+ }
+ else
+ {
+ register struct Lisp_String *s = XSTRING (object);
+
+ beg = 0;
+ end = s->size;
+ i = s->intervals;
+ }
+
+ if (!(beg <= position && position <= end))
+ args_out_of_range (make_number (position), make_number (position));
+ if (beg == end || NULL_INTERVAL_P (i))
+ return NULL_INTERVAL;
+
+ return find_interval (i, position);
+}
+\f
DEFUN ("text-properties-at", Ftext_properties_at,
Stext_properties_at, 1, 2, 0,
- "Return the list of properties held by the character at POSITION\n\
-in optional argument OBJECT, a string or buffer. If nil, OBJECT\n\
-defaults to the current buffer.\n\
+ "Return the list of properties of the character at POSITION in OBJECT.\n\
+OBJECT is the string or buffer to look for the properties in;\n\
+nil means the current buffer.\n\
If POSITION is at the end of OBJECT, the value is nil.")
(position, object)
Lisp_Object position, object;
return textget (Ftext_properties_at (position, object), prop);
}
-DEFUN ("get-char-property", Fget_char_property, Sget_char_property, 2, 3, 0,
- "Return the value of POSITION's property PROP, in OBJECT.\n\
-OBJECT is optional and defaults to the current buffer.\n\
-If POSITION is at the end of OBJECT, the value is nil.\n\
-If OBJECT is a buffer, then overlay properties are considered as well as\n\
-text properties.\n\
-If OBJECT is a window, then that window's buffer is used, but window-specific\n\
-overlays are considered only if they are associated with OBJECT.")
- (position, prop, object)
+/* Return the value of POSITION's property PROP, in OBJECT.
+ OBJECT is optional and defaults to the current buffer.
+ If OVERLAY is non-0, then in the case that the returned property is from
+ an overlay, the overlay found is returned in *OVERLAY, otherwise nil is
+ returned in *OVERLAY.
+ If POSITION is at the end of OBJECT, the value is nil.
+ If OBJECT is a buffer, then overlay properties are considered as well as
+ text properties.
+ If OBJECT is a window, then that window's buffer is used, but
+ window-specific overlays are considered only if they are associated
+ with OBJECT. */
+Lisp_Object
+get_char_property_and_overlay (position, prop, object, overlay)
Lisp_Object position, object;
register Lisp_Object prop;
+ Lisp_Object *overlay;
{
struct window *w = 0;
overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
noverlays = overlays_at (posn, 0, &overlay_vec, &len,
- &next_overlay, NULL);
+ &next_overlay, NULL, 0);
/* If there are more than 40,
make enough space for all, and try again. */
len = noverlays;
overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
noverlays = overlays_at (posn, 0, &overlay_vec, &len,
- &next_overlay, NULL);
+ &next_overlay, NULL, 0);
}
noverlays = sort_overlays (overlay_vec, noverlays, w);
{
tem = Foverlay_get (overlay_vec[noverlays], prop);
if (!NILP (tem))
- return (tem);
+ {
+ if (overlay)
+ /* Return the overlay we got the property from. */
+ *overlay = overlay_vec[noverlays];
+ return tem;
+ }
}
}
+
+ if (overlay)
+ /* Indicate that the return value is not from an overlay. */
+ *overlay = Qnil;
+
/* Not a buffer, or no appropriate overlay, so fall through to the
simpler case. */
- return (Fget_text_property (position, prop, object));
+ return Fget_text_property (position, prop, object);
+}
+
+DEFUN ("get-char-property", Fget_char_property, Sget_char_property, 2, 3, 0,
+ "Return the value of POSITION's property PROP, in OBJECT.\n\
+OBJECT is optional and defaults to the current buffer.\n\
+If POSITION is at the end of OBJECT, the value is nil.\n\
+If OBJECT is a buffer, then overlay properties are considered as well as\n\
+text properties.\n\
+If OBJECT is a window, then that window's buffer is used, but window-specific\n\
+overlays are considered only if they are associated with OBJECT.")
+ (position, prop, object)
+ Lisp_Object position, object;
+ register Lisp_Object prop;
+{
+ return get_char_property_and_overlay (position, prop, object, 0);
+}
+\f
+DEFUN ("next-char-property-change", Fnext_char_property_change,
+ Snext_char_property_change, 1, 2, 0,
+ "Return the position of next text property or overlay change.\n\
+This scans characters forward from POSITION in OBJECT till it finds\n\
+a change in some text property, or the beginning or end of an overlay,\n\
+and returns the position of that.\n\
+If none is found, the function returns (point-max).\n\
+\n\
+If the optional third argument LIMIT is non-nil, don't search\n\
+past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, limit)
+ Lisp_Object position, limit;
+{
+ Lisp_Object temp;
+
+ temp = Fnext_overlay_change (position);
+ if (! NILP (limit))
+ {
+ CHECK_NUMBER (limit, 2);
+ if (XINT (limit) < XINT (temp))
+ temp = limit;
+ }
+ return Fnext_property_change (position, Qnil, temp);
+}
+
+DEFUN ("previous-char-property-change", Fprevious_char_property_change,
+ Sprevious_char_property_change, 1, 2, 0,
+ "Return the position of previous text property or overlay change.\n\
+Scans characters backward from POSITION in OBJECT till it finds\n\
+a change in some text property, or the beginning or end of an overlay,\n\
+and returns the position of that.\n\
+If none is found, the function returns (point-max).\n\
+\n\
+If the optional third argument LIMIT is non-nil, don't search\n\
+past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, limit)
+ Lisp_Object position, limit;
+{
+ Lisp_Object temp;
+
+ temp = Fprevious_overlay_change (position);
+ if (! NILP (limit))
+ {
+ CHECK_NUMBER (limit, 2);
+ if (XINT (limit) > XINT (temp))
+ temp = limit;
+ }
+ return Fprevious_property_change (position, Qnil, temp);
+}
+
+
+DEFUN ("next-single-char-property-change", Fnext_single_char_property_change,
+ Snext_single_char_property_change, 2, 4, 0,
+ "Return the position of next text property or overlay change for a specific property.\n\
+Scans characters forward from POSITION till it finds\n\
+a change in the PROP property, then returns the position of the change.\n\
+The optional third argument OBJECT is the string or buffer to scan.\n\
+The property values are compared with `eq'.\n\
+Return nil if the property is constant all the way to the end of OBJECT.\n\
+If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
+If the optional fourth argument LIMIT is non-nil, don't search\n\
+past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, prop, object, limit)
+ Lisp_Object prop, position, object, limit;
+{
+ if (STRINGP (object))
+ {
+ position = Fnext_single_property_change (position, prop, object, limit);
+ if (NILP (position))
+ {
+ if (NILP (limit))
+ position = make_number (XSTRING (object)->size);
+ else
+ position = limit;
+ }
+ }
+ else
+ {
+ Lisp_Object initial_value, value;
+ int count = specpdl_ptr - specpdl;
+
+ if (! NILP (object))
+ CHECK_BUFFER (object, 0);
+
+ if (BUFFERP (object) && current_buffer != XBUFFER (object))
+ {
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ Fset_buffer (object);
+ }
+
+ initial_value = Fget_char_property (position, prop, object);
+
+ if (NILP (limit))
+ XSETFASTINT (limit, BUF_ZV (current_buffer));
+ else
+ CHECK_NUMBER_COERCE_MARKER (limit, 0);
+
+ for (;;)
+ {
+ position = Fnext_char_property_change (position, limit);
+ if (XFASTINT (position) >= XFASTINT (limit)) {
+ position = limit;
+ break;
+ }
+
+ value = Fget_char_property (position, prop, object);
+ if (!EQ (value, initial_value))
+ break;
+ }
+
+ unbind_to (count, Qnil);
+ }
+
+ return position;
}
+DEFUN ("previous-single-char-property-change",
+ Fprevious_single_char_property_change,
+ Sprevious_single_char_property_change, 2, 4, 0,
+ "Return the position of previous text property or overlay change for a specific property.\n\
+Scans characters backward from POSITION till it finds\n\
+a change in the PROP property, then returns the position of the change.\n\
+The optional third argument OBJECT is the string or buffer to scan.\n\
+The property values are compared with `eq'.\n\
+Return nil if the property is constant all the way to the start of OBJECT.\n\
+If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
+If the optional fourth argument LIMIT is non-nil, don't search\n\
+back past position LIMIT; return LIMIT if nothing is found before LIMIT.")
+ (position, prop, object, limit)
+ Lisp_Object prop, position, object, limit;
+{
+ if (STRINGP (object))
+ {
+ position = Fprevious_single_property_change (position, prop, object, limit);
+ if (NILP (position))
+ {
+ if (NILP (limit))
+ position = make_number (XSTRING (object)->size);
+ else
+ position = limit;
+ }
+ }
+ else
+ {
+ int count = specpdl_ptr - specpdl;
+
+ if (! NILP (object))
+ CHECK_BUFFER (object, 0);
+
+ if (BUFFERP (object) && current_buffer != XBUFFER (object))
+ {
+ record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ Fset_buffer (object);
+ }
+
+ if (NILP (limit))
+ XSETFASTINT (limit, BUF_BEGV (current_buffer));
+ else
+ CHECK_NUMBER_COERCE_MARKER (limit, 0);
+
+ if (XFASTINT (position) <= XFASTINT (limit))
+ position = limit;
+ else
+ {
+ Lisp_Object initial_value =
+ Fget_char_property (make_number (XFASTINT (position) - 1),
+ prop, object);
+
+ for (;;)
+ {
+ position = Fprevious_char_property_change (position, limit);
+
+ if (XFASTINT (position) <= XFASTINT (limit))
+ {
+ position = limit;
+ break;
+ }
+ else
+ {
+ Lisp_Object value =
+ Fget_char_property (make_number (XFASTINT (position) - 1),
+ prop, object);
+
+ if (!EQ (value, initial_value))
+ break;
+ }
+ }
+ }
+
+ unbind_to (count, Qnil);
+ }
+
+ return position;
+}
+\f
DEFUN ("next-property-change", Fnext_property_change,
Snext_property_change, 1, 3, 0,
"Return the position of next property change.\n\
? XSTRING (object)->size
: BUF_ZV (XBUFFER (object))));
else
- XSETFASTINT (position, next->position - (STRINGP (object)));
+ XSETFASTINT (position, next->position);
return position;
}
if (! NILP (limit) && !(next->position < XFASTINT (limit)))
return limit;
- XSETFASTINT (position, next->position - (STRINGP (object)));
+ XSETFASTINT (position, next->position);
return position;
}
if (! NILP (limit) && !(next->position < XFASTINT (limit)))
return limit;
- XSETFASTINT (position, next->position - (STRINGP (object)));
- return position;
+ return make_number (next->position);
}
DEFUN ("previous-property-change", Fprevious_property_change,
previous = previous_interval (i);
while (! NULL_INTERVAL_P (previous) && intervals_equal (previous, i)
&& (NILP (limit)
- || previous->position + LENGTH (previous) > XFASTINT (limit)))
+ || (previous->position + LENGTH (previous) > XFASTINT (limit))))
previous = previous_interval (previous);
if (NULL_INTERVAL_P (previous))
return limit;
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- XSETFASTINT (position, (previous->position + LENGTH (previous)
- - (STRINGP (object))));
- return position;
+ return make_number (previous->position + LENGTH (previous));
}
DEFUN ("previous-single-property-change", Fprevious_single_property_change,
while (! NULL_INTERVAL_P (previous)
&& EQ (here_val, textget (previous->plist, prop))
&& (NILP (limit)
- || previous->position + LENGTH (previous) > XFASTINT (limit)))
+ || (previous->position + LENGTH (previous) > XFASTINT (limit))))
previous = previous_interval (previous);
if (NULL_INTERVAL_P (previous))
return limit;
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- XSETFASTINT (position, (previous->position + LENGTH (previous)
- - (STRINGP (object))));
- return position;
+ return make_number (previous->position + LENGTH (previous));
}
-
+\f
/* Callers note, this can GC when OBJECT is a buffer (or nil). */
DEFUN ("add-text-properties", Fadd_text_properties,
GCPRO1 (properties);
/* If we're not starting on an interval boundary, we have to
- split this interval. */
+ split this interval. */
if (i->position != s)
{
/* If this interval already has the properties, we can
- skip it. */
+ skip it. */
if (interval_has_all_properties (properties, i))
{
int got = (LENGTH (i) - (s - i->position));
if (got >= len)
- return Qnil;
+ RETURN_UNGCPRO (Qnil);
len -= got;
i = next_interval (i);
}
}
}
+ if (BUFFERP (object))
+ modify_region (XBUFFER (object), XINT (start), XINT (end));
+
/* We are at the beginning of interval I, with LEN chars to scan. */
for (;;)
{
UNGCPRO;
if (interval_has_all_properties (properties, i))
- return modified ? Qt : Qnil;
+ {
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+
+ return modified ? Qt : Qnil;
+ }
if (LENGTH (i) == len)
{
add_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
i = split_interval_left (unchanged, len);
copy_properties (unchanged, i);
add_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
"Completely replace properties of text from START to END.\n\
The third argument PROPERTIES is the new property list.\n\
The optional fourth argument, OBJECT,\n\
-is the string or buffer containing the text.")
+is the string or buffer containing the text.\n\
+If OBJECT is omitted or nil, it defaults to the current buffer.")
(start, end, properties, object)
Lisp_Object start, end, properties, object;
+{
+ return set_text_properties (start, end, properties, object, Qt);
+}
+
+
+/* Replace properties of text from START to END with new list of
+ properties PROPERTIES. OBJECT is the buffer or string containing
+ the text. OBJECT nil means use the current buffer.
+ SIGNAL_AFTER_CHANGE_P nil means don't signal after changes. Value
+ is non-nil if properties were replaced; it is nil if there weren't
+ any properties to replace. */
+
+Lisp_Object
+set_text_properties (start, end, properties, object, signal_after_change_p)
+ Lisp_Object start, end, properties, object, signal_after_change_p;
{
register INTERVAL i, unchanged;
register INTERVAL prev_changed = NULL_INTERVAL;
&& XFASTINT (start) == 0
&& XFASTINT (end) == XSTRING (object)->size)
{
+ if (! XSTRING (object)->intervals)
+ return Qt;
+
XSTRING (object)->intervals = 0;
return Qt;
}
s = XINT (start);
len = XINT (end) - s;
+ if (BUFFERP (object))
+ modify_region (XBUFFER (object), XINT (start), XINT (end));
+
if (i->position != s)
{
unchanged = i;
copy_properties (unchanged, i);
i = split_interval_left (i, len);
set_properties (properties, i, object);
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+
return Qt;
}
set_properties (properties, i, object);
if (LENGTH (i) == len)
- return Qt;
+ {
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+
+ return Qt;
+ }
prev_changed = i;
len -= LENGTH (i);
set_properties (properties, i, object);
if (!NULL_INTERVAL_P (prev_changed))
merge_interval_left (i);
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
i = next_interval (i);
}
+ if (BUFFERP (object) && !NILP (signal_after_change_p))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
if (i->position != s)
{
/* No properties on this first interval -- return if
- it covers the entire region. */
+ it covers the entire region. */
if (! interval_has_some_properties (properties, i))
{
int got = (LENGTH (i) - (s - i->position));
}
}
+ if (BUFFERP (object))
+ modify_region (XBUFFER (object), XINT (start), XINT (end));
+
/* We are at the beginning of an interval, with len to scan */
for (;;)
{
if (LENGTH (i) == len)
{
remove_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
i = split_interval_left (i, len);
copy_properties (unchanged, i);
remove_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
i = next_interval (i);
}
}
-
+\f
DEFUN ("text-property-any", Ftext_property_any,
Stext_property_any, 4, 5, 0,
"Check text from START to END for property PROPERTY equalling VALUE.\n\
pos = i->position;
if (pos < XINT (start))
pos = XINT (start);
- return make_number (pos - (STRINGP (object)));
+ return make_number (pos);
}
i = next_interval (i);
}
{
if (i->position > s)
s = i->position;
- return make_number (s - (STRINGP (object)));
+ return make_number (s);
}
i = next_interval (i);
}
return Qnil;
}
-
-#if 0 /* You can use set-text-properties for this. */
-
-DEFUN ("erase-text-properties", Ferase_text_properties,
- Serase_text_properties, 2, 3, 0,
- "Remove all properties from the text from START to END.\n\
-The optional third argument, OBJECT,\n\
-is the string or buffer containing the text.")
- (start, end, object)
- Lisp_Object start, end, object;
-{
- register INTERVAL i;
- register INTERVAL prev_changed = NULL_INTERVAL;
- register int s, len, modified;
-
- if (NILP (object))
- XSETBUFFER (object, current_buffer);
-
- i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
- return Qnil;
-
- s = XINT (start);
- len = XINT (end) - s;
-
- if (i->position != s)
- {
- register int got;
- register INTERVAL unchanged = i;
-
- /* If there are properties here, then this text will be modified. */
- if (! NILP (i->plist))
- {
- i = split_interval_right (unchanged, s - unchanged->position);
- i->plist = Qnil;
- modified++;
-
- if (LENGTH (i) > len)
- {
- i = split_interval_right (i, len);
- copy_properties (unchanged, i);
- return Qt;
- }
-
- if (LENGTH (i) == len)
- return Qt;
-
- got = LENGTH (i);
- }
- /* If the text of I is without any properties, and contains
- LEN or more characters, then we may return without changing
- anything.*/
- else if (LENGTH (i) - (s - i->position) <= len)
- return Qnil;
- /* The amount of text to change extends past I, so just note
- how much we've gotten. */
- else
- got = LENGTH (i) - (s - i->position);
-
- len -= got;
- prev_changed = i;
- i = next_interval (i);
- }
-
- /* We are starting at the beginning of an interval, I. */
- while (len > 0)
- {
- if (LENGTH (i) >= len)
- {
- /* If I has no properties, simply merge it if possible. */
- if (NILP (i->plist))
- {
- if (! NULL_INTERVAL_P (prev_changed))
- merge_interval_left (i);
-
- return modified ? Qt : Qnil;
- }
-
- if (LENGTH (i) > len)
- i = split_interval_left (i, len);
- if (! NULL_INTERVAL_P (prev_changed))
- merge_interval_left (i);
- else
- i->plist = Qnil;
-
- return Qt;
- }
-
- /* Here if we still need to erase past the end of I */
- len -= LENGTH (i);
- if (NULL_INTERVAL_P (prev_changed))
- {
- modified += erase_properties (i);
- prev_changed = i;
- }
- else
- {
- modified += ! NILP (i->plist);
- /* Merging I will give it the properties of PREV_CHANGED. */
- prev_changed = i = merge_interval_left (i);
- }
-
- i = next_interval (i);
- }
-
- return modified ? Qt : Qnil;
-}
-#endif /* 0 */
-
+\f
/* I don't think this is the right interface to export; how often do you
want to do something like this, other than when you're copying objects
around?
if (! NILP (plist))
{
/* Must defer modifications to the interval tree in case src
- and dest refer to the same string or buffer. */
+ and dest refer to the same string or buffer. */
stuff = Fcons (Fcons (make_number (p),
Fcons (make_number (p + len),
Fcons (plist, Qnil))),
return modified ? Qt : Qnil;
}
+
+
+/* Return a list representing the text properties of OBJECT between
+ START and END. if PROP is non-nil, report only on that property.
+ Each result list element has the form (S E PLIST), where S and E
+ are positions in OBJECT and PLIST is a property list containing the
+ text properties of OBJECT between S and E. Value is nil if OBJECT
+ doesn't contain text properties between START and END. */
+
+Lisp_Object
+text_property_list (object, start, end, prop)
+ Lisp_Object object, start, end, prop;
+{
+ struct interval *i;
+ Lisp_Object result;
+
+ result = Qnil;
+
+ i = validate_interval_range (object, &start, &end, soft);
+ if (!NULL_INTERVAL_P (i))
+ {
+ int s = XINT (start);
+ int e = XINT (end);
+
+ while (s < e)
+ {
+ int interval_end, len;
+ Lisp_Object plist;
+
+ interval_end = i->position + LENGTH (i);
+ if (interval_end > e)
+ interval_end = e;
+ len = interval_end - s;
+
+ plist = i->plist;
+
+ if (!NILP (prop))
+ for (; !NILP (plist); plist = Fcdr (Fcdr (plist)))
+ if (EQ (Fcar (plist), prop))
+ {
+ plist = Fcons (prop, Fcons (Fcar (Fcdr (plist)), Qnil));
+ break;
+ }
+
+ if (!NILP (plist))
+ result = Fcons (Fcons (make_number (s),
+ Fcons (make_number (s + len),
+ Fcons (plist, Qnil))),
+ result);
+
+ i = next_interval (i);
+ if (NULL_INTERVAL_P (i))
+ break;
+ s = i->position;
+ }
+ }
+
+ return result;
+}
+
+
+/* Add text properties to OBJECT from LIST. LIST is a list of triples
+ (START END PLIST), where START and END are positions and PLIST is a
+ property list containing the text properties to add. Adjust START
+ and END positions by DELTA before adding properties. Value is
+ non-zero if OBJECT was modified. */
+
+int
+add_text_properties_from_list (object, list, delta)
+ Lisp_Object object, list, delta;
+{
+ struct gcpro gcpro1, gcpro2;
+ int modified_p = 0;
+
+ GCPRO2 (list, object);
+
+ for (; CONSP (list); list = XCDR (list))
+ {
+ Lisp_Object item, start, end, plist, tem;
+
+ item = XCAR (list);
+ start = make_number (XINT (XCAR (item)) + XINT (delta));
+ end = make_number (XINT (XCAR (XCDR (item))) + XINT (delta));
+ plist = XCAR (XCDR (XCDR (item)));
+
+ tem = Fadd_text_properties (start, end, plist, object);
+ if (!NILP (tem))
+ modified_p = 1;
+ }
+
+ UNGCPRO;
+ return modified_p;
+}
+
+
+
+/* Modify end-points of ranges in LIST destructively. LIST is a list
+ as returned from text_property_list. Change end-points equal to
+ OLD_END to NEW_END. */
+
+void
+extend_property_ranges (list, old_end, new_end)
+ Lisp_Object list, old_end, new_end;
+{
+ for (; CONSP (list); list = XCDR (list))
+ {
+ Lisp_Object item, end;
+
+ item = XCAR (list);
+ end = XCAR (XCDR (item));
+
+ if (EQ (end, old_end))
+ XCAR (XCDR (item)) = new_end;
+ }
+}
+
+
\f
/* Call the modification hook functions in LIST, each with START and END. */
UNGCPRO;
}
-/* Check for read-only intervals and signal an error if we find one.
- Then check for any modification hooks in the range START up to
- (but not including) END. Create a list of all these hooks in
- lexicographic order, eliminating consecutive extra copies of the
- same hook. Then call those hooks in order, with START and END - 1
- as arguments. */
+/* Check for read-only intervals between character positions START ... END,
+ in BUF, and signal an error if we find one.
+
+ Then check for any modification hooks in the range.
+ Create a list of all these hooks in lexicographic order,
+ eliminating consecutive extra copies of the same hook. Then call
+ those hooks in order, with START and END - 1 as arguments. */
void
verify_interval_modification (buf, start, end)
int start, end;
{
register INTERVAL intervals = BUF_INTERVALS (buf);
- register INTERVAL i, prev;
+ register INTERVAL i;
Lisp_Object hooks;
register Lisp_Object prev_mod_hooks;
Lisp_Object mod_hooks;
/* For an insert operation, check the two chars around the position. */
if (start == end)
{
- INTERVAL prev;
+ INTERVAL prev = NULL;
Lisp_Object before, after;
/* Set I to the interval containing the char after START,
if (NILP (Vinhibit_read_only) || CONSP (Vinhibit_read_only))
{
/* If I and PREV differ we need to check for the read-only
- property together with its stickiness. If either I or
+ property together with its stickiness. If either I or
PREV are 0, this check is all we need.
We have to take special care, since read-only may be
indirectly defined via the category property. */
if (TMEM (Qread_only, tem)
|| (NILP (Fplist_get (i->plist, Qread_only))
&& TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ text_read_only ();
}
}
if (! TMEM (Qread_only, tem)
&& (! NILP (Fplist_get (prev->plist,Qread_only))
|| ! TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ text_read_only ();
}
}
}
if (TMEM (Qread_only, tem)
|| (NILP (Fplist_get (i->plist, Qread_only))
&& TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ text_read_only ();
tem = textget (prev->plist, Qrear_nonsticky);
if (! TMEM (Qread_only, tem)
&& (! NILP (Fplist_get (prev->plist, Qread_only))
|| ! TMEM (Qcategory, tem)))
- error ("Attempt to insert within read-only text");
+ text_read_only ();
}
}
}
do
{
if (! INTERVAL_WRITABLE_P (i))
- error ("Attempt to modify read-only text");
+ text_read_only ();
mod_hooks = textget (i->plist, Qmodification_hooks);
if (! NILP (mod_hooks) && ! EQ (mod_hooks, prev_mod_hooks))
}
}
-/* Run the interval hooks for an insertion.
+/* Run the interval hooks for an insertion on character range START ... END.
verify_interval_modification chose which hooks to run;
this function is called after the insertion happens
so it can indicate the range of inserted text. */
Lisp_Object start, end;
{
if (! NILP (interval_insert_behind_hooks))
- call_mod_hooks (interval_insert_behind_hooks,
- make_number (start), make_number (end));
+ call_mod_hooks (interval_insert_behind_hooks, start, end);
if (! NILP (interval_insert_in_front_hooks)
&& ! EQ (interval_insert_in_front_hooks,
interval_insert_behind_hooks))
- call_mod_hooks (interval_insert_in_front_hooks,
- make_number (start), make_number (end));
+ call_mod_hooks (interval_insert_in_front_hooks, start, end);
}
\f
void
This also inhibits the use of the `intangible' text property.");
Vinhibit_point_motion_hooks = Qnil;
+ DEFVAR_LISP ("text-property-default-nonsticky",
+ &Vtext_property_default_nonsticky,
+ "Alist of properties vs the corresponding non-stickinesses.\n\
+Each element has the form (PROPERTY . NONSTICKINESS).\n\
+\n\
+If a character in a buffer has PROPERTY, new text inserted adjacent to\n\
+the character doesn't inherit PROPERTY if NONSTICKINESS is non-nil,\n\
+inherits it if NONSTICKINESS is nil. The front-sticky and\n\
+rear-nonsticky properties of the character overrides NONSTICKINESS.");
+ Vtext_property_default_nonsticky = Qnil;
+
staticpro (&interval_insert_behind_hooks);
staticpro (&interval_insert_in_front_hooks);
interval_insert_behind_hooks = Qnil;
Qfront_sticky = intern ("front-sticky");
staticpro (&Qrear_nonsticky);
Qrear_nonsticky = intern ("rear-nonsticky");
+ staticpro (&Qmouse_face);
+ Qmouse_face = intern ("mouse-face");
/* Properties that text might use to specify certain actions */
defsubr (&Stext_properties_at);
defsubr (&Sget_text_property);
defsubr (&Sget_char_property);
+ defsubr (&Snext_char_property_change);
+ defsubr (&Sprevious_char_property_change);
+ defsubr (&Snext_single_char_property_change);
+ defsubr (&Sprevious_single_char_property_change);
defsubr (&Snext_property_change);
defsubr (&Snext_single_property_change);
defsubr (&Sprevious_property_change);
/* defsubr (&Scopy_text_properties); */
}
-#else
-
-lose -- this shouldn't be compiled if USE_TEXT_PROPERTIES isn't defined
-
-#endif /* USE_TEXT_PROPERTIES */
HCoop / bpt / emacs.git / blobdiff