xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 173:8eaf7971accc r20-3b13

Import from CVS: tag r20-3b13

author	cvs
date	Mon, 13 Aug 2007 09:49:09 +0200
parents	929b76928fce
children	2d532a89d707

comparison

equal deleted inserted replaced

-:a38aed19690b
+:8eaf7971accc
 necessarily consistent with the extents that `map-extents'
 maps over, since `map-extents' sometimes pays attention to
 whether the endpoints of an extents are open or closed.
 But for our purposes, it greatly simplifies things to treat
 all extents as having closed endpoints.
 First, define >, <, <=, etc. as applied to extents to mean
 comparison according to the display order.  Comparison between an
 extent E and an index I means comparison between E and the range
 [I, I].
 Also define e>, e<, e<=, etc. to mean comparison according to the
 Now:
 Let R be a range.
 Let F be the first extent overlapping R.
 Let L be the last extent overlapping R.
 Theorem 1: R(1) lies between L and L(next), i.e. L <= R(1) < L(next).
 This follows easily from the definition of display order.  The
 basic reason that this theorem applies is that the display order
 sorts by increasing starting index.
 */
 #include <config.h>
 #include "lisp.h"
 #include "buffer.h"
 #include "debug.h"
 #include "device.h"
 #include "elhash.h"
 #include "extents.h"
 #include "faces.h"
 {
 /* RIGHT might not point to a valid extent (i.e. it's at the end
 	 of the list), so NEWPOS must round down. */
 unsigned int newpos = (left + right) >> 1;
 e = EXTENT_GAP_ARRAY_AT (ga, newpos);
 if (endp ? EXTENT_E_LESS (e, extent) : EXTENT_LESS (e, extent))
 	left = newpos+1;
 else
 	right = newpos;
 }
 ((markobj) (data->end_glyph));
 ((markobj) (data->invisible));
 ((markobj) (data->children));
 ((markobj) (data->read_only));
 ((markobj) (data->mouse_face));
