xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 70:131b0175ea99 r20-0b30

Import from CVS: tag r20-0b30

author	cvs
date	Mon, 13 Aug 2007 09:02:59 +0200
parents	56c54cf7c5b6
children	1ce6082ce73f

comparison

equal deleted inserted replaced

-:804d1389bcd6
+:131b0175ea99
 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. */
 /* A change to an extent occurred that will change the display, so
 notify redisplay.  Maybe also recurse over all the extent's
 descendants. */
 static void
-extent_changed_for_redisplay (EXTENT extent, int descendants_too,
+extent_changed_for_redisplay (EXTENT extent, int descendants_too)
-			      int invisibility_change)
 {
 Lisp_Object object;
 Lisp_Object rest;
 /* we could easily encounter a detached extent while traversing the
 	{
 	  /* first mark all of the extent's children.  We will lose big-time
 	     if there are any circularities here, so we sure as hell better
 	     ensure that there aren't. */
 	  LIST_LOOP (rest, XWEAK_LIST_LIST (children))
-	    extent_changed_for_redisplay (XEXTENT (XCAR (rest)), 1,
+	    extent_changed_for_redisplay (XEXTENT (XCAR (rest)), 1);
-					  invisibility_change);
 	}
 }
 /* now mark the extent itself. */
 {
 struct buffer *b;
 b = XBUFFER (object);
 BUF_FACECHANGE (b)++;
 MARK_EXTENTS_CHANGED;
-if (invisibility_change)
-MARK_CLIP_CHANGED;
 buffer_extent_signal_changed_region (b,
 					 extent_endpoint_bufpos (extent, 0),
 					 extent_endpoint_bufpos (extent, 1));
 }
 }
 This is called when properties such as the endpoints, the layout,
 or the priority changes.  Redisplay will be affected only if
 the extent has any displayable attributes. */
 static void
-extent_maybe_changed_for_redisplay (EXTENT extent, int descendants_too,
+extent_maybe_changed_for_redisplay (EXTENT extent, int descendants_too)
-				    int invisibility_change)
 {
 /* Retrieve the ancestor for efficiency */
 EXTENT anc = extent_ancestor (extent);
 if (!NILP (extent_face (anc)) || !NILP (extent_begin_glyph (anc)) ||
 !NILP (extent_end_glyph (anc)) || !NILP (extent_mouse_face (anc)) ||
-!NILP (extent_invisible (anc)) || invisibility_change)
+!NILP (extent_invisible (anc)))
-extent_changed_for_redisplay (extent, descendants_too,
+extent_changed_for_redisplay (extent, descendants_too);
-				  invisibility_change);
 }
 static EXTENT
 make_extent_detached (Lisp_Object object)
 {
 Extent_List *el = extent_extent_list (extent);
 extent_list_insert (el, extent);
 soe_insert (extent_object (extent), extent);
 /* only this extent changed */
-extent_maybe_changed_for_redisplay (extent, 0,
+extent_maybe_changed_for_redisplay (extent, 0);
-				      !NILP (extent_invisible (extent)));
 }
 static void
 extent_detach (EXTENT extent)
 {
 if (extent_detached_p (extent))
 return;
 el = extent_extent_list (extent);
 /* call this before messing with the extent. */
-extent_maybe_changed_for_redisplay (extent, 0,
+extent_maybe_changed_for_redisplay (extent, 0);
-				      !NILP (extent_invisible (extent)));
 extent_list_delete (el, extent);
 soe_delete (extent_object (extent), extent);
 set_extent_start (extent, -1);
 set_extent_end (extent, -1);
 }
 {
 assert (EQ (obj, extent_object (after)));
 assert (!extent_detached_p (after));
 }
-el = buffer_or_string_extent_list (obj);
+if (!buffer_or_string_extent_list (obj))
-if (!el || !extent_list_num_els(el))
 return;
-el = 0;
 st = buffer_or_string_bytind_to_memind (obj, from);
 en = buffer_or_string_bytind_to_memind (obj, to);
 if (flags & ME_MIGHT_MODIFY_TEXT)
 #ifdef ERROR_CHECK_EXTENTS
 sledgehammer_extent_check (obj);
 #endif
 el = buffer_or_string_extent_list (obj);
