/* Interface code for dealing with text properties.
- Copyright (C) 1993-1995, 1997, 1999-2011 Free Software Foundation, Inc.
+ Copyright (C) 1993-1995, 1997, 1999-2013 Free Software Foundation,
+ Inc.
This file is part of GNU Emacs.
along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include <config.h>
-#include <setjmp.h>
+
#include "lisp.h"
#include "intervals.h"
+#include "character.h"
#include "buffer.h"
#include "window.h"
-#ifndef NULL
-#define NULL (void *)0
-#endif
-
/* Test for membership, allowing for t (actually any non-cons) to mean the
universal set. */
\f
/* Types of hooks. */
-Lisp_Object Qmouse_left;
-Lisp_Object Qmouse_entered;
+static Lisp_Object Qmouse_left;
+static Lisp_Object Qmouse_entered;
Lisp_Object Qpoint_left;
Lisp_Object Qpoint_entered;
Lisp_Object Qcategory;
Lisp_Object Qlocal_map;
/* Visual properties text (including strings) may have. */
-Lisp_Object Qforeground, Qbackground, Qfont, Qunderline, Qstipple;
-Lisp_Object Qinvisible, Qread_only, Qintangible, Qmouse_face;
+static Lisp_Object Qforeground, Qbackground, Qunderline;
+Lisp_Object Qfont;
+static Lisp_Object Qstipple;
+Lisp_Object Qinvisible, Qintangible, Qmouse_face;
+static Lisp_Object Qread_only;
Lisp_Object Qminibuffer_prompt;
/* Sticky 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;
-
-static void text_read_only (Lisp_Object) NO_RETURN;
+static Lisp_Object interval_insert_behind_hooks;
+static 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
+static _Noreturn void
text_read_only (Lisp_Object propval)
{
if (STRINGP (propval))
xsignal0 (Qtext_read_only);
}
+/* Prepare to modify the region of BUFFER from START to END. */
+
+static void
+modify_region (Lisp_Object buffer, Lisp_Object start, Lisp_Object end)
+{
+ struct buffer *buf = XBUFFER (buffer), *old = current_buffer;
+
+ set_buffer_internal (buf);
+ modify_region_1 (XINT (start), XINT (end), true);
+ set_buffer_internal (old);
+}
-\f
/* Extract the interval at the position pointed to by BEGIN from
OBJECT, a string or buffer. Additionally, check that the positions
pointed to by BEGIN and END are within the bounds of OBJECT, and
Fprevious_property_change which call this function with BEGIN == END.
Handle this case specially.
- If FORCE is soft (0), it's OK to return NULL_INTERVAL. Otherwise,
+ If FORCE is soft (0), it's OK to return NULL. Otherwise,
create an interval tree for OBJECT if one doesn't exist, provided
the object actually contains text. In the current design, if there
is no text, there can be no text properties. */
validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *end, int force)
{
register INTERVAL i;
- EMACS_INT searchpos;
+ ptrdiff_t searchpos;
CHECK_STRING_OR_BUFFER (object);
CHECK_NUMBER_COERCE_MARKER (*begin);
/* If we are asked for a point, but from a subr which operates
on a range, then return nothing. */
if (EQ (*begin, *end) && begin != end)
- return NULL_INTERVAL;
+ return NULL;
if (XINT (*begin) > XINT (*end))
{
if (!(BUF_BEGV (b) <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= BUF_ZV (b)))
args_out_of_range (*begin, *end);
- i = BUF_INTERVALS (b);
+ i = buffer_intervals (b);
/* If there's no text, there are no properties. */
if (BUF_BEGV (b) == BUF_ZV (b))
- return NULL_INTERVAL;
+ return NULL;
searchpos = XINT (*begin);
}
else
{
- EMACS_INT len = SCHARS (object);
+ ptrdiff_t len = SCHARS (object);
if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= len))
XSETFASTINT (*begin, XFASTINT (*begin));
if (begin != end)
XSETFASTINT (*end, XFASTINT (*end));
- i = STRING_INTERVALS (object);
+ i = string_intervals (object);
if (len == 0)
- return NULL_INTERVAL;
+ return NULL;
searchpos = XINT (*begin);
}
- if (NULL_INTERVAL_P (i))
+ if (!i)
return (force ? create_root_interval (object) : i);
return find_interval (i, searchpos);
if (! EQ (Fcar (XCDR (tail1)), Fcar (XCDR (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. */
-static INLINE int
+static int
interval_has_some_properties (Lisp_Object plist, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
/* Return nonzero if the plist of interval I has any of the
property names in LIST, regardless of their values. */
-static INLINE int
+static int
interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
/* Go through each element of LIST. */
for (tail1 = list; CONSP (tail1); tail1 = XCDR (tail1))
{
- sym = Fcar (tail1);
+ sym = XCAR (tail1);
/* Go through i's plist, looking for tail1 */
for (tail2 = i->plist; CONSP (tail2); tail2 = XCDR (XCDR (tail2)))
}
/* Store new properties. */
- interval->plist = Fcopy_sequence (properties);
+ set_interval_plist (interval, Fcopy_sequence (properties));
}
/* Add the properties of PLIST to the interval I, or set
record_property_change (i->position, LENGTH (i),
sym1, Qnil, object);
}
- i->plist = Fcons (sym1, Fcons (val1, i->plist));
+ set_interval_plist (i, Fcons (sym1, Fcons (val1, i->plist)));
changed++;
}
}
}
if (changed)
- i->plist = current_plist;
+ set_interval_plist (i, current_plist);
return changed;
}
-
-#if 0
-/* Remove all properties from interval I. Return non-zero
- if this changes the interval. */
-
-static INLINE int
-erase_properties (INTERVAL i)
-{
- if (NILP (i->plist))
- return 0;
-
- i->plist = Qnil;
- return 1;
-}
-#endif
\f
/* Returns the interval of POSITION in OBJECT.
POSITION is BEG-based. */
INTERVAL
-interval_of (int position, Lisp_Object object)
+interval_of (ptrdiff_t position, Lisp_Object object)
{
register INTERVAL i;
- EMACS_INT beg, end;
+ ptrdiff_t beg, end;
if (NILP (object))
XSETBUFFER (object, current_buffer);
else if (EQ (object, Qt))
- return NULL_INTERVAL;
+ return NULL;
CHECK_STRING_OR_BUFFER (object);
beg = BUF_BEGV (b);
end = BUF_ZV (b);
- i = BUF_INTERVALS (b);
+ i = buffer_intervals (b);
}
else
{
beg = 0;
end = SCHARS (object);
- i = STRING_INTERVALS (object);
+ i = string_intervals (object);
}
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;
+ if (beg == end || !i)
+ return NULL;
return find_interval (i, position);
}
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &position, &position, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
/* If POSITION is at the end of the interval,
it means it's the end of OBJECT.
DEFUN ("get-text-property", Fget_text_property, Sget_text_property, 2, 3, 0,
doc: /* Return the value of POSITION's property PROP, in OBJECT.
-OBJECT is optional and defaults to the current buffer.
+OBJECT should be a buffer or a string; if omitted or nil, it defaults
+to the current buffer.
If POSITION is at the end of OBJECT, the value is nil. */)
(Lisp_Object position, Lisp_Object prop, Lisp_Object object)
{
}
if (BUFFERP (object))
{
- int noverlays;
+ ptrdiff_t noverlays;
Lisp_Object *overlay_vec;
struct buffer *obuf = current_buffer;
else
{
Lisp_Object initial_value, value;
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
if (! NILP (object))
CHECK_BUFFER (object);
if (BUFFERP (object) && current_buffer != XBUFFER (object))
{
- record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ record_unwind_current_buffer ();
Fset_buffer (object);
}
The property values are compared with `eq'.
If the property is constant all the way to the start of OBJECT, return the
first valid position in OBJECT.
-If the optional fourth argument LIMIT is non-nil, don't search
-back past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
+If the optional fourth argument LIMIT is non-nil, don't search back past
+position LIMIT; return LIMIT if nothing is found before reaching LIMIT. */)
(Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
{
if (STRINGP (object))
}
else
{
- int count = SPECPDL_INDEX ();
+ ptrdiff_t count = SPECPDL_INDEX ();
if (! NILP (object))
CHECK_BUFFER (object);
if (BUFFERP (object) && current_buffer != XBUFFER (object))
{
- record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+ record_unwind_current_buffer ();
Fset_buffer (object);
}
bother checking further intervals. */
if (EQ (limit, Qt))
{
- if (NULL_INTERVAL_P (i))
+ if (!i)
next = i;
else
next = next_interval (i);
- if (NULL_INTERVAL_P (next))
+ if (!next)
XSETFASTINT (position, (STRINGP (object)
? SCHARS (object)
: BUF_ZV (XBUFFER (object))));
return position;
}
- if (NULL_INTERVAL_P (i))
+ if (!i)
return limit;
next = next_interval (i);
- while (!NULL_INTERVAL_P (next) && intervals_equal (i, next)
+ while (next && intervals_equal (i, next)
&& (NILP (limit) || next->position < XFASTINT (limit)))
next = next_interval (next);
- if (NULL_INTERVAL_P (next)
+ if (!next
|| (next->position
>= (INTEGERP (limit)
? XFASTINT (limit)
CHECK_NUMBER_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return limit;
here_val = textget (i->plist, prop);
next = next_interval (i);
- while (! NULL_INTERVAL_P (next)
+ while (next
&& EQ (here_val, textget (next->plist, prop))
&& (NILP (limit) || next->position < XFASTINT (limit)))
next = next_interval (next);
- if (NULL_INTERVAL_P (next)
+ if (!next
|| (next->position
>= (INTEGERP (limit)
? XFASTINT (limit)
CHECK_NUMBER_COERCE_MARKER (limit);
i = validate_interval_range (object, &position, &position, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return limit;
/* Start with the interval containing the char before point. */
i = previous_interval (i);
previous = previous_interval (i);
- while (!NULL_INTERVAL_P (previous) && intervals_equal (previous, i)
+ while (previous && intervals_equal (previous, i)
&& (NILP (limit)
|| (previous->position + LENGTH (previous) > XFASTINT (limit))))
previous = previous_interval (previous);
- if (NULL_INTERVAL_P (previous)
+ if (!previous
|| (previous->position + LENGTH (previous)
<= (INTEGERP (limit)
? XFASTINT (limit)
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 (position))
+ if (i && i->position == XFASTINT (position))
i = previous_interval (i);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return limit;
here_val = textget (i->plist, prop);
previous = previous_interval (i);
- while (!NULL_INTERVAL_P (previous)
+ while (previous
&& EQ (here_val, textget (previous->plist, prop))
&& (NILP (limit)
|| (previous->position + LENGTH (previous) > XFASTINT (limit))))
previous = previous_interval (previous);
- if (NULL_INTERVAL_P (previous)
+ if (!previous
|| (previous->position + LENGTH (previous)
<= (INTEGERP (limit)
? XFASTINT (limit)
(Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register EMACS_INT s, len;
+ register ptrdiff_t s, len;
register int modified = 0;
struct gcpro gcpro1;
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &start, &end, hard);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
s = XINT (start);
skip it. */
if (interval_has_all_properties (properties, i))
{
- EMACS_INT got = (LENGTH (i) - (s - i->position));
+ ptrdiff_t got = (LENGTH (i) - (s - i->position));
if (got >= len)
RETURN_UNGCPRO (Qnil);
len -= got;
}
if (BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
/* We are at the beginning of interval I, with LEN chars to scan. */
for (;;)
{
- if (i == 0)
- abort ();
+ eassert (i != 0);
if (LENGTH (i) >= len)
{
&& XFASTINT (start) == 0
&& XFASTINT (end) == SCHARS (object))
{
- if (! STRING_INTERVALS (object))
+ if (!string_intervals (object))
return Qnil;
- STRING_SET_INTERVALS (object, NULL_INTERVAL);
+ set_string_intervals (object, NULL);
return Qt;
}
i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
{
/* If buffer has no properties, and we want none, return now. */
if (NILP (properties))
i = validate_interval_range (object, &start, &end, hard);
/* This can return if start == end. */
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
}
if (BUFFERP (object) && !NILP (coherent_change_p))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
set_text_properties_1 (start, end, properties, object, i);
}
/* Replace properties of text from START to END with new list of
- properties PROPERTIES. BUFFER is the buffer containing
+ properties PROPERTIES. OBJECT is the buffer or string containing
the text. This does not obey any hooks.
- You can provide the interval that START is located in as I,
- or pass NULL for I and this function will find it.
+ You should provide the interval that START is located in as I.
START and END can be in any order. */
void
-set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
+set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, INTERVAL i)
{
- register INTERVAL prev_changed = NULL_INTERVAL;
- register EMACS_INT s, len;
+ register INTERVAL prev_changed = NULL;
+ register ptrdiff_t s, len;
INTERVAL unchanged;
- s = XINT (start);
- len = XINT (end) - s;
- if (len == 0)
- return;
- if (len < 0)
+ if (XINT (start) < XINT (end))
{
- s = s + len;
- len = - len;
+ s = XINT (start);
+ len = XINT (end) - s;
}
+ else if (XINT (end) < XINT (start))
+ {
+ s = XINT (end);
+ len = XINT (start) - s;
+ }
+ else
+ return;
- if (i == 0)
- i = find_interval (BUF_INTERVALS (XBUFFER (buffer)), s);
+ eassert (i);
if (i->position != s)
{
{
copy_properties (unchanged, i);
i = split_interval_left (i, len);
- set_properties (properties, i, buffer);
+ set_properties (properties, i, object);
return;
}
- set_properties (properties, i, buffer);
+ set_properties (properties, i, object);
if (LENGTH (i) == len)
return;
/* We are starting at the beginning of an interval I. LEN is positive. */
do
{
- if (i == 0)
- abort ();
+ eassert (i != 0);
if (LENGTH (i) >= len)
{
/* 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, buffer);
- if (!NULL_INTERVAL_P (prev_changed))
+ set_properties (properties, i, object);
+ if (prev_changed)
merge_interval_left (i);
return;
}
/* 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, buffer);
- if (NULL_INTERVAL_P (prev_changed))
+ set_properties (properties, i, object);
+ if (!prev_changed)
prev_changed = i;
else
prev_changed = i = merge_interval_left (i);
(Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register EMACS_INT s, len;
+ register ptrdiff_t s, len;
register int modified = 0;
if (NILP (object))
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
s = XINT (start);
it covers the entire region. */
if (! interval_has_some_properties (properties, i))
{
- EMACS_INT got = (LENGTH (i) - (s - i->position));
+ ptrdiff_t got = (LENGTH (i) - (s - i->position));
if (got >= len)
return Qnil;
len -= got;
}
if (BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
/* We are at the beginning of an interval, with len to scan */
for (;;)
{
- if (i == 0)
- abort ();
+ eassert (i != 0);
if (LENGTH (i) >= len)
{
(Lisp_Object start, Lisp_Object end, Lisp_Object list_of_properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register EMACS_INT s, len;
+ register ptrdiff_t s, len;
register int modified = 0;
Lisp_Object properties;
properties = list_of_properties;
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
s = XINT (start);
it covers the entire region. */
if (! interval_has_some_properties_list (properties, i))
{
- EMACS_INT got = (LENGTH (i) - (s - i->position));
+ ptrdiff_t got = (LENGTH (i) - (s - i->position));
if (got >= len)
return Qnil;
len -= got;
and we call signal_after_change before returning if modified != 0. */
for (;;)
{
- if (i == 0)
- abort ();
+ eassert (i != 0);
if (LENGTH (i) >= len)
{
else if (LENGTH (i) == len)
{
if (!modified && BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
remove_properties (Qnil, properties, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
i = split_interval_left (i, len);
copy_properties (unchanged, i);
if (!modified && BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
remove_properties (Qnil, properties, i, object);
if (BUFFERP (object))
signal_after_change (XINT (start), XINT (end) - XINT (start),
if (interval_has_some_properties_list (properties, i))
{
if (!modified && BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ modify_region (object, start, end);
remove_properties (Qnil, properties, i, object);
modified = 1;
}
\f
DEFUN ("text-property-any", Ftext_property_any,
Stext_property_any, 4, 5, 0,
- doc: /* Check text from START to END for property PROPERTY equalling VALUE.
+ doc: /* Check text from START to END for property PROPERTY equaling VALUE.
If so, return the position of the first character whose property PROPERTY
is `eq' to VALUE. Otherwise return nil.
If the optional fifth argument OBJECT is a buffer (or nil, which means
(Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
{
register INTERVAL i;
- register EMACS_INT e, pos;
+ register ptrdiff_t e, pos;
if (NILP (object))
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return (!NILP (value) || EQ (start, end) ? Qnil : start);
e = XINT (end);
- while (! NULL_INTERVAL_P (i))
+ while (i)
{
if (i->position >= e)
break;
DEFUN ("text-property-not-all", Ftext_property_not_all,
Stext_property_not_all, 4, 5, 0,
- doc: /* Check text from START to END for property PROPERTY not equalling VALUE.
+ doc: /* Check text from START to END for property PROPERTY not equaling VALUE.
If so, return the position of the first character whose property PROPERTY
is not `eq' to VALUE. Otherwise, return nil.
If the optional fifth argument OBJECT is a buffer (or nil, which means
(Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
{
register INTERVAL i;
- register EMACS_INT s, e;
+ register ptrdiff_t s, e;
if (NILP (object))
XSETBUFFER (object, current_buffer);
i = validate_interval_range (object, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return (NILP (value) || EQ (start, end)) ? Qnil : start;
s = XINT (start);
e = XINT (end);
- while (! NULL_INTERVAL_P (i))
+ while (i)
{
if (i->position >= e)
break;
{
Lisp_Object prev_pos, front_sticky;
int is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
+ Lisp_Object defalt = Fassq (prop, Vtext_property_default_nonsticky);
if (NILP (buffer))
XSETBUFFER (buffer, current_buffer);
+ if (CONSP (defalt) && !NILP (XCDR (defalt)))
+ is_rear_sticky = 0;
+
if (XINT (pos) > BUF_BEGV (XBUFFER (buffer)))
/* Consider previous character. */
{
}
\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?
-
- I think it would be better to have a pair of functions, one which
- returns the text properties of a region as a list of ranges and
- plists, and another which applies such a list to another object. */
+/* Copying properties between objects. */
-/* Add properties from SRC to SRC of SRC, starting at POS in DEST.
+/* Add properties from START to END of SRC, starting at POS in DEST.
SRC and DEST may each refer to strings or buffers.
Optional sixth argument PROP causes only that property to be copied.
Properties are copied to DEST as if by `add-text-properties'.
Lisp_Object res;
Lisp_Object stuff;
Lisp_Object plist;
- EMACS_INT s, e, e2, p, len;
+ ptrdiff_t s, e, e2, p, len;
int modified = 0;
struct gcpro gcpro1, gcpro2;
i = validate_interval_range (src, &start, &end, soft);
- if (NULL_INTERVAL_P (i))
+ if (!i)
return Qnil;
CHECK_NUMBER_COERCE_MARKER (pos);
{
Lisp_Object dest_start, dest_end;
+ e = XINT (pos) + (XINT (end) - XINT (start));
+ if (MOST_POSITIVE_FIXNUM < e)
+ args_out_of_range (pos, end);
dest_start = pos;
- XSETFASTINT (dest_end, XINT (dest_start) + (XINT (end) - XINT (start)));
+ XSETFASTINT (dest_end, e);
/* Apply this to a copy of pos; it will try to increment its arguments,
which we don't want. */
validate_interval_range (dest, &dest_start, &dest_end, soft);
}
i = next_interval (i);
- if (NULL_INTERVAL_P (i))
+ if (!i)
break;
p += len;
result = Qnil;
i = validate_interval_range (object, &start, &end, soft);
- if (!NULL_INTERVAL_P (i))
+ if (i)
{
- EMACS_INT s = XINT (start);
- EMACS_INT e = XINT (end);
+ ptrdiff_t s = XINT (start);
+ ptrdiff_t e = XINT (end);
while (s < e)
{
- EMACS_INT interval_end, len;
+ ptrdiff_t interval_end, len;
Lisp_Object plist;
interval_end = i->position + LENGTH (i);
result);
i = next_interval (i);
- if (NULL_INTERVAL_P (i))
+ if (!i)
break;
s = i->position;
}
extend_property_ranges (Lisp_Object list, Lisp_Object new_end)
{
Lisp_Object prev = Qnil, head = list;
- EMACS_INT max = XINT (new_end);
+ ptrdiff_t max = XINT (new_end);
for (; CONSP (list); prev = list, list = XCDR (list))
{
those hooks in order, with START and END - 1 as arguments. */
void
-verify_interval_modification (struct buffer *buf, int start, int end)
+verify_interval_modification (struct buffer *buf,
+ ptrdiff_t start, ptrdiff_t end)
{
- register INTERVAL intervals = BUF_INTERVALS (buf);
- register INTERVAL i;
+ INTERVAL intervals = buffer_intervals (buf);
+ INTERVAL i;
Lisp_Object hooks;
- register Lisp_Object prev_mod_hooks;
+ Lisp_Object prev_mod_hooks;
Lisp_Object mod_hooks;
struct gcpro gcpro1;
interval_insert_behind_hooks = Qnil;
interval_insert_in_front_hooks = Qnil;
- if (NULL_INTERVAL_P (intervals))
+ if (!intervals)
return;
if (start > end)
{
- EMACS_INT temp = start;
+ ptrdiff_t temp = start;
start = end;
end = temp;
}
indirectly defined via the category property. */
if (i != prev)
{
- if (! NULL_INTERVAL_P (i))
+ if (i)
{
after = textget (i->plist, Qread_only);
}
}
- if (! NULL_INTERVAL_P (prev))
+ if (prev)
{
before = textget (prev->plist, Qread_only);
}
}
}
- else if (! NULL_INTERVAL_P (i))
+ else if (i)
{
after = textget (i->plist, Qread_only);
}
/* Run both insert hooks (just once if they're the same). */
- if (!NULL_INTERVAL_P (prev))
+ if (prev)
interval_insert_behind_hooks
= textget (prev->plist, Qinsert_behind_hooks);
- if (!NULL_INTERVAL_P (i))
+ if (i)
interval_insert_in_front_hooks
= textget (i->plist, Qinsert_in_front_hooks);
}
i = next_interval (i);
}
/* Keep going thru the interval containing the char before END. */
- while (! NULL_INTERVAL_P (i) && i->position < end);
+ while (i && i->position < end);
if (!inhibit_modification_hooks)
{
DEFVAR_LISP ("text-property-default-nonsticky",
Vtext_property_default_nonsticky,
- doc: /* Alist of properties vs the corresponding non-stickinesses.
+ doc: /* Alist of properties vs the corresponding non-stickiness.
Each element has the form (PROPERTY . NONSTICKINESS).
If a character in a buffer has PROPERTY, new text inserted adjacent to
the character doesn't inherit PROPERTY if NONSTICKINESS is non-nil,
inherits it if NONSTICKINESS is nil. The `front-sticky' and
`rear-nonsticky' properties of the character override NONSTICKINESS. */);
- /* Text property `syntax-table' should be nonsticky by default. */
+ /* Text properties `syntax-table'and `display' should be nonsticky
+ by default. */
Vtext_property_default_nonsticky
- = Fcons (Fcons (intern_c_string ("syntax-table"), Qt), Qnil);
+ = Fcons (Fcons (intern_c_string ("syntax-table"), Qt),
+ Fcons (Fcons (intern_c_string ("display"), Qt), Qnil));
staticpro (&interval_insert_behind_hooks);
staticpro (&interval_insert_in_front_hooks);
/* Common attributes one might give text */
- staticpro (&Qforeground);
- Qforeground = intern_c_string ("foreground");
- staticpro (&Qbackground);
- Qbackground = intern_c_string ("background");
- staticpro (&Qfont);
- Qfont = intern_c_string ("font");
- staticpro (&Qstipple);
- Qstipple = intern_c_string ("stipple");
- staticpro (&Qunderline);
- Qunderline = intern_c_string ("underline");
- staticpro (&Qread_only);
- Qread_only = intern_c_string ("read-only");
- staticpro (&Qinvisible);
- Qinvisible = intern_c_string ("invisible");
- staticpro (&Qintangible);
- Qintangible = intern_c_string ("intangible");
- staticpro (&Qcategory);
- Qcategory = intern_c_string ("category");
- staticpro (&Qlocal_map);
- Qlocal_map = intern_c_string ("local-map");
- staticpro (&Qfront_sticky);
- Qfront_sticky = intern_c_string ("front-sticky");
- staticpro (&Qrear_nonsticky);
- Qrear_nonsticky = intern_c_string ("rear-nonsticky");
- staticpro (&Qmouse_face);
- Qmouse_face = intern_c_string ("mouse-face");
- staticpro (&Qminibuffer_prompt);
- Qminibuffer_prompt = intern_c_string ("minibuffer-prompt");
+ DEFSYM (Qforeground, "foreground");
+ DEFSYM (Qbackground, "background");
+ DEFSYM (Qfont, "font");
+ DEFSYM (Qstipple, "stipple");
+ DEFSYM (Qunderline, "underline");
+ DEFSYM (Qread_only, "read-only");
+ DEFSYM (Qinvisible, "invisible");
+ DEFSYM (Qintangible, "intangible");
+ DEFSYM (Qcategory, "category");
+ DEFSYM (Qlocal_map, "local-map");
+ DEFSYM (Qfront_sticky, "front-sticky");
+ DEFSYM (Qrear_nonsticky, "rear-nonsticky");
+ DEFSYM (Qmouse_face, "mouse-face");
+ DEFSYM (Qminibuffer_prompt, "minibuffer-prompt");
/* Properties that text might use to specify certain actions */
- staticpro (&Qmouse_left);
- Qmouse_left = intern_c_string ("mouse-left");
- staticpro (&Qmouse_entered);
- Qmouse_entered = intern_c_string ("mouse-entered");
- staticpro (&Qpoint_left);
- Qpoint_left = intern_c_string ("point-left");
- staticpro (&Qpoint_entered);
- Qpoint_entered = intern_c_string ("point-entered");
+ DEFSYM (Qmouse_left, "mouse-left");
+ DEFSYM (Qmouse_entered, "mouse-entered");
+ DEFSYM (Qpoint_left, "point-left");
+ DEFSYM (Qpoint_entered, "point-entered");
defsubr (&Stext_properties_at);
defsubr (&Sget_text_property);
defsubr (&Sremove_list_of_text_properties);
defsubr (&Stext_property_any);
defsubr (&Stext_property_not_all);
-/* defsubr (&Serase_text_properties); */
-/* defsubr (&Scopy_text_properties); */
}
HCoop / bpt / emacs.git / blobdiff