xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 826:6728e641994e

[xemacs-hg @ 2002-05-05 11:30:15 by ben] syntax cache, 8-bit-format, lots of code cleanup README.packages: Update info about --package-path. i.c: Create an inheritable event and pass it on to XEmacs, so that ^C can be handled properly. Intercept ^C and signal the event. "Stop Build" in VC++ now works. bytecomp-runtime.el: Doc string changes. compat.el: Some attempts to redo this to make it truly useful and fix the "multiple versions interacting with each other" problem. Not yet done. Currently doesn't work. files.el: Use with-obsolete-variable to avoid warnings in new revert-buffer code. xemacs.mak: Split up CFLAGS into a version without flags specifying the C library. The problem seems to be that minitar depends on zlib, which depends specifically on libc.lib, not on any of the other C libraries. Unless you compile with libc.lib, you get errors -- specifically, no _errno in the other libraries, which must make it something other than an int. (#### But this doesn't seem to obtain in XEmacs, which also uses zlib, and can be linked with any of the C libraries. Maybe zlib is used differently and doesn't need errno, or maybe XEmacs provides an int errno; ... I don't understand. Makefile.in.in: Fix so that packages are around when testing. abbrev.c, alloc.c, buffer.c, buffer.h, bytecode.c, callint.c, casefiddle.c, casetab.c, casetab.h, charset.h, chartab.c, chartab.h, cmds.c, console-msw.h, console-stream.c, console-x.c, console.c, console.h, data.c, device-msw.c, device.c, device.h, dialog-msw.c, dialog-x.c, dired-msw.c, dired.c, doc.c, doprnt.c, dumper.c, editfns.c, elhash.c, emacs.c, eval.c, event-Xt.c, event-gtk.c, event-msw.c, event-stream.c, events.c, events.h, extents.c, extents.h, faces.c, file-coding.c, file-coding.h, fileio.c, fns.c, font-lock.c, frame-gtk.c, frame-msw.c, frame-x.c, frame.c, frame.h, glade.c, glyphs-gtk.c, glyphs-msw.c, glyphs-msw.h, glyphs-x.c, glyphs.c, glyphs.h, gui-msw.c, gui-x.c, gui.h, gutter.h, hash.h, indent.c, insdel.c, intl-win32.c, intl.c, keymap.c, lisp-disunion.h, lisp-union.h, lisp.h, lread.c, lrecord.h, lstream.c, lstream.h, marker.c, menubar-gtk.c, menubar-msw.c, menubar-x.c, menubar.c, minibuf.c, mule-ccl.c, mule-charset.c, mule-coding.c, mule-wnnfns.c, nas.c, objects-msw.c, objects-x.c, opaque.c, postgresql.c, print.c, process-nt.c, process-unix.c, process.c, process.h, profile.c, rangetab.c, redisplay-gtk.c, redisplay-msw.c, redisplay-output.c, redisplay-x.c, redisplay.c, redisplay.h, regex.c, regex.h, scrollbar-msw.c, search.c, select-x.c, specifier.c, specifier.h, symbols.c, symsinit.h, syntax.c, syntax.h, syswindows.h, tests.c, text.c, text.h, tooltalk.c, ui-byhand.c, ui-gtk.c, unicode.c, win32.c, window.c: Another big Ben patch. -- FUNCTIONALITY CHANGES: add partial support for 8-bit-fixed, 16-bit-fixed, and 32-bit-fixed formats. not quite done yet. (in particular, needs functions to actually convert the buffer.) NOTE: lots of changes to regex.c here. also, many new *_fmt() inline funs that take an Internal_Format argument. redo syntax cache code. make the cache per-buffer; keep the cache valid across calls to functions that use it. also keep it valid across insertions/deletions and extent changes, as much as is possible. eliminate the junky regex-reentrancy code by passing in the relevant lisp info to the regex routines as local vars. add general mechanism in extents code for signalling extent changes. fix numerous problems with the case-table implementation; yoshiki never properly transferred many algorithms from old-style to new-style case tables. redo char tables to support a default argument, so that mapping only occurs over changed args. change many chartab functions to accept Lisp_Object instead of Lisp_Char_Table *. comment out the code in font-lock.c by default, because font-lock.el no longer uses it. we should consider eliminating it entirely. Don't output bell as ^G in console-stream when not a TTY. add -mswindows-termination-handle to interface with i.c, so we can properly kill a build. add more error-checking to buffer/string macros. add some additional buffer_or_string_() funs. -- INTERFACE CHANGES AFFECTING MORE CODE: switch the arguments of write_c_string and friends to be consistent with write_fmt_string, which must have printcharfun first. change BI_* macros to BYTE_* for increased clarity; similarly for bi_* local vars. change VOID_TO_LISP to be a one-argument function. eliminate no-longer-needed CVOID_TO_LISP. -- char/string macro changes: rename MAKE_CHAR() to make_emchar() for slightly less confusion with make_char(). (The former generates an Emchar, the latter a Lisp object. Conceivably we should rename make_char() -> wrap_char() and similarly for make_int(), make_float().) Similar changes for other *CHAR* macros -- we now consistently use names with `emchar' whenever we are working with Emchars. Any remaining name with just `char' always refers to a Lisp object. rename macros with XSTRING_* to string_* except for those that reference actual fields in the Lisp_String object, following conventions used elsewhere. rename set_string_{data,length} macros (the only ones to work with a Lisp_String_* instead of a Lisp_Object) to set_lispstringp_* to make the difference clear. try to be consistent about caps vs. lowercase in macro/inline-fun names for chars and such, which wasn't the case before. we now reserve caps either for XFOO_ macros that reference object fields (e.g. XSTRING_DATA) or for things that have non-function semantics, e.g. directly modifying an arg (BREAKUP_EMCHAR) or evaluating an arg (any arg) more than once. otherwise, use lowercase. here is a summary of most of the macros/inline funs changed by all of the above changes: BYTE_*_P -> byte_*_p XSTRING_BYTE -> string_byte set_string_data/length -> set_lispstringp_data/length XSTRING_CHAR_LENGTH -> string_char_length XSTRING_CHAR -> string_emchar INTBYTE_FIRST_BYTE_P -> intbyte_first_byte_p INTBYTE_LEADING_BYTE_P -> intbyte_leading_byte_p charptr_copy_char -> charptr_copy_emchar LEADING_BYTE_* -> leading_byte_* CHAR_* -> EMCHAR_* *_CHAR_* -> *_EMCHAR_* *_CHAR -> *_EMCHAR CHARSET_BY_ -> charset_by_* BYTE_SHIFT_JIS* -> byte_shift_jis* BYTE_BIG5* -> byte_big5* REP_BYTES_BY_FIRST_BYTE -> rep_bytes_by_first_byte char_to_unicode -> emchar_to_unicode valid_char_p -> valid_emchar_p Change intbyte_strcmp -> qxestrcmp_c (duplicated functionality). -- INTERFACE CHANGES AFFECTING LESS CODE: use DECLARE_INLINE_HEADER in various places. remove '#ifdef emacs' from XEmacs-only files. eliminate CHAR_TABLE_VALUE(), which duplicated the functionality of get_char_table(). add BUFFER_TEXT_LOOP to simplify iterations over buffer text. define typedefs for signed and unsigned types of fixed sizes (INT_32_BIT, UINT_32_BIT, etc.). create ALIGN_FOR_TYPE as a higher-level interface onto ALIGN_SIZE; fix code to use it. add charptr_emchar_len to return the text length of the character pointed to by a ptr; use it in place of charcount_to_bytecount(..., 1). add emchar_len to return the text length of a given character. add types Bytexpos and Charxpos to generalize Bytebpos/Bytecount and Charbpos/Charcount, in code (particularly, the extents code and redisplay code) that works with either kind of index. rename redisplay struct params with names such as `charbpos' to e.g. `charpos' when they are e.g. a Charxpos, not a Charbpos. eliminate xxDEFUN in place of DEFUN; no longer necessary with changes awhile back to doc.c. split up big ugly combined list of EXFUNs in lisp.h on a file-by-file basis, since other prototypes are similarly split. rewrite some "*_UNSAFE" macros as inline funs and eliminate the _UNSAFE suffix. move most string code from lisp.h to text.h; the string code and text.h code is now intertwined in such a fashion that they need to be in the same place and partially interleaved. (you can't create forward references for inline funs) automated/lisp-tests.el, automated/symbol-tests.el, automated/test-harness.el: Fix test harness to output FAIL messages to stderr when in batch mode. Fix up some problems in lisp-tests/symbol-tests that were causing spurious failures.

author	ben
date	Sun, 05 May 2002 11:33:57 +0000
parents	6504113e7c2d
children	5d09ddada9ae

comparison

equal deleted inserted replaced

-:eb3bc15a6e0f
+:6728e641994e
 static Gap_Array_Marker *gap_array_marker_freelist;
 /* Convert a "memory position" (i.e. taking the gap into account) into
 the address of the element at (i.e. after) that position.  "Memory
-positions" are only used internally and are of type Membpos.
+positions" are only used internally and are of type Memxpos.
 "Array positions" are used externally and are of type int. */
 #define GAP_ARRAY_MEMEL_ADDR(ga, memel) ((ga)->array + (ga)->elsize*(memel))
 /* Number of elements currently in a gap array */
 #define GAP_ARRAY_NUM_ELS(ga) ((ga)->numels)
 /* ------------------------------- */
 typedef struct stack_of_extents
 {
 Extent_List *extents;
-Membpos pos; /* Position of stack of extents.  EXTENTS is the list of
+Memxpos pos; /* Position of stack of extents.  EXTENTS is the list of
 		 all extents that overlap this position.  This position
 		 can be -1 if the stack of extents is invalid (this
 		 happens when a buffer is first created or a string's
 		 stack of extents is created [a string's stack of extents
 		 is nuked when a GC occurs, to conserve memory]). */
 /* ------------------------------- */
 /*           map-extents           */
 /* ------------------------------- */
+typedef int (*map_extents_fun) (EXTENT extent, void *arg);
 typedef int Endpoint_Index;
-#define membpos_to_startind(x, start_open) \
+#define memxpos_to_startind(x, start_open) \
 ((Endpoint_Index) (((x) << 1) + !!(start_open)))
-#define membpos_to_endind(x, end_open) \
+#define memxpos_to_endind(x, end_open) \
 ((Endpoint_Index) (((x) << 1) - !!(end_open)))
-/* Combination macros */
-#define bytebpos_to_startind(buf, x, start_open) \
-membpos_to_startind (bytebpos_to_membpos (buf, x), start_open)
-#define bytebpos_to_endind(buf, x, end_open) \
-membpos_to_endind (bytebpos_to_membpos (buf, x), end_open)
 /* ------------------------------- */
 /*    buffer-or-string primitives  */
 /* ------------------------------- */
-/* Similar for Bytebposs and start/end indices. */
+/* Similar for Bytebpos's and start/end indices. */
-#define buffer_or_string_bytebpos_to_startind(obj, ind, start_open)	\
+#define buffer_or_string_bytexpos_to_startind(obj, ind, start_open)	\
-membpos_to_startind (buffer_or_string_bytebpos_to_membpos (obj, ind),	\
+memxpos_to_startind (buffer_or_string_bytexpos_to_memxpos (obj, ind),	\
 		      start_open)
-#define buffer_or_string_bytebpos_to_endind(obj, ind, end_open)		\
+#define buffer_or_string_bytexpos_to_endind(obj, ind, end_open)		\
-membpos_to_endind (buffer_or_string_bytebpos_to_membpos (obj, ind),	\
+memxpos_to_endind (buffer_or_string_bytexpos_to_memxpos (obj, ind),	\
 		    end_open)
 /* ------------------------------- */
 /*      Lisp-level functions       */
 /* ------------------------------- */
 /* Qtext defined in general.c */
 Lisp_Object Qcopy_function;
 Lisp_Object Qpaste_function;
-/* The idea here is that if we're given a list of faces, we
-need to "memoize" this so that two lists of faces that are `equal'
-turn into the same object.  When `set-extent-face' is called, we
-"memoize" into a list of actual faces; when `extent-face' is called,
-we do a reverse lookup to get the list of symbols. */
 static Lisp_Object canonicalize_extent_property (Lisp_Object prop,
 						 Lisp_Object value);
+typedef struct
+{
+Lisp_Object key, value;
+} Lisp_Object_pair;
+typedef struct
+{
+Dynarr_declare (Lisp_Object_pair);
+} Lisp_Object_pair_dynarr;
+static void extent_properties (EXTENT e, Lisp_Object_pair_dynarr *props);
 Lisp_Object Vextent_face_memoize_hash_table;
 Lisp_Object Vextent_face_reverse_memoize_hash_table;
 Lisp_Object Vextent_face_reusable_list;
 /* FSFmacs bogosity */
 Lisp_Object Vdefault_text_properties;
-EXFUN (Fextent_properties, 1);
-EXFUN (Fset_extent_property, 3);
 /* if true, we don't want to set any redisplay flags on modeline extent
 changes */
 int in_modeline_generation;
 /* Adjust the gap array markers in the range (FROM, TO].  Parallel to
 adjust_markers() in insdel.c. */
 static void
-gap_array_adjust_markers (Gap_Array *ga, Membpos from,
+gap_array_adjust_markers (Gap_Array *ga, Memxpos from,
-			  Membpos to, int amount)
+			  Memxpos to, int amount)
 {
 Gap_Array_Marker *m;
 for (m = ga->markers; m; m = m->next)
 m->pos = do_marker_adjustment (m->pos, from, to, amount);
 if (pos < gap)
 {
 memmove (GAP_ARRAY_MEMEL_ADDR (ga, pos + gapsize),
 	       GAP_ARRAY_MEMEL_ADDR (ga, pos),
 	       (gap - pos)*ga->elsize);
-gap_array_adjust_markers (ga, (Membpos) pos, (Membpos) gap,
+gap_array_adjust_markers (ga, (Memxpos) pos, (Memxpos) gap,
 				gapsize);
 }
 else if (pos > gap)
 {
 memmove (GAP_ARRAY_MEMEL_ADDR (ga, gap),
 	       GAP_ARRAY_MEMEL_ADDR (ga, gap + gapsize),
 	       (pos - gap)*ga->elsize);
-gap_array_adjust_markers (ga, (Membpos) (gap + gapsize),
+gap_array_adjust_markers (ga, (Memxpos) (gap + gapsize),
-				(Membpos) (pos + gapsize), - gapsize);
+				(Memxpos) (pos + gapsize), - gapsize);
 }
 ga->gap = pos;
 }
 /* Make the gap INCREMENT characters longer.  Parallel to make_gap() in
 An out-of-range value for POS is allowed, and guarantees that the
 position at the beginning or end of the extent list is returned. */
 static int
-extent_list_locate_from_pos (Extent_List *el, Membpos pos, int endp)
+extent_list_locate_from_pos (Extent_List *el, Memxpos pos, int endp)
 {
 struct extent fake_extent;
 /*
 Note that if we search for [POS, POS], then we get the following:
 }
 /* Return the extent at POS. */
 static EXTENT
-extent_list_at (Extent_List *el, Membpos pos, int endp)
+extent_list_at (Extent_List *el, Memxpos pos, int endp)
 {
 Gap_Array *ga = endp ? el->end : el->start;
 assert (pos >= 0 && pos < GAP_ARRAY_NUM_ELS (ga));
 return EXTENT_GAP_ARRAY_AT (ga, pos);
 {
 printf ("No SOE");
 return;
 }
 sel = soe->extents;
-printf ("SOE pos is %d (membpos %d)\n",
+printf ("SOE pos is %d (memxpos %d)\n",
 	  soe->pos < 0 ? soe->pos :
-	  buffer_or_string_membpos_to_bytebpos (obj, soe->pos),
+	  buffer_or_string_memxpos_to_bytexpos (obj, soe->pos),
 	  soe->pos);
 for (endp = 0; endp < 2; endp++)
 {
 printf (endp ? "SOE end:" : "SOE start:");
 for (i = 0; i < extent_list_num_els (sel); i++)
 }
 /* Move OBJ's stack of extents to lie over the specified position. */
 static void
-soe_move (Lisp_Object obj, Membpos pos)
+soe_move (Lisp_Object obj, Memxpos pos)
 {
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents_force (obj);
 Extent_List *sel = soe->extents;
 int numsoe = extent_list_num_els (sel);
 Extent_List *bel = buffer_or_string_extent_list (obj);
 #ifdef ERROR_CHECK_EXTENTS
 assert (bel);
 #endif
 #ifdef SOE_DEBUG
-printf ("Moving SOE from %d (membpos %d) to %d (membpos %d)\n",
+printf ("Moving SOE from %d (memxpos %d) to %d (memxpos %d)\n",
 	  soe->pos < 0 ? soe->pos :
-	  buffer_or_string_membpos_to_bytebpos (obj, soe->pos), soe->pos,
+	  buffer_or_string_memxpos_to_bytexpos (obj, soe->pos), soe->pos,
-	  buffer_or_string_membpos_to_bytebpos (obj, pos), pos);
+	  buffer_or_string_memxpos_to_bytexpos (obj, pos), pos);
 #endif
 if (soe->pos < pos)
 {
 direction = 1;
 endp = 0;
 /* ------------------------------- */
 /* 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_charbpos(). */
+use extent_endpoint_char(). */
-static Bytebpos
+Bytexpos
-extent_endpoint_bytebpos (EXTENT extent, int endp)
+extent_endpoint_byte (EXTENT extent, int endp)
 {
 assert (EXTENT_LIVE_P (extent));
 assert (!extent_detached_p (extent));
 {
-Membpos i = endp ? extent_end (extent) : extent_start (extent);
+Memxpos i = endp ? extent_end (extent) : extent_start (extent);
 Lisp_Object obj = extent_object (extent);
-return buffer_or_string_membpos_to_bytebpos (obj, i);
+return buffer_or_string_memxpos_to_bytexpos (obj, i);
 }
 }
-static Charbpos
+Charxpos
-extent_endpoint_charbpos (EXTENT extent, int endp)
+extent_endpoint_char (EXTENT extent, int endp)
 {
 assert (EXTENT_LIVE_P (extent));
 assert (!extent_detached_p (extent));
 {
-Membpos i = endp ? extent_end (extent) : extent_start (extent);
+Memxpos i = endp ? extent_end (extent) : extent_start (extent);
 Lisp_Object obj = extent_object (extent);
-return buffer_or_string_membpos_to_charbpos (obj, i);
+return buffer_or_string_memxpos_to_charxpos (obj, i);
 }
 }
-/* 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,
+signal_single_extent_changed (EXTENT extent, Lisp_Object property,
-			      int invisibility_change)
+			      Bytexpos old_start, Bytexpos old_end)
 {
-Lisp_Object object;
+EXTENT anc = extent_ancestor (extent);
-Lisp_Object rest;
+/* Redisplay checks */
+if (NILP (property) ?
+(!NILP (extent_face        (anc)) ||
+!NILP (extent_begin_glyph (anc)) ||
+!NILP (extent_end_glyph   (anc)) ||
+!NILP (extent_mouse_face  (anc)) ||
+!NILP (extent_invisible   (anc)) ||
+!NILP (extent_initial_redisplay_function (anc))) :
+EQ (property, Qface) ||
+EQ (property, Qmouse_face) ||
+EQ (property, Qbegin_glyph) ||
+EQ (property, Qend_glyph) ||
+EQ (property, Qbegin_glyph_layout) ||
+EQ (property, Qend_glyph_layout) ||
+EQ (property, Qinvisible) ||
+EQ (property, Qinitial_redisplay_function) ||
+EQ (property, Qpriority))
+{
+Lisp_Object object = extent_object (extent);
+if (extent_detached_p (extent))
+	return;
+else if (STRINGP (object))
+	{
+	  /* #### Changes to string extents can affect redisplay if they are
+	     in the modeline or in the gutters.
+	     If the extent is in some generated-modeline-string: when we
+	     change an extent in generated-modeline-string, this changes its
+	     parent, which is in `modeline-format', so we should force the
+	     modeline to be updated.  But how to determine whether a string
+	     is a `generated-modeline-string'?  Looping through all buffers
+	     is not very efficient.  Should we add all
+	     `generated-modeline-string' strings to a hash table?  Maybe
+	     efficiency is not the greatest concern here and there's no big
+	     loss in looping over the buffers.
+	     If the extent is in a gutter we mark the gutter as
+	     changed. This means (a) we can update extents in the gutters
+	     when we need it. (b) we don't have to update the gutters when
+	     only extents attached to buffers have changed. */
+	  if (!in_modeline_generation)
+	    MARK_EXTENTS_CHANGED;
+	  gutter_extent_signal_changed_region_maybe
+	    (object, extent_endpoint_char (extent, 0),
+	     extent_endpoint_char (extent, 1));
+	}
+else if (BUFFERP (object))
+	{
+	  struct buffer *b;
+	  b = XBUFFER (object);
+	  BUF_FACECHANGE (b)++;
+	  MARK_EXTENTS_CHANGED;
+	  if (NILP (property) ? !NILP (extent_invisible (anc)) :
+	      EQ (property, Qinvisible))
+	    MARK_CLIP_CHANGED;
+	  buffer_extent_signal_changed_region
+	    (b, extent_endpoint_char (extent, 0),
+	     extent_endpoint_char (extent, 1));
+	}
+}
+/* Check for syntax table property change */
+if (NILP (property) ? !NILP (Fextent_property (wrap_extent (extent),
+						 Qsyntax_table, Qnil)) :
+EQ (property, Qsyntax_table))
+signal_syntax_table_extent_changed (extent);
+}
+/* Make note that a change has happened in EXTENT.  The change was either
+to a property or to the endpoints (but not both at once).  If PROPERTY
+is non-nil, the change happened to that property; otherwise, the change
+happened to the endpoints, and the old ones are given.  Currently, all
+endpoints changes are in the form of two signals, a detach followed by
+an attach, and when detaching, we are signalled before the extent is
+detached. (You can distinguish a detach from an attach because the
+latter has old_start == -1 and old_end == -1.) (#### We don't currently
+give the old property.  If someone needs that, this will have to
+change.) KLUDGE: If PROPERTY is Qt, all properties may have changed
+because the parent was changed. #### We need to handle this properly, by
+mapping over properties. */
+static void
+signal_extent_changed (EXTENT extent, Lisp_Object property,
+		       Bytexpos old_start, Bytexpos old_end,
+		       int descendants_too)
+{
 /* we could easily encounter a detached extent while traversing the
 children, but we should never be able to encounter a dead extent. */
 assert (EXTENT_LIVE_P (extent));
 if (descendants_too)
 {
 Lisp_Object children = extent_children (extent);
 if (!NILP (children))
 	{
-	  /* first mark all of the extent's children.  We will lose big-time
+	  /* first process all of the extent's children.  We will lose
-	     if there are any circularities here, so we sure as hell better
+	     big-time if there are any circularities here, so we sure as
-	     ensure that there aren't. */
+	     hell better ensure that there aren't. */
-	  LIST_LOOP (rest, XWEAK_LIST_LIST (children))
+	  LIST_LOOP_2 (rest, XWEAK_LIST_LIST (children))
-	    extent_changed_for_redisplay (XEXTENT (XCAR (rest)), 1,
+	    signal_extent_changed (extent, property, old_start, old_end,
-					  invisibility_change);
+				   descendants_too);
 	}
 }
-/* now mark the extent itself. */
+/* now process the extent itself. */
+signal_single_extent_changed (extent, property, old_start, old_end);
-object = extent_object (extent);
+}
-if (extent_detached_p (extent))
-return;
-else if (STRINGP (object))
-{
-/* #### Changes to string extents can affect redisplay if they are
-in the modeline or in the gutters.
-If the extent is in some generated-modeline-string: when we
-change an extent in generated-modeline-string, this changes its
-parent, which is in `modeline-format', so we should force the
-modeline to be updated.  But how to determine whether a string
-is a `generated-modeline-string'?  Looping through all buffers
-is not very efficient.  Should we add all
-`generated-modeline-string' strings to a hash table?  Maybe
-efficiency is not the greatest concern here and there's no big
-loss in looping over the buffers.
-If the extent is in a gutter we mark the gutter as
-changed. This means (a) we can update extents in the gutters
-when we need it. (b) we don't have to update the gutters when
-only extents attached to buffers have changed. */
-if (!in_modeline_generation)
-	MARK_EXTENTS_CHANGED;
-gutter_extent_signal_changed_region_maybe (object,
-						 extent_endpoint_charbpos (extent, 0),
-						 extent_endpoint_charbpos (extent, 1));
-}
-else if (BUFFERP (object))
-{
-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_charbpos (extent, 0),
-					   extent_endpoint_charbpos (extent, 1));
-}
-}
-/* A change to an extent occurred that might affect redisplay.
-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,
+signal_extent_property_changed (EXTENT extent, Lisp_Object property,
-				    int invisibility_change)
+				int descendants_too)
 {
-/* Retrieve the ancestor for efficiency */
+signal_extent_changed (extent, property, 0, 0, descendants_too);
-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)) ||
-!NILP (extent_initial_redisplay_function (anc)) ||
-invisibility_change)
-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,
+signal_extent_changed (extent, Qnil, -1, -1, 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,
+signal_extent_changed (extent, Qnil,
-				      !NILP (extent_invisible (extent)));
+			 extent_endpoint_byte (extent, 0),
+			 extent_endpoint_char (extent, 0),
+			 0);
 extent_list_delete (el, extent);
 soe_delete (extent_object (extent), extent);
 set_extent_start (extent, -1);
 set_extent_end (extent, -1);
 }
 See the comments at map_extents() for info on the overlap rule.
 Assumes that all validation on the extent and buffer positions has
 already been performed (see Fextent_in_region_p ()).
 */
 static int
-extent_in_region_p (EXTENT extent, Bytebpos from, Bytebpos to,
+extent_in_region_p (EXTENT extent, Bytexpos from, Bytexpos to,
 		    unsigned int flags)
 {
 Lisp_Object obj = extent_object (extent);
 Endpoint_Index start, end, exs, exe;
 int start_open, end_open;
 case ME_ALL_EXTENTS_CLOSED_OPEN: start_open = 0, end_open = 1; break;
 case ME_ALL_EXTENTS_OPEN_CLOSED: start_open = 1, end_open = 0; break;
 default: abort(); return 0;
 }
-start = buffer_or_string_bytebpos_to_startind (obj, from,
+start = buffer_or_string_bytexpos_to_startind (obj, from,
 					       flags & ME_START_OPEN);
-end = buffer_or_string_bytebpos_to_endind (obj, to, ! (flags & ME_END_CLOSED));
+end = buffer_or_string_bytexpos_to_endind (obj, to,
-exs = membpos_to_startind (extent_start (extent), start_open);
+					     ! (flags & ME_END_CLOSED));
-exe = membpos_to_endind   (extent_end   (extent), end_open);
+exs = memxpos_to_startind (extent_start (extent), start_open);
+exe = memxpos_to_endind   (extent_end   (extent), end_open);
 /* It's easy to determine whether an extent lies *outside* the
 region -- just determine whether it's completely before
 or completely after the region.  Reject all such extents, so
 we're now left with only the extents that overlap the region.
 Furthermore, the results might be a little less sensible than
 the logic below. */
 static void
-map_extents_bytebpos (Bytebpos from, Bytebpos to, map_extents_fun fn, void *arg,
+map_extents (Bytexpos from, Bytexpos to, map_extents_fun fn,
-		    Lisp_Object obj, EXTENT after, unsigned int flags)
+	     void *arg, Lisp_Object obj, EXTENT after,
-{
+	     unsigned int flags)
-Membpos st, en; /* range we're mapping over */
+{
+Memxpos st, en; /* range we're mapping over */
 EXTENT range = 0; /* extent for this, if ME_MIGHT_MODIFY_TEXT */
 Extent_List *el = 0; /* extent list we're iterating over */
 Extent_List_Marker *posm = 0; /* marker for extent list,
 				   if ME_MIGHT_MODIFY_EXTENTS */
 /* count and struct for unwind-protect, if ME_MIGHT_THROW */
 el = buffer_or_string_extent_list (obj);
 if (!el || !extent_list_num_els(el))
 return;
 el = 0;
-st = buffer_or_string_bytebpos_to_membpos (obj, from);
+st = buffer_or_string_bytexpos_to_memxpos (obj, from);
-en = buffer_or_string_bytebpos_to_membpos (obj, to);
+en = buffer_or_string_bytexpos_to_memxpos (obj, to);
 if (flags & ME_MIGHT_MODIFY_TEXT)
 {
 /* The mapping function might change the text in the buffer,
 	 so make an internal extent to hold the range we're mapping
 	    /* ----- Now actually call the function ----- */
 	    obj2 = extent_object (e);
 	    if (extent_in_region_p (e,
-				    buffer_or_string_membpos_to_bytebpos (obj2,
+				    buffer_or_string_memxpos_to_bytexpos (obj2,
-								       st),
+									  st),
-				    buffer_or_string_membpos_to_bytebpos (obj2,
+				    buffer_or_string_memxpos_to_bytexpos (obj2,
-								       en),
+									  en),
 				    flags))
 	      {
 		if ((*fn)(e, arg))
 		  {
 		    /* Function wants us to stop mapping. */
 if (posm)
 	extent_list_delete_marker (el, posm);
 }
 }
-void
-map_extents (Charbpos from, Charbpos to, map_extents_fun fn,
-	     void *arg, Lisp_Object obj, EXTENT after, unsigned int flags)
-{
-map_extents_bytebpos (buffer_or_string_charbpos_to_bytebpos (obj, from),
-		      buffer_or_string_charbpos_to_bytebpos (obj, to), fn, arg,
-		      obj, after, flags);
-}
 /* ------------------------------- */
 /*         adjust_extents()        */
 /* ------------------------------- */
 /* Add AMOUNT to all extent endpoints in the range (FROM, TO].  This
 around with extent endpoints without detaching and reattaching
 the extents (this is provably correct and saves lots of time),
 so for safety we make it just look at the extent lists directly. */
 void
-adjust_extents (Lisp_Object obj, Membpos from, Membpos to, int amount)
+adjust_extents (Lisp_Object obj, Memxpos from, Memxpos to, int amount)
 {
 int endp;
 int pos;
 int startpos[2];
 Extent_List *el;
 There is no string correspondent for this because you can't
 delete characters from a string.
 */
 void
-adjust_extents_for_deletion (Lisp_Object object, Bytebpos from,
+adjust_extents_for_deletion (Lisp_Object object, Bytexpos from,
-			     Bytebpos to, int gapsize, int numdel,
+			     Bytexpos to, int gapsize, int numdel,
 			     int movegapsize)
 {
 struct adjust_extents_for_deletion_arg closure;
 int i;
-Membpos adjust_to = (Membpos) (to + gapsize);
+Memxpos adjust_to = (Memxpos) (to + gapsize);
 Bytecount amount = - numdel - movegapsize;
-Membpos oldsoe = 0, newsoe = 0;
+Memxpos oldsoe = 0, newsoe = 0;
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents (object);
 #ifdef ERROR_CHECK_EXTENTS
 sledgehammer_extent_check (object);
 #endif
 /* We're going to be playing weird games below with extents and the SOE
 and such, so compute the list now of all the extents that we're going
 to muck with.  If we do the mapping and adjusting together, things can
 get all screwed up. */
-map_extents_bytebpos (from, to, adjust_extents_for_deletion_mapper,
+map_extents (from, to, adjust_extents_for_deletion_mapper,
-		      (void *) &closure, object, 0,
+	       (void *) &closure, object, 0,
-		      /* extent endpoints move like markers regardless
+	       /* extent endpoints move like markers regardless
-			 of their open/closeness. */
+		  of their open/closeness. */
-		      ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
+	       ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
-		      ME_START_OR_END_IN_REGION | ME_INCLUDE_INTERNAL);
+	       ME_START_OR_END_IN_REGION | ME_INCLUDE_INTERNAL);
 /*
 Old and new values for the SOE's position. (It gets adjusted
 like a marker, just like extent endpoints.)
 */
 }
 for (i = 0; i < Dynarr_length (closure.list); i++)
 {
 EXTENT extent = Dynarr_at (closure.list, i);
-Membpos new_start = extent_start (extent);
+Memxpos new_start = extent_start (extent);
-Membpos new_end = extent_end (extent);
+Memxpos new_end = extent_end (extent);
 /* do_marker_adjustment() will not adjust values that should not be
 	 adjusted.  We're passing the same funky arguments to
 	 do_marker_adjustment() as buffer_delete_range() does. */
 new_start =
 /* This function returns the position of the beginning of
 the first run that begins after POS, or returns POS if
 there are no such runs. */
-static Bytebpos
+static Bytexpos
-extent_find_end_of_run (Lisp_Object obj, Bytebpos pos, int outside_accessible)
+extent_find_end_of_run (Lisp_Object obj, Bytexpos pos, int outside_accessible)
 {
 Extent_List *sel;
 Extent_List *bel = buffer_or_string_extent_list (obj);
-Bytebpos pos1, pos2;
+Bytexpos pos1, pos2;
 int elind1, elind2;
-Membpos mempos = buffer_or_string_bytebpos_to_membpos (obj, pos);
+Memxpos mempos = buffer_or_string_bytexpos_to_memxpos (obj, pos);
-Bytebpos limit = outside_accessible ?
+Bytexpos 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 || !extent_list_num_els (bel))
 return limit;
 sel = buffer_or_string_stack_of_extents_force (obj)->extents;
 soe_move (obj, mempos);
 /* Find the first start position after POS. */
 elind1 = extent_list_locate_from_pos (bel, mempos+1, 0);
 if (elind1 < extent_list_num_els (bel))
-pos1 = buffer_or_string_membpos_to_bytebpos
+pos1 = buffer_or_string_memxpos_to_bytexpos
 (obj, extent_start (extent_list_at (bel, elind1, 0)));
 else
 pos1 = limit;
 /* Find the first end position after POS.  The extent corresponding
 to this position is either in the SOE or is greater than or
 equal to POS1, so we just have to look in the SOE. */
 elind2 = extent_list_locate_from_pos (sel, mempos+1, 1);
 if (elind2 < extent_list_num_els (sel))
-pos2 = buffer_or_string_membpos_to_bytebpos
+pos2 = buffer_or_string_memxpos_to_bytexpos
 (obj, extent_end (extent_list_at (sel, elind2, 1)));
 else
 pos2 = limit;
 return min (min (pos1, pos2), limit);
 }
-static Bytebpos
+static Bytexpos
-extent_find_beginning_of_run (Lisp_Object obj, Bytebpos pos,
+extent_find_beginning_of_run (Lisp_Object obj, Bytexpos pos,
 			      int outside_accessible)
 {
 Extent_List *sel;
 Extent_List *bel = buffer_or_string_extent_list (obj);
-Bytebpos pos1, pos2;
+Bytexpos pos1, pos2;
 int elind1, elind2;
-Membpos mempos = buffer_or_string_bytebpos_to_membpos (obj, pos);
+Memxpos mempos = buffer_or_string_bytexpos_to_memxpos (obj, pos);
-Bytebpos limit = outside_accessible ?
+Bytexpos limit = outside_accessible ?
 buffer_or_string_absolute_begin_byte (obj) :
 buffer_or_string_accessible_begin_byte (obj);
 if (!bel || !extent_list_num_els(bel))
 return limit;
 sel = buffer_or_string_stack_of_extents_force (obj)->extents;
 soe_move (obj, mempos);
 /* Find the first end position before POS. */
 elind1 = extent_list_locate_from_pos (bel, mempos, 1);
 if (elind1 > 0)
-pos1 = buffer_or_string_membpos_to_bytebpos
+pos1 = buffer_or_string_memxpos_to_bytexpos
 (obj, extent_end (extent_list_at (bel, elind1 - 1, 1)));
 else
 pos1 = limit;
 /* Find the first start position before POS.  The extent corresponding
 to this position is either in the SOE or is less than or
 equal to POS1, so we just have to look in the SOE. */
 elind2 = extent_list_locate_from_pos (sel, mempos, 0);
 if (elind2 > 0)
-pos2 = buffer_or_string_membpos_to_bytebpos
+pos2 = buffer_or_string_memxpos_to_bytexpos
 (obj, extent_start (extent_list_at (sel, elind2 - 1, 0)));
 else
 pos2 = limit;
 return max (max (pos1, pos2), limit);
 return 0;
 }
 face_index
 extent_fragment_update (struct window *w, struct extent_fragment *ef,
-			Bytebpos pos, Lisp_Object last_glyph)
+			Bytexpos pos, Lisp_Object last_glyph)
 {
 int i;
 int seen_glyph = NILP (last_glyph) ? 1 : 0;
 Extent_List *sel =
 buffer_or_string_stack_of_extents_force (ef->object)->extents;
 EXTENT lhe = 0;
 struct extent dummy_lhe_extent;
-Membpos mempos = buffer_or_string_bytebpos_to_membpos (ef->object, pos);
+Memxpos mempos = buffer_or_string_bytexpos_to_memxpos (ef->object, pos);
 #ifdef ERROR_CHECK_EXTENTS
 assert (pos >= buffer_or_string_accessible_begin_byte (ef->object)
 	  && pos <= buffer_or_string_accessible_end_byte (ef->object));
 #endif
 if (!NILP (extent_begin_glyph (anc))) *bp++ = '*';
 *bp++ = (extent_start_open_p (anc) ? '(': '[');
 if (extent_detached_p (ext))
 strcpy (bp, "detached");
 else
-sprintf (bp, "%d, %d",
+sprintf (bp, "%ld, %ld",
 	     XINT (Fextent_start_position (obj)),
 	     XINT (Fextent_end_position (obj)));
 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);
+write_c_string (printcharfun, buf);
 tail = extent_plist_slot (anc);
 for (; !NILP (tail); tail = Fcdr (Fcdr (tail)))
 {
 	    printing_unreadable_object ("#<extent 0x%lx>",
 		   (long) XEXTENT (obj));
 	}
 if (!EXTENT_LIVE_P (XEXTENT (obj)))
-	write_c_string ("#<destroyed extent", printcharfun);
+	write_c_string (printcharfun, "#<destroyed extent");
 else
 	{
-	  write_c_string ("#<extent ", printcharfun);
+	  write_c_string (printcharfun, "#<extent ");
 	  print_extent_1 (obj, printcharfun, escapeflag);
-	  write_c_string (extent_detached_p (XEXTENT (obj))
+	  write_c_string (printcharfun, extent_detached_p (XEXTENT (obj))
-			  ? " from " : " in ", printcharfun);
+			  ? " from " : " in ");
 	  write_fmt_string (printcharfun, "%s%s%s", title, name, posttitle);
 	}
 }
 else
 {
 if (print_readably)
 	printing_unreadable_object ("#<extent>");
-write_c_string ("#<extent", printcharfun);
+write_c_string (printcharfun, "#<extent");
 }
-write_c_string (">", printcharfun);
+write_c_string (printcharfun, ">");
 }
 static int
 properties_equal (EXTENT e1, EXTENT e2, int depth)
 {
 }
 static int
 extent_remprop (Lisp_Object obj, Lisp_Object prop)
 {
-EXTENT ext = XEXTENT (obj);
+Lisp_Object retval = Fset_extent_property (obj, prop, Qunbound);
+if (UNBOUNDP (retval))
-/* This list is taken from Fset_extent_property, and should be kept
+return -1;
-in synch.  */
+else if (!NILP (retval))
-if (EQ (prop, Qread_only)
+return 1;
-|| EQ (prop, Qunique)
+else
-|| EQ (prop, Qduplicable)
+return 0;
-|| EQ (prop, Qinvisible)
-|| EQ (prop, Qdetachable)
-|| EQ (prop, Qdetached)
-|| EQ (prop, Qdestroyed)
-|| EQ (prop, Qpriority)
-|| EQ (prop, Qface)
-|| EQ (prop, Qinitial_redisplay_function)
-|| EQ (prop, Qafter_change_functions)
-|| EQ (prop, Qbefore_change_functions)
-|| EQ (prop, Qmouse_face)
-|| EQ (prop, Qhighlight)
-|| EQ (prop, Qbegin_glyph_layout)
-|| EQ (prop, Qend_glyph_layout)
-|| EQ (prop, Qglyph_layout)
-|| EQ (prop, Qbegin_glyph)
-|| EQ (prop, Qend_glyph)
-|| EQ (prop, Qstart_open)
-|| EQ (prop, Qend_open)
-|| EQ (prop, Qstart_closed)
-|| EQ (prop, Qend_closed)
-|| EQ (prop, Qkeymap))
-{
-/* #### Is this correct, anyway?  */
-return -1;
-}
-return external_remprop (extent_plist_addr (ext), prop, 0, ERROR_ME);
 }
 static Lisp_Object
 extent_plist (Lisp_Object obj)
 {
 }
 return extent;
 }
-/* Note that the returned value is a buffer position, not a byte index. */
+/* Note that the returned value is a char position, not a byte position. */
 static Lisp_Object
 extent_endpoint_external (Lisp_Object extent_obj, int endp)
 {
 EXTENT extent = decode_extent (extent_obj, 0);
 if (extent_detached_p (extent))
 return Qnil;
 else
-return make_int (extent_endpoint_charbpos (extent, endp));
+return make_int (extent_endpoint_char (extent, endp));
 }
 DEFUN ("extentp", Fextentp, 1, 1, 0, /*
 Return t if OBJECT is an extent.
 */
 Return length of EXTENT in characters.
 */
 (extent))
 {
 EXTENT e = decode_extent (extent, DE_MUST_BE_ATTACHED);
-return make_int (extent_endpoint_charbpos (e, 1)
+return make_int (extent_endpoint_char (e, 1)
-		   - extent_endpoint_charbpos (e, 0));
+		   - extent_endpoint_char (e, 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
 If OBJECT is nil, the current buffer is assumed.
 */
 (pos, object))
 {
 Lisp_Object obj = decode_buffer_or_string (object);
-Bytebpos bpos;
+Bytexpos xpos;
-bpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
+xpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
-bpos = extent_find_end_of_run (obj, bpos, 1);
+xpos = extent_find_end_of_run (obj, xpos, 1);
-return make_int (buffer_or_string_bytebpos_to_charbpos (obj, bpos));
+return make_int (buffer_or_string_bytexpos_to_charxpos (obj, xpos));
 }
 DEFUN ("previous-extent-change", Fprevious_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;
 If OBJECT is nil, the current buffer is assumed.
 */
 (pos, object))
 {
 Lisp_Object obj = decode_buffer_or_string (object);
-Bytebpos bpos;
+Bytexpos xpos;
-bpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
+xpos = get_buffer_or_string_pos_byte (obj, pos, GB_ALLOW_PAST_ACCESSIBLE);
-bpos = extent_find_beginning_of_run (obj, bpos, 1);
+xpos = extent_find_beginning_of_run (obj, xpos, 1);
-return make_int (buffer_or_string_bytebpos_to_charbpos (obj, bpos));
+return make_int (buffer_or_string_bytexpos_to_charxpos (obj, xpos));
 }
 /************************************************************************/
 /*		    	parent and children stuff			*/
 #ifdef ERROR_CHECK_EXTENTS
 assert (NILP (memq_no_quit (child, XWEAK_LIST_LIST (children))));
 #endif
 XWEAK_LIST_LIST (children) = Fcons (child, XWEAK_LIST_LIST (children));
+}
+static int
+compare_key_value_pairs (const void *humpty, const void *dumpty)
+{
+Lisp_Object_pair *foo = (Lisp_Object_pair *) humpty;
+Lisp_Object_pair *bar = (Lisp_Object_pair *) dumpty;
+if (EQ (foo->key, bar->key))
+return 0;
+return !NILP (Fstring_lessp (foo->key, bar->key)) ? -1 : 1;
 }
 DEFUN ("set-extent-parent", Fset_extent_parent, 2, 2, 0, /*
 Set the parent of EXTENT to PARENT (may be nil).
 See `extent-parent'.
 set_extent_no_chase_aux_field (e, parent, parent);
 e->flags.has_parent = 1;
 }
 /* changing the parent also changes the properties of all children. */
 {
+Lisp_Object_pair_dynarr *oldprops, *newprops;
+int i, orignewlength;
+/* perhaps there's a smarter way, but the following will work,
+and it's O(N*log N):
+(1) get the old props.
+(2) get the new props.
+(3) sort both.
+(4) loop through old props; if key not in new, add it, with value
+Qunbound.
+(5) vice-versa for new props.
+(6) sort both again.
+(7) now we have identical lists of keys; we run through and compare
+the values.
+Of course in reality the number of properties will be low, so
+an N^2 algorithm wouldn't be a problem, but the stuff below is just
+as easy to write given the existence of qsort and bsearch.
+*/
+oldprops = Dynarr_new (Lisp_Object_pair);
+newprops = Dynarr_new (Lisp_Object_pair);
+if (!NILP (cur_parent))
+extent_properties (XEXTENT (cur_parent), oldprops);
+if (!NILP (parent))
+extent_properties (XEXTENT (parent), newprops);
+qsort (Dynarr_atp (oldprops, 0), Dynarr_length (oldprops),
+	   sizeof (Lisp_Object_pair), compare_key_value_pairs);
+qsort (Dynarr_atp (newprops, 0), Dynarr_length (newprops),
+	   sizeof (Lisp_Object_pair), compare_key_value_pairs);
+orignewlength = Dynarr_length (newprops);
+for (i = 0; i < Dynarr_length (oldprops); i++)
+{
+	if (!bsearch (Dynarr_atp (oldprops, i), Dynarr_atp (newprops, 0),
+		      Dynarr_length (newprops), sizeof (Lisp_Object_pair),
+		      compare_key_value_pairs))
+	  {
+	    Lisp_Object_pair new;
+	    new.key = Dynarr_at (oldprops, i).key;
+	    new.value = Qunbound;
+	    Dynarr_add (newprops, new);
+	  }
+}
+for (i = 0; i < orignewlength; i++)
+{
+	if (!bsearch (Dynarr_atp (newprops, i), Dynarr_atp (oldprops, 0),
+		      Dynarr_length (oldprops), sizeof (Lisp_Object_pair),
+		      compare_key_value_pairs))
+	  {
+	    Lisp_Object_pair new;
+	    new.key = Dynarr_at (newprops, i).key;
+	    new.value = Qunbound;
+	    Dynarr_add (oldprops, new);
+	  }
+}
+qsort (Dynarr_atp (oldprops, 0), Dynarr_length (oldprops),
+	   sizeof (Lisp_Object_pair), compare_key_value_pairs);
+qsort (Dynarr_atp (newprops, 0), Dynarr_length (newprops),
+	   sizeof (Lisp_Object_pair), compare_key_value_pairs);
+for (i = 0; i < Dynarr_length (oldprops); i++)
+{
+	assert (EQ (Dynarr_at (oldprops, i).key, Dynarr_at (newprops, i).key));
+	if (!EQ (Dynarr_at (oldprops, i).value, Dynarr_at (newprops, i).value))
+	  signal_extent_property_changed (e, Dynarr_at (oldprops, i).key, 1);
+}
+Dynarr_free (oldprops);
+Dynarr_free (newprops);
+#if 0
+{
 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);
 }
+#endif /* 0 */
+}
 return Qnil;
 }
 /************************************************************************/
 undo records for transient extents via update-extent.
 For example, query-replace will do this.
 */
 static void
-set_extent_endpoints_1 (EXTENT extent, Membpos start, Membpos end)
+set_extent_endpoints_1 (EXTENT extent, Memxpos start, Memxpos end)
 {
 #ifdef ERROR_CHECK_EXTENTS
 Lisp_Object obj = extent_object (extent);
 assert (start <= end);
 /* Set extent's endpoints to S and E, and put extent in buffer or string
 OBJECT. (If OBJECT is nil, do not change the extent's object.) */
 void
-set_extent_endpoints (EXTENT extent, Bytebpos s, Bytebpos e, Lisp_Object object)
+set_extent_endpoints (EXTENT extent, Bytexpos s, Bytexpos e,
-{
+		      Lisp_Object object)
-Membpos start, end;
+{
+Memxpos start, end;
 if (NILP (object))
 {
 object = extent_object (extent);
 assert (!NILP (object));
 extent_detach (extent);
 extent_object (extent) = object;
 }
 start = s < 0 ? extent_start (extent) :
-buffer_or_string_bytebpos_to_membpos (object, s);
+buffer_or_string_bytexpos_to_memxpos (object, s);
 end = e < 0 ? extent_end (extent) :
-buffer_or_string_bytebpos_to_membpos (object, e);
+buffer_or_string_bytexpos_to_memxpos (object, e);
 set_extent_endpoints_1 (extent, start, end);
 }
 static void
 set_extent_openness (EXTENT extent, int start_open, int end_open)
 {
 if (start_open != -1)
-extent_start_open_p (extent) = start_open;
+{
+extent_start_open_p (extent) = start_open;
+signal_extent_property_changed (extent, Qstart_open, 1);
+}
 if (end_open != -1)
-extent_end_open_p (extent) = end_open;
+{
-/* changing the open/closedness of an extent does not affect
+extent_end_open_p (extent) = end_open;
-redisplay. */
+signal_extent_property_changed (extent, Qend_open, 1);
+}
 }
 static EXTENT
-make_extent_internal (Lisp_Object object, Bytebpos from, Bytebpos to)
+make_extent (Lisp_Object object, Bytexpos from, Bytexpos to)
 {
 EXTENT extent;
 extent = make_extent_detached (object);
 set_extent_endpoints (extent, from, to, Qnil);
 return extent;
 }
+/* Copy ORIGINAL, changing it to span FROM,TO in OBJECT. */
 static EXTENT
-copy_extent (EXTENT original, Bytebpos from, Bytebpos to, Lisp_Object object)
+copy_extent (EXTENT original, Bytexpos from, Bytexpos to, Lisp_Object object)
 {
 EXTENT e;
 e = make_extent_detached (object);
 if (from >= 0)
 	obj = Qnil;
 extent_obj = wrap_extent (make_extent_detached (obj));
 }
 else
 {
-Bytebpos start, end;
+Bytexpos start, end;
 get_buffer_or_string_range_byte (obj, from, to, &start, &end,
 				       GB_ALLOW_PAST_ACCESSIBLE);
-extent_obj = wrap_extent (make_extent_internal (obj, start, end));
+extent_obj = wrap_extent (make_extent (obj, start, end));
 }
 return extent_obj;
 }
 DEFUN ("copy-extent", Fcopy_extent, 1, 2, 0, /*
 See documentation on `detach-extent' for a discussion of undo recording.
 */
 (extent, start, end, buffer_or_string))
 {
 EXTENT ext;
-Bytebpos s, e;
+Bytexpos s, e;
 ext = decode_extent (extent, 0);
 if (NILP (buffer_or_string))
 {
 This is equivalent to whether `map-extents' would visit EXTENT when called
 with these args.
 */
 (extent, from, to, flags))
 {
-Bytebpos start, end;
+Bytexpos start, end;
 EXTENT ext = decode_extent (extent, DE_MUST_BE_ATTACHED);
 Lisp_Object obj = extent_object (ext);
 get_buffer_or_string_range_byte (obj, from, to, &start, &end, GB_ALLOW_NIL |
 				   GB_ALLOW_PAST_ACCESSIBLE);
 (function, object, from, to, maparg, flags, property, value))
 {
 /* This function can GC */
 struct slow_map_extents_arg closure;
 unsigned int me_flags;
-Bytebpos start, end;
+Bytexpos start, end;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 EXTENT after = 0;
 if (EXTENTP (object))
 {
 closure.map_routine = function;
 closure.result = Qnil;
 closure.property = property;
 closure.value = value;
-map_extents_bytebpos (start, end, slow_map_extents_function,
+map_extents (start, end, slow_map_extents_function,
-		      (void *) &closure, object, after,
+	       (void *) &closure, object, after,
-		      /* You never know what the user might do ... */
+	       /* You never know what the user might do ... */
-		      me_flags | ME_MIGHT_CALL_ELISP);
+	       me_flags | ME_MIGHT_CALL_ELISP);
 UNGCPRO;
 return closure.result;
 }
 Lisp_Object map_arg;
 Lisp_Object map_routine;
 Lisp_Object result;
 Lisp_Object property;
 Lisp_Object value;
-Bytebpos start_min;
+Bytexpos start_min;
-Bytebpos prev_start;
+Bytexpos prev_start;
-Bytebpos prev_end;
+Bytexpos prev_end;
 };
 static int
 slow_map_extent_children_function (EXTENT extent, void *arg)
 {
 /* This function can GC */
 struct slow_map_extent_children_arg *closure =
 (struct slow_map_extent_children_arg *) arg;
 Lisp_Object extent_obj;
-Bytebpos start = extent_endpoint_bytebpos (extent, 0);
+Bytexpos start = extent_endpoint_byte (extent, 0);
-Bytebpos end = extent_endpoint_bytebpos (extent, 1);
+Bytexpos end = extent_endpoint_byte (extent, 1);
 /* Make sure the extent starts inside the region of interest,
 rather than just overlaps it.
 */
 if (start < closure->start_min)
 return 0;
 /* Since the callback may change the buffer, compute all stored
 buffer positions here.
 */
 closure->start_min = -1;	/* no need for this any more */
-closure->prev_start = extent_endpoint_bytebpos (extent, 0);
+closure->prev_start = extent_endpoint_byte (extent, 0);
-closure->prev_end = extent_endpoint_bytebpos (extent, 1);
+closure->prev_end = extent_endpoint_byte (extent, 1);
 return !NILP (closure->result);
 }
 DEFUN ("map-extent-children", Fmap_extent_children, 1, 8, 0, /*
 (function, object, from, to, maparg, flags, property, value))
 {
 /* This function can GC */
 struct slow_map_extent_children_arg closure;
 unsigned int me_flags;
-Bytebpos start, end;
+Bytexpos start, end;
 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 EXTENT after = 0;
 if (EXTENTP (object))
 {
 closure.property = property;
 closure.value = value;
 closure.start_min = start;
 closure.prev_start = -1;
 closure.prev_end = -1;
-map_extents_bytebpos (start, end, slow_map_extent_children_function,
+map_extents (start, end, slow_map_extent_children_function,
-		      (void *) &closure, object, after,
+	       (void *) &closure, object, after,
-		      /* You never know what the user might do ... */
+	       /* You never know what the user might do ... */
-		      me_flags | ME_MIGHT_CALL_ELISP);
+	       me_flags | ME_MIGHT_CALL_ELISP);
 UNGCPRO;
 return closure.result;
 }
 */
 struct extent_at_arg
 {
 Lisp_Object best_match; /* or list of extents */
-Membpos best_start;
+Memxpos best_start;
-Membpos best_end;
+Memxpos best_end;
 Lisp_Object prop;
 EXTENT before;
 int all_extents;
-};
-enum extent_at_flag
-{
-EXTENT_AT_AFTER,
-EXTENT_AT_BEFORE,
-EXTENT_AT_AT
 };
 static enum extent_at_flag
 decode_extent_at_flag (Lisp_Object at_flag)
 {
 }
 return 0;
 }
-static Lisp_Object
+Lisp_Object
-extent_at_bytebpos (Bytebpos position, Lisp_Object object, Lisp_Object property,
+extent_at (Bytexpos position, Lisp_Object object,
-		  EXTENT before, enum extent_at_flag at_flag, int all_extents)
+	   Lisp_Object property, EXTENT before,
+	   enum extent_at_flag at_flag, int all_extents)
 {
 struct extent_at_arg closure;
 struct gcpro gcpro1;
 /* it might be argued that invalid positions should cause
 closure.prop = property;
 closure.before = before;
 closure.all_extents = all_extents;
 GCPRO1 (closure.best_match);
-map_extents_bytebpos (at_flag == EXTENT_AT_BEFORE ? position - 1 : position,
+map_extents (at_flag == EXTENT_AT_BEFORE ? prev_bytexpos (object, position) :
-		      at_flag == EXTENT_AT_AFTER ? position + 1 : position,
+	       position,
-		      extent_at_mapper, (void *) &closure, object, 0,
+	       at_flag == EXTENT_AT_AFTER ? next_bytexpos (object, position) :
-		      ME_START_OPEN | ME_ALL_EXTENTS_CLOSED);
+	       position,
+	       extent_at_mapper, (void *) &closure, object, 0,
+	       ME_START_OPEN | ME_ALL_EXTENTS_CLOSED);
 if (all_extents)
 closure.best_match = Fnreverse (closure.best_match);
 UNGCPRO;
 return closure.best_match;
 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))
 {
-Bytebpos position;
+Bytexpos position;
 EXTENT before_extent;
 enum extent_at_flag fl;
 object = decode_buffer_or_string (object);
 position = get_buffer_or_string_pos_byte (object, pos, GB_NO_ERROR_IF_BAD);
 before_extent = decode_extent (before, DE_MUST_BE_ATTACHED);
 if (before_extent && !EQ (object, extent_object (before_extent)))
 invalid_argument ("extent not in specified buffer or string", object);
 fl = decode_extent_at_flag (at_flag);
-return extent_at_bytebpos (position, object, property, before_extent, fl, 0);
+return extent_at (position, object, property, before_extent, fl, 0);
 }
 DEFUN ("extents-at", Fextents_at, 1, 5, 0, /*
 Find all extents at POS in OBJECT having PROPERTY set.
 Normally, an extent is "at" POS if it overlaps the region (POS, POS+1);
 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))
 {
-Bytebpos position;
+Bytexpos position;
 EXTENT before_extent;
 enum extent_at_flag fl;
 object = decode_buffer_or_string (object);
 position = get_buffer_or_string_pos_byte (object, pos, GB_NO_ERROR_IF_BAD);
 before_extent = decode_extent (before, DE_MUST_BE_ATTACHED);
 if (before_extent && !EQ (object, extent_object (before_extent)))
 invalid_argument ("extent not in specified buffer or string", object);
 fl = decode_extent_at_flag (at_flag);
-return extent_at_bytebpos (position, object, property, before_extent, fl, 1);
+return extent_at (position, object, property, before_extent, fl, 1);
 }
 /* ------------------------------- */
 /*   verify_extent_modification()  */
 /* ------------------------------- */
 */
 struct verify_extents_arg
 {
 Lisp_Object object;
-Membpos start;
+Memxpos start;
-Membpos end;
+Memxpos end;
 Lisp_Object iro; /* value of inhibit-read-only */
 };
 static int
 verify_extent_mapper (EXTENT extent, void *arg)
 /* Value of Vinhibit_read_only is precomputed and passed in for
 efficiency */
 void
-verify_extent_modification (Lisp_Object object, Bytebpos from, Bytebpos to,
+verify_extent_modification (Lisp_Object object, Bytexpos from, Bytexpos to,
 			    Lisp_Object inhibit_read_only_value)
 {
 int closed;
 struct verify_extents_arg closure;
 changed range has zero length, and a deletion otherwise.  This
 fails if a change (i.e. non-insertion, non-deletion) is happening.
 As far as I know, this doesn't currently occur in XEmacs. --ben */
 closed = (from==to);
 closure.object = object;
-closure.start = buffer_or_string_bytebpos_to_membpos (object, from);
+closure.start = buffer_or_string_bytexpos_to_memxpos (object, from);
-closure.end = buffer_or_string_bytebpos_to_membpos (object, to);
+closure.end = buffer_or_string_bytexpos_to_memxpos (object, to);
 closure.iro = inhibit_read_only_value;
-map_extents_bytebpos (from, to, verify_extent_mapper, (void *) &closure,
+map_extents (from, to, verify_extent_mapper, (void *) &closure,
-		      object, 0, closed ? ME_END_CLOSED : ME_START_OPEN);
+	       object, 0, closed ? ME_END_CLOSED : ME_START_OPEN);
 }
 /* ------------------------------------ */
 /*    process_extents_for_insertion()   */
 /* ------------------------------------ */
 struct process_extents_for_insertion_arg
 {
-Bytebpos opoint;
+Bytexpos opoint;
 int length;
 Lisp_Object object;
 };
 /*   A region of length LENGTH was just inserted at OPOINT.  Modify all
 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;
-Membpos indice = buffer_or_string_bytebpos_to_membpos (closure->object,
+Memxpos indice = buffer_or_string_bytexpos_to_memxpos (closure->object,
-						      closure->opoint);
+							 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.
 */
 Existence of zero-length open-open extents is unfortunately an
 inelegant part of the extent model, but there is no way around
 it. */
 {
-Membpos new_start = extent_start (extent);
+Memxpos new_start = extent_start (extent);
-Membpos new_end   = extent_end (extent);
+Memxpos new_end   = extent_end (extent);
 if (indice == extent_start (extent) && extent_start_open_p (extent)
 	/* zero-length () extents are exempt; see comment above. */
 	&& !(new_start == new_end && extent_end_open_p (extent))
 	)
 return 0;
 }
 void
-process_extents_for_insertion (Lisp_Object object, Bytebpos opoint,
+process_extents_for_insertion (Lisp_Object object, Bytexpos opoint,
 			       Bytecount length)
 {
 struct process_extents_for_insertion_arg closure;
 closure.opoint = opoint;
 closure.length = length;
 closure.object = object;
-map_extents_bytebpos (opoint, opoint + length,
+map_extents (opoint, opoint + length,
-		      process_extents_for_insertion_mapper,
+	       process_extents_for_insertion_mapper,
-		      (void *) &closure, object, 0,
+	       (void *) &closure, object, 0,
-		      ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS |
+	       ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS |
-		      ME_INCLUDE_INTERNAL);
+	       ME_INCLUDE_INTERNAL);
 }
 /* ------------------------------------ */
 /*    process_extents_for_deletion()    */
 /* ------------------------------------ */
 struct process_extents_for_deletion_arg
 {
-Membpos start, end;
+Memxpos start, end;
 int destroy_included_extents;
 };
 /* This function is called when we're about to delete the range [from, to].
 Detach all of the extents that are completely inside the range [from, to],
 /* DESTROY_THEM means destroy the extents instead of just deleting them.
 It is unused currently, but perhaps might be used (there used to
 be a function process_extents_for_destruction(), #if 0'd out,
 that did the equivalent). */
 void
-process_extents_for_deletion (Lisp_Object object, Bytebpos from,
+process_extents_for_deletion (Lisp_Object object, Bytexpos from,
-			      Bytebpos to, int destroy_them)
+			      Bytexpos to, int destroy_them)
 {
 struct process_extents_for_deletion_arg closure;
-closure.start = buffer_or_string_bytebpos_to_membpos (object, from);
+closure.start = buffer_or_string_bytexpos_to_memxpos (object, from);
-closure.end = buffer_or_string_bytebpos_to_membpos (object, to);
+closure.end = buffer_or_string_bytexpos_to_memxpos (object, to);
 closure.destroy_included_extents = destroy_them;
-map_extents_bytebpos (from, to, process_extents_for_deletion_mapper,
+map_extents (from, to, process_extents_for_deletion_mapper,
-		      (void *) &closure, object, 0,
+	       (void *) &closure, object, 0,
-		      ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS);
+	       ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS);
 }
 /* ------------------------------- */
 /*   report_extent_modification()  */
 /* ------------------------------- */
-struct report_extent_modification_closure {
+struct report_extent_modification_closure
+{
 Lisp_Object buffer;
-Charbpos start, end;
+Charxpos start, end;
 int afterp;
 int speccount;
 };
 static Lisp_Object
 the current buffer, in case we change it.  Do the recording only
 once.
 One confusing thing here is that our caller never actually calls
 unbind_to (closure.speccount).  This is because
-map_extents_bytebpos() unbinds before, and with a smaller
+map_extents() unbinds before, and with a smaller
 speccount.  The additional unbind_to_1() in
 report_extent_modification() would cause XEmacs to abort.  */
 if (closure->speccount == -1)
 {
 closure->speccount = specpdl_depth ();
 closure.start = start;
 closure.end = end;
 closure.afterp = afterp;
 closure.speccount = -1;
-map_extents (start, end, report_extent_modification_mapper, (void *)&closure,
+map_extents (charbpos_to_bytebpos (XBUFFER (buffer), start),
+	       charbpos_to_bytebpos (XBUFFER (buffer), end),
+	       report_extent_modification_mapper, (void *)&closure,
 	       buffer, NULL, ME_MIGHT_CALL_ELISP);
 }
 /************************************************************************/
 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);
+signal_extent_property_changed (extent, Qinvisible, 1);
 }
 }
 /* This function does "memoization" -- similar to the interning
 that happens with symbols.  Given a list of faces, an equivalent
 assert (!UNBOUNDP (face));
 return face;
 }
 }
+/* The idea here is that if we're given a list of faces, we
+need to "memoize" this so that two lists of faces that are `equal'
+turn into the same object.  When `set-extent-face' is called, we
+"memoize" into a list of actual faces; when `extent-face' is called,
+we do a reverse lookup to get the list of symbols. */
 static Lisp_Object
 canonicalize_extent_property (Lisp_Object prop, Lisp_Object value)
 {
 if (EQ (prop, Qface) || EQ (prop, Qmouse_face))
 value = (external_of_internal_memoized_face
 	     (memoize_extent_face_internal (value)));
 return value;
 }
 /* Do we need a lisp-level function ? */
-DEFUN ("set-extent-initial-redisplay-function", Fset_extent_initial_redisplay_function,
+DEFUN ("set-extent-initial-redisplay-function",
+Fset_extent_initial_redisplay_function,
 2,2,0, /*
 Note: This feature is experimental!
 Set initial-redisplay-function of EXTENT to the function
 FUNCTION.
 The first time the EXTENT is (re)displayed, an eval event will be
 dispatched calling FUNCTION with EXTENT as its only argument.
 */
 (extent, function))
 {
-EXTENT e = decode_extent(extent, DE_MUST_BE_ATTACHED);
+/* #### This is totally broken. */
+EXTENT e = decode_extent (extent, DE_MUST_BE_ATTACHED);
 e = extent_ancestor (e);  /* Is this needed? Macro also does chasing!*/
-set_extent_initial_redisplay_function(e,function);
+set_extent_initial_redisplay_function (e, function);
-extent_in_red_event_p(e) = 0;  /* If the function changed we can spawn
+extent_in_red_event_p (e) = 0;  /* If the function changed we can spawn
 				    new events */
-extent_changed_for_redisplay(e,1,0); /* Do we need to mark children too ?*/
+signal_extent_property_changed (e, Qinitial_redisplay_function, 1);
 return function;
 }
 DEFUN ("extent-face", Fextent_face, 1, 1, 0, /*
 Return the name of the face in which EXTENT is displayed, or nil
 e = extent_ancestor (e);
 face = memoize_extent_face_internal (face);
 extent_face (e) = face;
-extent_changed_for_redisplay (e, 1, 0);
+signal_extent_property_changed (e, Qface, 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);
+signal_extent_property_changed (e, Qmouse_face, 1);
 return orig_face;
 }
 void
 if (!endp)
 {
 set_extent_begin_glyph (extent, glyph);
 set_extent_begin_glyph_layout (extent, layout);
+signal_extent_property_changed (extent, Qbegin_glyph, 1);
+signal_extent_property_changed (extent, Qbegin_glyph_layout, 1);
 }
 else
 {
 set_extent_end_glyph (extent, glyph);
 set_extent_end_glyph_layout (extent, layout);
-}
+signal_extent_property_changed (extent, Qend_glyph, 1);
+signal_extent_property_changed (extent, Qend_glyph_layout, 1);
-extent_changed_for_redisplay (extent, 1, 0);
+}
 }
 static Lisp_Object
 glyph_layout_to_symbol (glyph_layout layout)
 {
 (extent, layout))
 {
 EXTENT e = decode_extent (extent, 0);
 e = extent_ancestor (e);
 set_extent_begin_glyph_layout (e, symbol_to_glyph_layout (layout));
-extent_maybe_changed_for_redisplay (e, 1, 0);
+signal_extent_property_changed (e, Qbegin_glyph_layout, 1);
 return layout;
 }
 DEFUN ("set-extent-end-glyph-layout", Fset_extent_end_glyph_layout, 2, 2, 0, /*
 Set the layout policy of EXTENT's end glyph.
 (extent, layout))
 {
 EXTENT e = decode_extent (extent, 0);
 e = extent_ancestor (e);
 set_extent_end_glyph_layout (e, symbol_to_glyph_layout (layout));
-extent_maybe_changed_for_redisplay (e, 1, 0);
+signal_extent_property_changed (e, Qend_glyph_layout, 1);
 return layout;
 }
 DEFUN ("extent-begin-glyph-layout", Fextent_begin_glyph_layout, 1, 1, 0, /*
 Return the layout policy associated with EXTENT's begin glyph.
 EXTENT e = decode_extent (extent, 0);
 CHECK_INT (priority);
 e = extent_ancestor (e);
 set_extent_priority (e, XINT (priority));
-extent_maybe_changed_for_redisplay (e, 1, 0);
+signal_extent_property_changed (e, Qpriority, 1);
 return priority;
 }
 DEFUN ("extent-priority", Fextent_priority, 1, 1, 0, /*
 Return the display priority of EXTENT; see `set-extent-priority'.
 */
 (extent, property, value))
 {
 /* This function can GC if property is `keymap' */
 EXTENT e = decode_extent (extent, 0);
+int signal_change = 0;
+/* If VALUE is unbound, the property is being removed through `remprop'.
+Return Qunbound if removal disallowed, Qt if anything removed,
+Qnil otherwise. */
+/* Keep in synch with stuff below. */
+if (UNBOUNDP (value))
+{
+int retval;
+if (EQ (property, Qread_only)
+	  || EQ (property, Qunique)
+	  || EQ (property, Qduplicable)
+	  || EQ (property, Qinvisible)
+	  || EQ (property, Qdetachable)
+	  || EQ (property, Qdetached)
+	  || EQ (property, Qdestroyed)
+	  || EQ (property, Qpriority)
+	  || EQ (property, Qface)
+	  || EQ (property, Qinitial_redisplay_function)
+	  || EQ (property, Qafter_change_functions)
+	  || EQ (property, Qbefore_change_functions)
+	  || EQ (property, Qmouse_face)
+	  || EQ (property, Qhighlight)
+	  || EQ (property, Qbegin_glyph_layout)
+	  || EQ (property, Qend_glyph_layout)
+	  || EQ (property, Qglyph_layout)
+	  || EQ (property, Qbegin_glyph)
+	  || EQ (property, Qend_glyph)
+	  || EQ (property, Qstart_open)
+	  || EQ (property, Qend_open)
+	  || EQ (property, Qstart_closed)
+	  || EQ (property, Qend_closed)
+	  || EQ (property, Qkeymap))
+	return Qunbound;
+retval = external_remprop (extent_plist_addr (e), property, 0,
+				 ERROR_ME);
+if (retval)
+	signal_extent_property_changed (e, property, 1);
+return retval ? Qt : Qnil;
+}
 if (EQ (property, Qread_only))
-set_extent_read_only (e, value);
+{
+set_extent_read_only (e, value);
+signal_change = 1;
+}
 else if (EQ (property, Qunique))
-extent_unique_p (e) = !NILP (value);
+{
+extent_unique_p (e) = !NILP (value);
+signal_change = 1;
+}
 else if (EQ (property, Qduplicable))
-extent_duplicable_p (e) = !NILP (value);
+{
+extent_duplicable_p (e) = !NILP (value);
+signal_change = 1;
+}
 else if (EQ (property, Qinvisible))
 set_extent_invisible (e, value);
 else if (EQ (property, Qdetachable))
-extent_detachable_p (e) = !NILP (value);
+{
+extent_detachable_p (e) = !NILP (value);
+signal_change = 1;
+}
 else if (EQ (property, Qdetached))
 {
 if (NILP (value))
-invalid_operation ("can only set `detached' to t", Qunbound);
+	invalid_operation ("can only set `detached' to t", Qunbound);
 Fdetach_extent (extent);
 }
 else if (EQ (property, Qdestroyed))
 {
 if (NILP (value))
-invalid_operation ("can only set `destroyed' to t", Qunbound);
+	invalid_operation ("can only set `destroyed' to t", Qunbound);
 Fdelete_extent (extent);
 }
 else if (EQ (property, Qpriority))
 Fset_extent_priority (extent, value);
 else if (EQ (property, Qface))
 Fset_extent_face (extent, value);
 else if (EQ (property, Qinitial_redisplay_function))
 Fset_extent_initial_redisplay_function (extent, value);
 else if (EQ (property, Qbefore_change_functions))
-set_extent_before_change_functions (e, value);
+{
+set_extent_before_change_functions (e, value);
+signal_change = 1;
+}
 else if (EQ (property, Qafter_change_functions))
-set_extent_after_change_functions (e, value);
+{
+set_extent_after_change_functions (e, value);
+signal_change = 1;
+}
 else if (EQ (property, Qmouse_face))
 Fset_extent_mouse_face (extent, value);
 /* Obsolete: */
 else if (EQ (property, Qhighlight))
 Fset_extent_mouse_face (extent, Qhighlight);
 if (EQ (property, Qkeymap))
 	while (!NILP (value) && NILP (Fkeymapp (value)))
 	  value = wrong_type_argument (Qkeymapp, value);
 external_plist_put (extent_plist_addr (e), property, value, 0, ERROR_ME);
-}
+signal_change = 1;
+}
+if (signal_change)
+signal_extent_property_changed (e, property, 1);
 return value;
 }
 DEFUN ("set-extent-properties", Fset_extent_properties, 2, 2, 0, /*
 Change some properties of EXTENT.
 					      property, 0, ERROR_ME);
 return UNBOUNDP (value) ? default_ : value;
 }
 }
+static void
+extent_properties (EXTENT e, Lisp_Object_pair_dynarr *props)
+{
+Lisp_Object face, anc_obj;
+glyph_layout layout;
+EXTENT anc;
+#define ADD_PROP(miftaaH, maal)			\
+do {						\
+Lisp_Object_pair p;				\
+p.key = miftaaH;				\
+p.value = maal;				\
+Dynarr_add (props, p);			\
+} while (0)
+if (!EXTENT_LIVE_P (e))
+{
+ADD_PROP (Qdestroyed, Qt);
+return;
+}
+anc = extent_ancestor (e);
+anc_obj = wrap_extent (anc);
+/* For efficiency, use the ancestor for all properties except detached */
+{
+EXTERNAL_PROPERTY_LIST_LOOP_3 (key, value, extent_plist_slot (anc))
+ADD_PROP (key, value);
+}
+if (!NILP (face = Fextent_face (anc_obj)))
+ADD_PROP (Qface, face);
+if (!NILP (face = Fextent_mouse_face (anc_obj)))
+ADD_PROP (Qmouse_face, face);
+if ((layout = (glyph_layout) extent_begin_glyph_layout (anc)) != GL_TEXT)
+{
+Lisp_Object sym = glyph_layout_to_symbol (layout);
+ADD_PROP (Qglyph_layout,       sym); /* compatibility */
+ADD_PROP (Qbegin_glyph_layout, sym);
+}
+if ((layout = (glyph_layout) extent_end_glyph_layout (anc)) != GL_TEXT)
+ADD_PROP (Qend_glyph_layout, glyph_layout_to_symbol (layout));
+if (!NILP (extent_end_glyph (anc)))
+ADD_PROP (Qend_glyph, extent_end_glyph (anc));
+if (!NILP (extent_begin_glyph (anc)))
+ADD_PROP (Qbegin_glyph, extent_begin_glyph (anc));
+if (extent_priority (anc) != 0)
+ADD_PROP (Qpriority, make_int (extent_priority (anc)));
+if (!NILP (extent_initial_redisplay_function (anc)))
+ADD_PROP (Qinitial_redisplay_function,
+	      extent_initial_redisplay_function (anc));
+if (!NILP (extent_before_change_functions (anc)))
+ADD_PROP (Qbefore_change_functions, extent_before_change_functions (anc));
+if (!NILP (extent_after_change_functions (anc)))
+ADD_PROP (Qafter_change_functions, extent_after_change_functions (anc));
+if (!NILP (extent_invisible (anc)))
+ADD_PROP (Qinvisible, extent_invisible (anc));
+if (!NILP (extent_read_only (anc)))
+ADD_PROP (Qread_only, extent_read_only (anc));
+if  (extent_normal_field (anc, end_open))
+ADD_PROP (Qend_open, Qt);
+if  (extent_normal_field (anc, start_open))
+ADD_PROP (Qstart_open, Qt);
+if  (extent_normal_field (anc, detachable))
+ADD_PROP (Qdetachable, Qt);
+if  (extent_normal_field (anc, duplicable))
+ADD_PROP (Qduplicable, Qt);
+if  (extent_normal_field (anc, unique))
+ADD_PROP (Qunique, Qt);
+/* detached is not an inherited property */
+if (extent_detached_p (e))
+ADD_PROP (Qdetached, Qt);
+#undef ADD_PROP
+}
 DEFUN ("extent-properties", Fextent_properties, 1, 1, 0, /*
 Return a property list of the attributes of EXTENT.
 Do not modify this list; use `set-extent-property' instead.
 */
 (extent))
 {
-EXTENT e, anc;
+EXTENT e;
-Lisp_Object result, face, anc_obj;
+Lisp_Object result = Qnil;
-glyph_layout layout;
+Lisp_Object_pair_dynarr *props;
+int i;
 CHECK_EXTENT (extent);
 e = XEXTENT (extent);
-if (!EXTENT_LIVE_P (e))
+props = Dynarr_new (Lisp_Object_pair);
-return cons3 (Qdestroyed, Qt, Qnil);
+extent_properties (e, props);
-anc = extent_ancestor (e);
+for (i = 0; i < Dynarr_length (props); i++)
-anc_obj = wrap_extent (anc);
+result = cons3 (Dynarr_at (props, i).key, Dynarr_at (props, i).value,
+		    result);
-/* For efficiency, use the ancestor for all properties except detached */
+Dynarr_free (props);
-result = extent_plist_slot (anc);
-if (!NILP (face = Fextent_face (anc_obj)))
-result = cons3 (Qface, face, result);
-if (!NILP (face = Fextent_mouse_face (anc_obj)))
-result = cons3 (Qmouse_face, face, result);
-if ((layout = (glyph_layout) extent_begin_glyph_layout (anc)) != GL_TEXT)
-{
-Lisp_Object sym = glyph_layout_to_symbol (layout);
-result = cons3 (Qglyph_layout,       sym, result); /* compatibility */
-result = cons3 (Qbegin_glyph_layout, sym, result);
-}
-if ((layout = (glyph_layout) extent_end_glyph_layout (anc)) != GL_TEXT)
-result = cons3 (Qend_glyph_layout, glyph_layout_to_symbol (layout), result);
-if (!NILP (extent_end_glyph (anc)))
-result = cons3 (Qend_glyph, extent_end_glyph (anc), result);
-if (!NILP (extent_begin_glyph (anc)))
-result = cons3 (Qbegin_glyph, extent_begin_glyph (anc), result);
-if (extent_priority (anc) != 0)
-result = cons3 (Qpriority, make_int (extent_priority (anc)), result);
-if (!NILP (extent_initial_redisplay_function (anc)))
-result = cons3 (Qinitial_redisplay_function,
-		    extent_initial_redisplay_function (anc), result);
-if (!NILP (extent_before_change_functions (anc)))
-result = cons3 (Qbefore_change_functions,
-		    extent_before_change_functions (anc), result);
-if (!NILP (extent_after_change_functions (anc)))
-result = cons3 (Qafter_change_functions,
-		    extent_after_change_functions (anc), result);
-if (!NILP (extent_invisible (anc)))
-result = cons3 (Qinvisible, extent_invisible (anc), result);
-if (!NILP (extent_read_only (anc)))
-result = cons3 (Qread_only, extent_read_only (anc), result);
-if  (extent_normal_field (anc, end_open))
-result = cons3 (Qend_open, Qt, result);
-if  (extent_normal_field (anc, start_open))
-result = cons3 (Qstart_open, Qt, result);
-if  (extent_normal_field (anc, detachable))
-result = cons3 (Qdetachable, Qt, result);
-if  (extent_normal_field (anc, duplicable))
-result = cons3 (Qduplicable, Qt, result);
-if  (extent_normal_field (anc, unique))
-result = cons3 (Qunique, Qt, result);
-/* detached is not an inherited property */
-if (extent_detached_p (e))
-result = cons3 (Qdetached, Qt, result);
 return result;
 }
 /************************************************************************/
 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);
+/* A bit of a lie. */
+signal_extent_property_changed (XEXTENT (Vlast_highlighted_extent),
+				      Qface, 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);
+signal_extent_property_changed (XEXTENT (extent_obj), Qface, 0);
 Vlast_highlighted_extent = extent_obj;
 }
 }
 DEFUN ("force-highlight-extent", Fforce_highlight_extent, 1, 2, 0, /*
 /************************************************************************/
 /* copy/paste hooks */
 static int
-run_extent_copy_paste_internal (EXTENT e, Charbpos from, Charbpos to,
+run_extent_copy_paste_internal (EXTENT e, Charxpos from, Charxpos to,
 				Lisp_Object object,
 				Lisp_Object prop)
 {
 /* This function can GC */
 Lisp_Object extent;
 }
 return 1;
 }
 static int
-run_extent_copy_function (EXTENT e, Bytebpos from, Bytebpos to)
+run_extent_copy_function (EXTENT e, Bytexpos from, Bytexpos to)
 {
 Lisp_Object object = extent_object (e);
 /* This function can GC */
 return run_extent_copy_paste_internal
-(e, buffer_or_string_bytebpos_to_charbpos (object, from),
+(e, buffer_or_string_bytexpos_to_charxpos (object, from),
-buffer_or_string_bytebpos_to_charbpos (object, to), object,
+buffer_or_string_bytexpos_to_charxpos (object, to), object,
 Qcopy_function);
 }
 static int
-run_extent_paste_function (EXTENT e, Bytebpos from, Bytebpos to,
+run_extent_paste_function (EXTENT e, Bytexpos from, Bytexpos to,
 			   Lisp_Object object)
 {
 /* This function can GC */
 return run_extent_copy_paste_internal
-(e, buffer_or_string_bytebpos_to_charbpos (object, from),
+(e, buffer_or_string_bytexpos_to_charxpos (object, from),
-buffer_or_string_bytebpos_to_charbpos (object, to), object,
+buffer_or_string_bytexpos_to_charxpos (object, to), object,
 Qpaste_function);
 }
-static void
+static int
-update_extent (EXTENT extent, Bytebpos from, Bytebpos to)
+run_extent_paste_function_char (EXTENT e, Charxpos from, Charxpos to,
-{
+				Lisp_Object object)
-set_extent_endpoints (extent, from, to, Qnil);
+{
-}
+/* This function can GC */
+return run_extent_copy_paste_internal (e, from, to, object, Qpaste_function);
-/* Insert an extent, usually from the dup_list of a string which
+}
-has just been inserted.
-This code does not handle the case of undo.
-*/
 static Lisp_Object
-insert_extent (EXTENT extent, Bytebpos new_start, Bytebpos new_end,
+insert_extent (EXTENT extent, Bytexpos new_start, Bytexpos new_end,
 	       Lisp_Object object, int run_hooks)
 {
 /* This function can GC */
 if (!EQ (extent_object (extent), object))
 goto copy_it;
 if (run_hooks &&
 	  !run_extent_paste_function (extent, new_start, new_end, object))
 	/* The paste-function said don't re-attach this extent here. */
 	return Qnil;
 else
-	update_extent (extent, new_start, new_end);
+	set_extent_endpoints (extent, new_start, new_end, Qnil);
 }
 else
 {
-Bytebpos exstart = extent_endpoint_bytebpos (extent, 0);
+Bytexpos exstart = extent_endpoint_byte (extent, 0);
-Bytebpos exend = extent_endpoint_bytebpos (extent, 1);
+Bytexpos exend = extent_endpoint_byte (extent, 1);
 if (exend < new_start || exstart > new_end)
 	goto copy_it;
 else
 	{
 	  new_start = min (exstart, new_start);
 	  new_end = max (exend, new_end);
 	  if (exstart != new_start || exend != new_end)
-	    update_extent (extent, new_start, new_end);
+	    set_extent_endpoints (extent, new_start, new_end, Qnil);
 	}
 }
 return wrap_extent (extent);
 }
 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,
+If EXTENT is already on the same object, and overlaps or is adjacent to
-but otherwise acts as if there were a replicating extent whose
+the given range, its range is merely extended to include the new range.
-parent is EXTENT in some string that was just inserted.
+Otherwise, a copy is made of the extent at the new position and object.
-Returns the newly-inserted extent.
+When a copy is made, the new extent is returned, copy/paste hooks are run,
+and the change is noted for undo recording.  When no copy is made, nil is
+returned.  See documentation on `detach-extent' for a discussion of undo
+recording.
 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.
+It's not really clear why this function exists any more.  It was a holdover
+from a much older implementation of extents, before extents could really
+exist on strings.
 */
 (extent, start, end, no_hooks, buffer_or_string))
 {
 EXTENT ext = decode_extent (extent, 0);
 Lisp_Object copy;
-Bytebpos s, e;
+Bytexpos s, e;
 buffer_or_string = decode_buffer_or_string (buffer_or_string);
 get_buffer_or_string_range_byte (buffer_or_string, start, end, &s, &e,
 				   GB_ALLOW_PAST_ACCESSIBLE);
 /* adding buffer extents to a string */
 struct add_string_extents_arg
 {
-Bytebpos from;
+Bytexpos from;
 Bytecount length;
 Lisp_Object string;
 };
 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_bytebpos (extent, 0) - closure->from;
+Bytecount start = extent_endpoint_byte (extent, 0) - closure->from;
-Bytecount end   = extent_endpoint_bytebpos (extent, 1) - closure->from;
+Bytecount end   = extent_endpoint_byte (extent, 1) - closure->from;
 if (extent_duplicable_p (extent))
 {
 start = max (start, 0);
 end = min (end, closure->length);
 }
 return 0;
 }
+struct add_string_extents_the_hard_way_arg
+{
+Charxpos from;
+Charcount length;
+Lisp_Object string;
+};
+static int
+add_string_extents_the_hard_way_mapper (EXTENT extent, void *arg)
+{
+/* This function can GC */
+struct add_string_extents_arg *closure =
+(struct add_string_extents_arg *) arg;
+Charcount start = extent_endpoint_char (extent, 0) - closure->from;
+Charcount end   = extent_endpoint_char (extent, 1) - closure->from;
+if (extent_duplicable_p (extent))
+{
+start = max (start, 0);
+end = min (end, closure->length);
+/* Run the copy-function to give an extent the option of
+	 not being copied into the string (or kill ring).
+	 */
+if (extent_duplicable_p (extent) &&
+	  !run_extent_copy_function (extent, start + closure->from,
+				     end + closure->from))
+	return 0;
+copy_extent (extent,
+		   string_index_char_to_byte (closure->string, start),
+		   string_index_char_to_byte (closure->string, end),
+		   closure->string);
+}
+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, Bytebpos opoint,
+add_string_extents (Lisp_Object string, struct buffer *buf, Bytexpos opoint,
 		    Bytecount length)
 {
 /* This function can GC */
-struct add_string_extents_arg closure;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object buffer;
-closure.from = opoint;
-closure.length = length;
-closure.string = string;
 buffer = wrap_buffer (buf);
 GCPRO2 (buffer, string);
-map_extents_bytebpos (opoint, opoint + length, add_string_extents_mapper,
-		      (void *) &closure, buffer, 0,
+if (XSTRING_FORMAT (string) == BUF_FORMAT (buf))
-		      /* ignore extents that just abut the region */
+{
-		      ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
+struct add_string_extents_arg closure;
-		      /* we are calling E-Lisp (the extent's copy function)
+closure.from = opoint;
-			 so anything might happen */
+closure.length = length;
-		      ME_MIGHT_CALL_ELISP);
+closure.string = string;
+map_extents (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 */
+		   ME_MIGHT_CALL_ELISP);
+}
+else
+{
+struct add_string_extents_the_hard_way_arg closure;
+closure.from = bytebpos_to_charbpos (buf, opoint);
+closure.length = (bytebpos_to_charbpos (buf, opoint + length) -
+			closure.from);
+closure.string = string;
+/* If the string and buffer are in different formats, things get
+	 tricky; the only reasonable way to do the operation is entirely in
+	 char offsets, which are invariant to format changes.  In practice,
+	 this won't be time-consuming because the byte/char conversions are
+	 mostly in the buffer, which will be in a fixed-width format. */
+map_extents (opoint, opoint + length,
+		   add_string_extents_the_hard_way_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 */
+		   ME_MIGHT_CALL_ELISP);
+}
 UNGCPRO;
 }
 struct splice_in_string_extents_arg
 {
 Bytecount pos;
 Bytecount length;
-Bytebpos opoint;
+Bytexpos opoint;
 Lisp_Object buffer;
 };
 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
 extent that is going into the buffer. */
-Bytebpos base_start = closure->opoint;
+Bytexpos base_start = closure->opoint;
-Bytebpos base_end = base_start + closure->length;
+Bytexpos base_end = base_start + closure->length;
-Bytebpos new_start = (base_start + extent_endpoint_bytebpos (extent, 0) -
+Bytexpos new_start = (base_start + extent_endpoint_byte (extent, 0) -
+			closure->pos);
+Bytexpos new_end = (base_start + extent_endpoint_byte (extent, 1) -
 		      closure->pos);
-Bytebpos new_end = (base_start + extent_endpoint_bytebpos (extent, 1) -
-		    closure->pos);
 if (new_start < base_start)
 new_start = base_start;
 if (new_end > base_end)
 new_end = base_end;
 copy_extent (extent, new_start, new_end, closure->buffer);
 return 0;
 }
+struct splice_in_string_extents_the_hard_way_arg
+{
+Charcount pos;
+Charcount length;
+Charxpos opoint;
+Lisp_Object buffer;
+};
+static int
+splice_in_string_extents_the_hard_way_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
+extent that is going into the buffer. */
+Charxpos base_start = closure->opoint;
+Charxpos base_end = base_start + closure->length;
+Charxpos new_start = (base_start + extent_endpoint_char (extent, 0) -
+			closure->pos);
+Charxpos new_end = (base_start + extent_endpoint_char (extent, 1) -
+		      closure->pos);
+if (new_start < base_start)
+new_start = base_start;
+if (new_end > base_end)
+new_end = base_end;
+if (new_end <= new_start)
+return 0;
+if (!extent_duplicable_p (extent))
+return 0;
+if (!inside_undo &&
+!run_extent_paste_function_char (extent, new_start, new_end,
+				       closure->buffer))
+return 0;
+copy_extent (extent,
+	       charbpos_to_bytebpos (XBUFFER (closure->buffer), new_start),
+	       charbpos_to_bytebpos (XBUFFER (closure->buffer), new_end),
+	       closure->buffer);
+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
 to get the string's extents into the buffer. */
 void
 splice_in_string_extents (Lisp_Object string, struct buffer *buf,
-			  Bytebpos opoint, Bytecount length, Bytecount pos)
+			  Bytexpos opoint, Bytecount length, Bytecount pos)
 {
-struct splice_in_string_extents_arg closure;
 struct gcpro gcpro1, gcpro2;
 Lisp_Object buffer = wrap_buffer (buf);
-closure.opoint = opoint;
-closure.pos = pos;
-closure.length = length;
-closure.buffer = buffer;
 GCPRO2 (buffer, string);
-map_extents_bytebpos (pos, pos + length,
+if (XSTRING_FORMAT (string) == BUF_FORMAT (buf))
-		      splice_in_string_extents_mapper,
+{
-		      (void *) &closure, string, 0,
+struct splice_in_string_extents_arg closure;
-		      /* ignore extents that just abut the region */
+closure.opoint = opoint;
-		      ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
+closure.pos = pos;
-		      /* we are calling E-Lisp (the extent's copy function)
+closure.length = length;
-			 so anything might happen */
+closure.buffer = buffer;
-		      ME_MIGHT_CALL_ELISP);
+map_extents (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 */
+		   ME_MIGHT_CALL_ELISP);
+}
+else
+{
+struct splice_in_string_extents_the_hard_way_arg closure;
+closure.opoint = bytebpos_to_charbpos (buf, opoint);
+closure.pos = string_index_byte_to_char (string, pos);
+closure.length = string_offset_byte_to_char_len (string, pos, length);
+closure.buffer = buffer;
+/* If the string and buffer are in different formats, things get
+	 tricky; the only reasonable way to do the operation is entirely in
+	 char offsets, which are invariant to format changes.  In practice,
+	 this won't be time-consuming because the byte/char conversions are
+	 mostly in the buffer, which will be in a fixed-width format. */
+map_extents (pos, pos + length,
+		   splice_in_string_extents_the_hard_way_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 */
+		   ME_MIGHT_CALL_ELISP);
+}
 UNGCPRO;
 }
 struct copy_string_extents_arg
 {
 {
 struct copy_string_extents_arg *closure =
 (struct copy_string_extents_arg *) arg;
 Bytecount old_start, old_end, new_start, new_end;
-old_start = extent_endpoint_bytebpos (extent, 0);
+old_start = extent_endpoint_byte (extent, 0);
-old_end   = extent_endpoint_bytebpos (extent, 1);
+old_end   = extent_endpoint_byte (extent, 1);
 old_start = max (closure->old_pos, old_start);
 old_end   = min (closure->old_pos + closure->length, old_end);
 if (old_start >= old_end)
 closure.new_pos = new_pos;
 closure.old_pos = old_pos;
 closure.new_string = new_string;
 closure.length = length;
 GCPRO2 (new_string, old_string);
-map_extents_bytebpos (old_pos, old_pos + length,
+map_extents (old_pos, old_pos + length,
-		      copy_string_extents_mapper,
+	       copy_string_extents_mapper,
-		      (void *) &closure, old_string, 0,
+	       (void *) &closure, old_string, 0,
-		      /* ignore extents that just abut the region */
+	       /* ignore extents that just abut the region */
-		      ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
+	       ME_END_CLOSED | ME_ALL_EXTENTS_OPEN |
-		      /* we are calling E-Lisp (the extent's copy function)
+	       /* we are calling E-Lisp (the extent's copy function)
-			 so anything might happen */
+		  so anything might happen */
-		      ME_MIGHT_CALL_ELISP);
+	       ME_MIGHT_CALL_ELISP);
 UNGCPRO;
 }
 /* Checklist for sanity checking:
 - {kill, yank, copy} at {open, closed} {start, end} of {writable, read-only} extent
 */
 Lisp_Object Qtext_prop;
 Lisp_Object Qtext_prop_extent_paste_function;
-static Lisp_Object
+/* Retrieve the value of the property PROP of the text at position POSITION
-get_text_property_bytebpos (Bytebpos position, Lisp_Object prop,
+in OBJECT.  TEXT-PROPS-ONLY means only look at extents with the
-			  Lisp_Object object, enum extent_at_flag fl,
+`text-prop' property, i.e. extents created by the text property
-			  int text_props_only)
+routines.  Otherwise, all extents are examined.  &&#### finish Note that
+the default extent_at_flag is EXTENT_AT_DEFAULT (same as
+EXTENT_AT_AFTER). */
+Lisp_Object
+get_char_property (Bytexpos position, Lisp_Object prop,
+		   Lisp_Object object, enum extent_at_flag fl,
+		   int text_props_only)
 {
 Lisp_Object extent;
 /* text_props_only specifies whether we only consider text-property
 extents (those with the 'text-prop property set) or all extents. */
 if (!text_props_only)
-extent = extent_at_bytebpos (position, object, prop, 0, fl, 0);
+extent = extent_at (position, object, prop, 0, fl, 0);
 else
 {
 EXTENT prior = 0;
 while (1)
 	{
-	  extent = extent_at_bytebpos (position, object, Qtext_prop, prior,
+	  extent = extent_at (position, object, Qtext_prop, prior, fl, 0);
-				     fl, 0);
 	  if (NILP (extent))
 	    return Qnil;
 	  if (EQ (prop, Fextent_property (extent, Qtext_prop, Qnil)))
 	    break;
 	  prior = XEXTENT (extent);
 return Fplist_get (Vdefault_text_properties, prop, Qnil);
 return Qnil;
 }
 static Lisp_Object
-get_text_property_1 (Lisp_Object pos, Lisp_Object prop, Lisp_Object object,
+get_char_property_char (Lisp_Object pos, Lisp_Object prop, Lisp_Object object,
-		     Lisp_Object at_flag, int text_props_only)
+			Lisp_Object at_flag, int text_props_only)
 {
-Bytebpos position;
+Bytexpos position;
 int invert = 0;
 object = decode_buffer_or_string (object);
 position = get_buffer_or_string_pos_byte (object, pos, GB_NO_ERROR_IF_BAD);
 invert = 1;
 }
 {
 Lisp_Object val =
-get_text_property_bytebpos (position, prop, object,
+get_char_property (position, prop, object,
-				decode_extent_at_flag (at_flag),
+			 decode_extent_at_flag (at_flag),
-				text_props_only);
+			 text_props_only);
 if (invert)
 val = NILP (val) ? Qt : Qnil;
 return val;
 }
 }
 This examines only those properties added with `put-text-property'.
 See also `get-char-property'.
 */
 (pos, prop, object, at_flag))
 {
-return get_text_property_1 (pos, prop, object, at_flag, 1);
+return get_char_property_char (pos, prop, object, at_flag, 1);
 }
 DEFUN ("get-char-property", Fget_char_property, 2, 4, 0, /*
 Return the value of the PROP property at the given position.
 Optional arg OBJECT specifies the buffer or string to look in, and
 This examines properties on all extents.
 See also `get-text-property'.
 */
 (pos, prop, object, at_flag))
 {
-return get_text_property_1 (pos, prop, object, at_flag, 0);
+return get_char_property_char (pos, prop, object, at_flag, 0);
 }
 /* About start/end-open/closed:
 These properties have to be handled specially because of their
 */
 struct put_text_prop_arg
 {
 Lisp_Object prop, value;	/* The property and value we are storing */
-Bytebpos start, end;	/* The region into which we are storing it */
+Bytexpos start, end;	/* The region into which we are storing it */
 Lisp_Object object;
 Lisp_Object the_extent;	/* Our chosen extent; this is used for
 				   communication between subsequent passes. */
 int changed_p;		/* Output: whether we have modified anything */
 };
 {
 struct put_text_prop_arg *closure = (struct put_text_prop_arg *) arg;
 Lisp_Object object = closure->object;
 Lisp_Object value = closure->value;
-Bytebpos e_start, e_end;
+Bytexpos e_start, e_end;
-Bytebpos start = closure->start;
+Bytexpos start = closure->start;
-Bytebpos end   = closure->end;
+Bytexpos end   = closure->end;
 Lisp_Object extent, e_val;
 int is_eq;
 extent = wrap_extent (e);
 openness later on in put_text_prop_openness_mapper(). */
 if (!EQ (Fextent_property (extent, Qtext_prop, Qnil), closure->prop))
 /* It's not for this property; do nothing. */
 return 0;
-e_start = extent_endpoint_bytebpos (e, 0);
+e_start = extent_endpoint_byte (e, 0);
-e_end   = extent_endpoint_bytebpos (e, 1);
+e_end   = extent_endpoint_byte (e, 1);
 e_val = Fextent_property (extent, closure->prop, Qnil);
 is_eq = EQ (value, e_val);
 if (!NILP (value) && NILP (closure->the_extent) && is_eq)
 {
 	 side-effecting the kill ring (that is, we never change the property
 	 on an extent after it has been created.)
 */
 if (e_start != start || e_end != end)
 	{
-	  Bytebpos new_start = min (e_start, start);
+	  Bytexpos new_start = min (e_start, start);
-	  Bytebpos new_end = max (e_end, end);
+	  Bytexpos new_end = max (e_end, end);
 	  set_extent_endpoints (e, new_start, new_end, Qnil);
 	  /* If we changed the endpoint, then we need to set its
 	     openness. */
 	  set_extent_openness (e, new_start != e_start
-			       ? !NILP (get_text_property_bytebpos
+			       ? !NILP (get_char_property
 					(start, Qstart_open, object,
 					 EXTENT_AT_AFTER, 1)) : -1,
 			       new_end != e_end
-			       ? NILP (get_text_property_bytebpos
+			       ? NILP (get_char_property
-				       (end - 1, Qend_closed, object,
+				       (prev_bytexpos (object, end),
+					Qend_closed, object,
 					EXTENT_AT_AFTER, 1))
 			       : -1);
 	  closure->changed_p = 1;
 	}
 closure->the_extent = extent;
 	 decided to reuse, so we can remove this existing extent as well (the
 	 whole thing, even the part outside of the region) and extend
 	 the-extent to cover it, resulting in the minimum number of extents in
 	 the buffer.
 */
-Bytebpos the_start = extent_endpoint_bytebpos (te, 0);
+Bytexpos the_start = extent_endpoint_byte (te, 0);
-Bytebpos the_end = extent_endpoint_bytebpos (te, 1);
+Bytexpos the_end = extent_endpoint_byte (te, 1);
 if (e_start != the_start &&  /* note AND not OR -- hmm, why is this
 				      the case? I think it's because the
 				      assumption that the text-property
 				      extents don't overlap makes it
 				      OK; changing it to an OR would
 				      result in changed_p sometimes getting
 				      falsely marked.  Is this bad? */
 	  e_end   != the_end)
 	{
-	  Bytebpos new_start = min (e_start, the_start);
+	  Bytexpos new_start = min (e_start, the_start);
-	  Bytebpos new_end = max (e_end, the_end);
+	  Bytexpos new_end = max (e_end, the_end);
 	  set_extent_endpoints (te, new_start, new_end, Qnil);
 	  /* If we changed the endpoint, then we need to set its
 	     openness.  We are setting the endpoint to be the same as
 	     that of the extent we're about to remove, and we assume
 	     (the invariant mentioned above) that extent has the
 	 decrease its end position.
 */
 if (e_end != start)
 	{
 	  set_extent_endpoints (e, e_start, start, Qnil);
-	  set_extent_openness (e, -1, NILP (get_text_property_bytebpos
+	  set_extent_openness (e, -1,
-				       (start - 1, Qend_closed, object,
+			       NILP (get_char_property
-					EXTENT_AT_AFTER, 1)));
+				     (prev_bytexpos (object, start),
+				      Qend_closed, object,
+				      EXTENT_AT_AFTER, 1)));
 	  closure->changed_p = 1;
 	}
 }
 else if (e_start >= start)
 {
 	 increase its start position.
 */
 if (e_start != end)
 	{
 	  set_extent_endpoints (e, end, e_end, Qnil);
-	  set_extent_openness (e, !NILP (get_text_property_bytebpos
+	  set_extent_openness (e, !NILP (get_char_property
 					(end, Qstart_open, object,
 					 EXTENT_AT_AFTER, 1)), -1);
 	  closure->changed_p = 1;
 	}
 }
 else
 {
 /* Otherwise, `extent' straddles the region.  We need to split it.
 */
 set_extent_endpoints (e, e_start, start, Qnil);
-set_extent_openness (e, -1, NILP (get_text_property_bytebpos
+set_extent_openness (e, -1, NILP (get_char_property
-					(start - 1, Qend_closed, object,
+					(prev_bytexpos (object, start),
+					 Qend_closed, object,
 					 EXTENT_AT_AFTER, 1)));
 set_extent_openness (copy_extent (e, end, e_end, extent_object (e)),
-			   !NILP (get_text_property_bytebpos
+			   !NILP (get_char_property
 				  (end, Qstart_open, object,
 				   EXTENT_AT_AFTER, 1)), -1);
 closure->changed_p = 1;
 }
 static int
 put_text_prop_openness_mapper (EXTENT e, void *arg)
 {
 struct put_text_prop_arg *closure = (struct put_text_prop_arg *) arg;
-Bytebpos e_start, e_end;
+Bytexpos e_start, e_end;
-Bytebpos start = closure->start;
+Bytexpos start = closure->start;
-Bytebpos end   = closure->end;
+Bytexpos end   = closure->end;
 Lisp_Object extent = wrap_extent (e);
-e_start = extent_endpoint_bytebpos (e, 0);
+e_start = extent_endpoint_byte (e, 0);
-e_end   = extent_endpoint_bytebpos (e, 1);
+e_end   = extent_endpoint_byte (e, 1);
 if (NILP (Fextent_property (extent, Qtext_prop, Qnil)))
 {
 /* It's not a text-property extent; do nothing. */
 ;
 return 0;  /* to continue mapping. */
 }
 static int
-put_text_prop (Bytebpos start, Bytebpos end, Lisp_Object object,
+put_text_prop (Bytexpos start, Bytexpos end, Lisp_Object object,
 	       Lisp_Object prop, Lisp_Object value,
 	       int duplicable_p)
 {
 /* This function can GC */
 struct put_text_prop_arg closure;
 closure.end = end;
 closure.object = object;
 closure.changed_p = 0;
 closure.the_extent = Qnil;
-map_extents_bytebpos (start, end,
+map_extents (start, end,
-		      put_text_prop_mapper,
+	       put_text_prop_mapper,
-		      (void *) &closure, object, 0,
+	       (void *) &closure, object, 0,
-		      /* get all extents that abut the region */
+	       /* get all extents that abut the region */
-		      ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
+	       ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
-		      /* it might QUIT or error if the user has
+#if 0
-			 fucked with the extent plist. */
+	       /* it might move the SOE because the callback function calls
-		      /* #### dmoore - I think this should include
+	       get_char_property(), which calls extent_at(), which calls
-			 ME_MIGHT_MOVE_SOE, since the callback function
+	       map_extents()
-			 might recurse back into map_extents_bytebpos. */
-		      ME_MIGHT_THROW |
+	       #### this was comment out before, and nothing seemed broken;
-		      ME_MIGHT_MODIFY_EXTENTS);
+	       #### but when I added the above comment and uncommented it,
+	       #### text property operations (e.g. font-lock) suddenly
+	       #### became *WAY* slow, and dominated font-lock, when a
+	       #### single extent spanning the entire buffer
+	       #### existed. --ben */
+	       ME_MIGHT_MOVE_SOE |
+#endif
+	       /* it might QUIT or error if the user has
+		  fucked with the extent plist. */
+	       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.
 */
 if (!NILP (value) && NILP (closure.the_extent))
 {
-Lisp_Object extent = wrap_extent (make_extent_internal (object, start, end));
+Lisp_Object extent =
+	wrap_extent (make_extent (object, start, end));
 closure.changed_p = 1;
 Fset_extent_property (extent, Qtext_prop, prop);
 Fset_extent_property (extent, prop, value);
 if (duplicable_p)
 	  extent_duplicable_p (XEXTENT (extent)) = 1;
 	  Fset_extent_property (extent, Qpaste_function,
 				Qtext_prop_extent_paste_function);
 	}
 set_extent_openness (XEXTENT (extent),
-			   !NILP (get_text_property_bytebpos
+			   !NILP (get_char_property
 				  (start, Qstart_open, object,
 				   EXTENT_AT_AFTER, 1)),
-			   NILP (get_text_property_bytebpos
+			   NILP (get_char_property
-				 (end - 1, Qend_closed, object,
+				 (prev_bytexpos (object, end),
+				  Qend_closed, object,
 				  EXTENT_AT_AFTER, 1)));
 }
 if (EQ (prop, Qstart_open) || EQ (prop, Qend_closed))
 {
-map_extents_bytebpos (start, end,
+map_extents (start, end, put_text_prop_openness_mapper,
-			  put_text_prop_openness_mapper,
+		   (void *) &closure, object, 0,
-			  (void *) &closure, object, 0,
+		   /* get all extents that abut the region */
-			  /* get all extents that abut the region */
+		   ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
-			  ME_ALL_EXTENTS_CLOSED | ME_END_CLOSED |
+		   ME_MIGHT_MODIFY_EXTENTS);
-			  ME_MIGHT_MODIFY_EXTENTS);
 }
 return closure.changed_p;
 }
 defaults to the current buffer.
 */
 (start, end, prop, value, object))
 {
 /* This function can GC */
-Bytebpos s, e;
+Bytexpos s, e;
 object = decode_buffer_or_string (object);
 get_buffer_or_string_range_byte (object, start, end, &s, &e, 0);
 put_text_prop (s, e, object, prop, value, 1);
 return prop;
 defaults to the current buffer.
 */
 (start, end, prop, value, object))
 {
 /* This function can GC */
-Bytebpos s, e;
+Bytexpos s, e;
 object = decode_buffer_or_string (object);
 get_buffer_or_string_range_byte (object, start, end, &s, &e, 0);
 put_text_prop (s, e, object, prop, value, 0);
 return prop;
 */
 (start, end, props, object))
 {
 /* This function can GC */
 int changed = 0;
-Bytebpos s, e;
+Bytexpos s, e;
 object = decode_buffer_or_string (object);
 get_buffer_or_string_range_byte (object, start, end, &s, &e, 0);
 CHECK_LIST (props);
 for (; !NILP (props); props = Fcdr (Fcdr (props)))
 */
 (start, end, props, object))
 {
 /* This function can GC */
 int changed = 0;
-Bytebpos s, e;
+Bytexpos s, e;
 object = decode_buffer_or_string (object);
 get_buffer_or_string_range_byte (object, start, end, &s, &e, 0);
 CHECK_LIST (props);
 for (; !NILP (props); props = Fcdr (Fcdr (props)))
 */
 (start, end, props, object))
 {
 /* This function can GC */
 int changed = 0;
-Bytebpos s, e;
+Bytexpos s, e;
 object = decode_buffer_or_string (object);
 get_buffer_or_string_range_byte (object, start, end, &s, &e, 0);
 CHECK_LIST (props);
 for (; !NILP (props); props = Fcdr (Fcdr (props)))
 #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
+Bytexpos
-to use it in connection with invisible extents (at least currently).
+next_single_property_change (Bytexpos pos, Lisp_Object prop,
-If this changes, consider moving this back into Lisp. */
+			     Lisp_Object object, Bytexpos limit)
+{
+Lisp_Object extent, value;
+int limit_was_nil;
+if (limit < 0)
+{
+limit = buffer_or_string_accessible_end_byte (object);
+limit_was_nil = 1;
+}
+else
+limit_was_nil = 0;
+extent = extent_at (pos, object, prop, 0, EXTENT_AT_AFTER, 0);
+if (!NILP (extent))
+value = Fextent_property (extent, prop, Qnil);
+else
+value = Qnil;
+while (1)
+{
+pos = extent_find_end_of_run (object, pos, 1);
+if (pos >= limit)
+	break; /* property is the same all the way to the end */
+extent = extent_at (pos, object, prop, 0, EXTENT_AT_AFTER, 0);
+if ((NILP (extent) && !NILP (value)) ||
+	  (!NILP (extent) && !EQ (value,
+				  Fextent_property (extent, prop, Qnil))))
+	return pos;
+}
+if (limit_was_nil)
+return -1;
+else
+return limit;
+}
+Bytexpos
+previous_single_property_change (Bytexpos pos, Lisp_Object prop,
+				 Lisp_Object object, Bytexpos limit)
+{
+Lisp_Object extent, value;
+int limit_was_nil;
+if (limit < 0)
+{
+limit = buffer_or_string_accessible_begin_byte (object);
+limit_was_nil = 1;
+}
+else
+limit_was_nil = 0;
+extent = extent_at (pos, object, prop, 0, EXTENT_AT_BEFORE, 0);
+if (!NILP (extent))
+value = Fextent_property (extent, prop, Qnil);
+else
+value = Qnil;
+while (1)
+{
+pos = extent_find_beginning_of_run (object, pos, 1);
+if (pos <= limit)
+	break; /* property is the same all the way to the end */
+extent = extent_at (pos, object, prop, 0, EXTENT_AT_BEFORE, 0);
+if ((NILP (extent) && !NILP (value)) ||
+	  (!NILP (extent) && !EQ (value,
+				  Fextent_property (extent, prop, Qnil))))
+	return pos;
+}
+if (limit_was_nil)
+return -1;
+else
+return limit;
+}
 DEFUN ("next-single-property-change", Fnext_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
 the value of PROP. (Note that this situation will not happen if you always
 use the text-property primitives.)
 */
 (pos, prop, object, limit))
 {
-Charbpos bpos;
+Bytexpos xpos;
-Charbpos blim;
+Bytexpos blim;
-Lisp_Object extent, value;
-int limit_was_nil;
 object = decode_buffer_or_string (object);
-bpos = get_buffer_or_string_pos_char (object, pos, 0);
+xpos = get_buffer_or_string_pos_byte (object, pos, 0);
-if (NILP (limit))
+blim = !NILP (limit) ? get_buffer_or_string_pos_byte (object, limit, 0) : -1;
-{
-blim = buffer_or_string_accessible_end_char (object);
+blim = next_single_property_change (xpos, prop, object, blim);
-limit_was_nil = 1;
-}
+if (blim < 0)
-else
-{
-blim = get_buffer_or_string_pos_char (object, limit, 0);
-limit_was_nil = 0;
-}
-extent = Fextent_at (make_int (bpos), object, prop, Qnil, Qnil);
-if (!NILP (extent))
-value = Fextent_property (extent, prop, Qnil);
-else
-value = Qnil;
-while (1)
-{
-bpos = XINT (Fnext_extent_change (make_int (bpos), object));
-if (bpos >= blim)
-	break; /* property is the same all the way to the end */
-extent = Fextent_at (make_int (bpos), object, prop, Qnil, Qnil);
-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;
 else
-return make_int (blim);
+return make_int (buffer_or_string_bytexpos_to_charxpos (object, blim));
 }
-/* See comment on previous function about why this is written in C. */
 DEFUN ("previous-single-property-change", 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
 the value of PROP. (Note that this situation will not happen if you always
 use the text-property primitives.)
 */
 (pos, prop, object, limit))
 {
-Charbpos bpos;
+Bytexpos xpos;
-Charbpos blim;
+Bytexpos blim;
-Lisp_Object extent, value;
-int limit_was_nil;
 object = decode_buffer_or_string (object);
-bpos = get_buffer_or_string_pos_char (object, pos, 0);
+xpos = get_buffer_or_string_pos_byte (object, pos, 0);
-if (NILP (limit))
+blim = !NILP (limit) ? get_buffer_or_string_pos_byte (object, limit, 0) : -1;
-{
-blim = buffer_or_string_accessible_begin_char (object);
+blim = previous_single_property_change (xpos, prop, object, blim);
-limit_was_nil = 1;
-}
+if (blim < 0)
-else
-{
-blim = get_buffer_or_string_pos_char (object, limit, 0);
-limit_was_nil = 0;
-}
-/* extent-at refers to the character AFTER bpos, but we want the
-character before bpos.  Thus the - 1.  extent-at simply
-returns nil on bogus positions, so not to worry. */
-extent = Fextent_at (make_int (bpos - 1), object, prop, Qnil, Qnil);
-if (!NILP (extent))
-value = Fextent_property (extent, prop, Qnil);
-else
-value = Qnil;
-while (1)
-{
-bpos = XINT (Fprevious_extent_change (make_int (bpos), object));
-if (bpos <= blim)
-	break; /* property is the same all the way to the beginning */
-extent = Fextent_at (make_int (bpos - 1), object, prop, Qnil, Qnil);
-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;
 else
-return make_int (blim);
+return make_int (buffer_or_string_bytexpos_to_charxpos (object, blim));
 }
 #ifdef MEMORY_USAGE_STATS
 int

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 826:6728e641994e