xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	8fc7fe29b841

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 Lisp_Object Qend_closed;
 Lisp_Object Qread_only;
 /* Qhighlight defined in general.c */
 Lisp_Object Qunique;
 Lisp_Object Qduplicable;
-Lisp_Object Qreplicating;
 Lisp_Object Qdetachable;
 Lisp_Object Qpriority;
 Lisp_Object Qmouse_face;
 Lisp_Object Qglyph_layout;  /* This exists only for backwards compatibility. */
 *bp++ = ' ';
 if (!NILP (extent_read_only (anc))) *bp++ = '%';
 if (!NILP (extent_mouse_face (anc))) *bp++ = 'H';
 if (extent_unique_p (anc)) *bp++ = 'U';
-else if (extent_replicating_p (anc)) *bp++ = 'R';
 else if (extent_duplicable_p (anc)) *bp++ = 'D';
 if (!NILP (extent_invisible (anc))) *bp++ = 'I';
 if (!NILP (extent_read_only (anc)) || !NILP (extent_mouse_face (anc)) ||
-extent_unique_p (anc) || extent_replicating_p (anc) ||
+extent_unique_p (anc) ||
 extent_duplicable_p (anc) || !NILP (extent_invisible (anc)))
 *bp++ = ' ';
 tail = extent_plist_slot (anc);
 return Qnil;
 else
 return make_int (extent_endpoint_bufpos (extent, endp));
 }
-DEFUN ("extentp", Fextentp, Sextentp, 1, 1, 0 /*
+DEFUN ("extentp", Fextentp, 1, 1, 0, /*
 T if OBJECT is an extent.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (EXTENTP (object))
 return Qt;
 return Qnil;
 }
-DEFUN ("extent-live-p", Fextent_live_p, Sextent_live_p, 1, 1, 0 /*
+DEFUN ("extent-live-p", Fextent_live_p, 1, 1, 0, /*
 T if OBJECT is an extent and the extent has not been destroyed.
-*/ )
+*/
-(object)
+(object))
-Lisp_Object object;
 {
 if (EXTENTP (object) && EXTENT_LIVE_P (XEXTENT (object)))
 return Qt;
 return Qnil;
 }
-DEFUN ("extent-detached-p", Fextent_detached_p, Sextent_detached_p, 1, 1, 0 /*
+DEFUN ("extent-detached-p", Fextent_detached_p, 1, 1, 0, /*
 T if EXTENT is detached.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 if (extent_detached_p (decode_extent (extent, 0)))
 return Qt;
 return Qnil;
 }
-DEFUN ("extent-object", Fextent_object, Sextent_object, 1, 1, 0 /*
+DEFUN ("extent-object", Fextent_object, 1, 1, 0, /*
 Return object (buffer or string) EXTENT refers to.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 return extent_object (decode_extent (extent, 0));
 }
-DEFUN ("extent-start-position", Fextent_start_position,
+DEFUN ("extent-start-position", Fextent_start_position, 1, 1, 0, /*
-Sextent_start_position, 1, 1, 0 /*
 Return start position of EXTENT, or nil if EXTENT is detached.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 return extent_endpoint_external (extent, 0);
 }
-DEFUN ("extent-end-position", Fextent_end_position,
+DEFUN ("extent-end-position", Fextent_end_position, 1, 1, 0, /*
-Sextent_end_position, 1, 1, 0 /*
 Return end position of EXTENT, or nil if EXTENT is detached.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 return extent_endpoint_external (extent, 1);
 }
-DEFUN ("extent-length", Fextent_length, Sextent_length, 1, 1, 0 /*
+DEFUN ("extent-length", Fextent_length, 1, 1, 0, /*
 Return length of EXTENT in characters.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT e = decode_extent (extent, DE_MUST_BE_ATTACHED);
 return make_int (extent_endpoint_bufpos (e, 1)
 		   - extent_endpoint_bufpos (e, 0));
 }
-DEFUN ("next-extent", Fnext_extent, Snext_extent, 1, 1, 0 /*
+DEFUN ("next-extent", Fnext_extent, 1, 1, 0, /*
 Find next extent after EXTENT.
 If EXTENT is a buffer return the first extent in the buffer; likewise
 for strings.
 Extents in a buffer are ordered in what is called the \"display\"
 order, which sorts by increasing start positions and then by *decreasing*
 `map-extents' instead of this function; it is much more efficient.
 The primary use of this function should be to enumerate all the
 extents in a buffer.
 Note: The display order is not necessarily the order that `map-extents'
 processes extents in!
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object val;
 EXTENT next;
 if (EXTENTP (extent))
 return (Qnil);
 XSETEXTENT (val, next);
 return (val);
 }
-DEFUN ("previous-extent", Fprevious_extent, Sprevious_extent, 1, 1, 0 /*
+DEFUN ("previous-extent", Fprevious_extent, 1, 1, 0, /*
 Find last extent before EXTENT.
 If EXTENT is a buffer return the last extent in the buffer; likewise
 for strings.
 This function is analogous to `next-extent'.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object val;
 EXTENT prev;
 if (EXTENTP (extent))
 return (val);
 }
 #ifdef DEBUG_XEMACS
-DEFUN ("next-e-extent", Fnext_e_extent, Snext_e_extent, 1, 1, 0 /*
+DEFUN ("next-e-extent", Fnext_e_extent, 1, 1, 0, /*
 Find next extent after EXTENT using the \"e\" order.
 If EXTENT is a buffer return the first extent in the buffer; likewise
 for strings.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object val;
 EXTENT next;
 if (EXTENTP (extent))
 return (Qnil);
 XSETEXTENT (val, next);
 return (val);
 }
-DEFUN ("previous-e-extent", Fprevious_e_extent, Sprevious_e_extent, 1, 1, 0 /*
+DEFUN ("previous-e-extent", Fprevious_e_extent, 1, 1, 0, /*
 Find last extent before EXTENT using the \"e\" order.
 If EXTENT is a buffer return the last extent in the buffer; likewise
 for strings.
 This function is analogous to `next-e-extent'.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object val;
 EXTENT prev;
 if (EXTENTP (extent))
 return (val);
 }
 #endif
-DEFUN ("next-extent-change", Fnext_extent_change, Snext_extent_change,
+DEFUN ("next-extent-change", Fnext_extent_change, 1, 2, 0, /*
-1, 2, 0 /*
 Return the next position after POS where an extent begins or ends.
 If POS is at the end of the buffer or string, POS will be returned;
 otherwise a position greater than POS will always be returned.
 If BUFFER is nil, the current buffer is assumed.
-*/ )
+*/
-(pos, object)
+(pos, object))
-Lisp_Object pos, object;
 {
 Lisp_Object obj = decode_buffer_or_string (object);
 Bytind bpos;
 bpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
 bpos = extent_find_end_of_run (obj, bpos, 1);
 return make_int (buffer_or_string_bytind_to_bufpos (obj, bpos));
 }
