1 /* Interface code for dealing with text properties.
2 Copyright (C) 1993, 1994, 1995, 1997 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
23 #include "intervals.h"
28 #define NULL (void *)0
31 /* Test for membership, allowing for t (actually any non-cons) to mean the
34 #define TMEM(sym, set) (CONSP (set) ? ! NILP (Fmemq (sym, set)) : ! NILP (set))
37 /* NOTES: previous- and next- property change will have to skip
38 zero-length intervals if they are implemented. This could be done
39 inside next_interval and previous_interval.
41 set_properties needs to deal with the interval property cache.
43 It is assumed that for any interval plist, a property appears
44 only once on the list. Although some code i.e., remove_properties,
45 handles the more general case, the uniqueness of properties is
46 necessary for the system to remain consistent. This requirement
47 is enforced by the subrs installing properties onto the intervals. */
49 /* The rest of the file is within this conditional */
50 #ifdef USE_TEXT_PROPERTIES
53 Lisp_Object Qmouse_left
;
54 Lisp_Object Qmouse_entered
;
55 Lisp_Object Qpoint_left
;
56 Lisp_Object Qpoint_entered
;
57 Lisp_Object Qcategory
;
58 Lisp_Object Qlocal_map
;
60 /* Visual properties text (including strings) may have. */
61 Lisp_Object Qforeground
, Qbackground
, Qfont
, Qunderline
, Qstipple
;
62 Lisp_Object Qinvisible
, Qread_only
, Qintangible
;
64 /* Sticky properties */
65 Lisp_Object Qfront_sticky
, Qrear_nonsticky
;
67 /* If o1 is a cons whose cdr is a cons, return non-zero and set o2 to
68 the o1's cdr. Otherwise, return zero. This is handy for
70 #define PLIST_ELT_P(o1, o2) (CONSP (o1) && ((o2)=XCONS (o1)->cdr, CONSP (o2)))
72 Lisp_Object Vinhibit_point_motion_hooks
;
73 Lisp_Object Vdefault_text_properties
;
75 /* verify_interval_modification saves insertion hooks here
76 to be run later by report_interval_modification. */
77 Lisp_Object interval_insert_behind_hooks
;
78 Lisp_Object interval_insert_in_front_hooks
;
80 /* Extract the interval at the position pointed to by BEGIN from
81 OBJECT, a string or buffer. Additionally, check that the positions
82 pointed to by BEGIN and END are within the bounds of OBJECT, and
83 reverse them if *BEGIN is greater than *END. The objects pointed
84 to by BEGIN and END may be integers or markers; if the latter, they
85 are coerced to integers.
87 When OBJECT is a string, we increment *BEGIN and *END
88 to make them origin-one.
90 Note that buffer points don't correspond to interval indices.
91 For example, point-max is 1 greater than the index of the last
92 character. This difference is handled in the caller, which uses
93 the validated points to determine a length, and operates on that.
94 Exceptions are Ftext_properties_at, Fnext_property_change, and
95 Fprevious_property_change which call this function with BEGIN == END.
96 Handle this case specially.
98 If FORCE is soft (0), it's OK to return NULL_INTERVAL. Otherwise,
99 create an interval tree for OBJECT if one doesn't exist, provided
100 the object actually contains text. In the current design, if there
101 is no text, there can be no text properties. */
107 validate_interval_range (object
, begin
, end
, force
)
108 Lisp_Object object
, *begin
, *end
;
114 CHECK_STRING_OR_BUFFER (object
, 0);
115 CHECK_NUMBER_COERCE_MARKER (*begin
, 0);
116 CHECK_NUMBER_COERCE_MARKER (*end
, 0);
118 /* If we are asked for a point, but from a subr which operates
119 on a range, then return nothing. */
120 if (EQ (*begin
, *end
) && begin
!= end
)
121 return NULL_INTERVAL
;
123 if (XINT (*begin
) > XINT (*end
))
131 if (BUFFERP (object
))
133 register struct buffer
*b
= XBUFFER (object
);
135 if (!(BUF_BEGV (b
) <= XINT (*begin
) && XINT (*begin
) <= XINT (*end
)
136 && XINT (*end
) <= BUF_ZV (b
)))
137 args_out_of_range (*begin
, *end
);
138 i
= BUF_INTERVALS (b
);
140 /* If there's no text, there are no properties. */
141 if (BUF_BEGV (b
) == BUF_ZV (b
))
142 return NULL_INTERVAL
;
144 searchpos
= XINT (*begin
);
148 register struct Lisp_String
*s
= XSTRING (object
);
150 if (! (0 <= XINT (*begin
) && XINT (*begin
) <= XINT (*end
)
151 && XINT (*end
) <= s
->size
))
152 args_out_of_range (*begin
, *end
);
153 /* User-level Positions in strings start with 0,
154 but the interval code always wants positions starting with 1. */
155 XSETFASTINT (*begin
, XFASTINT (*begin
) + 1);
157 XSETFASTINT (*end
, XFASTINT (*end
) + 1);
161 return NULL_INTERVAL
;
163 searchpos
= XINT (*begin
);
166 if (NULL_INTERVAL_P (i
))
167 return (force
? create_root_interval (object
) : i
);
169 return find_interval (i
, searchpos
);
172 /* Validate LIST as a property list. If LIST is not a list, then
173 make one consisting of (LIST nil). Otherwise, verify that LIST
174 is even numbered and thus suitable as a plist. */
177 validate_plist (list
)
186 register Lisp_Object tail
;
187 for (i
= 0, tail
= list
; !NILP (tail
); i
++)
193 error ("Odd length text property list");
197 return Fcons (list
, Fcons (Qnil
, Qnil
));
200 /* Return nonzero if interval I has all the properties,
201 with the same values, of list PLIST. */
204 interval_has_all_properties (plist
, i
)
208 register Lisp_Object tail1
, tail2
, sym1
, sym2
;
211 /* Go through each element of PLIST. */
212 for (tail1
= plist
; ! NILP (tail1
); tail1
= Fcdr (Fcdr (tail1
)))
217 /* Go through I's plist, looking for sym1 */
218 for (tail2
= i
->plist
; ! NILP (tail2
); tail2
= Fcdr (Fcdr (tail2
)))
219 if (EQ (sym1
, Fcar (tail2
)))
221 /* Found the same property on both lists. If the
222 values are unequal, return zero. */
223 if (! EQ (Fcar (Fcdr (tail1
)), Fcar (Fcdr (tail2
))))
226 /* Property has same value on both lists; go to next one. */
238 /* Return nonzero if the plist of interval I has any of the
239 properties of PLIST, regardless of their values. */
242 interval_has_some_properties (plist
, i
)
246 register Lisp_Object tail1
, tail2
, sym
;
248 /* Go through each element of PLIST. */
249 for (tail1
= plist
; ! NILP (tail1
); tail1
= Fcdr (Fcdr (tail1
)))
253 /* Go through i's plist, looking for tail1 */
254 for (tail2
= i
->plist
; ! NILP (tail2
); tail2
= Fcdr (Fcdr (tail2
)))
255 if (EQ (sym
, Fcar (tail2
)))
262 /* Changing the plists of individual intervals. */
264 /* Return the value of PROP in property-list PLIST, or Qunbound if it
267 property_value (plist
, prop
)
268 Lisp_Object plist
, prop
;
272 while (PLIST_ELT_P (plist
, value
))
273 if (EQ (XCONS (plist
)->car
, prop
))
274 return XCONS (value
)->car
;
276 plist
= XCONS (value
)->cdr
;
281 /* Set the properties of INTERVAL to PROPERTIES,
282 and record undo info for the previous values.
283 OBJECT is the string or buffer that INTERVAL belongs to. */
286 set_properties (properties
, interval
, object
)
287 Lisp_Object properties
, object
;
290 Lisp_Object sym
, value
;
292 if (BUFFERP (object
))
294 /* For each property in the old plist which is missing from PROPERTIES,
295 or has a different value in PROPERTIES, make an undo record. */
296 for (sym
= interval
->plist
;
297 PLIST_ELT_P (sym
, value
);
298 sym
= XCONS (value
)->cdr
)
299 if (! EQ (property_value (properties
, XCONS (sym
)->car
),
302 record_property_change (interval
->position
, LENGTH (interval
),
303 XCONS (sym
)->car
, XCONS (value
)->car
,
307 /* For each new property that has no value at all in the old plist,
308 make an undo record binding it to nil, so it will be removed. */
309 for (sym
= properties
;
310 PLIST_ELT_P (sym
, value
);
311 sym
= XCONS (value
)->cdr
)
312 if (EQ (property_value (interval
->plist
, XCONS (sym
)->car
), Qunbound
))
314 record_property_change (interval
->position
, LENGTH (interval
),
315 XCONS (sym
)->car
, Qnil
,
320 /* Store new properties. */
321 interval
->plist
= Fcopy_sequence (properties
);
324 /* Add the properties of PLIST to the interval I, or set
325 the value of I's property to the value of the property on PLIST
326 if they are different.
328 OBJECT should be the string or buffer the interval is in.
330 Return nonzero if this changes I (i.e., if any members of PLIST
331 are actually added to I's plist) */
334 add_properties (plist
, i
, object
)
339 Lisp_Object tail1
, tail2
, sym1
, val1
;
340 register int changed
= 0;
342 struct gcpro gcpro1
, gcpro2
, gcpro3
;
347 /* No need to protect OBJECT, because we can GC only in the case
348 where it is a buffer, and live buffers are always protected.
349 I and its plist are also protected, via OBJECT. */
350 GCPRO3 (tail1
, sym1
, val1
);
352 /* Go through each element of PLIST. */
353 for (tail1
= plist
; ! NILP (tail1
); tail1
= Fcdr (Fcdr (tail1
)))
356 val1
= Fcar (Fcdr (tail1
));
359 /* Go through I's plist, looking for sym1 */
360 for (tail2
= i
->plist
; ! NILP (tail2
); tail2
= Fcdr (Fcdr (tail2
)))
361 if (EQ (sym1
, Fcar (tail2
)))
363 /* No need to gcpro, because tail2 protects this
364 and it must be a cons cell (we get an error otherwise). */
365 register Lisp_Object this_cdr
;
367 this_cdr
= Fcdr (tail2
);
368 /* Found the property. Now check its value. */
371 /* The properties have the same value on both lists.
372 Continue to the next property. */
373 if (EQ (val1
, Fcar (this_cdr
)))
376 /* Record this change in the buffer, for undo purposes. */
377 if (BUFFERP (object
))
379 record_property_change (i
->position
, LENGTH (i
),
380 sym1
, Fcar (this_cdr
), object
);
383 /* I's property has a different value -- change it */
384 Fsetcar (this_cdr
, val1
);
391 /* Record this change in the buffer, for undo purposes. */
392 if (BUFFERP (object
))
394 record_property_change (i
->position
, LENGTH (i
),
397 i
->plist
= Fcons (sym1
, Fcons (val1
, i
->plist
));
407 /* For any members of PLIST which are properties of I, remove them
409 OBJECT is the string or buffer containing I. */
412 remove_properties (plist
, i
, object
)
417 register Lisp_Object tail1
, tail2
, sym
, current_plist
;
418 register int changed
= 0;
420 current_plist
= i
->plist
;
421 /* Go through each element of plist. */
422 for (tail1
= plist
; ! NILP (tail1
); tail1
= Fcdr (Fcdr (tail1
)))
426 /* First, remove the symbol if its at the head of the list */
427 while (! NILP (current_plist
) && EQ (sym
, Fcar (current_plist
)))
429 if (BUFFERP (object
))
431 record_property_change (i
->position
, LENGTH (i
),
432 sym
, Fcar (Fcdr (current_plist
)),
436 current_plist
= Fcdr (Fcdr (current_plist
));
440 /* Go through i's plist, looking for sym */
441 tail2
= current_plist
;
442 while (! NILP (tail2
))
444 register Lisp_Object
this;
445 this = Fcdr (Fcdr (tail2
));
446 if (EQ (sym
, Fcar (this)))
448 if (BUFFERP (object
))
450 record_property_change (i
->position
, LENGTH (i
),
451 sym
, Fcar (Fcdr (this)), object
);
454 Fsetcdr (Fcdr (tail2
), Fcdr (Fcdr (this)));
462 i
->plist
= current_plist
;
467 /* Remove all properties from interval I. Return non-zero
468 if this changes the interval. */
482 /* Returns the interval of the POSITION in OBJECT.
483 POSITION is BEG-based. */
486 interval_of (position
, object
)
494 XSETBUFFER (object
, current_buffer
);
495 else if (EQ (object
, Qt
))
496 return NULL_INTERVAL
;
498 CHECK_STRING_OR_BUFFER (object
, 0);
500 if (BUFFERP (object
))
502 register struct buffer
*b
= XBUFFER (object
);
506 i
= BUF_INTERVALS (b
);
510 register struct Lisp_String
*s
= XSTRING (object
);
512 /* We expect position to be 1-based. */
518 if (!(beg
<= position
&& position
<= end
))
519 args_out_of_range (make_number (position
), make_number (position
));
520 if (beg
== end
|| NULL_INTERVAL_P (i
))
521 return NULL_INTERVAL
;
523 return find_interval (i
, position
);
526 DEFUN ("text-properties-at", Ftext_properties_at
,
527 Stext_properties_at
, 1, 2, 0,
528 "Return the list of properties of the character at POSITION in OBJECT.\n\
529 OBJECT is the string or buffer to look for the properties in;\n\
530 nil means the current buffer.\n\
531 If POSITION is at the end of OBJECT, the value is nil.")
533 Lisp_Object position
, object
;
538 XSETBUFFER (object
, current_buffer
);
540 i
= validate_interval_range (object
, &position
, &position
, soft
);
541 if (NULL_INTERVAL_P (i
))
543 /* If POSITION is at the end of the interval,
544 it means it's the end of OBJECT.
545 There are no properties at the very end,
546 since no character follows. */
547 if (XINT (position
) == LENGTH (i
) + i
->position
)
553 DEFUN ("get-text-property", Fget_text_property
, Sget_text_property
, 2, 3, 0,
554 "Return the value of POSITION's property PROP, in OBJECT.\n\
555 OBJECT is optional and defaults to the current buffer.\n\
556 If POSITION is at the end of OBJECT, the value is nil.")
557 (position
, prop
, object
)
558 Lisp_Object position
, object
;
561 return textget (Ftext_properties_at (position
, object
), prop
);
564 DEFUN ("get-char-property", Fget_char_property
, Sget_char_property
, 2, 3, 0,
565 "Return the value of POSITION's property PROP, in OBJECT.\n\
566 OBJECT is optional and defaults to the current buffer.\n\
567 If POSITION is at the end of OBJECT, the value is nil.\n\
568 If OBJECT is a buffer, then overlay properties are considered as well as\n\
570 If OBJECT is a window, then that window's buffer is used, but window-specific\n\
571 overlays are considered only if they are associated with OBJECT.")
572 (position
, prop
, object
)
573 Lisp_Object position
, object
;
574 register Lisp_Object prop
;
576 struct window
*w
= 0;
578 CHECK_NUMBER_COERCE_MARKER (position
, 0);
581 XSETBUFFER (object
, current_buffer
);
583 if (WINDOWP (object
))
585 w
= XWINDOW (object
);
588 if (BUFFERP (object
))
590 int posn
= XINT (position
);
592 Lisp_Object
*overlay_vec
, tem
;
595 struct buffer
*obuf
= current_buffer
;
597 set_buffer_temp (XBUFFER (object
));
599 /* First try with room for 40 overlays. */
601 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
603 noverlays
= overlays_at (posn
, 0, &overlay_vec
, &len
,
604 &next_overlay
, NULL
);
606 /* If there are more than 40,
607 make enough space for all, and try again. */
611 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
612 noverlays
= overlays_at (posn
, 0, &overlay_vec
, &len
,
613 &next_overlay
, NULL
);
615 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
617 set_buffer_temp (obuf
);
619 /* Now check the overlays in order of decreasing priority. */
620 while (--noverlays
>= 0)
622 tem
= Foverlay_get (overlay_vec
[noverlays
], prop
);
627 /* Not a buffer, or no appropriate overlay, so fall through to the
629 return (Fget_text_property (position
, prop
, object
));
632 DEFUN ("next-char-property-change", Fnext_char_property_change
,
633 Snext_char_property_change
, 1, 2, 0,
634 "Return the position of next text property or overlay change.\n\
635 This scans characters forward from POSITION in OBJECT till it finds\n\
636 a change in some text property, or the beginning or end of an overlay,\n\
637 and returns the position of that.\n\
638 If none is found, the function returns (point-max).\n\
640 If the optional third argument LIMIT is non-nil, don't search\n\
641 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
643 Lisp_Object position
, limit
;
647 temp
= Fnext_overlay_change (position
);
650 CHECK_NUMBER (limit
, 2);
651 if (XINT (limit
) < XINT (temp
))
654 return Fnext_property_change (position
, Qnil
, temp
);
657 DEFUN ("previous-char-property-change", Fprevious_char_property_change
,
658 Sprevious_char_property_change
, 1, 2, 0,
659 "Return the position of previous text property or overlay change.\n\
660 Scans characters backward from POSITION in OBJECT till it finds\n\
661 a change in some text property, or the beginning or end of an overlay,\n\
662 and returns the position of that.\n\
663 If none is found, the function returns (point-max).\n\
665 If the optional third argument LIMIT is non-nil, don't search\n\
666 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
668 Lisp_Object position
, limit
;
672 temp
= Fprevious_overlay_change (position
);
675 CHECK_NUMBER (limit
, 2);
676 if (XINT (limit
) > XINT (temp
))
679 return Fprevious_property_change (position
, Qnil
, temp
);
682 DEFUN ("next-property-change", Fnext_property_change
,
683 Snext_property_change
, 1, 3, 0,
684 "Return the position of next property change.\n\
685 Scans characters forward from POSITION in OBJECT till it finds\n\
686 a change in some text property, then returns the position of the change.\n\
687 The optional second argument OBJECT is the string or buffer to scan.\n\
688 Return nil if the property is constant all the way to the end of OBJECT.\n\
689 If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
690 If the optional third argument LIMIT is non-nil, don't search\n\
691 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
692 (position
, object
, limit
)
693 Lisp_Object position
, object
, limit
;
695 register INTERVAL i
, next
;
698 XSETBUFFER (object
, current_buffer
);
700 if (! NILP (limit
) && ! EQ (limit
, Qt
))
701 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
703 i
= validate_interval_range (object
, &position
, &position
, soft
);
705 /* If LIMIT is t, return start of next interval--don't
706 bother checking further intervals. */
709 if (NULL_INTERVAL_P (i
))
712 next
= next_interval (i
);
714 if (NULL_INTERVAL_P (next
))
715 XSETFASTINT (position
, (STRINGP (object
)
716 ? XSTRING (object
)->size
717 : BUF_ZV (XBUFFER (object
))));
719 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
723 if (NULL_INTERVAL_P (i
))
726 next
= next_interval (i
);
728 while (! NULL_INTERVAL_P (next
) && intervals_equal (i
, next
)
729 && (NILP (limit
) || next
->position
< XFASTINT (limit
)))
730 next
= next_interval (next
);
732 if (NULL_INTERVAL_P (next
))
734 if (! NILP (limit
) && !(next
->position
< XFASTINT (limit
)))
737 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
741 /* Return 1 if there's a change in some property between BEG and END. */
744 property_change_between_p (beg
, end
)
747 register INTERVAL i
, next
;
748 Lisp_Object object
, pos
;
750 XSETBUFFER (object
, current_buffer
);
751 XSETFASTINT (pos
, beg
);
753 i
= validate_interval_range (object
, &pos
, &pos
, soft
);
754 if (NULL_INTERVAL_P (i
))
757 next
= next_interval (i
);
758 while (! NULL_INTERVAL_P (next
) && intervals_equal (i
, next
))
760 next
= next_interval (next
);
761 if (NULL_INTERVAL_P (next
))
763 if (next
->position
>= end
)
767 if (NULL_INTERVAL_P (next
))
773 DEFUN ("next-single-property-change", Fnext_single_property_change
,
774 Snext_single_property_change
, 2, 4, 0,
775 "Return the position of next property change for a specific property.\n\
776 Scans characters forward from POSITION till it finds\n\
777 a change in the PROP property, then returns the position of the change.\n\
778 The optional third argument OBJECT is the string or buffer to scan.\n\
779 The property values are compared with `eq'.\n\
780 Return nil if the property is constant all the way to the end of OBJECT.\n\
781 If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
782 If the optional fourth argument LIMIT is non-nil, don't search\n\
783 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
784 (position
, prop
, object
, limit
)
785 Lisp_Object position
, prop
, object
, limit
;
787 register INTERVAL i
, next
;
788 register Lisp_Object here_val
;
791 XSETBUFFER (object
, current_buffer
);
794 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
796 i
= validate_interval_range (object
, &position
, &position
, soft
);
797 if (NULL_INTERVAL_P (i
))
800 here_val
= textget (i
->plist
, prop
);
801 next
= next_interval (i
);
802 while (! NULL_INTERVAL_P (next
)
803 && EQ (here_val
, textget (next
->plist
, prop
))
804 && (NILP (limit
) || next
->position
< XFASTINT (limit
)))
805 next
= next_interval (next
);
807 if (NULL_INTERVAL_P (next
))
809 if (! NILP (limit
) && !(next
->position
< XFASTINT (limit
)))
812 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
816 DEFUN ("previous-property-change", Fprevious_property_change
,
817 Sprevious_property_change
, 1, 3, 0,
818 "Return the position of previous property change.\n\
819 Scans characters backwards from POSITION in OBJECT till it finds\n\
820 a change in some text property, then returns the position of the change.\n\
821 The optional second argument OBJECT is the string or buffer to scan.\n\
822 Return nil if the property is constant all the way to the start of OBJECT.\n\
823 If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
824 If the optional third argument LIMIT is non-nil, don't search\n\
825 back past position LIMIT; return LIMIT if nothing is found until LIMIT.")
826 (position
, object
, limit
)
827 Lisp_Object position
, object
, limit
;
829 register INTERVAL i
, previous
;
832 XSETBUFFER (object
, current_buffer
);
835 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
837 i
= validate_interval_range (object
, &position
, &position
, soft
);
838 if (NULL_INTERVAL_P (i
))
841 /* Start with the interval containing the char before point. */
842 if (i
->position
== XFASTINT (position
))
843 i
= previous_interval (i
);
845 previous
= previous_interval (i
);
846 while (! NULL_INTERVAL_P (previous
) && intervals_equal (previous
, i
)
848 || previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
849 previous
= previous_interval (previous
);
850 if (NULL_INTERVAL_P (previous
))
853 && !(previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
856 XSETFASTINT (position
, (previous
->position
+ LENGTH (previous
)
857 - (STRINGP (object
))));
861 DEFUN ("previous-single-property-change", Fprevious_single_property_change
,
862 Sprevious_single_property_change
, 2, 4, 0,
863 "Return the position of previous property change for a specific property.\n\
864 Scans characters backward from POSITION till it finds\n\
865 a change in the PROP property, then returns the position of the change.\n\
866 The optional third argument OBJECT is the string or buffer to scan.\n\
867 The property values are compared with `eq'.\n\
868 Return nil if the property is constant all the way to the start of OBJECT.\n\
869 If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
870 If the optional fourth argument LIMIT is non-nil, don't search\n\
871 back past position LIMIT; return LIMIT if nothing is found until LIMIT.")
872 (position
, prop
, object
, limit
)
873 Lisp_Object position
, prop
, object
, limit
;
875 register INTERVAL i
, previous
;
876 register Lisp_Object here_val
;
879 XSETBUFFER (object
, current_buffer
);
882 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
884 i
= validate_interval_range (object
, &position
, &position
, soft
);
886 /* Start with the interval containing the char before point. */
887 if (! NULL_INTERVAL_P (i
) && i
->position
== XFASTINT (position
))
888 i
= previous_interval (i
);
890 if (NULL_INTERVAL_P (i
))
893 here_val
= textget (i
->plist
, prop
);
894 previous
= previous_interval (i
);
895 while (! NULL_INTERVAL_P (previous
)
896 && EQ (here_val
, textget (previous
->plist
, prop
))
898 || previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
899 previous
= previous_interval (previous
);
900 if (NULL_INTERVAL_P (previous
))
903 && !(previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
906 XSETFASTINT (position
, (previous
->position
+ LENGTH (previous
)
907 - (STRINGP (object
))));
911 /* Callers note, this can GC when OBJECT is a buffer (or nil). */
913 DEFUN ("add-text-properties", Fadd_text_properties
,
914 Sadd_text_properties
, 3, 4, 0,
915 "Add properties to the text from START to END.\n\
916 The third argument PROPERTIES is a property list\n\
917 specifying the property values to add.\n\
918 The optional fourth argument, OBJECT,\n\
919 is the string or buffer containing the text.\n\
920 Return t if any property value actually changed, nil otherwise.")
921 (start
, end
, properties
, object
)
922 Lisp_Object start
, end
, properties
, object
;
924 register INTERVAL i
, unchanged
;
925 register int s
, len
, modified
= 0;
928 properties
= validate_plist (properties
);
929 if (NILP (properties
))
933 XSETBUFFER (object
, current_buffer
);
935 i
= validate_interval_range (object
, &start
, &end
, hard
);
936 if (NULL_INTERVAL_P (i
))
940 len
= XINT (end
) - s
;
942 /* No need to protect OBJECT, because we GC only if it's a buffer,
943 and live buffers are always protected. */
946 /* If we're not starting on an interval boundary, we have to
947 split this interval. */
948 if (i
->position
!= s
)
950 /* If this interval already has the properties, we can
952 if (interval_has_all_properties (properties
, i
))
954 int got
= (LENGTH (i
) - (s
- i
->position
));
956 RETURN_UNGCPRO (Qnil
);
958 i
= next_interval (i
);
963 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
964 copy_properties (unchanged
, i
);
968 if (BUFFERP (object
))
969 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
971 /* We are at the beginning of interval I, with LEN chars to scan. */
977 if (LENGTH (i
) >= len
)
979 /* We can UNGCPRO safely here, because there will be just
980 one more chance to gc, in the next call to add_properties,
981 and after that we will not need PROPERTIES or OBJECT again. */
984 if (interval_has_all_properties (properties
, i
))
986 if (BUFFERP (object
))
987 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
988 XINT (end
) - XINT (start
));
990 return modified
? Qt
: Qnil
;
993 if (LENGTH (i
) == len
)
995 add_properties (properties
, i
, object
);
996 if (BUFFERP (object
))
997 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
998 XINT (end
) - XINT (start
));
1002 /* i doesn't have the properties, and goes past the change limit */
1004 i
= split_interval_left (unchanged
, len
);
1005 copy_properties (unchanged
, i
);
1006 add_properties (properties
, i
, object
);
1007 if (BUFFERP (object
))
1008 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1009 XINT (end
) - XINT (start
));
1014 modified
+= add_properties (properties
, i
, object
);
1015 i
= next_interval (i
);
1019 /* Callers note, this can GC when OBJECT is a buffer (or nil). */
1021 DEFUN ("put-text-property", Fput_text_property
,
1022 Sput_text_property
, 4, 5, 0,
1023 "Set one property of the text from START to END.\n\
1024 The third and fourth arguments PROPERTY and VALUE\n\
1025 specify the property to add.\n\
1026 The optional fifth argument, OBJECT,\n\
1027 is the string or buffer containing the text.")
1028 (start
, end
, property
, value
, object
)
1029 Lisp_Object start
, end
, property
, value
, object
;
1031 Fadd_text_properties (start
, end
,
1032 Fcons (property
, Fcons (value
, Qnil
)),
1037 DEFUN ("set-text-properties", Fset_text_properties
,
1038 Sset_text_properties
, 3, 4, 0,
1039 "Completely replace properties of text from START to END.\n\
1040 The third argument PROPERTIES is the new property list.\n\
1041 The optional fourth argument, OBJECT,\n\
1042 is the string or buffer containing the text.")
1043 (start
, end
, properties
, object
)
1044 Lisp_Object start
, end
, properties
, object
;
1046 register INTERVAL i
, unchanged
;
1047 register INTERVAL prev_changed
= NULL_INTERVAL
;
1048 register int s
, len
;
1049 Lisp_Object ostart
, oend
;
1050 int have_modified
= 0;
1055 properties
= validate_plist (properties
);
1058 XSETBUFFER (object
, current_buffer
);
1060 /* If we want no properties for a whole string,
1061 get rid of its intervals. */
1062 if (NILP (properties
) && STRINGP (object
)
1063 && XFASTINT (start
) == 0
1064 && XFASTINT (end
) == XSTRING (object
)->size
)
1066 if (! XSTRING (object
)->intervals
)
1069 XSTRING (object
)->intervals
= 0;
1073 i
= validate_interval_range (object
, &start
, &end
, soft
);
1075 if (NULL_INTERVAL_P (i
))
1077 /* If buffer has no properties, and we want none, return now. */
1078 if (NILP (properties
))
1081 /* Restore the original START and END values
1082 because validate_interval_range increments them for strings. */
1086 i
= validate_interval_range (object
, &start
, &end
, hard
);
1087 /* This can return if start == end. */
1088 if (NULL_INTERVAL_P (i
))
1093 len
= XINT (end
) - s
;
1095 if (BUFFERP (object
))
1096 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
1098 if (i
->position
!= s
)
1101 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1103 if (LENGTH (i
) > len
)
1105 copy_properties (unchanged
, i
);
1106 i
= split_interval_left (i
, len
);
1107 set_properties (properties
, i
, object
);
1108 if (BUFFERP (object
))
1109 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1110 XINT (end
) - XINT (start
));
1115 set_properties (properties
, i
, object
);
1117 if (LENGTH (i
) == len
)
1119 if (BUFFERP (object
))
1120 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1121 XINT (end
) - XINT (start
));
1128 i
= next_interval (i
);
1131 /* We are starting at the beginning of an interval, I */
1137 if (LENGTH (i
) >= len
)
1139 if (LENGTH (i
) > len
)
1140 i
= split_interval_left (i
, len
);
1142 /* We have to call set_properties even if we are going to
1143 merge the intervals, so as to make the undo records
1144 and cause redisplay to happen. */
1145 set_properties (properties
, i
, object
);
1146 if (!NULL_INTERVAL_P (prev_changed
))
1147 merge_interval_left (i
);
1148 if (BUFFERP (object
))
1149 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1150 XINT (end
) - XINT (start
));
1156 /* We have to call set_properties even if we are going to
1157 merge the intervals, so as to make the undo records
1158 and cause redisplay to happen. */
1159 set_properties (properties
, i
, object
);
1160 if (NULL_INTERVAL_P (prev_changed
))
1163 prev_changed
= i
= merge_interval_left (i
);
1165 i
= next_interval (i
);
1168 if (BUFFERP (object
))
1169 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1170 XINT (end
) - XINT (start
));
1174 DEFUN ("remove-text-properties", Fremove_text_properties
,
1175 Sremove_text_properties
, 3, 4, 0,
1176 "Remove some properties from text from START to END.\n\
1177 The third argument PROPERTIES is a property list\n\
1178 whose property names specify the properties to remove.\n\
1179 \(The values stored in PROPERTIES are ignored.)\n\
1180 The optional fourth argument, OBJECT,\n\
1181 is the string or buffer containing the text.\n\
1182 Return t if any property was actually removed, nil otherwise.")
1183 (start
, end
, properties
, object
)
1184 Lisp_Object start
, end
, properties
, object
;
1186 register INTERVAL i
, unchanged
;
1187 register int s
, len
, modified
= 0;
1190 XSETBUFFER (object
, current_buffer
);
1192 i
= validate_interval_range (object
, &start
, &end
, soft
);
1193 if (NULL_INTERVAL_P (i
))
1197 len
= XINT (end
) - s
;
1199 if (i
->position
!= s
)
1201 /* No properties on this first interval -- return if
1202 it covers the entire region. */
1203 if (! interval_has_some_properties (properties
, i
))
1205 int got
= (LENGTH (i
) - (s
- i
->position
));
1209 i
= next_interval (i
);
1211 /* Split away the beginning of this interval; what we don't
1216 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1217 copy_properties (unchanged
, i
);
1221 if (BUFFERP (object
))
1222 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
1224 /* We are at the beginning of an interval, with len to scan */
1230 if (LENGTH (i
) >= len
)
1232 if (! interval_has_some_properties (properties
, i
))
1233 return modified
? Qt
: Qnil
;
1235 if (LENGTH (i
) == len
)
1237 remove_properties (properties
, i
, object
);
1238 if (BUFFERP (object
))
1239 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1240 XINT (end
) - XINT (start
));
1244 /* i has the properties, and goes past the change limit */
1246 i
= split_interval_left (i
, len
);
1247 copy_properties (unchanged
, i
);
1248 remove_properties (properties
, i
, object
);
1249 if (BUFFERP (object
))
1250 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1251 XINT (end
) - XINT (start
));
1256 modified
+= remove_properties (properties
, i
, object
);
1257 i
= next_interval (i
);
1261 DEFUN ("text-property-any", Ftext_property_any
,
1262 Stext_property_any
, 4, 5, 0,
1263 "Check text from START to END for property PROPERTY equalling VALUE.\n\
1264 If so, return the position of the first character whose property PROPERTY\n\
1265 is `eq' to VALUE. Otherwise return nil.\n\
1266 The optional fifth argument, OBJECT, is the string or buffer\n\
1267 containing the text.")
1268 (start
, end
, property
, value
, object
)
1269 Lisp_Object start
, end
, property
, value
, object
;
1271 register INTERVAL i
;
1272 register int e
, pos
;
1275 XSETBUFFER (object
, current_buffer
);
1276 i
= validate_interval_range (object
, &start
, &end
, soft
);
1277 if (NULL_INTERVAL_P (i
))
1278 return (!NILP (value
) || EQ (start
, end
) ? Qnil
: start
);
1281 while (! NULL_INTERVAL_P (i
))
1283 if (i
->position
>= e
)
1285 if (EQ (textget (i
->plist
, property
), value
))
1288 if (pos
< XINT (start
))
1290 return make_number (pos
- (STRINGP (object
)));
1292 i
= next_interval (i
);
1297 DEFUN ("text-property-not-all", Ftext_property_not_all
,
1298 Stext_property_not_all
, 4, 5, 0,
1299 "Check text from START to END for property PROPERTY not equalling VALUE.\n\
1300 If so, return the position of the first character whose property PROPERTY\n\
1301 is not `eq' to VALUE. Otherwise, return nil.\n\
1302 The optional fifth argument, OBJECT, is the string or buffer\n\
1303 containing the text.")
1304 (start
, end
, property
, value
, object
)
1305 Lisp_Object start
, end
, property
, value
, object
;
1307 register INTERVAL i
;
1311 XSETBUFFER (object
, current_buffer
);
1312 i
= validate_interval_range (object
, &start
, &end
, soft
);
1313 if (NULL_INTERVAL_P (i
))
1314 return (NILP (value
) || EQ (start
, end
)) ? Qnil
: start
;
1318 while (! NULL_INTERVAL_P (i
))
1320 if (i
->position
>= e
)
1322 if (! EQ (textget (i
->plist
, property
), value
))
1324 if (i
->position
> s
)
1326 return make_number (s
- (STRINGP (object
)));
1328 i
= next_interval (i
);
1333 #if 0 /* You can use set-text-properties for this. */
1335 DEFUN ("erase-text-properties", Ferase_text_properties
,
1336 Serase_text_properties
, 2, 3, 0,
1337 "Remove all properties from the text from START to END.\n\
1338 The optional third argument, OBJECT,\n\
1339 is the string or buffer containing the text.")
1340 (start
, end
, object
)
1341 Lisp_Object start
, end
, object
;
1343 register INTERVAL i
;
1344 register INTERVAL prev_changed
= NULL_INTERVAL
;
1345 register int s
, len
, modified
;
1348 XSETBUFFER (object
, current_buffer
);
1350 i
= validate_interval_range (object
, &start
, &end
, soft
);
1351 if (NULL_INTERVAL_P (i
))
1355 len
= XINT (end
) - s
;
1357 if (i
->position
!= s
)
1360 register INTERVAL unchanged
= i
;
1362 /* If there are properties here, then this text will be modified. */
1363 if (! NILP (i
->plist
))
1365 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1369 if (LENGTH (i
) > len
)
1371 i
= split_interval_right (i
, len
);
1372 copy_properties (unchanged
, i
);
1376 if (LENGTH (i
) == len
)
1381 /* If the text of I is without any properties, and contains
1382 LEN or more characters, then we may return without changing
1384 else if (LENGTH (i
) - (s
- i
->position
) <= len
)
1386 /* The amount of text to change extends past I, so just note
1387 how much we've gotten. */
1389 got
= LENGTH (i
) - (s
- i
->position
);
1393 i
= next_interval (i
);
1396 /* We are starting at the beginning of an interval, I. */
1399 if (LENGTH (i
) >= len
)
1401 /* If I has no properties, simply merge it if possible. */
1402 if (NILP (i
->plist
))
1404 if (! NULL_INTERVAL_P (prev_changed
))
1405 merge_interval_left (i
);
1407 return modified
? Qt
: Qnil
;
1410 if (LENGTH (i
) > len
)
1411 i
= split_interval_left (i
, len
);
1412 if (! NULL_INTERVAL_P (prev_changed
))
1413 merge_interval_left (i
);
1420 /* Here if we still need to erase past the end of I */
1422 if (NULL_INTERVAL_P (prev_changed
))
1424 modified
+= erase_properties (i
);
1429 modified
+= ! NILP (i
->plist
);
1430 /* Merging I will give it the properties of PREV_CHANGED. */
1431 prev_changed
= i
= merge_interval_left (i
);
1434 i
= next_interval (i
);
1437 return modified
? Qt
: Qnil
;
1441 /* I don't think this is the right interface to export; how often do you
1442 want to do something like this, other than when you're copying objects
1445 I think it would be better to have a pair of functions, one which
1446 returns the text properties of a region as a list of ranges and
1447 plists, and another which applies such a list to another object. */
1449 /* Add properties from SRC to SRC of SRC, starting at POS in DEST.
1450 SRC and DEST may each refer to strings or buffers.
1451 Optional sixth argument PROP causes only that property to be copied.
1452 Properties are copied to DEST as if by `add-text-properties'.
1453 Return t if any property value actually changed, nil otherwise. */
1455 /* Note this can GC when DEST is a buffer. */
1458 copy_text_properties (start
, end
, src
, pos
, dest
, prop
)
1459 Lisp_Object start
, end
, src
, pos
, dest
, prop
;
1465 int s
, e
, e2
, p
, len
, modified
= 0;
1466 struct gcpro gcpro1
, gcpro2
;
1468 i
= validate_interval_range (src
, &start
, &end
, soft
);
1469 if (NULL_INTERVAL_P (i
))
1472 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
1474 Lisp_Object dest_start
, dest_end
;
1477 XSETFASTINT (dest_end
, XINT (dest_start
) + (XINT (end
) - XINT (start
)));
1478 /* Apply this to a copy of pos; it will try to increment its arguments,
1479 which we don't want. */
1480 validate_interval_range (dest
, &dest_start
, &dest_end
, soft
);
1491 e2
= i
->position
+ LENGTH (i
);
1498 while (! NILP (plist
))
1500 if (EQ (Fcar (plist
), prop
))
1502 plist
= Fcons (prop
, Fcons (Fcar (Fcdr (plist
)), Qnil
));
1505 plist
= Fcdr (Fcdr (plist
));
1509 /* Must defer modifications to the interval tree in case src
1510 and dest refer to the same string or buffer. */
1511 stuff
= Fcons (Fcons (make_number (p
),
1512 Fcons (make_number (p
+ len
),
1513 Fcons (plist
, Qnil
))),
1517 i
= next_interval (i
);
1518 if (NULL_INTERVAL_P (i
))
1525 GCPRO2 (stuff
, dest
);
1527 while (! NILP (stuff
))
1530 res
= Fadd_text_properties (Fcar (res
), Fcar (Fcdr (res
)),
1531 Fcar (Fcdr (Fcdr (res
))), dest
);
1534 stuff
= Fcdr (stuff
);
1539 return modified
? Qt
: Qnil
;
1542 /* Call the modification hook functions in LIST, each with START and END. */
1545 call_mod_hooks (list
, start
, end
)
1546 Lisp_Object list
, start
, end
;
1548 struct gcpro gcpro1
;
1550 while (!NILP (list
))
1552 call2 (Fcar (list
), start
, end
);
1558 /* Check for read-only intervals between character positions START ... END,
1559 in BUF, and signal an error if we find one.
1561 Then check for any modification hooks in the range.
1562 Create a list of all these hooks in lexicographic order,
1563 eliminating consecutive extra copies of the same hook. Then call
1564 those hooks in order, with START and END - 1 as arguments. */
1567 verify_interval_modification (buf
, start
, end
)
1571 register INTERVAL intervals
= BUF_INTERVALS (buf
);
1572 register INTERVAL i
, prev
;
1574 register Lisp_Object prev_mod_hooks
;
1575 Lisp_Object mod_hooks
;
1576 struct gcpro gcpro1
;
1579 prev_mod_hooks
= Qnil
;
1582 interval_insert_behind_hooks
= Qnil
;
1583 interval_insert_in_front_hooks
= Qnil
;
1585 if (NULL_INTERVAL_P (intervals
))
1595 /* For an insert operation, check the two chars around the position. */
1599 Lisp_Object before
, after
;
1601 /* Set I to the interval containing the char after START,
1602 and PREV to the interval containing the char before START.
1603 Either one may be null. They may be equal. */
1604 i
= find_interval (intervals
, start
);
1606 if (start
== BUF_BEGV (buf
))
1608 else if (i
->position
== start
)
1609 prev
= previous_interval (i
);
1610 else if (i
->position
< start
)
1612 if (start
== BUF_ZV (buf
))
1615 /* If Vinhibit_read_only is set and is not a list, we can
1616 skip the read_only checks. */
1617 if (NILP (Vinhibit_read_only
) || CONSP (Vinhibit_read_only
))
1619 /* If I and PREV differ we need to check for the read-only
1620 property together with its stickiness. If either I or
1621 PREV are 0, this check is all we need.
1622 We have to take special care, since read-only may be
1623 indirectly defined via the category property. */
1626 if (! NULL_INTERVAL_P (i
))
1628 after
= textget (i
->plist
, Qread_only
);
1630 /* If interval I is read-only and read-only is
1631 front-sticky, inhibit insertion.
1632 Check for read-only as well as category. */
1634 && NILP (Fmemq (after
, Vinhibit_read_only
)))
1638 tem
= textget (i
->plist
, Qfront_sticky
);
1639 if (TMEM (Qread_only
, tem
)
1640 || (NILP (Fplist_get (i
->plist
, Qread_only
))
1641 && TMEM (Qcategory
, tem
)))
1642 error ("Attempt to insert within read-only text");
1646 if (! NULL_INTERVAL_P (prev
))
1648 before
= textget (prev
->plist
, Qread_only
);
1650 /* If interval PREV is read-only and read-only isn't
1651 rear-nonsticky, inhibit insertion.
1652 Check for read-only as well as category. */
1654 && NILP (Fmemq (before
, Vinhibit_read_only
)))
1658 tem
= textget (prev
->plist
, Qrear_nonsticky
);
1659 if (! TMEM (Qread_only
, tem
)
1660 && (! NILP (Fplist_get (prev
->plist
,Qread_only
))
1661 || ! TMEM (Qcategory
, tem
)))
1662 error ("Attempt to insert within read-only text");
1666 else if (! NULL_INTERVAL_P (i
))
1668 after
= textget (i
->plist
, Qread_only
);
1670 /* If interval I is read-only and read-only is
1671 front-sticky, inhibit insertion.
1672 Check for read-only as well as category. */
1673 if (! NILP (after
) && NILP (Fmemq (after
, Vinhibit_read_only
)))
1677 tem
= textget (i
->plist
, Qfront_sticky
);
1678 if (TMEM (Qread_only
, tem
)
1679 || (NILP (Fplist_get (i
->plist
, Qread_only
))
1680 && TMEM (Qcategory
, tem
)))
1681 error ("Attempt to insert within read-only text");
1683 tem
= textget (prev
->plist
, Qrear_nonsticky
);
1684 if (! TMEM (Qread_only
, tem
)
1685 && (! NILP (Fplist_get (prev
->plist
, Qread_only
))
1686 || ! TMEM (Qcategory
, tem
)))
1687 error ("Attempt to insert within read-only text");
1692 /* Run both insert hooks (just once if they're the same). */
1693 if (!NULL_INTERVAL_P (prev
))
1694 interval_insert_behind_hooks
1695 = textget (prev
->plist
, Qinsert_behind_hooks
);
1696 if (!NULL_INTERVAL_P (i
))
1697 interval_insert_in_front_hooks
1698 = textget (i
->plist
, Qinsert_in_front_hooks
);
1702 /* Loop over intervals on or next to START...END,
1703 collecting their hooks. */
1705 i
= find_interval (intervals
, start
);
1708 if (! INTERVAL_WRITABLE_P (i
))
1709 error ("Attempt to modify read-only text");
1711 mod_hooks
= textget (i
->plist
, Qmodification_hooks
);
1712 if (! NILP (mod_hooks
) && ! EQ (mod_hooks
, prev_mod_hooks
))
1714 hooks
= Fcons (mod_hooks
, hooks
);
1715 prev_mod_hooks
= mod_hooks
;
1718 i
= next_interval (i
);
1720 /* Keep going thru the interval containing the char before END. */
1721 while (! NULL_INTERVAL_P (i
) && i
->position
< end
);
1724 hooks
= Fnreverse (hooks
);
1725 while (! EQ (hooks
, Qnil
))
1727 call_mod_hooks (Fcar (hooks
), make_number (start
),
1729 hooks
= Fcdr (hooks
);
1735 /* Run the interval hooks for an insertion on character range START ... END.
1736 verify_interval_modification chose which hooks to run;
1737 this function is called after the insertion happens
1738 so it can indicate the range of inserted text. */
1741 report_interval_modification (start
, end
)
1742 Lisp_Object start
, end
;
1744 if (! NILP (interval_insert_behind_hooks
))
1745 call_mod_hooks (interval_insert_behind_hooks
, start
, end
);
1746 if (! NILP (interval_insert_in_front_hooks
)
1747 && ! EQ (interval_insert_in_front_hooks
,
1748 interval_insert_behind_hooks
))
1749 call_mod_hooks (interval_insert_in_front_hooks
, start
, end
);
1755 DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties
,
1756 "Property-list used as default values.\n\
1757 The value of a property in this list is seen as the value for every\n\
1758 character that does not have its own value for that property.");
1759 Vdefault_text_properties
= Qnil
;
1761 DEFVAR_LISP ("inhibit-point-motion-hooks", &Vinhibit_point_motion_hooks
,
1762 "If non-nil, don't run `point-left' and `point-entered' text properties.\n\
1763 This also inhibits the use of the `intangible' text property.");
1764 Vinhibit_point_motion_hooks
= Qnil
;
1766 staticpro (&interval_insert_behind_hooks
);
1767 staticpro (&interval_insert_in_front_hooks
);
1768 interval_insert_behind_hooks
= Qnil
;
1769 interval_insert_in_front_hooks
= Qnil
;
1772 /* Common attributes one might give text */
1774 staticpro (&Qforeground
);
1775 Qforeground
= intern ("foreground");
1776 staticpro (&Qbackground
);
1777 Qbackground
= intern ("background");
1779 Qfont
= intern ("font");
1780 staticpro (&Qstipple
);
1781 Qstipple
= intern ("stipple");
1782 staticpro (&Qunderline
);
1783 Qunderline
= intern ("underline");
1784 staticpro (&Qread_only
);
1785 Qread_only
= intern ("read-only");
1786 staticpro (&Qinvisible
);
1787 Qinvisible
= intern ("invisible");
1788 staticpro (&Qintangible
);
1789 Qintangible
= intern ("intangible");
1790 staticpro (&Qcategory
);
1791 Qcategory
= intern ("category");
1792 staticpro (&Qlocal_map
);
1793 Qlocal_map
= intern ("local-map");
1794 staticpro (&Qfront_sticky
);
1795 Qfront_sticky
= intern ("front-sticky");
1796 staticpro (&Qrear_nonsticky
);
1797 Qrear_nonsticky
= intern ("rear-nonsticky");
1799 /* Properties that text might use to specify certain actions */
1801 staticpro (&Qmouse_left
);
1802 Qmouse_left
= intern ("mouse-left");
1803 staticpro (&Qmouse_entered
);
1804 Qmouse_entered
= intern ("mouse-entered");
1805 staticpro (&Qpoint_left
);
1806 Qpoint_left
= intern ("point-left");
1807 staticpro (&Qpoint_entered
);
1808 Qpoint_entered
= intern ("point-entered");
1810 defsubr (&Stext_properties_at
);
1811 defsubr (&Sget_text_property
);
1812 defsubr (&Sget_char_property
);
1813 defsubr (&Snext_char_property_change
);
1814 defsubr (&Sprevious_char_property_change
);
1815 defsubr (&Snext_property_change
);
1816 defsubr (&Snext_single_property_change
);
1817 defsubr (&Sprevious_property_change
);
1818 defsubr (&Sprevious_single_property_change
);
1819 defsubr (&Sadd_text_properties
);
1820 defsubr (&Sput_text_property
);
1821 defsubr (&Sset_text_properties
);
1822 defsubr (&Sremove_text_properties
);
1823 defsubr (&Stext_property_any
);
1824 defsubr (&Stext_property_not_all
);
1825 /* defsubr (&Serase_text_properties); */
1826 /* defsubr (&Scopy_text_properties); */
1831 lose
-- this shouldn
't be compiled if USE_TEXT_PROPERTIES isn't defined
1833 #endif /* USE_TEXT_PROPERTIES */