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"
#ifndef NULL
#define NULL (void *)0
#endif
+
+/* 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))
\f
/* NOTES: previous- and next- property change will have to skip
#define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCONS (o1)->cdr, CONSP (o2)))
Lisp_Object Vinhibit_point_motion_hooks;
-Lisp_Object Vdefault_properties;
+Lisp_Object Vdefault_text_properties;
+/* 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;
\f
/* Extract the interval at the position pointed to by BEGIN from
OBJECT, a string or buffer. Additionally, check that the positions
if (! EQ (property_value (properties, XCONS (sym)->car),
XCONS (value)->car))
{
- 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,
object);
sym = XCONS (value)->cdr)
if (EQ (property_value (interval->plist, XCONS (sym)->car), 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,
object);
/* 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);
}
/* 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);
}
{
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);
{
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);
}
in optional argument OBJECT, a string or buffer. If nil, OBJECT\n\
defaults to the current buffer.\n\
If POSITION is at the end of OBJECT, the value is nil.")
- (pos, object)
- Lisp_Object pos, object;
+ (position, object)
+ Lisp_Object position, object;
{
register INTERVAL i;
if (NILP (object))
XSETBUFFER (object, current_buffer);
- i = validate_interval_range (object, &pos, &pos, soft);
+ i = validate_interval_range (object, &position, &position, soft);
if (NULL_INTERVAL_P (i))
return Qnil;
- /* If POS is at the end of the interval,
+ /* If POSITION is at the end of the interval,
it means it's the end of OBJECT.
There are no properties at the very end,
since no character follows. */
- if (XINT (pos) == LENGTH (i) + i->position)
+ if (XINT (position) == LENGTH (i) + i->position)
return Qnil;
return i->plist;
}
DEFUN ("get-text-property", Fget_text_property, Sget_text_property, 2, 3, 0,
- "Return the value of position POS's property PROP, in OBJECT.\n\
+ "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.")
- (pos, prop, object)
- Lisp_Object pos, object;
+ (position, prop, object)
+ Lisp_Object position, object;
Lisp_Object prop;
{
- return textget (Ftext_properties_at (pos, object), prop);
+ 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 POS's property PROP, in OBJECT.\n\
+ "Return the value of POSITION's property PROP, in OBJECT.\n\
OBJECT is optional and defaults to the current buffer.\n\
-If POS is at the end of OBJECT, the value is nil.\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.")
- (pos, prop, object)
- Lisp_Object pos, object;
+ (position, prop, object)
+ Lisp_Object position, object;
register Lisp_Object prop;
{
struct window *w = 0;
- CHECK_NUMBER_COERCE_MARKER (pos, 0);
+ CHECK_NUMBER_COERCE_MARKER (position, 0);
if (NILP (object))
XSETBUFFER (object, current_buffer);
}
if (BUFFERP (object))
{
- int posn = XINT (pos);
+ int posn = XINT (position);
int noverlays;
Lisp_Object *overlay_vec, tem;
int next_overlay;
int len;
+ struct buffer *obuf = current_buffer;
+
+ set_buffer_temp (XBUFFER (object));
/* First try with room for 40 overlays. */
len = 40;
}
noverlays = sort_overlays (overlay_vec, noverlays, w);
+ set_buffer_temp (obuf);
+
/* Now check the overlays in order of decreasing priority. */
while (--noverlays >= 0)
{
}
/* Not a buffer, or no appropriate overlay, so fall through to the
simpler case. */
- return (Fget_text_property (pos, prop, object));
+ return (Fget_text_property (position, prop, object));
}
DEFUN ("next-property-change", Fnext_property_change,
Snext_property_change, 1, 3, 0,
"Return the position of next property change.\n\
-Scans characters forward from POS in OBJECT till it finds\n\
+Scans characters forward from POSITION in OBJECT till it finds\n\
a change in some text property, then returns the position of the change.\n\
The optional second argument OBJECT is the string or buffer to scan.\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 POS, never equal.\n\n\
+If the value is non-nil, it is a position greater than POSITION, never equal.\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.")
- (pos, object, limit)
- Lisp_Object pos, object, limit;
+ (position, object, limit)
+ Lisp_Object position, object, limit;
{
register INTERVAL i, next;
if (NILP (object))
XSETBUFFER (object, current_buffer);
- if (!NILP (limit))
+ if (! NILP (limit) && ! EQ (limit, Qt))
CHECK_NUMBER_COERCE_MARKER (limit, 0);
- i = validate_interval_range (object, &pos, &pos, soft);
+ i = validate_interval_range (object, &position, &position, soft);
+
+ /* If LIMIT is t, return start of next interval--don't
+ bother checking further intervals. */
+ if (EQ (limit, Qt))
+ {
+ if (NULL_INTERVAL_P (i))
+ next = i;
+ else
+ next = next_interval (i);
+
+ if (NULL_INTERVAL_P (next))
+ XSETFASTINT (position, (STRINGP (object)
+ ? XSTRING (object)->size
+ : BUF_ZV (XBUFFER (object))));
+ else
+ XSETFASTINT (position, next->position - (STRINGP (object)));
+ return position;
+ }
+
if (NULL_INTERVAL_P (i))
return limit;
next = next_interval (i);
+
while (! NULL_INTERVAL_P (next) && intervals_equal (i, next)
&& (NILP (limit) || next->position < XFASTINT (limit)))
next = next_interval (next);
if (! NILP (limit) && !(next->position < XFASTINT (limit)))
return limit;
- XSETFASTINT (pos, next->position - (STRINGP (object)));
- return pos;
+ XSETFASTINT (position, next->position - (STRINGP (object)));
+ return position;
}
/* Return 1 if there's a change in some property between BEG and END. */
DEFUN ("next-single-property-change", Fnext_single_property_change,
Snext_single_property_change, 2, 4, 0,
"Return the position of next property change for a specific property.\n\
-Scans characters forward from POS till it finds\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 POS, never equal.\n\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.")
- (pos, prop, object, limit)
- Lisp_Object pos, prop, object, limit;
+ (position, prop, object, limit)
+ Lisp_Object position, prop, object, limit;
{
register INTERVAL i, next;
register Lisp_Object here_val;
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit, 0);
- i = validate_interval_range (object, &pos, &pos, soft);
+ i = validate_interval_range (object, &position, &position, soft);
if (NULL_INTERVAL_P (i))
return limit;
if (! NILP (limit) && !(next->position < XFASTINT (limit)))
return limit;
- XSETFASTINT (pos, next->position - (STRINGP (object)));
- return pos;
+ XSETFASTINT (position, next->position - (STRINGP (object)));
+ return position;
}
DEFUN ("previous-property-change", Fprevious_property_change,
Sprevious_property_change, 1, 3, 0,
"Return the position of previous property change.\n\
-Scans characters backwards from POS in OBJECT till it finds\n\
+Scans characters backwards from POSITION in OBJECT till it finds\n\
a change in some text property, then returns the position of the change.\n\
The optional second argument OBJECT is the string or buffer to scan.\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 POS, never equal.\n\n\
+If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
If the optional third argument LIMIT is non-nil, don't search\n\
back past position LIMIT; return LIMIT if nothing is found until LIMIT.")
- (pos, object, limit)
- Lisp_Object pos, object, limit;
+ (position, object, limit)
+ Lisp_Object position, object, limit;
{
register INTERVAL i, previous;
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit, 0);
- i = validate_interval_range (object, &pos, &pos, soft);
+ i = validate_interval_range (object, &position, &position, soft);
if (NULL_INTERVAL_P (i))
return limit;
/* Start with the interval containing the char before point. */
- if (i->position == XFASTINT (pos))
+ if (i->position == XFASTINT (position))
i = previous_interval (i);
previous = previous_interval (i);
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- XSETFASTINT (pos, (previous->position + LENGTH (previous)
+ XSETFASTINT (position, (previous->position + LENGTH (previous)
- (STRINGP (object))));
- return pos;
+ return position;
}
DEFUN ("previous-single-property-change", Fprevious_single_property_change,
Sprevious_single_property_change, 2, 4, 0,
"Return the position of previous property change for a specific property.\n\
-Scans characters backward from POS till it finds\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 POS, never equal.\n\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 until LIMIT.")
- (pos, prop, object, limit)
- Lisp_Object pos, prop, object, limit;
+ (position, prop, object, limit)
+ Lisp_Object position, prop, object, limit;
{
register INTERVAL i, previous;
register Lisp_Object here_val;
if (!NILP (limit))
CHECK_NUMBER_COERCE_MARKER (limit, 0);
- i = validate_interval_range (object, &pos, &pos, soft);
+ i = validate_interval_range (object, &position, &position, soft);
/* Start with the interval containing the char before point. */
- if (! NULL_INTERVAL_P (i) && i->position == XFASTINT (pos))
+ if (! NULL_INTERVAL_P (i) && i->position == XFASTINT (position))
i = previous_interval (i);
if (NULL_INTERVAL_P (i))
&& !(previous->position + LENGTH (previous) > XFASTINT (limit)))
return limit;
- XSETFASTINT (pos, (previous->position + LENGTH (previous)
+ XSETFASTINT (position, (previous->position + LENGTH (previous)
- (STRINGP (object))));
- return pos;
+ return position;
}
/* Callers note, this can GC when OBJECT is a buffer (or nil). */
DEFUN ("add-text-properties", Fadd_text_properties,
Sadd_text_properties, 3, 4, 0,
"Add properties to the text from START to END.\n\
-The third argument PROPS is a property list\n\
+The third argument PROPERTIES is a property list\n\
specifying the property values to add.\n\
The optional fourth argument, OBJECT,\n\
is the string or buffer containing the text.\n\
{
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;
}
DEFUN ("put-text-property", Fput_text_property,
Sput_text_property, 4, 5, 0,
"Set one property of the text from START to END.\n\
-The third and fourth arguments PROP and VALUE\n\
+The third and fourth arguments PROPERTY and VALUE\n\
specify the property to add.\n\
The optional fifth argument, OBJECT,\n\
is the string or buffer containing the text.")
- (start, end, prop, value, object)
- Lisp_Object start, end, prop, value, object;
+ (start, end, property, value, object)
+ Lisp_Object start, end, property, value, object;
{
Fadd_text_properties (start, end,
- Fcons (prop, Fcons (value, Qnil)),
+ Fcons (property, Fcons (value, Qnil)),
object);
return Qnil;
}
DEFUN ("set-text-properties", Fset_text_properties,
Sset_text_properties, 3, 4, 0,
"Completely replace properties of text from START to END.\n\
-The third argument PROPS is the new property list.\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.")
- (start, end, props, object)
- Lisp_Object start, end, props, object;
+ (start, end, properties, object)
+ Lisp_Object start, end, properties, object;
{
register INTERVAL i, unchanged;
register INTERVAL prev_changed = NULL_INTERVAL;
register int s, len;
Lisp_Object ostart, oend;
+ int have_modified = 0;
ostart = start;
oend = end;
- props = validate_plist (props);
+ properties = validate_plist (properties);
if (NILP (object))
XSETBUFFER (object, current_buffer);
/* If we want no properties for a whole string,
get rid of its intervals. */
- if (NILP (props) && STRINGP (object)
+ if (NILP (properties) && STRINGP (object)
&& XFASTINT (start) == 0
&& XFASTINT (end) == XSTRING (object)->size)
{
+ if (! XSTRING (object)->intervals)
+ return Qt;
+
XSTRING (object)->intervals = 0;
return Qt;
}
if (NULL_INTERVAL_P (i))
{
- /* If buffer has no props, and we want none, return now. */
- if (NILP (props))
+ /* If buffer has no properties, and we want none, return now. */
+ if (NILP (properties))
return Qnil;
/* Restore the original START and END values
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 (props, i, object);
+ set_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+
return Qt;
}
- set_properties (props, i, object);
+ set_properties (properties, i, object);
if (LENGTH (i) == len)
- return Qt;
+ {
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+
+ return Qt;
+ }
prev_changed = i;
len -= LENGTH (i);
if (LENGTH (i) > len)
i = split_interval_left (i, len);
- if (NULL_INTERVAL_P (prev_changed))
- set_properties (props, i, object);
- else
+ /* We have to call set_properties even if we are going to
+ merge the intervals, so as to make the undo records
+ and cause redisplay to happen. */
+ set_properties (properties, i, object);
+ if (!NULL_INTERVAL_P (prev_changed))
merge_interval_left (i);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
len -= LENGTH (i);
+
+ /* We have to call set_properties even if we are going to
+ merge the intervals, so as to make the undo records
+ and cause redisplay to happen. */
+ set_properties (properties, i, object);
if (NULL_INTERVAL_P (prev_changed))
- {
- set_properties (props, i, object);
- prev_changed = i;
- }
+ prev_changed = i;
else
prev_changed = i = merge_interval_left (i);
i = next_interval (i);
}
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
DEFUN ("remove-text-properties", Fremove_text_properties,
Sremove_text_properties, 3, 4, 0,
"Remove some properties from text from START to END.\n\
-The third argument PROPS is a property list\n\
+The third argument PROPERTIES is a property list\n\
whose property names specify the properties to remove.\n\
-\(The values stored in PROPS are ignored.)\n\
+\(The values stored in PROPERTIES are ignored.)\n\
The optional fourth argument, OBJECT,\n\
is the string or buffer containing the text.\n\
Return t if any property was actually removed, nil otherwise.")
- (start, end, props, object)
- Lisp_Object start, end, props, object;
+ (start, end, properties, object)
+ Lisp_Object start, end, properties, object;
{
register INTERVAL i, unchanged;
register int s, len, modified = 0;
{
/* No properties on this first interval -- return if
it covers the entire region. */
- if (! interval_has_some_properties (props, i))
+ if (! interval_has_some_properties (properties, i))
{
int got = (LENGTH (i) - (s - i->position));
if (got >= len)
}
}
+ 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)
{
- if (! interval_has_some_properties (props, i))
+ if (! interval_has_some_properties (properties, i))
return modified ? Qt : Qnil;
if (LENGTH (i) == len)
{
- remove_properties (props, i, object);
+ remove_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
unchanged = i;
i = split_interval_left (i, len);
copy_properties (unchanged, i);
- remove_properties (props, i, object);
+ remove_properties (properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
return Qt;
}
len -= LENGTH (i);
- modified += remove_properties (props, i, object);
+ modified += remove_properties (properties, i, object);
i = next_interval (i);
}
}
DEFUN ("text-property-any", Ftext_property_any,
Stext_property_any, 4, 5, 0,
- "Check text from START to END to see if PROP is ever `eq' to VALUE.\n\
-If so, return the position of the first character whose PROP is `eq'\n\
-to VALUE. Otherwise return nil.\n\
+ "Check text from START to END for property PROPERTY equalling VALUE.\n\
+If so, return the position of the first character whose property PROPERTY\n\
+is `eq' to VALUE. Otherwise return nil.\n\
The optional fifth argument, OBJECT, is the string or buffer\n\
containing the text.")
- (start, end, prop, value, object)
- Lisp_Object start, end, prop, value, object;
+ (start, end, property, value, object)
+ Lisp_Object start, end, property, value, object;
{
register INTERVAL i;
register int e, pos;
{
if (i->position >= e)
break;
- if (EQ (textget (i->plist, prop), value))
+ if (EQ (textget (i->plist, property), value))
{
pos = i->position;
if (pos < XINT (start))
DEFUN ("text-property-not-all", Ftext_property_not_all,
Stext_property_not_all, 4, 5, 0,
- "Check text from START to END to see if PROP is ever not `eq' to VALUE.\n\
-If so, return the position of the first character whose PROP is not\n\
-`eq' to VALUE. Otherwise, return nil.\n\
+ "Check text from START to END for property PROPERTY not equalling VALUE.\n\
+If so, return the position of the first character whose property PROPERTY\n\
+is not `eq' to VALUE. Otherwise, return nil.\n\
The optional fifth argument, OBJECT, is the string or buffer\n\
containing the text.")
- (start, end, prop, value, object)
- Lisp_Object start, end, prop, value, object;
+ (start, end, property, value, object)
+ Lisp_Object start, end, property, value, object;
{
register INTERVAL i;
register int s, e;
{
if (i->position >= e)
break;
- if (! EQ (textget (i->plist, prop), value))
+ if (! EQ (textget (i->plist, property), value))
{
if (i->position > s)
s = i->position;
return modified ? Qt : Qnil;
}
+\f
+/* Call the modification hook functions in LIST, each with START and END. */
+
+static void
+call_mod_hooks (list, start, end)
+ Lisp_Object list, start, end;
+{
+ struct gcpro gcpro1;
+ GCPRO1 (list);
+ while (!NILP (list))
+ {
+ call2 (Fcar (list), start, end);
+ list = Fcdr (list);
+ }
+ 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. */
+void
+verify_interval_modification (buf, start, end)
+ struct buffer *buf;
+ int start, end;
+{
+ register INTERVAL intervals = BUF_INTERVALS (buf);
+ register INTERVAL i, prev;
+ Lisp_Object hooks;
+ register Lisp_Object prev_mod_hooks;
+ Lisp_Object mod_hooks;
+ struct gcpro gcpro1;
+
+ hooks = Qnil;
+ prev_mod_hooks = Qnil;
+ mod_hooks = Qnil;
+
+ interval_insert_behind_hooks = Qnil;
+ interval_insert_in_front_hooks = Qnil;
+
+ if (NULL_INTERVAL_P (intervals))
+ return;
+
+ if (start > end)
+ {
+ int temp = start;
+ start = end;
+ end = temp;
+ }
+
+ /* For an insert operation, check the two chars around the position. */
+ if (start == end)
+ {
+ INTERVAL prev;
+ Lisp_Object before, after;
+
+ /* Set I to the interval containing the char after START,
+ and PREV to the interval containing the char before START.
+ Either one may be null. They may be equal. */
+ i = find_interval (intervals, start);
+
+ if (start == BUF_BEGV (buf))
+ prev = 0;
+ else if (i->position == start)
+ prev = previous_interval (i);
+ else if (i->position < start)
+ prev = i;
+ if (start == BUF_ZV (buf))
+ i = 0;
+
+ /* If Vinhibit_read_only is set and is not a list, we can
+ skip the read_only checks. */
+ 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
+ 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 (i != prev)
+ {
+ if (! NULL_INTERVAL_P (i))
+ {
+ after = textget (i->plist, Qread_only);
+
+ /* If interval I is read-only and read-only is
+ front-sticky, inhibit insertion.
+ Check for read-only as well as category. */
+ if (! NILP (after)
+ && NILP (Fmemq (after, Vinhibit_read_only)))
+ {
+ Lisp_Object tem;
+
+ tem = textget (i->plist, Qfront_sticky);
+ if (TMEM (Qread_only, tem)
+ || (NILP (Fplist_get (i->plist, Qread_only))
+ && TMEM (Qcategory, tem)))
+ error ("Attempt to insert within read-only text");
+ }
+ }
+
+ if (! NULL_INTERVAL_P (prev))
+ {
+ before = textget (prev->plist, Qread_only);
+
+ /* If interval PREV is read-only and read-only isn't
+ rear-nonsticky, inhibit insertion.
+ Check for read-only as well as category. */
+ if (! NILP (before)
+ && NILP (Fmemq (before, Vinhibit_read_only)))
+ {
+ Lisp_Object tem;
+
+ 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");
+ }
+ }
+ }
+ else if (! NULL_INTERVAL_P (i))
+ {
+ after = textget (i->plist, Qread_only);
+
+ /* If interval I is read-only and read-only is
+ front-sticky, inhibit insertion.
+ Check for read-only as well as category. */
+ if (! NILP (after) && NILP (Fmemq (after, Vinhibit_read_only)))
+ {
+ Lisp_Object tem;
+
+ tem = textget (i->plist, Qfront_sticky);
+ if (TMEM (Qread_only, tem)
+ || (NILP (Fplist_get (i->plist, Qread_only))
+ && TMEM (Qcategory, tem)))
+ error ("Attempt to insert within read-only text");
+
+ 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");
+ }
+ }
+ }
+
+ /* Run both insert hooks (just once if they're the same). */
+ if (!NULL_INTERVAL_P (prev))
+ interval_insert_behind_hooks
+ = textget (prev->plist, Qinsert_behind_hooks);
+ if (!NULL_INTERVAL_P (i))
+ interval_insert_in_front_hooks
+ = textget (i->plist, Qinsert_in_front_hooks);
+ }
+ else
+ {
+ /* Loop over intervals on or next to START...END,
+ collecting their hooks. */
+
+ i = find_interval (intervals, start);
+ do
+ {
+ if (! INTERVAL_WRITABLE_P (i))
+ error ("Attempt to modify read-only text");
+
+ mod_hooks = textget (i->plist, Qmodification_hooks);
+ if (! NILP (mod_hooks) && ! EQ (mod_hooks, prev_mod_hooks))
+ {
+ hooks = Fcons (mod_hooks, hooks);
+ prev_mod_hooks = mod_hooks;
+ }
+
+ i = next_interval (i);
+ }
+ /* Keep going thru the interval containing the char before END. */
+ while (! NULL_INTERVAL_P (i) && i->position < end);
+
+ GCPRO1 (hooks);
+ hooks = Fnreverse (hooks);
+ while (! EQ (hooks, Qnil))
+ {
+ call_mod_hooks (Fcar (hooks), make_number (start),
+ make_number (end));
+ hooks = Fcdr (hooks);
+ }
+ UNGCPRO;
+ }
+}
+
+/* Run the interval hooks for an insertion.
+ 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. */
+
+void
+report_interval_modification (start, end)
+ Lisp_Object start, end;
+{
+ if (! NILP (interval_insert_behind_hooks))
+ call_mod_hooks (interval_insert_behind_hooks,
+ make_number (start), make_number (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));
+}
+\f
void
syms_of_textprop ()
{
- DEFVAR_LISP ("default-properties", &Vdefault_properties,
+ DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties,
"Property-list used as default values.\n\
-The value of a property in this list is seen as the value for every character\n\
-that does not have its own value for that property.");
- Vdefault_properties = Qnil;
+The value of a property in this list is seen as the value for every\n\
+character that does not have its own value for that property.");
+ Vdefault_text_properties = Qnil;
DEFVAR_LISP ("inhibit-point-motion-hooks", &Vinhibit_point_motion_hooks,
"If non-nil, don't run `point-left' and `point-entered' text properties.\n\
This also inhibits the use of the `intangible' text property.");
Vinhibit_point_motion_hooks = Qnil;
+
+ staticpro (&interval_insert_behind_hooks);
+ staticpro (&interval_insert_in_front_hooks);
+ interval_insert_behind_hooks = Qnil;
+ interval_insert_in_front_hooks = Qnil;
+
/* Common attributes one might give text */