-DEFUN ("previous-extent-change", Fprevious_extent_change,
+DEFUN ("previous-extent-change", Fprevious_extent_change, 1, 2, 0, /*
-Sprevious_extent_change, 1, 2, 0 /*
 Return the last position before POS where an extent begins or ends.
 If POS is at the beginning of the buffer or string, POS will be returned;
 otherwise a position less than POS will always be returned.
 If OBJECT is nil, the current buffer is assumed.
-*/ )
+*/
-(pos, object)
+(pos, object))
-Lisp_Object pos, object;
 {
 Lisp_Object obj = decode_buffer_or_string (object);
 Bytind bpos;
 bpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
 /************************************************************************/
 /*		    	parent and children stuff			*/
 /************************************************************************/
-DEFUN ("extent-parent", Fextent_parent, Sextent_parent, 1, 1, 0 /*
+DEFUN ("extent-parent", Fextent_parent, 1, 1, 0, /*
 Return the parent (if any) of EXTENT.
 If an extent has a parent, it derives all its properties from that extent
 and has no properties of its own. (The only \"properties\" that the
 extent keeps are the buffer/string it refers to and the start and end
 points.) It is possible for an extent's parent to itself have a parent.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 /* do I win the prize for the strangest split infinitive? */
 {
 EXTENT e = decode_extent (extent, 0);
 return extent_parent (e);
 }
-DEFUN ("extent-children", Fextent_children, Sextent_children, 1, 1, 0 /*
+DEFUN ("extent-children", Fextent_children, 1, 1, 0, /*
 Return a list of the children (if any) of EXTENT.
 The children of an extent are all those extents whose parent is that extent.
 This function does not recursively trace children of children.
 \(To do that, use `extent-descendants'.)
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT e = decode_extent (extent, 0);
 Lisp_Object children = extent_children (e);
 if (!NILP (children))
 assert (NILP (memq_no_quit (child, XWEAK_LIST_LIST (children))));
 #endif
 XWEAK_LIST_LIST (children) = Fcons (child, XWEAK_LIST_LIST (children));
 }
-DEFUN ("set-extent-parent", Fset_extent_parent, Sset_extent_parent, 2, 2, 0 /*
+DEFUN ("set-extent-parent", Fset_extent_parent, 2, 2, 0, /*
 Set the parent of EXTENT to PARENT (may be nil).
 See `extent-parent'.
-*/ )
+*/
-(extent, parent)
+(extent, parent))
-Lisp_Object extent, parent;
 {
 EXTENT e = decode_extent (extent, 0);
 Lisp_Object cur_parent = extent_parent (e);
 Lisp_Object rest;
 Fset_extent_parent (extent_obj, Qnil);
 /* mark the extent as destroyed */
 extent_object (extent) = Qt;
 }
-DEFUN ("make-extent", Fmake_extent, Smake_extent, 2, 3, 0 /*
+DEFUN ("make-extent", Fmake_extent, 2, 3, 0, /*
 Make an extent for the range [FROM, TO) in BUFFER-OR-STRING.
 BUFFER-OR-STRING defaults to the current buffer.  Insertions at point
 TO will be outside of the extent; insertions at FROM will be inside the
 extent, causing the extent to grow. (This is the same way that markers
 behave.) You can change the behavior of insertions at the endpoints
 using `set-extent-property'.  The extent is initially detached if both
 FROM and TO are nil, and in this case BUFFER-OR-STRING defaults to nil,
 meaning the extent is in no buffer and no string.
-*/ )
+*/
-(from, to, buffer_or_string)
+(from, to, buffer_or_string))
-Lisp_Object from, to, buffer_or_string;
 {
 Lisp_Object extent_obj = Qnil;
 Lisp_Object obj;
 obj = decode_buffer_or_string (buffer_or_string);
 XSETEXTENT (extent_obj, make_extent_internal (obj, start, end));
 }
 return extent_obj;
 }
-DEFUN ("copy-extent", Fcopy_extent, Scopy_extent, 1, 2, 0 /*
+DEFUN ("copy-extent", Fcopy_extent, 1, 2, 0, /*
 Make a copy of EXTENT.  It is initially detached.
 Optional argument BUFFER-OR-STRING defaults to EXTENT's buffer or string.
-*/ )
+*/
-(extent, buffer_or_string)
+(extent, buffer_or_string))
-Lisp_Object extent, buffer_or_string;
 {
 EXTENT ext = decode_extent (extent, 0);
 if (NILP (buffer_or_string))
 buffer_or_string = extent_object (ext);
 XSETEXTENT (extent, copy_extent (ext, -1, -1, buffer_or_string));
 return extent;
 }
-DEFUN ("delete-extent", Fdelete_extent, Sdelete_extent, 1, 1, 0 /*
+DEFUN ("delete-extent", Fdelete_extent, 1, 1, 0, /*
 Remove EXTENT from its buffer and destroy it.
 This does not modify the buffer's text, only its display properties.
 The extent cannot be used thereafter.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT ext;
 /* We do not call decode_extent() here because already-destroyed
 extents are OK. */
 return Qnil;
 destroy_extent (ext);
 return Qnil;
 }
-DEFUN ("detach-extent", Fdetach_extent, Sdetach_extent, 1, 1, 0 /*
+DEFUN ("detach-extent", Fdetach_extent, 1, 1, 0, /*
 Remove EXTENT from its buffer in such a way that it can be re-inserted.
 An extent is also detached when all of its characters are all killed by a
 deletion, unless its `detachable' property has been unset.
 Extents which have the `duplicable' attribute are tracked by the undo
 as is attachment via `insert-extent' and string insertion.  Extent motion,
 face changes, and attachment via `make-extent' and `set-extent-endpoints'
 are not recorded.  This means that extent changes which are to be undo-able
 must be performed by character editing, or by insertion and detachment of
 duplicable extents.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT ext = decode_extent (extent, 0);
 if (extent_detached_p (ext))
 return extent;
 extent_detach (ext);
 return extent;
 }
-DEFUN ("set-extent-endpoints", Fset_extent_endpoints, Sset_extent_endpoints,
+DEFUN ("set-extent-endpoints", Fset_extent_endpoints, 3, 4, 0, /*
-3, 4, 0 /*
 Set the endpoints of EXTENT to START, END.
 If START and END are null, call detach-extent on EXTENT.
 BUFFER-OR-STRING specifies the new buffer or string that the extent should
 be in, and defaults to EXTENT's buffer or string. (If nil, and EXTENT
 is in no buffer and no string, it defaults to the current buffer.)
 See documentation on `detach-extent' for a discussion of undo recording.
-*/ )
+*/
-(extent, start, end, buffer_or_string)
+(extent, start, end, buffer_or_string))
-Lisp_Object extent, start, end, buffer_or_string;
 {
 EXTENT ext;
 Bytind s, e;
 ext = decode_extent (extent, 0);
 flags = XCDR (flags);
 }
 return retval;
 }
