1 /* Interface code for dealing with text properties.
2 Copyright (C) 1993, 1994, 1995 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 DEFUN ("text-properties-at", Ftext_properties_at
,
483 Stext_properties_at
, 1, 2, 0,
484 "Return the list of properties held by the character at POSITION\n\
485 in optional argument OBJECT, a string or buffer. If nil, OBJECT\n\
486 defaults to the current buffer.\n\
487 If POSITION is at the end of OBJECT, the value is nil.")
489 Lisp_Object position
, object
;
494 XSETBUFFER (object
, current_buffer
);
496 i
= validate_interval_range (object
, &position
, &position
, soft
);
497 if (NULL_INTERVAL_P (i
))
499 /* If POSITION is at the end of the interval,
500 it means it's the end of OBJECT.
501 There are no properties at the very end,
502 since no character follows. */
503 if (XINT (position
) == LENGTH (i
) + i
->position
)
509 DEFUN ("get-text-property", Fget_text_property
, Sget_text_property
, 2, 3, 0,
510 "Return the value of POSITION's property PROP, in OBJECT.\n\
511 OBJECT is optional and defaults to the current buffer.\n\
512 If POSITION is at the end of OBJECT, the value is nil.")
513 (position
, prop
, object
)
514 Lisp_Object position
, object
;
517 return textget (Ftext_properties_at (position
, object
), prop
);
520 DEFUN ("get-char-property", Fget_char_property
, Sget_char_property
, 2, 3, 0,
521 "Return the value of POSITION's property PROP, in OBJECT.\n\
522 OBJECT is optional and defaults to the current buffer.\n\
523 If POSITION is at the end of OBJECT, the value is nil.\n\
524 If OBJECT is a buffer, then overlay properties are considered as well as\n\
526 If OBJECT is a window, then that window's buffer is used, but window-specific\n\
527 overlays are considered only if they are associated with OBJECT.")
528 (position
, prop
, object
)
529 Lisp_Object position
, object
;
530 register Lisp_Object prop
;
532 struct window
*w
= 0;
534 CHECK_NUMBER_COERCE_MARKER (position
, 0);
537 XSETBUFFER (object
, current_buffer
);
539 if (WINDOWP (object
))
541 w
= XWINDOW (object
);
544 if (BUFFERP (object
))
546 int posn
= XINT (position
);
548 Lisp_Object
*overlay_vec
, tem
;
551 struct buffer
*obuf
= current_buffer
;
553 set_buffer_temp (XBUFFER (object
));
555 /* First try with room for 40 overlays. */
557 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
559 noverlays
= overlays_at (posn
, 0, &overlay_vec
, &len
,
560 &next_overlay
, NULL
);
562 /* If there are more than 40,
563 make enough space for all, and try again. */
567 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
568 noverlays
= overlays_at (posn
, 0, &overlay_vec
, &len
,
569 &next_overlay
, NULL
);
571 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
573 set_buffer_temp (obuf
);
575 /* Now check the overlays in order of decreasing priority. */
576 while (--noverlays
>= 0)
578 tem
= Foverlay_get (overlay_vec
[noverlays
], prop
);
583 /* Not a buffer, or no appropriate overlay, so fall through to the
585 return (Fget_text_property (position
, prop
, object
));
588 DEFUN ("next-property-change", Fnext_property_change
,
589 Snext_property_change
, 1, 3, 0,
590 "Return the position of next property change.\n\
591 Scans characters forward from POSITION in OBJECT till it finds\n\
592 a change in some text property, then returns the position of the change.\n\
593 The optional second argument OBJECT is the string or buffer to scan.\n\
594 Return nil if the property is constant all the way to the end of OBJECT.\n\
595 If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
596 If the optional third argument LIMIT is non-nil, don't search\n\
597 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
598 (position
, object
, limit
)
599 Lisp_Object position
, object
, limit
;
601 register INTERVAL i
, next
;
604 XSETBUFFER (object
, current_buffer
);
606 if (! NILP (limit
) && ! EQ (limit
, Qt
))
607 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
609 i
= validate_interval_range (object
, &position
, &position
, soft
);
611 /* If LIMIT is t, return start of next interval--don't
612 bother checking further intervals. */
615 if (NULL_INTERVAL_P (i
))
618 next
= next_interval (i
);
620 if (NULL_INTERVAL_P (next
))
621 XSETFASTINT (position
, (STRINGP (object
)
622 ? XSTRING (object
)->size
623 : BUF_ZV (XBUFFER (object
))));
625 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
629 if (NULL_INTERVAL_P (i
))
632 next
= next_interval (i
);
634 while (! NULL_INTERVAL_P (next
) && intervals_equal (i
, next
)
635 && (NILP (limit
) || next
->position
< XFASTINT (limit
)))
636 next
= next_interval (next
);
638 if (NULL_INTERVAL_P (next
))
640 if (! NILP (limit
) && !(next
->position
< XFASTINT (limit
)))
643 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
647 /* Return 1 if there's a change in some property between BEG and END. */
650 property_change_between_p (beg
, end
)
653 register INTERVAL i
, next
;
654 Lisp_Object object
, pos
;
656 XSETBUFFER (object
, current_buffer
);
657 XSETFASTINT (pos
, beg
);
659 i
= validate_interval_range (object
, &pos
, &pos
, soft
);
660 if (NULL_INTERVAL_P (i
))
663 next
= next_interval (i
);
664 while (! NULL_INTERVAL_P (next
) && intervals_equal (i
, next
))
666 next
= next_interval (next
);
667 if (NULL_INTERVAL_P (next
))
669 if (next
->position
>= end
)
673 if (NULL_INTERVAL_P (next
))
679 DEFUN ("next-single-property-change", Fnext_single_property_change
,
680 Snext_single_property_change
, 2, 4, 0,
681 "Return the position of next property change for a specific property.\n\
682 Scans characters forward from POSITION till it finds\n\
683 a change in the PROP property, then returns the position of the change.\n\
684 The optional third argument OBJECT is the string or buffer to scan.\n\
685 The property values are compared with `eq'.\n\
686 Return nil if the property is constant all the way to the end of OBJECT.\n\
687 If the value is non-nil, it is a position greater than POSITION, never equal.\n\n\
688 If the optional fourth argument LIMIT is non-nil, don't search\n\
689 past position LIMIT; return LIMIT if nothing is found before LIMIT.")
690 (position
, prop
, object
, limit
)
691 Lisp_Object position
, prop
, object
, limit
;
693 register INTERVAL i
, next
;
694 register Lisp_Object here_val
;
697 XSETBUFFER (object
, current_buffer
);
700 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
702 i
= validate_interval_range (object
, &position
, &position
, soft
);
703 if (NULL_INTERVAL_P (i
))
706 here_val
= textget (i
->plist
, prop
);
707 next
= next_interval (i
);
708 while (! NULL_INTERVAL_P (next
)
709 && EQ (here_val
, textget (next
->plist
, prop
))
710 && (NILP (limit
) || next
->position
< XFASTINT (limit
)))
711 next
= next_interval (next
);
713 if (NULL_INTERVAL_P (next
))
715 if (! NILP (limit
) && !(next
->position
< XFASTINT (limit
)))
718 XSETFASTINT (position
, next
->position
- (STRINGP (object
)));
722 DEFUN ("previous-property-change", Fprevious_property_change
,
723 Sprevious_property_change
, 1, 3, 0,
724 "Return the position of previous property change.\n\
725 Scans characters backwards from POSITION in OBJECT till it finds\n\
726 a change in some text property, then returns the position of the change.\n\
727 The optional second argument OBJECT is the string or buffer to scan.\n\
728 Return nil if the property is constant all the way to the start of OBJECT.\n\
729 If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
730 If the optional third argument LIMIT is non-nil, don't search\n\
731 back past position LIMIT; return LIMIT if nothing is found until LIMIT.")
732 (position
, object
, limit
)
733 Lisp_Object position
, object
, limit
;
735 register INTERVAL i
, previous
;
738 XSETBUFFER (object
, current_buffer
);
741 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
743 i
= validate_interval_range (object
, &position
, &position
, soft
);
744 if (NULL_INTERVAL_P (i
))
747 /* Start with the interval containing the char before point. */
748 if (i
->position
== XFASTINT (position
))
749 i
= previous_interval (i
);
751 previous
= previous_interval (i
);
752 while (! NULL_INTERVAL_P (previous
) && intervals_equal (previous
, i
)
754 || previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
755 previous
= previous_interval (previous
);
756 if (NULL_INTERVAL_P (previous
))
759 && !(previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
762 XSETFASTINT (position
, (previous
->position
+ LENGTH (previous
)
763 - (STRINGP (object
))));
767 DEFUN ("previous-single-property-change", Fprevious_single_property_change
,
768 Sprevious_single_property_change
, 2, 4, 0,
769 "Return the position of previous property change for a specific property.\n\
770 Scans characters backward from POSITION till it finds\n\
771 a change in the PROP property, then returns the position of the change.\n\
772 The optional third argument OBJECT is the string or buffer to scan.\n\
773 The property values are compared with `eq'.\n\
774 Return nil if the property is constant all the way to the start of OBJECT.\n\
775 If the value is non-nil, it is a position less than POSITION, never equal.\n\n\
776 If the optional fourth argument LIMIT is non-nil, don't search\n\
777 back past position LIMIT; return LIMIT if nothing is found until LIMIT.")
778 (position
, prop
, object
, limit
)
779 Lisp_Object position
, prop
, object
, limit
;
781 register INTERVAL i
, previous
;
782 register Lisp_Object here_val
;
785 XSETBUFFER (object
, current_buffer
);
788 CHECK_NUMBER_COERCE_MARKER (limit
, 0);
790 i
= validate_interval_range (object
, &position
, &position
, soft
);
792 /* Start with the interval containing the char before point. */
793 if (! NULL_INTERVAL_P (i
) && i
->position
== XFASTINT (position
))
794 i
= previous_interval (i
);
796 if (NULL_INTERVAL_P (i
))
799 here_val
= textget (i
->plist
, prop
);
800 previous
= previous_interval (i
);
801 while (! NULL_INTERVAL_P (previous
)
802 && EQ (here_val
, textget (previous
->plist
, prop
))
804 || previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
805 previous
= previous_interval (previous
);
806 if (NULL_INTERVAL_P (previous
))
809 && !(previous
->position
+ LENGTH (previous
) > XFASTINT (limit
)))
812 XSETFASTINT (position
, (previous
->position
+ LENGTH (previous
)
813 - (STRINGP (object
))));
817 /* Callers note, this can GC when OBJECT is a buffer (or nil). */
819 DEFUN ("add-text-properties", Fadd_text_properties
,
820 Sadd_text_properties
, 3, 4, 0,
821 "Add properties to the text from START to END.\n\
822 The third argument PROPERTIES is a property list\n\
823 specifying the property values to add.\n\
824 The optional fourth argument, OBJECT,\n\
825 is the string or buffer containing the text.\n\
826 Return t if any property value actually changed, nil otherwise.")
827 (start
, end
, properties
, object
)
828 Lisp_Object start
, end
, properties
, object
;
830 register INTERVAL i
, unchanged
;
831 register int s
, len
, modified
= 0;
834 properties
= validate_plist (properties
);
835 if (NILP (properties
))
839 XSETBUFFER (object
, current_buffer
);
841 i
= validate_interval_range (object
, &start
, &end
, hard
);
842 if (NULL_INTERVAL_P (i
))
846 len
= XINT (end
) - s
;
848 /* No need to protect OBJECT, because we GC only if it's a buffer,
849 and live buffers are always protected. */
852 /* If we're not starting on an interval boundary, we have to
853 split this interval. */
854 if (i
->position
!= s
)
856 /* If this interval already has the properties, we can
858 if (interval_has_all_properties (properties
, i
))
860 int got
= (LENGTH (i
) - (s
- i
->position
));
862 RETURN_UNGCPRO (Qnil
);
864 i
= next_interval (i
);
869 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
870 copy_properties (unchanged
, i
);
874 if (BUFFERP (object
))
875 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
877 /* We are at the beginning of interval I, with LEN chars to scan. */
883 if (LENGTH (i
) >= len
)
885 /* We can UNGCPRO safely here, because there will be just
886 one more chance to gc, in the next call to add_properties,
887 and after that we will not need PROPERTIES or OBJECT again. */
890 if (interval_has_all_properties (properties
, i
))
892 if (BUFFERP (object
))
893 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
894 XINT (end
) - XINT (start
));
896 return modified
? Qt
: Qnil
;
899 if (LENGTH (i
) == len
)
901 add_properties (properties
, i
, object
);
902 if (BUFFERP (object
))
903 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
904 XINT (end
) - XINT (start
));
908 /* i doesn't have the properties, and goes past the change limit */
910 i
= split_interval_left (unchanged
, len
);
911 copy_properties (unchanged
, i
);
912 add_properties (properties
, i
, object
);
913 if (BUFFERP (object
))
914 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
915 XINT (end
) - XINT (start
));
920 modified
+= add_properties (properties
, i
, object
);
921 i
= next_interval (i
);
925 /* Callers note, this can GC when OBJECT is a buffer (or nil). */
927 DEFUN ("put-text-property", Fput_text_property
,
928 Sput_text_property
, 4, 5, 0,
929 "Set one property of the text from START to END.\n\
930 The third and fourth arguments PROPERTY and VALUE\n\
931 specify the property to add.\n\
932 The optional fifth argument, OBJECT,\n\
933 is the string or buffer containing the text.")
934 (start
, end
, property
, value
, object
)
935 Lisp_Object start
, end
, property
, value
, object
;
937 Fadd_text_properties (start
, end
,
938 Fcons (property
, Fcons (value
, Qnil
)),
943 DEFUN ("set-text-properties", Fset_text_properties
,
944 Sset_text_properties
, 3, 4, 0,
945 "Completely replace properties of text from START to END.\n\
946 The third argument PROPERTIES is the new property list.\n\
947 The optional fourth argument, OBJECT,\n\
948 is the string or buffer containing the text.")
949 (start
, end
, properties
, object
)
950 Lisp_Object start
, end
, properties
, object
;
952 register INTERVAL i
, unchanged
;
953 register INTERVAL prev_changed
= NULL_INTERVAL
;
955 Lisp_Object ostart
, oend
;
956 int have_modified
= 0;
961 properties
= validate_plist (properties
);
964 XSETBUFFER (object
, current_buffer
);
966 /* If we want no properties for a whole string,
967 get rid of its intervals. */
968 if (NILP (properties
) && STRINGP (object
)
969 && XFASTINT (start
) == 0
970 && XFASTINT (end
) == XSTRING (object
)->size
)
972 if (! XSTRING (object
)->intervals
)
975 XSTRING (object
)->intervals
= 0;
979 i
= validate_interval_range (object
, &start
, &end
, soft
);
981 if (NULL_INTERVAL_P (i
))
983 /* If buffer has no properties, and we want none, return now. */
984 if (NILP (properties
))
987 /* Restore the original START and END values
988 because validate_interval_range increments them for strings. */
992 i
= validate_interval_range (object
, &start
, &end
, hard
);
993 /* This can return if start == end. */
994 if (NULL_INTERVAL_P (i
))
999 len
= XINT (end
) - s
;
1001 if (BUFFERP (object
))
1002 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
1004 if (i
->position
!= s
)
1007 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1009 if (LENGTH (i
) > len
)
1011 copy_properties (unchanged
, i
);
1012 i
= split_interval_left (i
, len
);
1013 set_properties (properties
, i
, object
);
1014 if (BUFFERP (object
))
1015 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1016 XINT (end
) - XINT (start
));
1021 set_properties (properties
, i
, object
);
1023 if (LENGTH (i
) == len
)
1025 if (BUFFERP (object
))
1026 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1027 XINT (end
) - XINT (start
));
1034 i
= next_interval (i
);
1037 /* We are starting at the beginning of an interval, I */
1043 if (LENGTH (i
) >= len
)
1045 if (LENGTH (i
) > len
)
1046 i
= split_interval_left (i
, len
);
1048 /* We have to call set_properties even if we are going to
1049 merge the intervals, so as to make the undo records
1050 and cause redisplay to happen. */
1051 set_properties (properties
, i
, object
);
1052 if (!NULL_INTERVAL_P (prev_changed
))
1053 merge_interval_left (i
);
1054 if (BUFFERP (object
))
1055 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1056 XINT (end
) - XINT (start
));
1062 /* We have to call set_properties even if we are going to
1063 merge the intervals, so as to make the undo records
1064 and cause redisplay to happen. */
1065 set_properties (properties
, i
, object
);
1066 if (NULL_INTERVAL_P (prev_changed
))
1069 prev_changed
= i
= merge_interval_left (i
);
1071 i
= next_interval (i
);
1074 if (BUFFERP (object
))
1075 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1076 XINT (end
) - XINT (start
));
1080 DEFUN ("remove-text-properties", Fremove_text_properties
,
1081 Sremove_text_properties
, 3, 4, 0,
1082 "Remove some properties from text from START to END.\n\
1083 The third argument PROPERTIES is a property list\n\
1084 whose property names specify the properties to remove.\n\
1085 \(The values stored in PROPERTIES are ignored.)\n\
1086 The optional fourth argument, OBJECT,\n\
1087 is the string or buffer containing the text.\n\
1088 Return t if any property was actually removed, nil otherwise.")
1089 (start
, end
, properties
, object
)
1090 Lisp_Object start
, end
, properties
, object
;
1092 register INTERVAL i
, unchanged
;
1093 register int s
, len
, modified
= 0;
1096 XSETBUFFER (object
, current_buffer
);
1098 i
= validate_interval_range (object
, &start
, &end
, soft
);
1099 if (NULL_INTERVAL_P (i
))
1103 len
= XINT (end
) - s
;
1105 if (i
->position
!= s
)
1107 /* No properties on this first interval -- return if
1108 it covers the entire region. */
1109 if (! interval_has_some_properties (properties
, i
))
1111 int got
= (LENGTH (i
) - (s
- i
->position
));
1115 i
= next_interval (i
);
1117 /* Split away the beginning of this interval; what we don't
1122 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1123 copy_properties (unchanged
, i
);
1127 if (BUFFERP (object
))
1128 modify_region (XBUFFER (object
), XINT (start
), XINT (end
));
1130 /* We are at the beginning of an interval, with len to scan */
1136 if (LENGTH (i
) >= len
)
1138 if (! interval_has_some_properties (properties
, i
))
1139 return modified
? Qt
: Qnil
;
1141 if (LENGTH (i
) == len
)
1143 remove_properties (properties
, i
, object
);
1144 if (BUFFERP (object
))
1145 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1146 XINT (end
) - XINT (start
));
1150 /* i has the properties, and goes past the change limit */
1152 i
= split_interval_left (i
, len
);
1153 copy_properties (unchanged
, i
);
1154 remove_properties (properties
, i
, object
);
1155 if (BUFFERP (object
))
1156 signal_after_change (XINT (start
), XINT (end
) - XINT (start
),
1157 XINT (end
) - XINT (start
));
1162 modified
+= remove_properties (properties
, i
, object
);
1163 i
= next_interval (i
);
1167 DEFUN ("text-property-any", Ftext_property_any
,
1168 Stext_property_any
, 4, 5, 0,
1169 "Check text from START to END for property PROPERTY equalling VALUE.\n\
1170 If so, return the position of the first character whose property PROPERTY\n\
1171 is `eq' to VALUE. Otherwise return nil.\n\
1172 The optional fifth argument, OBJECT, is the string or buffer\n\
1173 containing the text.")
1174 (start
, end
, property
, value
, object
)
1175 Lisp_Object start
, end
, property
, value
, object
;
1177 register INTERVAL i
;
1178 register int e
, pos
;
1181 XSETBUFFER (object
, current_buffer
);
1182 i
= validate_interval_range (object
, &start
, &end
, soft
);
1183 if (NULL_INTERVAL_P (i
))
1184 return (!NILP (value
) || EQ (start
, end
) ? Qnil
: start
);
1187 while (! NULL_INTERVAL_P (i
))
1189 if (i
->position
>= e
)
1191 if (EQ (textget (i
->plist
, property
), value
))
1194 if (pos
< XINT (start
))
1196 return make_number (pos
- (STRINGP (object
)));
1198 i
= next_interval (i
);
1203 DEFUN ("text-property-not-all", Ftext_property_not_all
,
1204 Stext_property_not_all
, 4, 5, 0,
1205 "Check text from START to END for property PROPERTY not equalling VALUE.\n\
1206 If so, return the position of the first character whose property PROPERTY\n\
1207 is not `eq' to VALUE. Otherwise, return nil.\n\
1208 The optional fifth argument, OBJECT, is the string or buffer\n\
1209 containing the text.")
1210 (start
, end
, property
, value
, object
)
1211 Lisp_Object start
, end
, property
, value
, object
;
1213 register INTERVAL i
;
1217 XSETBUFFER (object
, current_buffer
);
1218 i
= validate_interval_range (object
, &start
, &end
, soft
);
1219 if (NULL_INTERVAL_P (i
))
1220 return (NILP (value
) || EQ (start
, end
)) ? Qnil
: start
;
1224 while (! NULL_INTERVAL_P (i
))
1226 if (i
->position
>= e
)
1228 if (! EQ (textget (i
->plist
, property
), value
))
1230 if (i
->position
> s
)
1232 return make_number (s
- (STRINGP (object
)));
1234 i
= next_interval (i
);
1239 #if 0 /* You can use set-text-properties for this. */
1241 DEFUN ("erase-text-properties", Ferase_text_properties
,
1242 Serase_text_properties
, 2, 3, 0,
1243 "Remove all properties from the text from START to END.\n\
1244 The optional third argument, OBJECT,\n\
1245 is the string or buffer containing the text.")
1246 (start
, end
, object
)
1247 Lisp_Object start
, end
, object
;
1249 register INTERVAL i
;
1250 register INTERVAL prev_changed
= NULL_INTERVAL
;
1251 register int s
, len
, modified
;
1254 XSETBUFFER (object
, current_buffer
);
1256 i
= validate_interval_range (object
, &start
, &end
, soft
);
1257 if (NULL_INTERVAL_P (i
))
1261 len
= XINT (end
) - s
;
1263 if (i
->position
!= s
)
1266 register INTERVAL unchanged
= i
;
1268 /* If there are properties here, then this text will be modified. */
1269 if (! NILP (i
->plist
))
1271 i
= split_interval_right (unchanged
, s
- unchanged
->position
);
1275 if (LENGTH (i
) > len
)
1277 i
= split_interval_right (i
, len
);
1278 copy_properties (unchanged
, i
);
1282 if (LENGTH (i
) == len
)
1287 /* If the text of I is without any properties, and contains
1288 LEN or more characters, then we may return without changing
1290 else if (LENGTH (i
) - (s
- i
->position
) <= len
)
1292 /* The amount of text to change extends past I, so just note
1293 how much we've gotten. */
1295 got
= LENGTH (i
) - (s
- i
->position
);
1299 i
= next_interval (i
);
1302 /* We are starting at the beginning of an interval, I. */
1305 if (LENGTH (i
) >= len
)
1307 /* If I has no properties, simply merge it if possible. */
1308 if (NILP (i
->plist
))
1310 if (! NULL_INTERVAL_P (prev_changed
))
1311 merge_interval_left (i
);
1313 return modified
? Qt
: Qnil
;
1316 if (LENGTH (i
) > len
)
1317 i
= split_interval_left (i
, len
);
1318 if (! NULL_INTERVAL_P (prev_changed
))
1319 merge_interval_left (i
);
1326 /* Here if we still need to erase past the end of I */
1328 if (NULL_INTERVAL_P (prev_changed
))
1330 modified
+= erase_properties (i
);
1335 modified
+= ! NILP (i
->plist
);
1336 /* Merging I will give it the properties of PREV_CHANGED. */
1337 prev_changed
= i
= merge_interval_left (i
);
1340 i
= next_interval (i
);
1343 return modified
? Qt
: Qnil
;
1347 /* I don't think this is the right interface to export; how often do you
1348 want to do something like this, other than when you're copying objects
1351 I think it would be better to have a pair of functions, one which
1352 returns the text properties of a region as a list of ranges and
1353 plists, and another which applies such a list to another object. */
1355 /* Add properties from SRC to SRC of SRC, starting at POS in DEST.
1356 SRC and DEST may each refer to strings or buffers.
1357 Optional sixth argument PROP causes only that property to be copied.
1358 Properties are copied to DEST as if by `add-text-properties'.
1359 Return t if any property value actually changed, nil otherwise. */
1361 /* Note this can GC when DEST is a buffer. */
1364 copy_text_properties (start
, end
, src
, pos
, dest
, prop
)
1365 Lisp_Object start
, end
, src
, pos
, dest
, prop
;
1371 int s
, e
, e2
, p
, len
, modified
= 0;
1372 struct gcpro gcpro1
, gcpro2
;
1374 i
= validate_interval_range (src
, &start
, &end
, soft
);
1375 if (NULL_INTERVAL_P (i
))
1378 CHECK_NUMBER_COERCE_MARKER (pos
, 0);
1380 Lisp_Object dest_start
, dest_end
;
1383 XSETFASTINT (dest_end
, XINT (dest_start
) + (XINT (end
) - XINT (start
)));
1384 /* Apply this to a copy of pos; it will try to increment its arguments,
1385 which we don't want. */
1386 validate_interval_range (dest
, &dest_start
, &dest_end
, soft
);
1397 e2
= i
->position
+ LENGTH (i
);
1404 while (! NILP (plist
))
1406 if (EQ (Fcar (plist
), prop
))
1408 plist
= Fcons (prop
, Fcons (Fcar (Fcdr (plist
)), Qnil
));
1411 plist
= Fcdr (Fcdr (plist
));
1415 /* Must defer modifications to the interval tree in case src
1416 and dest refer to the same string or buffer. */
1417 stuff
= Fcons (Fcons (make_number (p
),
1418 Fcons (make_number (p
+ len
),
1419 Fcons (plist
, Qnil
))),
1423 i
= next_interval (i
);
1424 if (NULL_INTERVAL_P (i
))
1431 GCPRO2 (stuff
, dest
);
1433 while (! NILP (stuff
))
1436 res
= Fadd_text_properties (Fcar (res
), Fcar (Fcdr (res
)),
1437 Fcar (Fcdr (Fcdr (res
))), dest
);
1440 stuff
= Fcdr (stuff
);
1445 return modified
? Qt
: Qnil
;
1448 /* Call the modification hook functions in LIST, each with START and END. */
1451 call_mod_hooks (list
, start
, end
)
1452 Lisp_Object list
, start
, end
;
1454 struct gcpro gcpro1
;
1456 while (!NILP (list
))
1458 call2 (Fcar (list
), start
, end
);
1464 /* Check for read-only intervals and signal an error if we find one.
1465 Then check for any modification hooks in the range START up to
1466 (but not including) END. Create a list of all these hooks in
1467 lexicographic order, eliminating consecutive extra copies of the
1468 same hook. Then call those hooks in order, with START and END - 1
1472 verify_interval_modification (buf
, start
, end
)
1476 register INTERVAL intervals
= BUF_INTERVALS (buf
);
1477 register INTERVAL i
, prev
;
1479 register Lisp_Object prev_mod_hooks
;
1480 Lisp_Object mod_hooks
;
1481 struct gcpro gcpro1
;
1484 prev_mod_hooks
= Qnil
;
1487 interval_insert_behind_hooks
= Qnil
;
1488 interval_insert_in_front_hooks
= Qnil
;
1490 if (NULL_INTERVAL_P (intervals
))
1500 /* For an insert operation, check the two chars around the position. */
1504 Lisp_Object before
, after
;
1506 /* Set I to the interval containing the char after START,
1507 and PREV to the interval containing the char before START.
1508 Either one may be null. They may be equal. */
1509 i
= find_interval (intervals
, start
);
1511 if (start
== BUF_BEGV (buf
))
1513 else if (i
->position
== start
)
1514 prev
= previous_interval (i
);
1515 else if (i
->position
< start
)
1517 if (start
== BUF_ZV (buf
))
1520 /* If Vinhibit_read_only is set and is not a list, we can
1521 skip the read_only checks. */
1522 if (NILP (Vinhibit_read_only
) || CONSP (Vinhibit_read_only
))
1524 /* If I and PREV differ we need to check for the read-only
1525 property together with its stickiness. If either I or
1526 PREV are 0, this check is all we need.
1527 We have to take special care, since read-only may be
1528 indirectly defined via the category property. */
1531 if (! NULL_INTERVAL_P (i
))
1533 after
= textget (i
->plist
, Qread_only
);
1535 /* If interval I is read-only and read-only is
1536 front-sticky, inhibit insertion.
1537 Check for read-only as well as category. */
1539 && NILP (Fmemq (after
, Vinhibit_read_only
)))
1543 tem
= textget (i
->plist
, Qfront_sticky
);
1544 if (TMEM (Qread_only
, tem
)
1545 || (NILP (Fplist_get (i
->plist
, Qread_only
))
1546 && TMEM (Qcategory
, tem
)))
1547 error ("Attempt to insert within read-only text");
1551 if (! NULL_INTERVAL_P (prev
))
1553 before
= textget (prev
->plist
, Qread_only
);
1555 /* If interval PREV is read-only and read-only isn't
1556 rear-nonsticky, inhibit insertion.
1557 Check for read-only as well as category. */
1559 && NILP (Fmemq (before
, Vinhibit_read_only
)))
1563 tem
= textget (prev
->plist
, Qrear_nonsticky
);
1564 if (! TMEM (Qread_only
, tem
)
1565 && (! NILP (Fplist_get (prev
->plist
,Qread_only
))
1566 || ! TMEM (Qcategory
, tem
)))
1567 error ("Attempt to insert within read-only text");
1571 else if (! NULL_INTERVAL_P (i
))
1573 after
= textget (i
->plist
, Qread_only
);
1575 /* If interval I is read-only and read-only is
1576 front-sticky, inhibit insertion.
1577 Check for read-only as well as category. */
1578 if (! NILP (after
) && NILP (Fmemq (after
, Vinhibit_read_only
)))
1582 tem
= textget (i
->plist
, Qfront_sticky
);
1583 if (TMEM (Qread_only
, tem
)
1584 || (NILP (Fplist_get (i
->plist
, Qread_only
))
1585 && TMEM (Qcategory
, tem
)))
1586 error ("Attempt to insert within read-only text");
1588 tem
= textget (prev
->plist
, Qrear_nonsticky
);
1589 if (! TMEM (Qread_only
, tem
)
1590 && (! NILP (Fplist_get (prev
->plist
, Qread_only
))
1591 || ! TMEM (Qcategory
, tem
)))
1592 error ("Attempt to insert within read-only text");
1597 /* Run both insert hooks (just once if they're the same). */
1598 if (!NULL_INTERVAL_P (prev
))
1599 interval_insert_behind_hooks
1600 = textget (prev
->plist
, Qinsert_behind_hooks
);
1601 if (!NULL_INTERVAL_P (i
))
1602 interval_insert_in_front_hooks
1603 = textget (i
->plist
, Qinsert_in_front_hooks
);
1607 /* Loop over intervals on or next to START...END,
1608 collecting their hooks. */
1610 i
= find_interval (intervals
, start
);
1613 if (! INTERVAL_WRITABLE_P (i
))
1614 error ("Attempt to modify read-only text");
1616 mod_hooks
= textget (i
->plist
, Qmodification_hooks
);
1617 if (! NILP (mod_hooks
) && ! EQ (mod_hooks
, prev_mod_hooks
))
1619 hooks
= Fcons (mod_hooks
, hooks
);
1620 prev_mod_hooks
= mod_hooks
;
1623 i
= next_interval (i
);
1625 /* Keep going thru the interval containing the char before END. */
1626 while (! NULL_INTERVAL_P (i
) && i
->position
< end
);
1629 hooks
= Fnreverse (hooks
);
1630 while (! EQ (hooks
, Qnil
))
1632 call_mod_hooks (Fcar (hooks
), make_number (start
),
1634 hooks
= Fcdr (hooks
);
1640 /* Run the interval hooks for an insertion.
1641 verify_interval_modification chose which hooks to run;
1642 this function is called after the insertion happens
1643 so it can indicate the range of inserted text. */
1646 report_interval_modification (start
, end
)
1647 Lisp_Object start
, end
;
1649 if (! NILP (interval_insert_behind_hooks
))
1650 call_mod_hooks (interval_insert_behind_hooks
,
1651 make_number (start
), make_number (end
));
1652 if (! NILP (interval_insert_in_front_hooks
)
1653 && ! EQ (interval_insert_in_front_hooks
,
1654 interval_insert_behind_hooks
))
1655 call_mod_hooks (interval_insert_in_front_hooks
,
1656 make_number (start
), make_number (end
));
1662 DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties
,
1663 "Property-list used as default values.\n\
1664 The value of a property in this list is seen as the value for every\n\
1665 character that does not have its own value for that property.");
1666 Vdefault_text_properties
= Qnil
;
1668 DEFVAR_LISP ("inhibit-point-motion-hooks", &Vinhibit_point_motion_hooks
,
1669 "If non-nil, don't run `point-left' and `point-entered' text properties.\n\
1670 This also inhibits the use of the `intangible' text property.");
1671 Vinhibit_point_motion_hooks
= Qnil
;
1673 staticpro (&interval_insert_behind_hooks
);
1674 staticpro (&interval_insert_in_front_hooks
);
1675 interval_insert_behind_hooks
= Qnil
;
1676 interval_insert_in_front_hooks
= Qnil
;
1679 /* Common attributes one might give text */
1681 staticpro (&Qforeground
);
1682 Qforeground
= intern ("foreground");
1683 staticpro (&Qbackground
);
1684 Qbackground
= intern ("background");
1686 Qfont
= intern ("font");
1687 staticpro (&Qstipple
);
1688 Qstipple
= intern ("stipple");
1689 staticpro (&Qunderline
);
1690 Qunderline
= intern ("underline");
1691 staticpro (&Qread_only
);
1692 Qread_only
= intern ("read-only");
1693 staticpro (&Qinvisible
);
1694 Qinvisible
= intern ("invisible");
1695 staticpro (&Qintangible
);
1696 Qintangible
= intern ("intangible");
1697 staticpro (&Qcategory
);
1698 Qcategory
= intern ("category");
1699 staticpro (&Qlocal_map
);
1700 Qlocal_map
= intern ("local-map");
1701 staticpro (&Qfront_sticky
);
1702 Qfront_sticky
= intern ("front-sticky");
1703 staticpro (&Qrear_nonsticky
);
1704 Qrear_nonsticky
= intern ("rear-nonsticky");
1706 /* Properties that text might use to specify certain actions */
1708 staticpro (&Qmouse_left
);
1709 Qmouse_left
= intern ("mouse-left");
1710 staticpro (&Qmouse_entered
);
1711 Qmouse_entered
= intern ("mouse-entered");
1712 staticpro (&Qpoint_left
);
1713 Qpoint_left
= intern ("point-left");
1714 staticpro (&Qpoint_entered
);
1715 Qpoint_entered
= intern ("point-entered");
1717 defsubr (&Stext_properties_at
);
1718 defsubr (&Sget_text_property
);
1719 defsubr (&Sget_char_property
);
1720 defsubr (&Snext_property_change
);
1721 defsubr (&Snext_single_property_change
);
1722 defsubr (&Sprevious_property_change
);
1723 defsubr (&Sprevious_single_property_change
);
1724 defsubr (&Sadd_text_properties
);
1725 defsubr (&Sput_text_property
);
1726 defsubr (&Sset_text_properties
);
1727 defsubr (&Sremove_text_properties
);
1728 defsubr (&Stext_property_any
);
1729 defsubr (&Stext_property_not_all
);
1730 /* defsubr (&Serase_text_properties); */
1731 /* defsubr (&Scopy_text_properties); */
1736 lose
-- this shouldn
't be compiled if USE_TEXT_PROPERTIES isn't defined
1738 #endif /* USE_TEXT_PROPERTIES */