Lisp_Object interval_insert_behind_hooks;
Lisp_Object interval_insert_in_front_hooks;
-static void text_read_only P_ ((Lisp_Object)) NO_RETURN;
+static void text_read_only (Lisp_Object) NO_RETURN;
/* 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 (propval)
- Lisp_Object propval;
+text_read_only (Lisp_Object propval)
{
if (STRINGP (propval))
xsignal1 (Qtext_read_only, propval);
#define hard 1
INTERVAL
-validate_interval_range (object, begin, end, force)
- Lisp_Object object, *begin, *end;
- int force;
+validate_interval_range (Lisp_Object object, Lisp_Object *begin, Lisp_Object *end, int force)
{
register INTERVAL i;
- int searchpos;
+ EMACS_INT searchpos;
CHECK_STRING_OR_BUFFER (object);
CHECK_NUMBER_COERCE_MARKER (*begin);
}
else
{
- int len = SCHARS (object);
+ EMACS_INT len = SCHARS (object);
if (! (0 <= XINT (*begin) && XINT (*begin) <= XINT (*end)
&& XINT (*end) <= len))
is even numbered and thus suitable as a plist. */
static Lisp_Object
-validate_plist (list)
- Lisp_Object list;
+validate_plist (Lisp_Object list)
{
if (NILP (list))
return Qnil;
with the same values, of list PLIST. */
static int
-interval_has_all_properties (plist, i)
- Lisp_Object plist;
- INTERVAL i;
+interval_has_all_properties (Lisp_Object plist, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym1;
register int found;
properties of PLIST, regardless of their values. */
static INLINE int
-interval_has_some_properties (plist, i)
- Lisp_Object plist;
- INTERVAL i;
+interval_has_some_properties (Lisp_Object plist, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
property names in LIST, regardless of their values. */
static INLINE int
-interval_has_some_properties_list (list, i)
- Lisp_Object list;
- INTERVAL i;
+interval_has_some_properties_list (Lisp_Object list, INTERVAL i)
{
register Lisp_Object tail1, tail2, sym;
/* Return the value of PROP in property-list PLIST, or Qunbound if it
has none. */
static Lisp_Object
-property_value (plist, prop)
- Lisp_Object plist, prop;
+property_value (Lisp_Object plist, Lisp_Object prop)
{
Lisp_Object value;
OBJECT is the string or buffer that INTERVAL belongs to. */
static void
-set_properties (properties, interval, object)
- Lisp_Object properties, object;
- INTERVAL interval;
+set_properties (Lisp_Object properties, INTERVAL interval, Lisp_Object object)
{
Lisp_Object sym, value;
are actually added to I's plist) */
static int
-add_properties (plist, i, object)
- Lisp_Object plist;
- INTERVAL i;
- Lisp_Object object;
+add_properties (Lisp_Object plist, INTERVAL i, Lisp_Object object)
{
Lisp_Object tail1, tail2, sym1, val1;
register int changed = 0;
OBJECT is the string or buffer containing I. */
static int
-remove_properties (plist, list, i, object)
- Lisp_Object plist, list;
- INTERVAL i;
- Lisp_Object object;
+remove_properties (Lisp_Object plist, Lisp_Object list, INTERVAL i, Lisp_Object object)
{
register Lisp_Object tail1, tail2, sym, current_plist;
register int changed = 0;
if this changes the interval. */
static INLINE int
-erase_properties (i)
- INTERVAL i;
+erase_properties (INTERVAL i)
{
if (NILP (i->plist))
return 0;
POSITION is BEG-based. */
INTERVAL
-interval_of (position, object)
- int position;
- Lisp_Object object;
+interval_of (int position, Lisp_Object object)
{
register INTERVAL i;
- int beg, end;
+ EMACS_INT beg, end;
if (NILP (object))
XSETBUFFER (object, current_buffer);
the current buffer), POSITION is a buffer position (integer or marker).
If OBJECT is a string, POSITION is a 0-based index into it.
If POSITION is at the end of OBJECT, the value is nil. */)
- (position, object)
- Lisp_Object position, object;
+ (Lisp_Object position, Lisp_Object object)
{
register INTERVAL i;
doc: /* Return the value of POSITION's property PROP, in OBJECT.
OBJECT is optional and defaults to the current buffer.
If POSITION is at the end of OBJECT, the value is nil. */)
- (position, prop, object)
- Lisp_Object position, object;
- Lisp_Object prop;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object)
{
return textget (Ftext_properties_at (position, object), prop);
}
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;
+get_char_property_and_overlay (Lisp_Object position, register Lisp_Object prop, Lisp_Object object, Lisp_Object *overlay)
{
struct window *w = 0;
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. */)
- (position, prop, object)
- Lisp_Object position, object;
- register Lisp_Object prop;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object)
{
return get_char_property_and_overlay (position, prop, object, 0);
}
a window, then that window's buffer is used, but window-specific
overlays are considered only if they are associated with OBJECT. If
POSITION is at the end of OBJECT, both car and cdr are nil. */)
- (position, prop, object)
- Lisp_Object position, object;
- register Lisp_Object prop;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object)
{
Lisp_Object overlay;
Lisp_Object val
If the optional second argument LIMIT is non-nil, don't search
past position LIMIT; return LIMIT if nothing is found before LIMIT.
LIMIT is a no-op if it is greater than (point-max). */)
- (position, limit)
- Lisp_Object position, limit;
+ (Lisp_Object position, Lisp_Object limit)
{
Lisp_Object temp;
If the optional second argument LIMIT is non-nil, don't search
past position LIMIT; return LIMIT if nothing is found before LIMIT.
LIMIT is a no-op if it is less than (point-min). */)
- (position, limit)
- Lisp_Object position, limit;
+ (Lisp_Object position, Lisp_Object limit)
{
Lisp_Object temp;
last valid position in OBJECT.
If the optional fourth argument LIMIT is non-nil, don't search
past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
- (position, prop, object, limit)
- Lisp_Object prop, position, object, limit;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
{
if (STRINGP (object))
{
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. */)
- (position, prop, object, limit)
- Lisp_Object prop, position, object, limit;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
{
if (STRINGP (object))
{
If the optional third argument LIMIT is non-nil, don't search
past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
- (position, object, limit)
- Lisp_Object position, object, limit;
+ (Lisp_Object position, Lisp_Object object, Lisp_Object limit)
{
register INTERVAL i, next;
/* Return 1 if there's a change in some property between BEG and END. */
int
-property_change_between_p (beg, end)
- int beg, end;
+property_change_between_p (EMACS_INT beg, EMACS_INT end)
{
register INTERVAL i, next;
Lisp_Object object, pos;
If the optional fourth argument LIMIT is non-nil, don't search
past position LIMIT; return LIMIT if nothing is found before LIMIT. */)
- (position, prop, object, limit)
- Lisp_Object position, prop, object, limit;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
{
register INTERVAL i, next;
register Lisp_Object here_val;
If the optional third argument LIMIT is non-nil, don't search
back past position LIMIT; return LIMIT if nothing is found until LIMIT. */)
- (position, object, limit)
- Lisp_Object position, object, limit;
+ (Lisp_Object position, Lisp_Object object, Lisp_Object limit)
{
register INTERVAL i, previous;
If the optional fourth argument LIMIT is non-nil, don't search
back past position LIMIT; return LIMIT if nothing is found until LIMIT. */)
- (position, prop, object, limit)
- Lisp_Object position, prop, object, limit;
+ (Lisp_Object position, Lisp_Object prop, Lisp_Object object, Lisp_Object limit)
{
register INTERVAL i, previous;
register Lisp_Object here_val;
START and END are buffer positions (integers or markers).
If OBJECT is a string, START and END are 0-based indices into it.
Return t if any property value actually changed, nil otherwise. */)
- (start, end, properties, object)
- Lisp_Object start, end, properties, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register int s, len, modified = 0;
+ register EMACS_INT s, len;
+ register int modified = 0;
struct gcpro gcpro1;
properties = validate_plist (properties);
skip it. */
if (interval_has_all_properties (properties, i))
{
- int got = (LENGTH (i) - (s - i->position));
+ EMACS_INT got = (LENGTH (i) - (s - i->position));
if (got >= len)
RETURN_UNGCPRO (Qnil);
len -= got;
If the optional fifth argument OBJECT is a buffer (or nil, which means
the current buffer), START and END are buffer positions (integers or
markers). If OBJECT is a string, START and END are 0-based indices into it. */)
- (start, end, property, value, object)
- Lisp_Object start, end, property, value, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
{
Fadd_text_properties (start, end,
Fcons (property, Fcons (value, Qnil)),
markers). If OBJECT is a string, START and END are 0-based indices into it.
If PROPERTIES is nil, the effect is to remove all properties from
the designated part of OBJECT. */)
- (start, end, properties, object)
- Lisp_Object start, end, properties, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
{
return set_text_properties (start, end, properties, object, Qt);
}
otherwise. */
Lisp_Object
-set_text_properties (start, end, properties, object, coherent_change_p)
- Lisp_Object start, end, properties, object, coherent_change_p;
+set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, Lisp_Object coherent_change_p)
{
register INTERVAL i;
Lisp_Object ostart, oend;
START and END can be in any order. */
void
-set_text_properties_1 (start, end, properties, buffer, i)
- Lisp_Object start, end, properties, buffer;
- INTERVAL i;
+set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
{
register INTERVAL prev_changed = NULL_INTERVAL;
- register int s, len;
+ register EMACS_INT s, len;
INTERVAL unchanged;
s = XINT (start);
Return t if any property was actually removed, nil otherwise.
Use `set-text-properties' if you want to remove all text properties. */)
- (start, end, properties, object)
- Lisp_Object start, end, properties, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register int s, len, modified = 0;
+ register EMACS_INT s, len;
+ register int modified = 0;
if (NILP (object))
XSETBUFFER (object, current_buffer);
it covers the entire region. */
if (! interval_has_some_properties (properties, i))
{
- int got = (LENGTH (i) - (s - i->position));
+ EMACS_INT got = (LENGTH (i) - (s - i->position));
if (got >= len)
return Qnil;
len -= got;
the current buffer), START and END are buffer positions (integers or
markers). If OBJECT is a string, START and END are 0-based indices into it.
Return t if any property was actually removed, nil otherwise. */)
- (start, end, list_of_properties, object)
- Lisp_Object start, end, list_of_properties, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object list_of_properties, Lisp_Object object)
{
register INTERVAL i, unchanged;
- register int s, len, modified = 0;
+ register EMACS_INT s, len;
+ register int modified = 0;
Lisp_Object properties;
properties = list_of_properties;
it covers the entire region. */
if (! interval_has_some_properties_list (properties, i))
{
- int got = (LENGTH (i) - (s - i->position));
+ EMACS_INT got = (LENGTH (i) - (s - i->position));
if (got >= len)
return Qnil;
len -= got;
if (LENGTH (i) >= len)
{
if (! interval_has_some_properties_list (properties, i))
- if (modified)
- {
- if (BUFFERP (object))
- signal_after_change (XINT (start), XINT (end) - XINT (start),
- XINT (end) - XINT (start));
- return Qt;
- }
- else
- return Qnil;
-
- if (LENGTH (i) == len)
+ {
+ if (modified)
+ {
+ if (BUFFERP (object))
+ signal_after_change (XINT (start),
+ XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+ return Qt;
+ }
+ else
+ return Qnil;
+ }
+ else if (LENGTH (i) == len)
{
if (!modified && BUFFERP (object))
modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
XINT (end) - XINT (start));
return Qt;
}
-
- /* i has the properties, and goes past the change limit */
- unchanged = i;
- i = split_interval_left (i, len);
- copy_properties (unchanged, i);
- if (!modified && BUFFERP (object))
- modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
- remove_properties (Qnil, properties, i, object);
- if (BUFFERP (object))
- signal_after_change (XINT (start), XINT (end) - XINT (start),
- XINT (end) - XINT (start));
- return Qt;
+ else
+ { /* i has the properties, and goes past the change limit. */
+ unchanged = i;
+ i = split_interval_left (i, len);
+ copy_properties (unchanged, i);
+ if (!modified && BUFFERP (object))
+ modify_region (XBUFFER (object), XINT (start), XINT (end), 1);
+ remove_properties (Qnil, properties, i, object);
+ if (BUFFERP (object))
+ signal_after_change (XINT (start), XINT (end) - XINT (start),
+ XINT (end) - XINT (start));
+ return Qt;
+ }
}
-
if (interval_has_some_properties_list (properties, i))
{
if (!modified && BUFFERP (object))
If the optional fifth argument OBJECT is a buffer (or nil, which means
the current buffer), START and END are buffer positions (integers or
markers). If OBJECT is a string, START and END are 0-based indices into it. */)
- (start, end, property, value, object)
- Lisp_Object start, end, property, value, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
{
register INTERVAL i;
- register int e, pos;
+ register EMACS_INT e, pos;
if (NILP (object))
XSETBUFFER (object, current_buffer);
If the optional fifth argument OBJECT is a buffer (or nil, which means
the current buffer), START and END are buffer positions (integers or
markers). If OBJECT is a string, START and END are 0-based indices into it. */)
- (start, end, property, value, object)
- Lisp_Object start, end, property, value, object;
+ (Lisp_Object start, Lisp_Object end, Lisp_Object property, Lisp_Object value, Lisp_Object object)
{
register INTERVAL i;
- register int s, e;
+ register EMACS_INT s, e;
if (NILP (object))
XSETBUFFER (object, current_buffer);
BUFFER can be either a buffer or nil (meaning current buffer). */
int
-text_property_stickiness (prop, pos, buffer)
- Lisp_Object prop, pos, buffer;
+text_property_stickiness (Lisp_Object prop, Lisp_Object pos, Lisp_Object buffer)
{
Lisp_Object prev_pos, front_sticky;
int is_rear_sticky = 1, is_front_sticky = 0; /* defaults */
/* Note this can GC when DEST is a buffer. */
Lisp_Object
-copy_text_properties (start, end, src, pos, dest, prop)
- Lisp_Object start, end, src, pos, dest, prop;
+copy_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object src, Lisp_Object pos, Lisp_Object dest, Lisp_Object prop)
{
INTERVAL i;
Lisp_Object res;
Lisp_Object stuff;
Lisp_Object plist;
- int s, e, e2, p, len, modified = 0;
+ EMACS_INT s, e, e2, p, len;
+ int modified = 0;
struct gcpro gcpro1, gcpro2;
i = validate_interval_range (src, &start, &end, soft);
doesn't contain text properties between START and END. */
Lisp_Object
-text_property_list (object, start, end, prop)
- Lisp_Object object, start, end, prop;
+text_property_list (Lisp_Object object, Lisp_Object start, Lisp_Object end, Lisp_Object prop)
{
struct interval *i;
Lisp_Object result;
i = validate_interval_range (object, &start, &end, soft);
if (!NULL_INTERVAL_P (i))
{
- int s = XINT (start);
- int e = XINT (end);
+ EMACS_INT s = XINT (start);
+ EMACS_INT e = XINT (end);
while (s < e)
{
- int interval_end, len;
+ EMACS_INT interval_end, len;
Lisp_Object plist;
interval_end = i->position + LENGTH (i);
non-zero if OBJECT was modified. */
int
-add_text_properties_from_list (object, list, delta)
- Lisp_Object object, list, delta;
+add_text_properties_from_list (Lisp_Object object, Lisp_Object list, Lisp_Object delta)
{
struct gcpro gcpro1, gcpro2;
int modified_p = 0;
end-points to NEW_END. */
Lisp_Object
-extend_property_ranges (list, new_end)
- Lisp_Object list, new_end;
+extend_property_ranges (Lisp_Object list, Lisp_Object new_end)
{
Lisp_Object prev = Qnil, head = list;
- int max = XINT (new_end);
+ EMACS_INT max = XINT (new_end);
for (; CONSP (list); prev = list, list = XCDR (list))
{
/* 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;
+call_mod_hooks (Lisp_Object list, Lisp_Object start, Lisp_Object end)
{
struct gcpro gcpro1;
GCPRO1 (list);
those hooks in order, with START and END - 1 as arguments. */
void
-verify_interval_modification (buf, start, end)
- struct buffer *buf;
- int start, end;
+verify_interval_modification (struct buffer *buf, int start, int end)
{
register INTERVAL intervals = BUF_INTERVALS (buf);
register INTERVAL i;
if (start > end)
{
- int temp = start;
+ EMACS_INT temp = start;
start = end;
end = temp;
}
so it can indicate the range of inserted text. */
void
-report_interval_modification (start, end)
- Lisp_Object start, end;
+report_interval_modification (Lisp_Object start, Lisp_Object end)
{
if (! NILP (interval_insert_behind_hooks))
call_mod_hooks (interval_insert_behind_hooks, start, end);
}
\f
void
-syms_of_textprop ()
+syms_of_textprop (void)
{
DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties,
doc: /* Property-list used as default values.