-DEFUN ("extent-in-region-p", Fextent_in_region_p, Sextent_in_region_p,
+DEFUN ("extent-in-region-p", Fextent_in_region_p, 1, 4, 0, /*
-1, 4, 0 /*
 Return whether EXTENT overlaps a specified region.
 This is equivalent to whether `map-extents' would visit EXTENT when called
 with these args.
-*/ )
+*/
-(extent, from, to, flags)
+(extent, from, to, flags))
-Lisp_Object extent, from, to, flags;
 {
 EXTENT ext;
 Lisp_Object obj;
 Bytind start, end;
 return 0;
 else
 return 1;
 }
-DEFUN ("map-extents", Fmap_extents, Smap_extents, 1, 8, 0 /*
+DEFUN ("map-extents", Fmap_extents, 1, 8, 0, /*
 Map FUNCTION over the extents which overlap a region in OBJECT.
 OBJECT is normally a buffer or string but could be an extent (see below).
 The region is normally bounded by [FROM, TO) (i.e. the beginning of the
 region is closed and the end of the region is open), but this can be
 changed with the FLAGS argument (see below for a complete discussion).
 `start-and-end-in-region', and `start-or-end-in-region' may be specified.
 If optional arg PROPERTY is non-nil, only extents with that property set
 on them will be visited.  If optional arg VALUE is non-nil, only extents
 whose value for that property is `eq' to VALUE will be visited.
-*/ )
+*/
-(function, object, from, to, maparg, flags, property, value)
+(function, object, from, to, maparg, flags, property, value))
-Lisp_Object function, object, from, to, maparg, flags, property, value;
 {
 /* This function can GC */
 struct slow_map_extents_arg closure;
 unsigned int me_flags;
 Bytind start, end;
 return 0;
 else
 return 1;
 }
-DEFUN ("map-extent-children", Fmap_extent_children, Smap_extent_children,
+DEFUN ("map-extent-children", Fmap_extent_children, 1, 8, 0, /*
-1, 8, 0 /*
 Map FUNCTION over the extents in the region from FROM to TO.
 FUNCTION is called with arguments (extent, MAPARG).  See `map-extents'
 for a full discussion of the arguments FROM, TO, and FLAGS.
 The arguments are the same as for `map-extents', but this function differs
 inside E but end before E's end.
 Thus, this function may be used to walk a tree of extents in a buffer:
 	(defun walk-extents (buffer &optional ignore)
 	 (map-extent-children 'walk-extents buffer))
-*/ )
+*/
-(function, object, from, to, maparg, flags, property, value)
+(function, object, from, to, maparg, flags, property, value))
-Lisp_Object function, object, from, to, maparg, flags, property, value;
 {
 /* This function can GC */
 struct slow_map_extent_children_arg closure;
 unsigned int me_flags;
 Bytind start, end;
 XSETEXTENT (extent_obj, closure.best_match);
 return extent_obj;
 }
-DEFUN ("extent-at", Fextent_at, Sextent_at, 1, 5, 0 /*
+DEFUN ("extent-at", Fextent_at, 1, 5, 0, /*
 Find \"smallest\" extent at POS in OBJECT having PROPERTY set.
 Normally, an extent is \"at\" POS if it overlaps the region (POS, POS+1);
 i.e. if it covers the character after POS. (However, see the definition
 of AT-FLAG.) \"Smallest\" means the extent that comes last in the display
 order; this normally means the extent whose start position is closest to
 			This includes all zero-length extents at POS.
 Note that in all cases, the start-openness and end-openness of the extents
 considered is ignored.  If you want to pay attention to those properties,
 you should use `map-extents', which gives you more control.
-*/ )
+*/
-(pos, object, property, before, at_flag)
+(pos, object, property, before, at_flag))
-Lisp_Object pos, object, property, before, at_flag;
 {
 Bytind position;
 EXTENT before_extent;
 enum extent_at_flag fl;
 value = (external_of_internal_memoized_face
 	     (memoize_extent_face_internal (value)));
 return value;
 }
-DEFUN ("extent-face", Fextent_face, Sextent_face, 1, 1, 0 /*
+DEFUN ("extent-face", Fextent_face, 1, 1, 0, /*
 Return the name of the face in which EXTENT is displayed, or nil
 if the extent's face is unspecified.  This might also return a list
 of face names.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object face;
 CHECK_EXTENT (extent);
 face = extent_face (XEXTENT (extent));
 return external_of_internal_memoized_face (face);
 }
-DEFUN ("set-extent-face", Fset_extent_face, Sset_extent_face, 2, 2, 0 /*
+DEFUN ("set-extent-face", Fset_extent_face, 2, 2, 0, /*
 Make the given EXTENT have the graphic attributes specified by FACE.
 FACE can also be a list of faces, and all faces listed will apply,
 with faces earlier in the list taking priority over those later in the
 list.
-*/ )
+*/
-(extent, face)
+(extent, face))
-Lisp_Object extent, face;
 {
 EXTENT e;
 Lisp_Object orig_face = face;
 CHECK_EXTENT (extent);
 return orig_face;
 }
-DEFUN ("extent-mouse-face", Fextent_mouse_face, Sextent_mouse_face, 1, 1, 0 /*
+DEFUN ("extent-mouse-face", Fextent_mouse_face, 1, 1, 0, /*
 Return the face used to highlight EXTENT when the mouse passes over it.
 The return value will be a face name, a list of face names, or nil
 if the extent's mouse face is unspecified.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 Lisp_Object face;
 CHECK_EXTENT (extent);
 face = extent_mouse_face (XEXTENT (extent));
 return external_of_internal_memoized_face (face);
 }
-DEFUN ("set-extent-mouse-face", Fset_extent_mouse_face, Sset_extent_mouse_face,
+DEFUN ("set-extent-mouse-face", Fset_extent_mouse_face, 2, 2, 0, /*
-2, 2, 0 /*
 Set the face used to highlight EXTENT when the mouse passes over it.
 FACE can also be a list of faces, and all faces listed will apply,
 with faces earlier in the list taking priority over those later in the
 list.
-*/ )
+*/
-(extent, face)
+(extent, face))
-Lisp_Object extent, face;
 {
 EXTENT e;
 Lisp_Object orig_face = face;
 CHECK_EXTENT (extent);
 set_extent_glyph (extent, glyph, endp, layout);
 return glyph;
 }
-DEFUN ("set-extent-begin-glyph", Fset_extent_begin_glyph,
+DEFUN ("set-extent-begin-glyph", Fset_extent_begin_glyph, 2, 3, 0, /*
-Sset_extent_begin_glyph, 2, 3, 0 /*
 Display a bitmap, subwindow or string at the beginning of EXTENT.
 BEGIN-GLYPH must be a glyph object.  The layout policy defaults to `text'.
-*/ )
+*/
-(extent, begin_glyph, layout)
+(extent, begin_glyph, layout))
-Lisp_Object extent, begin_glyph, layout;
 {
 return set_extent_glyph_1 (extent, begin_glyph, 0, layout);
 }