-return (data->parent);
+return data->parent;
 }
 void
 allocate_extent_auxiliary (EXTENT ext)
 {
 if (NILP (object))
 XSETBUFFER (object, current_buffer);
 else
 CHECK_LIVE_BUFFER_OR_STRING (object);
 return object;
 }
 EXTENT
 extent_ancestor_1 (EXTENT e)
 {
 while (e->flags.has_parent)
 static struct extent_info *
 buffer_or_string_extent_info_force (Lisp_Object object)
 {
 struct extent_info *info = buffer_or_string_extent_info (object);
 if (!info)
 {
 Lisp_Object extent_info;
 assert (STRINGP (object)); /* should never happen for buffers --
 /* Return the start (endp == 0) or end (endp == 1) of an extent as
 a byte index.  If you want the value as a memory index, use
 extent_endpoint().  If you want the value as a buffer position,
 use extent_endpoint_bufpos(). */
 static Bytind
 extent_endpoint_bytind (EXTENT extent, int endp)
 {
 assert (EXTENT_LIVE_P (extent));
 assert (!extent_detached_p (extent));
 {
 					  invisibility_change);
 	}
 }
 /* now mark the extent itself. */
 object = extent_object (extent);
 if (!BUFFERP (object) || extent_detached_p (extent))
 /* #### Can changes to string extents affect redisplay?
 I will have to think about this.  What about string glyphs?
 				      !NILP (extent_invisible (extent)));
 }
 static void
 extent_detach (EXTENT extent)
 {
 Extent_List *el;
 if (extent_detached_p (extent))
 return;
 el = extent_extent_list (extent);
 };
 static Lisp_Object
 map_extents_unwind (Lisp_Object obj)
 {
 struct map_extents_struct *closure =
 (struct map_extents_struct *) get_opaque_ptr (obj);
 free_opaque_ptr (obj);
 if (closure->range)
 extent_detach (closure->range);
 if (closure->mkr)
 	range_start_type = 2;
 	range_start_pos = 0;
 #else
 	Stack_Of_Extents *soe = buffer_or_string_stack_of_extents_force (obj);
 	int numsoe;
 	/* Move the SOE to the closer end of the range.  This dictates
 	   whether we map over start positions or end positions. */
 	range_endp = 0;
 	soe_move (obj, st);
 	numsoe = extent_list_num_els (soe->extents);
 	       ME_START_IN_REGION or ME_END_IN_REGION was specified.
 	       RANGE_ENDP already specified so no need to do anything else. */
 	  }
 }
 #endif
 /* ---------- Now loop over the extents. ---------- */
 /* We combine the code for the two stages because much of it
 overlaps. */
 for (stage = 0; stage < 2; stage++)
 {
 struct adjust_extents_for_deletion_arg closure;
 int i;
 Memind adjust_to = (Memind) (to + gapsize);
 Bytecount amount = - numdel - movegapsize;
-Memind oldsoe, newsoe;
+Memind oldsoe = 0, newsoe = 0;
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents (object);
 #ifdef ERROR_CHECK_EXTENTS
 sledgehammer_extent_check (object);
 #endif
 {
 CONST EXTENT foo = * (CONST EXTENT *) humpty;
 CONST EXTENT bar = * (CONST EXTENT *) dumpty;
 if (extent_priority (foo) < extent_priority (bar))
 return -1;
-return (extent_priority (foo) > extent_priority (bar));
+return extent_priority (foo) > extent_priority (bar);
 }
 static void
 extent_fragment_sort_by_priority (extent_dynarr *extarr)
 {
 EXTENT e = extent_list_at (sel, i, 0);
 if (extent_start (e) == mempos && !NILP (extent_begin_glyph (e)))
 	{
 	  Lisp_Object glyph = extent_begin_glyph (e);
 	  struct glyph_block gb;
 	  gb.glyph = glyph;
 	  gb.extent = Qnil;
 	  XSETEXTENT (gb.extent, e);
 	  Dynarr_add (ef->begin_glyphs, gb);
 	}
 }
 /* Determine the end glyphs at POS. */
 for (i = 0; i < extent_list_num_els (sel); i++)
 {
 EXTENT e = extent_list_at (sel, i, 1);
 if (extent_end (e) == mempos && !NILP (extent_end_glyph (e)))
 	{
 	  Lisp_Object glyph = extent_end_glyph (e);
 	  struct glyph_block gb;
 	  gb.glyph = glyph;
 	  gb.extent = Qnil;
 	  XSETEXTENT (gb.extent, e);
 	  Dynarr_add (ef->end_glyphs, gb);
 	}
 extent_fragment_sort_by_priority (ef->extents);
 /* Now merge the faces together into a single face.  The code to
 do this is in faces.c because it involves manipulating faces. */
 return get_extent_fragment_face_cache_index (w, ef);
 }
 /************************************************************************/
 /*	  	        extent-object methods				*/
 /************************************************************************/
 {
 struct extent *extent = XEXTENT (obj);
 ((markobj) (extent_object (extent)));
 ((markobj) (extent_no_chase_normal_field (extent, face)));
-return (extent->plist);
+return extent->plist;
 }
 static char *
-print_extent_1 (char *buf, Lisp_Object extent_obj)
+print_extent_1 (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-EXTENT ext = XEXTENT (extent_obj);
+EXTENT ext = XEXTENT (obj);
 EXTENT anc = extent_ancestor (ext);
-char *bp = buf;
 Lisp_Object tail;
+char buf[64], *bp = buf;
 /* Retrieve the ancestor and use it, for faster retrieval of properties */
 if (!NILP (extent_begin_glyph (anc))) *bp++ = '*';
 *bp++ = (extent_start_open_p (anc) ? '(': '[');
 if (extent_detached_p (ext))
 sprintf (bp, "detached");
 else
 {
-Bufpos from = XINT (Fextent_start_position (extent_obj));
+Bufpos from = XINT (Fextent_start_position (obj));
-Bufpos to = XINT (Fextent_end_position (extent_obj));
+Bufpos to = XINT (Fextent_end_position (obj));
 sprintf (bp, "%d, %d", from, to);
 }
 bp += strlen (bp);
 *bp++ = (extent_end_open_p (anc) ? ')': ']');
 if (!NILP (extent_end_glyph (anc))) *bp++ = '*';
 if (!NILP (extent_read_only (anc)) || !NILP (extent_mouse_face (anc)) ||
 extent_unique_p (anc) ||
 extent_duplicable_p (anc) || !NILP (extent_invisible (anc)))
 *bp++ = ' ';
+*bp = '\0';
+write_c_string (buf, printcharfun);
 tail = extent_plist_slot (anc);
 for (; !NILP (tail); tail = Fcdr (Fcdr (tail)))
 {
-struct Lisp_String *k;
 Lisp_Object v = XCAR (XCDR (tail));
 if (NILP (v)) continue;
-if (!SYMBOLP (XCAR (tail)))
+print_internal (XCAR (tail), printcharfun, escapeflag);
-	{
+write_c_string (" ", printcharfun);
-	  /* ### Fix this! */
+}
-	  strcpy (bp, "non-symbol ");
-	  bp += 11;
+sprintf (buf, "0x%lx", (long) ext);
-	  continue;
+write_c_string (buf, printcharfun);
-	}
-k = XSYMBOL (XCAR (tail))->name;
-memcpy (bp, (char *) string_data (k), string_length (k));
-bp += string_length (k);
-*bp++ = ' ';
-}
-sprintf (bp, "0x%lx", (long) ext);
-bp += strlen (bp);
-*bp++ = 0;
-return buf;
 }
 static void
 print_extent (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 {
-char buf2[256];
 if (escapeflag)
 {
 CONST char *title = "";
 CONST char *name = "";
 CONST char *posttitle = "";
 Lisp_Object obj2 = Qnil;
 /* Destroyed extents have 't' in the object field, causing
 	 extent_object() to abort (maybe). */
 if (EXTENT_LIVE_P (XEXTENT (obj)))
 	obj2 = extent_object (XEXTENT (obj));
 if (NILP (obj2))
 	title = "no buffer";
 else if (BUFFERP (obj2))
 	{
 	  if (BUFFER_LIVE_P (XBUFFER (obj2)))
 	  assert (STRINGP (obj2));
 	  title = "string \"";
 	  posttitle = "\"";
 	  name = (char *) XSTRING_DATA (obj2);
 	}
 if (print_readably)
 	{
 	  if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	    error ("printing unreadable object #<destroyed extent>");
 	  else
-	    error ("printing unreadable object #<extent %s>",
+	    error ("printing unreadable object #<extent 0x%lx>",
-		   print_extent_1 (buf2, obj));
+		   (long)XEXTENT (obj));
 	}
 if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	write_c_string ("#<destroyed extent", printcharfun);
 else
 	{
-	  char buf[256];
+	  char *buf = alloca (strlen (title) + strlen (name)
+			      + strlen (posttitle));
 	  write_c_string ("#<extent ", printcharfun);
-	  if (extent_detached_p (XEXTENT (obj)))
+	  print_extent_1 (obj, printcharfun, escapeflag);
-	    sprintf (buf, "%s from %s%s%s",
+	  write_c_string (extent_detached_p (XEXTENT (obj))
-		     print_extent_1 (buf2, obj), title, name, posttitle);
+			  ? " from " : " in ", printcharfun);
-	  else
+	  sprintf (buf, "%s%s%s", title, name, posttitle);
-	    sprintf (buf, "%s in %s%s%s",
-		     print_extent_1 (buf2, obj),
-		     title, name, posttitle);
 	  write_c_string (buf, printcharfun);
 	}
 }
 else
 {
 if (value)
 return 0;
 }
 /* compare the random elements of the plists. */
-return (!plists_differ (extent_no_chase_plist (e1),
+return !plists_differ (extent_no_chase_plist (e1),
-			  extent_no_chase_plist (e2),
+			 extent_no_chase_plist (e2),
-			  0, 0, depth + 1));
+			 0, 0, depth + 1);
 }
 static int
 extent_equal (Lisp_Object o1, Lisp_Object o2, int depth)
 {
 if (NILP (obj) && (flags & DE_MUST_HAVE_BUFFER))
 {
 signal_simple_error ("extent doesn't belong to a buffer or string",
 			   extent_obj);
 }
 if (extent_detached_p (extent) && (flags & DE_MUST_BE_ATTACHED))
 {
 signal_simple_error ("extent cannot be detached", extent_obj);
 }
 {
 if (EXTENTP (object))
 return Qt;
 return Qnil;
 }
 DEFUN ("extent-live-p", Fextent_live_p, 1, 1, 0, /*
 T if OBJECT is an extent and the extent has not been destroyed.
 */
 (object))
 {
 next = extent_next (decode_extent (extent, DE_MUST_BE_ATTACHED));
 else
 next = extent_first (decode_buffer_or_string (extent));
 if (!next)
-return (Qnil);
+return Qnil;
 XSETEXTENT (val, next);
-return (val);
+return val;
 }
 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
 prev = extent_previous (decode_extent (extent, DE_MUST_BE_ATTACHED));
 else
 prev = extent_last (decode_buffer_or_string (extent));
 if (!prev)
-return (Qnil);
+return Qnil;
 XSETEXTENT (val, prev);
-return (val);
+return val;
 }
 #ifdef DEBUG_XEMACS
 DEFUN ("next-e-extent", Fnext_e_extent, 1, 1, 0, /*
 next = extent_e_next (decode_extent (extent, DE_MUST_BE_ATTACHED));
 else
 next = extent_e_first (decode_buffer_or_string (extent));
 if (!next)
-return (Qnil);
+return Qnil;
 XSETEXTENT (val, next);
-return (val);
+return val;
 }
 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
 prev = extent_e_previous (decode_extent (extent, DE_MUST_BE_ATTACHED));
 else
 prev = extent_e_last (decode_buffer_or_string (extent));
 if (!prev)
-return (Qnil);
+return Qnil;
 XSETEXTENT (val, prev);
-return (val);
+return val;
 }
 #endif
 DEFUN ("next-extent-change", Fnext_extent_change, 1, 2, 0, /*
 static EXTENT
 make_extent_internal (Lisp_Object object, Bytind from, Bytind to)
 {
 EXTENT extent;
 extent = make_extent_detached (object);
 set_extent_endpoints (extent, from, to, Qnil);
 return extent;
 }
 	Lisp_Object extent;
 	XSETEXTENT (extent, e);
 	add_extent_to_children_list (XEXTENT (parent), extent);
 }
 }
 /* #### it's still unclear to me that this Energize-specific junk
 needs to be in here.  Just use the general mechanisms, or fix
 them up! --ben */
 #ifdef ENERGIZE
 if (energize_extent_data (original))
 #endif
 return e;
 }
 static void
 destroy_extent (EXTENT extent)
 {
 Lisp_Object rest, nextrest, children;
 Lisp_Object extent_obj = Qnil;
 if (!extent_detached_p (extent))
 else
 buffer_or_string = decode_buffer_or_string (buffer_or_string);
 if (NILP (start) && NILP (end))
 return Fdetach_extent (extent);
 get_buffer_or_string_range_byte (buffer_or_string, start, end, &s, &e,
 				   GB_ALLOW_PAST_ACCESSIBLE);
 set_extent_endpoints (ext, s, e, buffer_or_string);
 return extent;
 /* ------------------------------- */
 /*             extent-at           */
 /* ------------------------------- */
 /* find "smallest" matching extent containing pos -- (flag == 0) means
 all extents match, else (EXTENT_FLAGS (extent) & flag) must be true;
 for more than one matching extent with precisely the same endpoints,
 we choose the last extent in the extents_list.
 The search stops just before "before", if that is non-null.
 */
 return Qnil;
 closure.best_match = 0;
 closure.prop = property;
 closure.before = before;
 map_extents_bytind (at_flag == EXTENT_AT_BEFORE ? position - 1 : position,
 		      at_flag == EXTENT_AT_AFTER ? position + 1 : position,
 		      extent_at_mapper, (void *) &closure, object, 0,
 		      ME_START_OPEN | ME_ALL_EXTENTS_CLOSED);
 {
 Bytind opoint;
 int length;
 Lisp_Object object;
 };
 /*   A region of length LENGTH was just inserted at OPOINT.  Modify all
 of the extents as required for the insertion, based on their
 start-open/end-open properties.
 */
 static int
 process_extents_for_insertion_mapper (EXTENT extent, void *arg)
 {
 struct process_extents_for_insertion_arg *closure =
 (struct process_extents_for_insertion_arg *) arg;
-Memind indecks = buffer_or_string_bytind_to_memind (closure->object,
+Memind indice = buffer_or_string_bytind_to_memind (closure->object,
 						      closure->opoint);
 /* When this function is called, one end of the newly-inserted text should
 be adjacent to some endpoint of the extent, or disjoint from it.  If
 the insertion overlaps any existing extent, something is wrong.
 */
 #ifdef ERROR_CHECK_EXTENTS
-if (extent_start (extent) > indecks &&
+if (extent_start (extent) > indice &&
-extent_start (extent) < indecks + closure->length)
+extent_start (extent) < indice + closure->length)
 abort ();
-if (extent_end (extent) > indecks &&
+if (extent_end (extent) > indice &&
-extent_end (extent) < indecks + closure->length)
+extent_end (extent) < indice + closure->length)
 abort ();
 #endif
 /* The extent-adjustment code adjusted the extent's endpoints as if
 they were markers -- endpoints at the gap (i.e. the insertion
 {
 Memind new_start, new_end;
 new_start = extent_start (extent);
 new_end = extent_end (extent);
-if (indecks == extent_start (extent) && extent_start_open_p (extent) &&
+if (indice == extent_start (extent) && extent_start_open_p (extent) &&
 	/* coerce zero-length () extents to [) */
 	new_start != new_end)
 new_start += closure->length;
-if (indecks == extent_end (extent) && !extent_end_open_p (extent))
+if (indice == extent_end (extent) && !extent_end_open_p (extent))
 new_end += closure->length;
 set_extent_endpoints_1 (extent, new_start, new_end);
 }
 return 0;
 struct process_extents_for_insertion_arg closure;
 closure.opoint = opoint;
 closure.length = length;
 closure.object = object;
 map_extents_bytind (opoint, opoint + length,
 		      process_extents_for_insertion_mapper,
 		      (void *) &closure, object, 0,
 		      ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS |
 		      ME_INCLUDE_INTERNAL);
 if they're detachable or open-open. */
 static int
 process_extents_for_deletion_mapper (EXTENT extent, void *arg)
 {
 struct process_extents_for_deletion_arg *closure =
 (struct process_extents_for_deletion_arg *) arg;
 /* If the extent lies completely within the range that
 is being deleted, then nuke the extent if it's detachable
 (otherwise, it will become a zero-length extent). */
 /* We canonicalize the given list into another list.
 We try to avoid consing except when necessary, so we have
 a reusable list.
 */
 if (thelen < len)
 {
 cons = Vextent_face_reusable_list;
 while (!NILP (XCDR (cons)))
 	cons = XCDR (cons);
 the `extent-property' function.
 The following symbols have predefined meanings:
 detached           Removes the extent from its buffer; setting this is
 the same as calling `detach-extent'.
 destroyed          Removes the extent from its buffer, and makes it
 unusable in the future; this is the same calling
 `delete-extent'.
 priority           Change redisplay priority; same as `set-extent-priority'.
 start-open         Whether the set of characters within the extent is
 treated being open on the left, that is, whether
 the start position is an exclusive, rather than
 inclusive, boundary.  If true, then characters
 inserted exactly at the beginning of the extent
 will remain outside of the extent; otherwise they
 will go into the extent, extending it.
 end-open           Whether the set of characters within the extent is
 treated being open on the right, that is, whether
 the end position is an exclusive, rather than
 inclusive, boundary.  If true, then characters
 inserted exactly at the end of the extent will
 remain outside of the extent; otherwise they will
 go into the extent, extending it.
 By default, extents have the `end-open' but not the
 `start-open' property set.
 read-only          Text within this extent will be unmodifiable.
 detachable         Whether the extent gets detached (as with
 `detach-extent') when all the text within the
 extent is deleted.  This is true by default.  If
 this property is not set, the extent becomes a
 zero-length extent when its text is deleted. (In
 such a case, the `start-open' property is
 automatically removed if both the `start-open' and
 `end-open' properties are set, since zero-length
 extents open on both ends are not allowed.)
 face               The face in which to display the text.  Setting
 this is the same as calling `set-extent-face'.
 mouse-face	    If non-nil, the extent will be highlighted in this
 		    face when the mouse moves over it.
 highlight          Obsolete: Setting this property is equivalent to
 		    setting a `mouse-face' property of `highlight'.
 		    Reading this property returns non-nil if
 		    the extent has a non-nil `mouse-face' property.
 duplicable         Whether this extent should be copied into strings,
 so that kill, yank, and undo commands will restore
 or copy it.  `duplicable' extents are copied from
 an extent into a string when `buffer-substring' or
 a similar function creates a string.  The extents
 in a string are copied into other strings created
 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.
 unique             Meaningful only in conjunction with `duplicable'.
 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'
 and `invisible-text-glyph'.  In all cases,
 however, the text is still visible to other
 functions that examine a buffer's text.
 keymap             This keymap is consulted for mouse clicks on this
 extent, or keypresses made while point is within the
 extent.
 copy-function      This is a hook that is run when a duplicable extent
 is about to be copied from a buffer to a string (or
 the kill ring).  It is called with three arguments,
 the extent, and the buffer-positions within it
 which are being copied.  If this function returns
 nil, then the extent will not be copied; otherwise
 it will.
 paste-function     This is a hook that is run when a duplicable extent is
 about to be copied from a string (or the kill ring)
 into a buffer.  It is called with three arguments,
 the original extent, and the buffer positions which
 the copied extent will occupy.  (This hook is run
 inserted into the buffer.)  Note that the extent
 argument may be detached when this function is run.
 If this function returns nil, no extent will be
 inserted.  Otherwise, there will be an extent
 covering the range in question.
 If the original extent is not attached to a buffer,
 then it will be re-attached at this range.
 Otherwise, a copy will be made, and that copy
 attached here.
 The copy-function and paste-function are meaningful
 only for extents with the `duplicable' flag set,
 and if they are not specified, behave as if `t' was
 the returned value.  When these hooks are invoked,
 the current buffer is the buffer which the extent
 is being copied from/to, respectively.
 begin-glyph        A glyph to be displayed at the beginning of the extent,
 or nil.
 end-glyph          A glyph to be displayed at the end of the extent,
 or nil.
 begin-glyph-layout The layout policy (one of `text', `whitespace',
 `inside-margin', or `outside-margin') of the extent's
 Fset_extent_face (extent, value);
 else if (EQ (property, Qmouse_face))
 Fset_extent_mouse_face (extent, value);
 /* Obsolete: */
 else if (EQ (property, Qhighlight))
 Fset_extent_mouse_face (extent, Qhighlight);
 else if (EQ (property, Qbegin_glyph_layout))
 Fset_extent_begin_glyph_layout (extent, value);
 else if (EQ (property, Qend_glyph_layout))
 Fset_extent_end_glyph_layout (extent, value);
 /* For backwards compatibility.  We use begin glyph because it is by
 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, default_))
 {
 EXTENT e = decode_extent (extent, 0);
 if      (EQ (property, Qdetached))
-return (extent_detached_p (e) ? Qt : Qnil);
+return extent_detached_p (e) ? Qt : Qnil;
 else if (EQ (property, Qdestroyed))
-return (!EXTENT_LIVE_P (e) ? Qt : Qnil);
+return !EXTENT_LIVE_P (e) ? Qt : Qnil;
-#define RETURN_FLAG(flag) \
+#define RETURN_FLAG(flag) return extent_normal_field (e, flag) ? Qt : Qnil
-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, 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 extent_start_open_p (e) ? Qnil : Qt;
 else if (EQ (property, Qend_closed))
-return (extent_end_open_p (e) ? Qnil : Qt);
+return extent_end_open_p (e) ? Qnil : Qt;
 else if (EQ (property, Qpriority))
 return make_int (extent_priority (e));
 else if (EQ (property, Qread_only))
 return extent_read_only (e);
 else if (EQ (property, Qinvisible))
 Lisp_Object value;
 value = external_plist_get (extent_plist_addr (e), property, 0,
 				  ERROR_ME);
 if (UNBOUNDP (value))
-	return defalt;
+	return default_;
 return value;
 }
 }
 DEFUN ("extent-properties", Fextent_properties, 1, 1, 0, /*
 /************************************************************************/
 /*		    	     highlighting      				*/
 /************************************************************************/
 /* The display code looks into the Vlast_highlighted_extent variable to
 correctly display highlighted extents.  This updates that variable,
 and marks the appropriate buffers as needing some redisplay.
 */
 static void
 do_highlight (Lisp_Object extent_obj, int highlight_p)
 (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));
+return Fforce_highlight_extent (extent_obj, highlight_p);
 }
 /************************************************************************/
 /*			   strings and extents				*/
 (e, buffer_or_string_bytind_to_bufpos (object, from),
 buffer_or_string_bytind_to_bufpos (object, to), object,
 Qpaste_function);
 }
 static void
 update_extent (EXTENT extent, Bytind from, Bytind to)
 {
 set_extent_endpoints (extent, from, to, Qnil);
 /* #### remove this crap */
 #ifdef ENERGIZE
 }
 else
 {
 Bytind exstart = extent_endpoint_bytind (extent, 0);
 Bytind exend = extent_endpoint_bytind (extent, 1);
 if (exend < new_start || exstart > new_end)
 	goto copy_it;
 else
 	{
 	  new_start = min (exstart, new_start);
 static int
 add_string_extents_mapper (EXTENT extent, void *arg)
 {
 /* This function can GC */
 struct add_string_extents_arg *closure =
 (struct add_string_extents_arg *) arg;
 Bytecount start = extent_endpoint_bytind (extent, 0) - closure->from;
 Bytecount end = extent_endpoint_bytind (extent, 1) - closure->from;
 if (extent_duplicable_p (extent))
 {
 EXTENT e;
 start = max (start, 0);
 return 0;
 }
 /* Add the extents in buffer BUF from OPOINT to OPOINT+LENGTH to
 the string STRING. */
 void
 add_string_extents (Lisp_Object string, struct buffer *buf, Bytind opoint,
 		    Bytecount length)
 {
 /* This function can GC */
 struct add_string_extents_arg closure;
 closure.from = opoint;
 closure.length = length;
 closure.string = string;
 buffer = make_buffer (buf);
 GCPRO2 (buffer, string);
 map_extents_bytind (opoint, opoint + length, add_string_extents_mapper,
 		      (void *) &closure, buffer, 0,
 		      /* ignore extents that just abut the region */
 		      ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
 		      /* we are calling E-Lisp (the extent's copy function)
 			 so anything might happen */
 static int
 splice_in_string_extents_mapper (EXTENT extent, void *arg)
 {
 /* This function can GC */
 struct splice_in_string_extents_arg *closure =
 (struct splice_in_string_extents_arg *) arg;
 /* BASE_START and BASE_END are the limits in the buffer of the string
 that was just inserted.
 NEW_START and NEW_END are the prospective buffer positions of the
 /* We have just inserted a section of STRING (starting at POS, of
 length LENGTH) into buffer BUF at OPOINT.  Do whatever is necessary
 to get the string's extents into the buffer. */
 void
 splice_in_string_extents (Lisp_Object string, struct buffer *buf,
 			  Bytind opoint, Bytecount length, Bytecount pos)
 {
 struct splice_in_string_extents_arg closure;
 struct gcpro gcpro1, gcpro2;
 closure.pos = pos;
 closure.length = length;
 closure.buffer = buffer;
 GCPRO2 (buffer, string);
 map_extents_bytind (pos, pos + length,
 		      splice_in_string_extents_mapper,
 		      (void *) &closure, string, 0,
 		      /* ignore extents that just abut the region */
 		      ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
 		      /* we are calling E-Lisp (the extent's copy function)
 			 so anything might happen */
 struct copy_string_extents_1_arg
 {
 Lisp_Object parent_in_question;
 EXTENT found_extent;
 };
 static int
 copy_string_extents_1_mapper (EXTENT extent, void *arg)
 {
 struct copy_string_extents_1_arg *closure =
 (struct copy_string_extents_1_arg *) arg;
 return 0;
 }
 static int
 copy_string_extents_mapper (EXTENT extent, void *arg)
 {
 struct copy_string_extents_arg *closure =
 (struct copy_string_extents_arg *) arg;
 Bytecount old_start, old_end;
 Bytecount new_start, new_end;
 old_start = extent_endpoint_bytind (extent, 0);
 /* The string NEW_STRING was partially constructed from OLD_STRING.
 In particular, the section of length LEN starting at NEW_POS in
 NEW_STRING came from the section of the same length starting at
 OLD_POS in OLD_STRING.  Copy the extents as appropriate. */
 void
 copy_string_extents (Lisp_Object new_string, Lisp_Object old_string,
 		     Bytecount new_pos, Bytecount old_pos,
 		     Bytecount length)
 {
 struct copy_string_extents_arg closure;
 {
 struct put_text_prop_arg *closure = (struct put_text_prop_arg *) arg;
 Lisp_Object object = closure->object;
 Lisp_Object value = closure->value;
 Bytind e_start, e_end;
 Bytind start = closure->start;
 Bytind end   = closure->end;
 Lisp_Object extent, e_val;
 int is_eq;
 static int
 put_text_prop_openness_mapper (EXTENT e, void *arg)
 {
 struct put_text_prop_arg *closure = (struct put_text_prop_arg *) arg;
 Bytind e_start, e_end;
 Bytind start = closure->start;
 Bytind end   = closure->end;
 Lisp_Object extent;
 XSETEXTENT (extent, e);
 e_start = extent_endpoint_bytind (e, 0);
 {
 Lisp_Object prop = XCAR (props);
 Lisp_Object value = Fcar (XCDR (props));
 changed |= put_text_prop (s, e, object, prop, value, 1);
 }
-return (changed ? Qt : Qnil);
+return changed ? Qt : Qnil;
 }
 DEFUN ("add-nonduplicable-text-properties",
 Fadd_nonduplicable_text_properties, 3, 4, 0, /*
 {
 Lisp_Object prop = XCAR (props);
 Lisp_Object value = Fcar (XCDR (props));
 changed |= put_text_prop (s, e, object, prop, value, 0);
 }
-return (changed ? Qt : Qnil);
+return changed ? Qt : Qnil;
 }
 DEFUN ("remove-text-properties", Fremove_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
 for (; !NILP (props); props = Fcdr (Fcdr (props)))
 {
 Lisp_Object prop = XCAR (props);
 changed |= put_text_prop (s, e, object, prop, Qnil, 1);
 }
-return (changed ? Qt : Qnil);
+return changed ? Qt : Qnil;
 }
 /* Whenever a text-prop extent is pasted into a buffer (via `yank' or `insert'
 or whatever) we attach the properties to the buffer by calling
 `put-text-property' instead of by simply allowing the extent to be copied or
 again.  By handing the insertion hackery in this way, we make kill/yank
 behave consistently with put-text-property and not fragment the extents
 (since text-prop extents must partition, not overlap).
 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, 3, 3, 0, /*
 Used as the `paste-function' property of `text-prop' extents.
 */
 if ((NILP (extent) && !NILP (value)) ||
 	  (!NILP (extent) && !EQ (value,
 				  Fextent_property (extent, prop, Qnil))))
 	return make_int (bpos);
 }
 /* I think it's more sensible for this function to return nil always
 in this situation and it used to do it this way, but it's been changed
 for FSF compatibility. */
 if (limit_was_nil)
 return Qnil;

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 173:8eaf7971accc r20-3b13