-if (!el || !extent_list_num_els(el))
+if (!el)
 return;
 /* IMPORTANT! Compute the starting positions of the extents to
 modify BEFORE doing any modification!  Otherwise the starting
 position for the second time through the loop might get
 incorrectly calculated (I got bit by this bug real bad). */
 startpos[0] = extent_list_locate_from_pos (el, from+1, 0);
 Memind mempos = buffer_or_string_bytind_to_memind (obj, pos);
 Bytind limit = outside_accessible ?
 buffer_or_string_absolute_end_byte (obj) :
 buffer_or_string_accessible_end_byte (obj);
-if (!bel || !extent_list_num_els(bel))
+if (!bel)
 return limit;
 sel = buffer_or_string_stack_of_extents_force (obj)->extents;
 soe_move (obj, mempos);
 Memind mempos = buffer_or_string_bytind_to_memind (obj, pos);
 Bytind limit = outside_accessible ?
 buffer_or_string_absolute_begin_byte (obj) :
 buffer_or_string_accessible_begin_byte (obj);
-if (!bel || !extent_list_num_els(bel))
+if (!bel)
 return limit;
 sel = buffer_or_string_stack_of_extents_force (obj)->extents;
 soe_move (obj, mempos);
 *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_unique_p (anc) || extent_replicating_p (anc) ||
 extent_duplicable_p (anc) || !NILP (extent_invisible (anc)))
 *bp++ = ' ';
 tail = extent_plist_slot (anc);
 add_extent_to_children_list (XEXTENT (parent), extent);
 set_extent_no_chase_aux_field (e, parent, parent);
 e->flags.has_parent = 1;
 }
 /* changing the parent also changes the properties of all children. */
-{
+extent_maybe_changed_for_redisplay (e, 1);
-int old_invis = (!NILP (cur_parent) &&
-		     !NILP (extent_invisible (XEXTENT (cur_parent))));
-int new_invis = (!NILP (parent) &&
-		     !NILP (extent_invisible (XEXTENT (parent))));
-extent_maybe_changed_for_redisplay (e, 1, new_invis != old_invis);
-}
 return Qnil;
 }
 /************************************************************************/
 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))
 {
 /* This function can GC */
 struct slow_map_extents_arg closure;
 unsigned int me_flags;
 Bytind start, end;
 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))
 {
 Bytind position;
 EXTENT before_extent;
 enum extent_at_flag fl;
 return 0;
 if (CONSP (closure->iro) && !NILP (Fmemq (prop, closure->iro)))
 return 0;
-#if 0 /* Nobody seems to care for this any more -sb */
 /* Allow deletion if the extent is completely contained in
 the region being deleted.
 This is important for supporting tokens which are internally
 write-protected, but which can be killed and yanked as a whole.
 Ignore open/closed distinctions at this point.
 */
 if (closure->start != closure->end &&
 extent_start (extent) >= closure->start &&
 extent_end (extent) <= closure->end)
 return 0;
-#endif
 while (1)
 Fsignal (Qbuffer_read_only, (list1 (closure->object)));
 RETURN_NOT_REACHED(0)
 set_extent_invisible (EXTENT extent, Lisp_Object value)
 {
 if (!EQ (extent_invisible (extent), value))
 {
 set_extent_invisible_1 (extent, value);
-extent_changed_for_redisplay (extent, 1, 1);
+extent_changed_for_redisplay (extent, 1);
 }
 }
 /* This function does "memoization" -- similar to the interning
 that happens with symbols.  Given a list of faces, an equivalent
 with faces earlier in the list taking priority over those later in the
 list.
 */
 (extent, face))
 {
-EXTENT e = decode_extent(extent, 0);
+EXTENT e;
 Lisp_Object orig_face = face;
+CHECK_EXTENT (extent);
+e = XEXTENT (extent);
 /* retrieve the ancestor for efficiency and proper redisplay noting. */
 e = extent_ancestor (e);
 face = memoize_extent_face_internal (face);
 extent_face (e) = face;
-extent_changed_for_redisplay (e, 1, 0);
+extent_changed_for_redisplay (e, 1);
 return orig_face;
 }
 e = extent_ancestor (e);
 face = memoize_extent_face_internal (face);
 set_extent_mouse_face (e, face);