-DEFUN ("set-extent-end-glyph", Fset_extent_end_glyph,
+DEFUN ("set-extent-end-glyph", Fset_extent_end_glyph, 2, 3, 0, /*
-Sset_extent_end_glyph, 2, 3, 0 /*
 Display a bitmap, subwindow or string at the end of the EXTENT.
 END-GLYPH must be a glyph object.  The layout policy defaults to `text'.
-*/ )
+*/
-(extent, end_glyph, layout)
+(extent, end_glyph, layout))
-Lisp_Object extent, end_glyph, layout;
 {
 return set_extent_glyph_1 (extent, end_glyph, 1, layout);
 }
-DEFUN ("extent-begin-glyph", Fextent_begin_glyph, Sextent_begin_glyph,
+DEFUN ("extent-begin-glyph", Fextent_begin_glyph, 1, 1, 0, /*
-1, 1, 0 /*
 Return the glyph object displayed at the beginning of EXTENT.
 If there is none, nil is returned.
-*/ )
+*/
-(extent_obj)
+(extent_obj))
-Lisp_Object extent_obj;
 {
 return extent_begin_glyph (decode_extent (extent_obj, 0));
 }
-DEFUN ("extent-end-glyph", Fextent_end_glyph, Sextent_end_glyph, 1, 1, 0 /*
+DEFUN ("extent-end-glyph", Fextent_end_glyph, 1, 1, 0, /*
 Return the glyph object displayed at the end of EXTENT.
 If there is none, nil is returned.
-*/ )
+*/
-(extent_obj)
+(extent_obj))
-Lisp_Object extent_obj;
 {
 return extent_end_glyph (decode_extent (extent_obj, 0));
 }
-DEFUN ("set-extent-begin-glyph-layout", Fset_extent_begin_glyph_layout,
+DEFUN ("set-extent-begin-glyph-layout", Fset_extent_begin_glyph_layout, 2, 2, 0, /*
-Sset_extent_begin_glyph_layout, 2, 2, 0 /*
 Set the layout policy of the given extent's begin glyph.
 Access this using the `extent-begin-glyph-layout' function.
-*/ )
+*/
-	(extent, layout)
+(extent, layout))
-	Lisp_Object extent, layout;
 {
 EXTENT e = decode_extent (extent, 0);
 e = extent_ancestor (e);
 extent_begin_glyph_layout (e) = symbol_to_glyph_layout (layout);
 extent_maybe_changed_for_redisplay (e, 1);
 return layout;
 }
-DEFUN ("set-extent-end-glyph-layout", Fset_extent_end_glyph_layout,
+DEFUN ("set-extent-end-glyph-layout", Fset_extent_end_glyph_layout, 2, 2, 0, /*
-Sset_extent_end_glyph_layout, 2, 2, 0 /*
 Set the layout policy of the given extent's end glyph.
 Access this using the `extent-end-glyph-layout' function.
-*/ )
+*/
-	(extent, layout)
+(extent, layout))
-	Lisp_Object extent, layout;
 {
 EXTENT e = decode_extent (extent, 0);
 e = extent_ancestor (e);
 extent_end_glyph_layout (e) = symbol_to_glyph_layout (layout);
 extent_maybe_changed_for_redisplay (e, 1);
 return layout;
 }
-DEFUN ("extent-begin-glyph-layout", Fextent_begin_glyph_layout,
+DEFUN ("extent-begin-glyph-layout", Fextent_begin_glyph_layout, 1, 1, 0, /*
-Sextent_begin_glyph_layout, 1, 1, 0 /*
 Return the layout policy associated with the given extent's begin glyph.
 Set this using the `set-extent-begin-glyph-layout' function.
-*/ )
+*/
-	(extent)
+(extent))
-	Lisp_Object extent;
 {
 EXTENT e = decode_extent (extent, 0);
 return glyph_layout_to_symbol (extent_begin_glyph_layout (e));
 }
-DEFUN ("extent-end-glyph-layout", Fextent_end_glyph_layout,
+DEFUN ("extent-end-glyph-layout", Fextent_end_glyph_layout, 1, 1, 0, /*
-Sextent_end_glyph_layout, 1, 1, 0 /*
 Return the layout policy associated with the given extent's end glyph.
 Set this using the `set-extent-end-glyph-layout' function.
-*/ )
+*/
-	(extent)
+(extent))
-	Lisp_Object extent;
 {
 EXTENT e = decode_extent (extent, 0);
 return glyph_layout_to_symbol (extent_end_glyph_layout (e));
 }
-DEFUN ("set-extent-priority", Fset_extent_priority, Sset_extent_priority,
+DEFUN ("set-extent-priority", Fset_extent_priority, 2, 2, 0, /*
-2, 2, 0 /*
 Changes the display priority of EXTENT.
 When the extent attributes are being merged for display, the priority
 is used to determine which extent takes precedence in the event of a
 conflict (two extents whose faces both specify font, for example: the
 font of the extent with the higher priority will be used).
 Extents are created with priority 0; priorities may be negative.
-*/ )
+*/
-	(extent, pri)
+(extent, pri))
-	Lisp_Object extent, pri;
 {
 EXTENT e = decode_extent (extent, 0);
 CHECK_INT (pri);
 e = extent_ancestor (e);
 set_extent_priority (e, XINT (pri));
 extent_maybe_changed_for_redisplay (e, 1);
 return pri;
 }
-DEFUN ("extent-priority", Fextent_priority, Sextent_priority, 1, 1, 0 /*
+DEFUN ("extent-priority", Fextent_priority, 1, 1, 0, /*
 Return the display priority of EXTENT; see `set-extent-priority'.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT e = decode_extent (extent, 0);
 return make_int (extent_priority (e));
 }
-DEFUN ("set-extent-property", Fset_extent_property, Sset_extent_property,
+DEFUN ("set-extent-property", Fset_extent_property, 3, 3, 0, /*
-3, 3, 0 /*
 Change a property of an extent.
 PROPERTY may be any symbol; the value stored may be accessed with
 the `extent-property' function.
 The following symbols have predefined meanings:
 from the string using `concat' or `substring'.
 When `insert' or a similar function inserts the
 string into a buffer, the extents are copied back
 into the buffer.
-replicating        Meaningful only in conjunction with `duplicable'.
+unique             Meaningful only in conjunction with `duplicable'.
-If this flag is set, extents that are copied from
+When this is set, there may be only one instance
-buffers into strings are made children of the
+of this extent attached at a time: if it is copied
-original extent.  When the string is pasted back
+to the kill ring and then yanked, the extent is
-into a buffer, the same extent (i.e. the `eq'
+not copied.  If, however, it is killed (removed
-predicate applies) that was originally in the
+from the buffer) and then yanked, it will be
-buffer will be used if possible -- i.e. if the
+re-attached at the new position.
-extent is detached or the paste location abuts or
-overlaps the extent.  This behavior is compatible
-with the old "extent replica" behavior and was
-apparently required by Energize.
-unique             Meaningful only in conjunction with `duplicable'
-and `replicating'.  When this is set, there may be
-only one instance of this extent attached at a
-time: if it is copied to the kill ring and then
-yanked, the extent is not copied.  If, however, it
-is killed (removed from the buffer) and then
-yanked, it will be re-attached at the new
-position.
 invisible          If the value is non-nil, text under this extent
 may be treated as not present for the purpose of
 redisplay, or may be displayed using an ellipsis
 or other marker; see `buffer-invisibility-spec'
 begin-glyph-layout The layout policy (one of `text', `whitespace',
 `inside-margin', or `outside-margin') of the extent's
 begin glyph.
-end-glyph-layout   The layout policy of the extent's end glyph.
+end-glyph-layout The layout policy of the extent's end glyph.  */
-*/ )
+(extent, property, value))
-(extent, property, value)
-Lisp_Object extent, property, value;
 {
 /* This function can GC if property is `keymap' */
 EXTENT e = decode_extent (extent, 0);
 CHECK_SYMBOL (property);
 set_extent_read_only (e, value);
 else if (EQ (property, Qunique))
 extent_unique_p (e) = !NILP (value);
 else if (EQ (property, Qduplicable))
 extent_duplicable_p (e) = !NILP (value);
-else if (EQ (property, Qreplicating))
-extent_replicating_p (e) = !NILP (value);
 else if (EQ (property, Qinvisible))
 set_extent_invisible (e, value);
 else if (EQ (property, Qdetachable))
 extent_detachable_p (e) = !NILP (value);
 }
 return value;
 }
-DEFUN ("extent-property", Fextent_property, Sextent_property, 2, 3, 0 /*
+DEFUN ("extent-property", Fextent_property, 2, 3, 0, /*
 Return EXTENT's value for property PROPERTY.
 See `set-extent-property' for the built-in property names.
-*/ )
+*/
-(extent, property, defalt)
+(extent, property, defalt))
-Lisp_Object extent, property, defalt;
 {
 EXTENT e = decode_extent (extent, 0);
 CHECK_SYMBOL (property);
 if      (EQ (property, Qdetached))
 return (extent_normal_field (e, flag) ? Qt : Qnil)
 else if (EQ (property, Qstart_open))	 RETURN_FLAG (start_open);
 else if (EQ (property, Qend_open))	 RETURN_FLAG (end_open);
 else if (EQ (property, Qunique))	 RETURN_FLAG (unique);
 else if (EQ (property, Qduplicable))	 RETURN_FLAG (duplicable);
-else if (EQ (property, Qreplicating))	 RETURN_FLAG (replicating);
 else if (EQ (property, Qdetachable))	 RETURN_FLAG (detachable);
 #undef RETURN_FLAG
 /* Support (but don't document...) the obvious antonyms. */
 else if (EQ (property, Qstart_closed))
 return (extent_start_open_p (e) ? Qnil : Qt);
 	return defalt;
 return value;
 }
 }
-DEFUN ("extent-properties", Fextent_properties, Sextent_properties, 1, 1, 0 /*
+DEFUN ("extent-properties", Fextent_properties, 1, 1, 0, /*
 Return a property list of the attributes of the given extent.
 Do not modify this list; use `set-extent-property' instead.
-*/ )
+*/
-(extent)
+(extent))
-Lisp_Object extent;
 {
 EXTENT e, anc;
 Lisp_Object result, face, anc_obj = Qnil;
 CHECK_EXTENT (extent);
 #define CONS_FLAG(flag, sym) if (extent_normal_field (anc, flag)) \
 result = Fcons (sym, Fcons (Qt, result))
 CONS_FLAG (end_open, Qend_open);
 CONS_FLAG (start_open, Qstart_open);
-CONS_FLAG (replicating, Qreplicating);
 CONS_FLAG (detachable, Qdetachable);
 CONS_FLAG (duplicable, Qduplicable);
 CONS_FLAG (unique, Qunique);
 #undef CONS_FLAG
 extent_changed_for_redisplay (XEXTENT (extent_obj), 0);
 Vlast_highlighted_extent = extent_obj;
 }
 }
-DEFUN ("force-highlight-extent", Fforce_highlight_extent,
+DEFUN ("force-highlight-extent", Fforce_highlight_extent, 1, 2, 0, /*
-Sforce_highlight_extent, 1, 2, 0 /*
 Highlight or unhighlight the given extent.
 If the second arg is non-nil, it will be highlighted, else dehighlighted.
 This is the same as `highlight-extent', except that it will work even
 on extents without the `mouse-face' property.
-*/ )
+*/
-(extent_obj, highlight_p)
+(extent_obj, highlight_p))
-Lisp_Object extent_obj, highlight_p;
 {
 if (NILP (extent_obj))
 highlight_p = Qnil;
 else
 XSETEXTENT (extent_obj, decode_extent (extent_obj, DE_MUST_BE_ATTACHED));
 do_highlight (extent_obj, !NILP (highlight_p));
 return Qnil;
 }
-DEFUN ("highlight-extent", Fhighlight_extent, Shighlight_extent, 1, 2, 0 /*
+DEFUN ("highlight-extent", Fhighlight_extent, 1, 2, 0, /*
 Highlight the given extent, if it is highlightable
 \(that is, if it has the `mouse-face' property).
 If the second arg is non-nil, it will be highlighted, else dehighlighted.
 Highlighted extents are displayed as if they were merged with the face
 or faces specified by the `mouse-face' property.
-*/ )
+*/
-(extent_obj, highlight_p)
+(extent_obj, highlight_p))
-Lisp_Object extent_obj, highlight_p;
 {
 if (EXTENTP (extent_obj) && NILP (extent_mouse_face (XEXTENT (extent_obj))))
 return Qnil;
 else
 return (Fforce_highlight_extent (extent_obj, highlight_p));
 XSETEXTENT (tmp, copy_extent (extent, new_start, new_end, object));
 return tmp;
 }
 }