-extent_changed_for_redisplay (e, 1, 0);
+extent_changed_for_redisplay (e, 1);
 return orig_face;
 }
 void
 {
 set_extent_end_glyph (extent, glyph);
 extent_end_glyph_layout (extent) = layout;
 }
-extent_changed_for_redisplay (extent, 1, 0);
+extent_changed_for_redisplay (extent, 1);
 }
 static Lisp_Object
 glyph_layout_to_symbol (unsigned int layout)
 {
 (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, 0);
+extent_maybe_changed_for_redisplay (e, 1);
 return layout;
 }
 DEFUN ("set-extent-end-glyph-layout", Fset_extent_end_glyph_layout, 2, 2, 0, /*
 Set the layout policy of the given extent's end glyph.
 (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, 0);
+extent_maybe_changed_for_redisplay (e, 1);
 return layout;
 }
 DEFUN ("extent-begin-glyph-layout", Fextent_begin_glyph_layout, 1, 1, 0, /*
 Return the layout policy associated with the given extent's begin glyph.
 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, 0);
+extent_maybe_changed_for_redisplay (e, 1);
 return pri;
 }
 DEFUN ("extent-priority", Fextent_priority, 1, 1, 0, /*
 Return the display priority of EXTENT; see `set-extent-priority'.
 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'.
+replicating        Meaningful only in conjunction with `duplicable'.
-When this is set, there may be only one instance
+If this flag is set, extents that are copied from
-of this extent attached at a time: if it is copied
+buffers into strings are made children of the
-to the kill ring and then yanked, the extent is
+original extent.  When the string is pasted back
-not copied.  If, however, it is killed (removed
+into a buffer, the same extent (i.e. the `eq'
-from the buffer) and then yanked, it will be
+predicate applies) that was originally in the
-re-attached at the new position.
+buffer will be used if possible -- i.e. if the
+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))
 {
 /* This function can GC if property is `keymap' */
 EXTENT e = decode_extent (extent, 0);
 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 (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);
 #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
 if (EXTENTP (Vlast_highlighted_extent) &&
 EXTENT_LIVE_P (XEXTENT (Vlast_highlighted_extent)))
 {
 /* do not recurse on descendants.  Only one extent is highlighted
 	 at a time. */
-extent_changed_for_redisplay (XEXTENT (Vlast_highlighted_extent), 0, 0);
+extent_changed_for_redisplay (XEXTENT (Vlast_highlighted_extent), 0);
 }
 Vlast_highlighted_extent = Qnil;
 if (!NILP (extent_obj)
 && BUFFERP (extent_object (XEXTENT (extent_obj)))
 && highlight_p)
 {
-extent_changed_for_redisplay (XEXTENT (extent_obj), 0, 0);
+extent_changed_for_redisplay (XEXTENT (extent_obj), 0);
 Vlast_highlighted_extent = extent_obj;
 }
 }
 DEFUN ("force-highlight-extent", Fforce_highlight_extent, 1, 2, 0, /*
 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 (!inside_undo &&
+if (!extent_replicating_p (extent))
-!run_extent_paste_function (extent, new_start, new_end,
+{
-				  closure->buffer))
+if (!inside_undo &&
-return 0;
+	  !run_extent_paste_function (extent, new_start, new_end,
-copy_extent (extent, new_start, new_end, closure->buffer);
+				      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;
 		      (void *) &closure, object, 0,
 		      /* get all extents that abut the region */
 		      ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
 		      /* it might QUIT or error if the user has
 			 fucked with the extent plist. */
-		      /* #### dmoore - I think this should include
-			 ME_MIGHT_MOVE_SOE, since the callback function
-			 might recurse back into map_extents_bytind. */
 		      ME_MIGHT_THROW |
 		      ME_MIGHT_MODIFY_EXTENTS);
 /* If we made it through the loop without reusing an extent
 (and we want there to be one) make it now.
 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
 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 */

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 70:131b0175ea99 r20-0b30