-DEFUN ("insert-extent", Finsert_extent, Sinsert_extent, 1, 5, 0 /*
+DEFUN ("insert-extent", Finsert_extent, 1, 5, 0, /*
 Insert EXTENT from START to END in BUFFER-OR-STRING.
 BUFFER-OR-STRING defaults to the current buffer if omitted.
 This operation does not insert any characters,
 but otherwise acts as if there were a replicating extent whose
 parent is EXTENT in some string that was just inserted.
 Returns the newly-inserted extent.
 The fourth arg, NO-HOOKS, can be used to inhibit the running of the
 extent's `paste-function' property if it has one.
 See documentation on `detach-extent' for a discussion of undo recording.
-*/ )
+*/
-(extent, start, end, no_hooks, buffer_or_string)
+(extent, start, end, no_hooks, buffer_or_string))
-Lisp_Object extent, start, end, no_hooks, buffer_or_string;
 {
 EXTENT ext = decode_extent (extent, 0);
 Lisp_Object copy;
 Bytind s, e;
 if (extent_duplicable_p (extent) &&
 	  !run_extent_copy_function (extent, start + closure->from,
 				     end + closure->from))
 	return 0;
 e = copy_extent (extent, start, end, closure->string);
-if (extent_replicating_p (extent))
-	{
-	  Lisp_Object e_obj = Qnil, extent_obj = Qnil;
-	  XSETEXTENT (e_obj, e);
-	  XSETEXTENT (extent_obj, extent);
-	  Fset_extent_parent (e_obj, extent_obj);
-	}
 }
 return 0;
 }
 return 0;
 if (!extent_duplicable_p (extent))
 return 0;
-if (!extent_replicating_p (extent))
+if (!inside_undo &&
-{
+!run_extent_paste_function (extent, new_start, new_end,
-if (!inside_undo &&
+				  closure->buffer))
-	  !run_extent_paste_function (extent, new_start, new_end,
+return 0;
-				      closure->buffer))
+copy_extent (extent, new_start, new_end, closure->buffer);
-	return 0;
-copy_extent (extent, new_start, new_end, closure->buffer);
-}
-else
-{
-Bytind parstart = 0;
-Bytind parend = 0;
-Lisp_Object parent_obj = extent_parent (extent);
-EXTENT parent;
-if (!EXTENTP (parent_obj))
-	return 0;
-parent = XEXTENT (parent_obj);
-if (!EXTENT_LIVE_P (parent))
-	return 0;
-if (!extent_detached_p (parent))
-	{
-	  parstart = extent_endpoint_bytind (parent, 0);
-	  parend = extent_endpoint_bytind (parent, 1);
-	}
-/* #### remove this crap */
-#ifdef ENERGIZE
-/* Energize extents like toplevel-forms can only be pasted
-	 in the buffer they come from.  This should be parametrized
-	 in the generic extent objects.  Right now just silently
-	 skip the extents if it's not from the same buffer.
-	 */
-if (!EQ (extent_object (parent), closure->buffer)
-	  && energize_extent_data (parent))
-	return 0;
-#endif
-/* If this is a `unique' extent, and it is currently attached
-	 somewhere other than here (non-overlapping), then don't copy
-	 it (that's what `unique' means).  If however it is detached,
-	 or if we are inserting inside/adjacent to the original
-	 extent, then insert_extent() will simply reattach it, which
-	 is what we want.
-	 */
-if (extent_unique_p (parent)
-	  && !extent_detached_p (parent)
-	  && (!EQ (extent_object (parent), closure->buffer)
-	      || parend > new_end
-	      || parstart < new_start))
-	return 0;
-insert_extent (parent, new_start, new_end,
-		     closure->buffer, !inside_undo);
-}
 return 0;
 }
 /* We have just inserted a section of STRING (starting at POS, of
 length LENGTH) into buffer BUF at OPOINT.  Do whatever is necessary
 copy_string_extents_1_mapper (EXTENT extent, void *arg)
 {
 struct copy_string_extents_1_arg *closure =
 (struct copy_string_extents_1_arg *) arg;
-if (extent_replicating_p (extent) &&
-EQ (extent_parent (extent), closure->parent_in_question))
-{
-closure->found_extent = extent;
-return 1; /* stop mapping */
-}
 return 0;
 }
 static int
 copy_string_extents_mapper (EXTENT extent, void *arg)
 return 0;
 new_start = old_start + closure->new_pos - closure->old_pos;
 new_end = old_end + closure->new_pos - closure->old_pos;
-if (extent_replicating_p (extent))
-{
-struct copy_string_extents_1_arg closure_1;
-closure_1.parent_in_question = extent_parent (extent);
-closure_1.found_extent = 0;
-/* When adding a replicating extent, we need to make sure
-	 that there isn't an existing replicating extent referring
-	 to the same parent extent that abuts or overlaps.  If so,
-	 we merge with that extent rather than adding anew. */
-map_extents_bytind (closure->old_pos, closure->old_pos + closure->length,
-			  copy_string_extents_1_mapper,
-			  (void *) &closure, closure->new_string, 0,
-			  /* get all extents that abut the region */
-			  ME_END_CLOSED | ME_ALL_EXTENTS_CLOSED);
-if (closure_1.found_extent)
-	{
-	  Bytecount exstart =
-	    extent_endpoint_bytind (closure_1.found_extent, 0);
-	  Bytecount exend =
-	    extent_endpoint_bytind (closure_1.found_extent, 1);
-	  exstart = min (exstart, new_start);
-	  exend = max (exend, new_end);
-	  set_extent_endpoints (closure_1.found_extent, exstart, exend, Qnil);
-	  return 0;
-	}
-}
 copy_extent (extent,
 	       old_start + closure->new_pos - closure->old_pos,
 	       old_end + closure->new_pos - closure->old_pos,
 	       closure->new_string);
 return 0;
 val = NILP (val) ? Qt : Qnil;
 return val;
 }
 }
-DEFUN ("get-text-property", Fget_text_property, Sget_text_property, 2, 4, 0 /*
+DEFUN ("get-text-property", Fget_text_property, 2, 4, 0, /*
 Returns the value of the PROP property at the given position.
 Optional arg OBJECT specifies the buffer or string to look in, and
 defaults to the current buffer.
 Optional arg AT-FLAG controls what it means for a property to be \"at\"
 a position, and has the same meaning as in `extent-at'.
 This examines only those properties added with `put-text-property'.
 See also `get-char-property'.
-*/ )
+*/
-(pos, prop, object, at_flag)
+(pos, prop, object, at_flag))
-Lisp_Object pos, prop, object, at_flag;
 {
 return get_text_property_1 (pos, prop, object, at_flag, 1);
 }
-DEFUN ("get-char-property", Fget_char_property, Sget_char_property, 2, 4, 0 /*
+DEFUN ("get-char-property", Fget_char_property, 2, 4, 0, /*
 Returns the value of the PROP property at the given position.
 Optional arg OBJECT specifies the buffer or string to look in, and
 defaults to the current buffer.
 Optional arg AT-FLAG controls what it means for a property to be \"at\"
 a position, and has the same meaning as in `extent-at'.
 This examines properties on all extents.
 See also `get-text-property'.
-*/ )
+*/
-(pos, prop, object, at_flag)
+(pos, prop, object, at_flag))
-Lisp_Object pos, prop, object, at_flag;
 {
 return get_text_property_1 (pos, prop, object, at_flag, 0);
 }
 /* About start/end-open/closed:
 }
 return closure.changed_p;
 }
-DEFUN ("put-text-property", Fput_text_property, Sput_text_property, 4, 5, 0 /*
+DEFUN ("put-text-property", Fput_text_property, 4, 5, 0, /*
 Adds the given property/value to all characters in the specified region.
 The property is conceptually attached to the characters rather than the
 region.  The properties are copied when the characters are copied/pasted.
 Fifth argument OBJECT is the buffer or string containing the text, and
 defaults to the current buffer.
-*/ )
+*/
-(start, end, prop, value, object)
+(start, end, prop, value, object))
-Lisp_Object start, end, prop, value, object;
 {
 /* This function can GC */
 Bytind s, e;
 object = decode_buffer_or_string (object);
 CHECK_SYMBOL (prop);
 put_text_prop (s, e, object, prop, value, 1);
 return prop;
 }
-DEFUN ("put-nonduplicable-text-property", Fput_nonduplicable_text_property,
+DEFUN ("put-nonduplicable-text-property",
-Sput_nonduplicable_text_property, 4, 5, 0 /*
+Fput_nonduplicable_text_property, 4, 5, 0, /*
 Adds the given property/value to all characters in the specified region.
 The property is conceptually attached to the characters rather than the
 region, however the properties will not be copied when the characters
 are copied.
 Fifth argument OBJECT is the buffer or string containing the text, and
 defaults to the current buffer.
-*/ )
+*/
-(start, end, prop, value, object)
+(start, end, prop, value, object))
-Lisp_Object start, end, prop, value, object;
 {
 /* This function can GC */
 Bytind s, e;
 object = decode_buffer_or_string (object);
 CHECK_SYMBOL (prop);
 put_text_prop (s, e, object, prop, value, 0);
 return prop;
 }
-DEFUN ("add-text-properties", Fadd_text_properties, Sadd_text_properties,
+DEFUN ("add-text-properties", Fadd_text_properties, 3, 4, 0, /*
-3, 4, 0 /*
 Add properties to the characters from START to END.
 The third argument PROPS is a property list specifying the property values
 to add.  The optional fourth argument, OBJECT, is the buffer or string
 containing the text and defaults to the current buffer.  Returns t if
 any property was changed, nil otherwise.
-*/ )
+*/
-	(start, end, props, object)
+(start, end, props, object))
-	Lisp_Object start, end, props, object;
 {
 /* This function can GC */
 int changed = 0;
 Bytind s, e;
 return (changed ? Qt : Qnil);
 }
 DEFUN ("add-nonduplicable-text-properties",
-Fadd_nonduplicable_text_properties,
+Fadd_nonduplicable_text_properties, 3, 4, 0, /*
-Sadd_nonduplicable_text_properties,
-3, 4, 0 /*
 Add nonduplicable properties to the characters from START to END.
 (The properties will not be copied when the characters are copied.)
 The third argument PROPS is a property list specifying the property values
 to add.  The optional fourth argument, OBJECT, is the buffer or string
 containing the text and defaults to the current buffer.  Returns t if
 any property was changed, nil otherwise.
-*/ )
+*/
-	(start, end, props, object)
+(start, end, props, object))
-	Lisp_Object start, end, props, object;
 {
 /* This function can GC */
 int changed = 0;
 Bytind s, e;
 changed |= put_text_prop (s, e, object, prop, value, 0);
 }
 return (changed ? Qt : Qnil);
 }
-DEFUN ("remove-text-properties", Fremove_text_properties,
+DEFUN ("remove-text-properties", Fremove_text_properties, 3, 4, 0, /*
-Sremove_text_properties, 3, 4, 0 /*
 Remove the given properties from all characters in the specified region.
 PROPS should be a plist, but the values in that plist are ignored (treated
 as nil).  Returns t if any property was changed, nil otherwise.
 Fourth argument OBJECT is the buffer or string containing the text, and
 defaults to the current buffer.
-*/ )
+*/
-	(start, end, props, object)
+(start, end, props, object))
-	Lisp_Object start, end, props, object;
 {
 /* This function can GC */
 int changed = 0;
 Bytind s, e;
 The lisp implementation of this was probably fast enough, but since I moved
 the rest of the put-text-prop code here, I moved this as well for
 completeness.
 */
-DEFUN ("text-prop-extent-paste-function", Ftext_prop_extent_paste_function,
+DEFUN ("text-prop-extent-paste-function",
-Stext_prop_extent_paste_function, 3, 3, 0 /*
+Ftext_prop_extent_paste_function, 3, 3, 0, /*
 Used as the `paste-function' property of `text-prop' extents.
-*/ )
+*/
-(extent, from, to)
+(extent, from, to))
-Lisp_Object extent, from, to;
 {
 /* This function can GC */
 Lisp_Object prop, val;
 prop = Fextent_property (extent, Qtext_prop, Qnil);
 if (NILP (prop))
 signal_simple_error ("internal error: no text-prop", extent);
 val = Fextent_property (extent, prop, Qnil);
+#if 0
+/* removed by bill perry, 2/9/97
+** This little bit of code would not allow you to have a text property
+** with a value of Qnil.  This is bad bad bad.
+*/
 if (NILP (val))
 signal_simple_error_2 ("internal error: no text-prop",
 			   extent, prop);
+#endif
 Fput_text_property (from, to, prop, val, Qnil);
 return Qnil; /* important! */
 }
 /* This function could easily be written in Lisp but the C code wants
 to use it in connection with invisible extents (at least currently).
 If this changes, consider moving this back into Lisp. */
-DEFUN ("next-single-property-change", Fnext_single_property_change,
+DEFUN ("next-single-property-change", Fnext_single_property_change, 2, 4, 0, /*
-Snext_single_property_change, 2, 4, 0 /*
 Return the position of next property change for a specific property.
 Scans characters forward from POS till it finds a change in the PROP
 property, then returns the position of the change.  The optional third
 argument OBJECT is the buffer or string to scan (defaults to the current
 buffer).
 past position LIMIT; return LIMIT if nothing is found before LIMIT.
 If two or more extents with conflicting non-nil values for PROP overlap
 a particular character, it is undefined which value is considered to be
 the value of PROP. (Note that this situation will not happen if you always
 use the text-property primitives.)
-*/ )
+*/
-(pos, prop, object, limit)
+(pos, prop, object, limit))
-Lisp_Object pos, prop, object, limit;
 {
 Bufpos bpos;
 Bufpos blim;
 Lisp_Object extent, value;
 int limit_was_nil;
 return make_int (blim);
 }
 /* See comment on previous function about why this is written in C. */
-DEFUN ("previous-single-property-change", Fprevious_single_property_change,
+DEFUN ("previous-single-property-change",
-Sprevious_single_property_change, 2, 4, 0 /*
+Fprevious_single_property_change, 2, 4, 0, /*
 Return the position of next property change for a specific property.
 Scans characters backward from POS till it finds a change in the PROP
 property, then returns the position of the change.  The optional third
 argument OBJECT is the buffer or string to scan (defaults to the current
 buffer).
 past position LIMIT; return LIMIT if nothing is found until LIMIT.
 If two or more extents with conflicting non-nil values for PROP overlap
 a particular character, it is undefined which value is considered to be
 the value of PROP. (Note that this situation will not happen if you always
 use the text-property primitives.)
-*/ )
+*/
-(pos, prop, object, limit)
+(pos, prop, object, limit))
-Lisp_Object pos, prop, object, limit;
 {
 Bufpos bpos;
 Bufpos blim;
 Lisp_Object extent, value;
 int limit_was_nil;
 defsymbol (&Qend_closed, "end-closed");
 defsymbol (&Qread_only, "read-only");
 /* defsymbol (&Qhighlight, "highlight"); in faces.c */
 defsymbol (&Qunique, "unique");
 defsymbol (&Qduplicable, "duplicable");
-defsymbol (&Qreplicating, "replicating");
 defsymbol (&Qdetachable, "detachable");
 defsymbol (&Qpriority, "priority");
 defsymbol (&Qmouse_face, "mouse-face");
 defsymbol (&Qglyph_layout, "glyph-layout");	/* backwards compatibility */
 defsymbol (&Qtext_prop, "text-prop");
 defsymbol (&Qtext_prop_extent_paste_function,
 	     "text-prop-extent-paste-function");
-defsubr (&Sextentp);
+DEFSUBR (Fextentp);
-defsubr (&Sextent_live_p);
+DEFSUBR (Fextent_live_p);
-defsubr (&Sextent_detached_p);
+DEFSUBR (Fextent_detached_p);
-defsubr (&Sextent_start_position);
+DEFSUBR (Fextent_start_position);
-defsubr (&Sextent_end_position);
+DEFSUBR (Fextent_end_position);
-defsubr (&Sextent_object);
+DEFSUBR (Fextent_object);
-defsubr (&Sextent_length);
+DEFSUBR (Fextent_length);
 #if 0
-defsubr (&Sstack_of_extents);
+DEFSUBR (Fstack_of_extents);
 #endif
-defsubr (&Smake_extent);
+DEFSUBR (Fmake_extent);
-defsubr (&Scopy_extent);
+DEFSUBR (Fcopy_extent);
-defsubr (&Sdelete_extent);
+DEFSUBR (Fdelete_extent);
-defsubr (&Sdetach_extent);
+DEFSUBR (Fdetach_extent);
-defsubr (&Sset_extent_endpoints);
+DEFSUBR (Fset_extent_endpoints);
-defsubr (&Snext_extent);
+DEFSUBR (Fnext_extent);
-defsubr (&Sprevious_extent);
+DEFSUBR (Fprevious_extent);
 #if DEBUG_XEMACS
-defsubr (&Snext_e_extent);
+DEFSUBR (Fnext_e_extent);
-defsubr (&Sprevious_e_extent);
+DEFSUBR (Fprevious_e_extent);
 #endif
-defsubr (&Snext_extent_change);
+DEFSUBR (Fnext_extent_change);
-defsubr (&Sprevious_extent_change);
+DEFSUBR (Fprevious_extent_change);
-defsubr (&Sextent_parent);
+DEFSUBR (Fextent_parent);
-defsubr (&Sextent_children);
+DEFSUBR (Fextent_children);
-defsubr (&Sset_extent_parent);
+DEFSUBR (Fset_extent_parent);
-defsubr (&Sextent_in_region_p);
+DEFSUBR (Fextent_in_region_p);
-defsubr (&Smap_extents);
+DEFSUBR (Fmap_extents);
-defsubr (&Smap_extent_children);
+DEFSUBR (Fmap_extent_children);
-defsubr (&Sextent_at);
+DEFSUBR (Fextent_at);
-defsubr (&Sextent_face);
+DEFSUBR (Fextent_face);
-defsubr (&Sset_extent_face);
+DEFSUBR (Fset_extent_face);
-defsubr (&Sextent_mouse_face);
+DEFSUBR (Fextent_mouse_face);
-defsubr (&Sset_extent_mouse_face);
+DEFSUBR (Fset_extent_mouse_face);
-defsubr (&Sset_extent_begin_glyph);
+DEFSUBR (Fset_extent_begin_glyph);
-defsubr (&Sset_extent_end_glyph);
+DEFSUBR (Fset_extent_end_glyph);
-defsubr (&Sextent_begin_glyph);
+DEFSUBR (Fextent_begin_glyph);
-defsubr (&Sextent_end_glyph);
+DEFSUBR (Fextent_end_glyph);
-defsubr (&Sset_extent_begin_glyph_layout);
+DEFSUBR (Fset_extent_begin_glyph_layout);
-defsubr (&Sset_extent_end_glyph_layout);
+DEFSUBR (Fset_extent_end_glyph_layout);
-defsubr (&Sextent_begin_glyph_layout);
+DEFSUBR (Fextent_begin_glyph_layout);
-defsubr (&Sextent_end_glyph_layout);
+DEFSUBR (Fextent_end_glyph_layout);
-defsubr (&Sset_extent_priority);
+DEFSUBR (Fset_extent_priority);
-defsubr (&Sextent_priority);
+DEFSUBR (Fextent_priority);
-defsubr (&Sset_extent_property);
+DEFSUBR (Fset_extent_property);
-defsubr (&Sextent_property);
+DEFSUBR (Fextent_property);
-defsubr (&Sextent_properties);
+DEFSUBR (Fextent_properties);
-defsubr (&Shighlight_extent);
+DEFSUBR (Fhighlight_extent);
-defsubr (&Sforce_highlight_extent);
+DEFSUBR (Fforce_highlight_extent);
-defsubr (&Sinsert_extent);
+DEFSUBR (Finsert_extent);
-defsubr (&Sget_text_property);
+DEFSUBR (Fget_text_property);
-defsubr (&Sget_char_property);
+DEFSUBR (Fget_char_property);
-defsubr (&Sput_text_property);
+DEFSUBR (Fput_text_property);
-defsubr (&Sput_nonduplicable_text_property);
+DEFSUBR (Fput_nonduplicable_text_property);
-defsubr (&Sadd_text_properties);
+DEFSUBR (Fadd_text_properties);
-defsubr (&Sadd_nonduplicable_text_properties);
+DEFSUBR (Fadd_nonduplicable_text_properties);
-defsubr (&Sremove_text_properties);
+DEFSUBR (Fremove_text_properties);
-defsubr (&Stext_prop_extent_paste_function);
+DEFSUBR (Ftext_prop_extent_paste_function);
-defsubr (&Snext_single_property_change);
+DEFSUBR (Fnext_single_property_change);
-defsubr (&Sprevious_single_property_change);
+DEFSUBR (Fprevious_single_property_change);
 }
 void
 vars_of_extents (void)
 {

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 20:859a2309aef8 r19-15b93