X-Git-Url: http://git.chise.org/gitweb/?a=blobdiff_plain;f=src%2Fextents.c;h=5fd8ad5367fa5e4bea4b71dbf4b3f91513412369;hb=975655e6b5b1526ee82b159b3eadf69888c42090;hp=da6bde74d9b4f32df1a8a50a6ada2e85f261ebfd;hpb=6883ee56ec887c2c48abe5b06b5e66aa74031910;p=chise%2Fxemacs-chise.git- diff --git a/src/extents.c b/src/extents.c index da6bde7..5fd8ad5 100644 --- a/src/extents.c +++ b/src/extents.c @@ -222,12 +222,12 @@ Boston, MA 02111-1307, USA. */ #include "faces.h" #include "frame.h" #include "glyphs.h" -#include "hash.h" #include "insdel.h" #include "keymap.h" #include "opaque.h" #include "process.h" #include "redisplay.h" +#include "gutter.h" /* ------------------------------- */ /* gap array */ @@ -261,7 +261,7 @@ typedef struct gap_array Gap_Array_Marker *markers; } Gap_Array; -Gap_Array_Marker *gap_array_marker_freelist; +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 @@ -302,7 +302,7 @@ typedef struct extent_list Extent_List_Marker *markers; } Extent_List; -Extent_List_Marker *extent_list_marker_freelist; +static Extent_List_Marker *extent_list_marker_freelist; #define EXTENT_LESS_VALS(e,st,nd) ((extent_start (e) < (st)) || \ ((extent_start (e) == (st)) && \ @@ -445,9 +445,6 @@ Lisp_Object Qinside_margin; Lisp_Object Qwhitespace; /* Qtext defined in general.c */ -/* partially used in redisplay */ -Lisp_Object Qglyph_invisible; - Lisp_Object Qcopy_function; Lisp_Object Qpaste_function; @@ -465,10 +462,13 @@ 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; + /************************************************************************/ /* Generalized gap array */ @@ -536,7 +536,7 @@ gap_array_make_gap (Gap_Array *ga, int increment) int old_gap_size; /* If we have to get more space, get enough to last a while. We use - a geometric progession that saves on realloc space. */ + a geometric progression that saves on realloc space. */ increment += 100 + ga->numels / 8; ptr = (char *) xrealloc (ptr, @@ -891,8 +891,8 @@ static Extent_List * allocate_extent_list (void) { Extent_List *el = xnew (Extent_List); - el->start = make_gap_array (sizeof(EXTENT)); - el->end = make_gap_array (sizeof(EXTENT)); + el->start = make_gap_array (sizeof (EXTENT)); + el->end = make_gap_array (sizeof (EXTENT)); el->markers = 0; return el; } @@ -911,29 +911,31 @@ free_extent_list (Extent_List *el) /************************************************************************/ static Lisp_Object -mark_extent_auxiliary (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_extent_auxiliary (Lisp_Object obj) { struct extent_auxiliary *data = XEXTENT_AUXILIARY (obj); - ((markobj) (data->begin_glyph)); - ((markobj) (data->end_glyph)); - ((markobj) (data->invisible)); - ((markobj) (data->children)); - ((markobj) (data->read_only)); - ((markobj) (data->mouse_face)); - ((markobj) (data->initial_redisplay_function)); + mark_object (data->begin_glyph); + mark_object (data->end_glyph); + mark_object (data->invisible); + mark_object (data->children); + mark_object (data->read_only); + mark_object (data->mouse_face); + mark_object (data->initial_redisplay_function); + mark_object (data->before_change_functions); + mark_object (data->after_change_functions); return data->parent; } DEFINE_LRECORD_IMPLEMENTATION ("extent-auxiliary", extent_auxiliary, mark_extent_auxiliary, internal_object_printer, - 0, 0, 0, struct extent_auxiliary); + 0, 0, 0, 0, struct extent_auxiliary); void allocate_extent_auxiliary (EXTENT ext) { Lisp_Object extent_aux; struct extent_auxiliary *data = - alloc_lcrecord_type (struct extent_auxiliary, lrecord_extent_auxiliary); + alloc_lcrecord_type (struct extent_auxiliary, &lrecord_extent_auxiliary); copy_lcrecord (data, &extent_auxiliary_defaults); XSETEXTENT_AUXILIARY (extent_aux, data); @@ -972,12 +974,11 @@ static void free_soe (struct stack_of_extents *soe); static void soe_invalidate (Lisp_Object obj); static Lisp_Object -mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_extent_info (Lisp_Object obj) { - struct extent_info *data = - (struct extent_info *) XEXTENT_INFO (obj); + struct extent_info *data = (struct extent_info *) XEXTENT_INFO (obj); int i; - Extent_List *list; + Extent_List *list = data->extents; /* Vbuffer_defaults and Vbuffer_local_symbols are buffer-like objects that are created specially and never have their extent @@ -988,7 +989,6 @@ mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object)) (Also the list can be zero when we're dealing with a destroyed buffer.) */ - list = data->extents; if (list) { for (i = 0; i < extent_list_num_els (list); i++) @@ -997,7 +997,7 @@ mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object)) Lisp_Object exobj; XSETEXTENT (exobj, extent); - ((markobj) (exobj)); + mark_object (exobj); } } @@ -1026,7 +1026,7 @@ finalize_extent_info (void *header, int for_disksave) DEFINE_LRECORD_IMPLEMENTATION ("extent-info", extent_info, mark_extent_info, internal_object_printer, - finalize_extent_info, 0, 0, + finalize_extent_info, 0, 0, 0, struct extent_info); static Lisp_Object @@ -1034,7 +1034,7 @@ allocate_extent_info (void) { Lisp_Object extent_info; struct extent_info *data = - alloc_lcrecord_type (struct extent_info, lrecord_extent_info); + alloc_lcrecord_type (struct extent_info, &lrecord_extent_info); XSETEXTENT_INFO (extent_info, data); data->extents = allocate_extent_list (); @@ -1541,8 +1541,7 @@ extent_endpoint_bytind (EXTENT extent, int endp) assert (EXTENT_LIVE_P (extent)); assert (!extent_detached_p (extent)); { - Memind i = (endp) ? (extent_end (extent)) : - (extent_start (extent)); + Memind i = endp ? extent_end (extent) : extent_start (extent); Lisp_Object obj = extent_object (extent); return buffer_or_string_memind_to_bytind (obj, i); } @@ -1554,8 +1553,7 @@ extent_endpoint_bufpos (EXTENT extent, int endp) assert (EXTENT_LIVE_P (extent)); assert (!extent_detached_p (extent)); { - Memind i = (endp) ? (extent_end (extent)) : - (extent_start (extent)); + Memind i = endp ? extent_end (extent) : extent_start (extent); Lisp_Object obj = extent_object (extent); return buffer_or_string_memind_to_bufpos (obj, i); } @@ -1595,33 +1593,47 @@ extent_changed_for_redisplay (EXTENT extent, int descendants_too, object = extent_object (extent); - if (!BUFFERP (object) || extent_detached_p (extent)) - /* #### Can changes to string extents affect redisplay? - I will have to think about this. What about string glyphs? - Things in the modeline? etc. */ - /* #### changes to string extents can certainly affect redisplay - 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 hashtable? - Maybe efficiency is not the greatest concern here and there's - no big loss in looping over the buffers. */ + if (extent_detached_p (extent)) return; - { - struct buffer *b; - b = XBUFFER (object); - BUF_FACECHANGE (b)++; - MARK_EXTENTS_CHANGED; - if (invisibility_change) - MARK_CLIP_CHANGED; - buffer_extent_signal_changed_region (b, - extent_endpoint_bufpos (extent, 0), - extent_endpoint_bufpos (extent, 1)); - } + 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_bufpos (extent, 0), + extent_endpoint_bufpos (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_bufpos (extent, 0), + extent_endpoint_bufpos (extent, 1)); + } } /* A change to an extent occurred that might affect redisplay. @@ -1822,7 +1834,7 @@ extent_in_region_p (EXTENT extent, Bytind from, Bytind to, Endpoint_Index start, end, exs, exe; int start_open, end_open; unsigned int all_extents_flags = flags & ME_ALL_EXTENTS_MASK; - unsigned int in_region_flags = flags & ME_IN_REGION_MASK; + unsigned int in_region_flags = flags & ME_IN_REGION_MASK; int retval; /* A zero-length region is treated as closed-closed. */ @@ -1832,31 +1844,30 @@ extent_in_region_p (EXTENT extent, Bytind from, Bytind to, flags &= ~ME_START_OPEN; } - switch (all_extents_flags) + /* So is a zero-length extent. */ + if (extent_start (extent) == extent_end (extent)) + start_open = 0, end_open = 0; + /* `all_extents_flags' will almost always be zero. */ + else if (all_extents_flags == 0) { - case ME_ALL_EXTENTS_CLOSED: - start_open = end_open = 0; break; - case ME_ALL_EXTENTS_OPEN: - start_open = end_open = 1; break; - 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: start_open = extent_start_open_p (extent); - end_open = extent_end_open_p (extent); - break; + end_open = extent_end_open_p (extent); } - - /* So is a zero-length extent. */ - if (extent_start (extent) == extent_end (extent)) - start_open = end_open = 0; + else + switch (all_extents_flags) + { + case ME_ALL_EXTENTS_CLOSED: start_open = 0, end_open = 0; break; + case ME_ALL_EXTENTS_OPEN: start_open = 1, end_open = 1; break; + 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(); break; + } start = buffer_or_string_bytind_to_startind (obj, from, flags & ME_START_OPEN); end = buffer_or_string_bytind_to_endind (obj, to, ! (flags & ME_END_CLOSED)); exs = memind_to_startind (extent_start (extent), start_open); - exe = memind_to_endind (extent_end (extent), end_open); + exe = memind_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 @@ -1868,20 +1879,24 @@ extent_in_region_p (EXTENT extent, Bytind from, Bytind to, return 0; /* See if any further restrictions are called for. */ - switch (in_region_flags) - { - case ME_START_IN_REGION: - retval = start <= exs && exs <= end; break; - case ME_END_IN_REGION: - retval = start <= exe && exe <= end; break; - case ME_START_AND_END_IN_REGION: - retval = start <= exs && exe <= end; break; - case ME_START_OR_END_IN_REGION: - retval = (start <= exs && exs <= end) || (start <= exe && exe <= end); - break; - default: - retval = 1; break; - } + /* in_region_flags will almost always be zero. */ + if (in_region_flags == 0) + retval = 1; + else + switch (in_region_flags) + { + case ME_START_IN_REGION: + retval = start <= exs && exs <= end; break; + case ME_END_IN_REGION: + retval = start <= exe && exe <= end; break; + case ME_START_AND_END_IN_REGION: + retval = start <= exs && exe <= end; break; + case ME_START_OR_END_IN_REGION: + retval = (start <= exs && exs <= end) || (start <= exe && exe <= end); + break; + default: + abort(); break; + } return flags & ME_NEGATE_IN_REGION ? !retval : retval; } @@ -2600,12 +2615,11 @@ extent_fragment_delete (struct extent_fragment *ef) xfree (ef); } -/* Note: CONST is losing, but `const' is part of the interface of qsort() */ static int extent_priority_sort_function (const void *humpty, const void *dumpty) { - CONST EXTENT foo = * (CONST EXTENT *) humpty; - CONST EXTENT bar = * (CONST EXTENT *) dumpty; + const EXTENT foo = * (const EXTENT *) humpty; + const EXTENT bar = * (const EXTENT *) dumpty; if (extent_priority (foo) < extent_priority (bar)) return -1; return extent_priority (foo) > extent_priority (bar); @@ -2864,7 +2878,7 @@ extent_fragment_update (struct window *w, struct extent_fragment *ef, xzero (dummy_lhe_extent); set_extent_priority (&dummy_lhe_extent, mouse_highlight_priority); - /* Need to break up thefollowing expression, due to an */ + /* Need to break up the following expression, due to an */ /* error in the Digital UNIX 3.2g C compiler (Digital */ /* UNIX Compiler Driver 3.11). */ f = extent_mouse_face (lhe); @@ -2911,37 +2925,13 @@ extent_fragment_update (struct window *w, struct extent_fragment *ef, extent objects. They are similar to the functions for other lrecord objects. allocate_extent() is in alloc.c, not here. */ -static Lisp_Object mark_extent (Lisp_Object, void (*) (Lisp_Object)); -static int extent_equal (Lisp_Object, Lisp_Object, int depth); -static unsigned long extent_hash (Lisp_Object obj, int depth); -static void print_extent (Lisp_Object obj, Lisp_Object printcharfun, - int escapeflag); -static Lisp_Object extent_getprop (Lisp_Object obj, Lisp_Object prop); -static int extent_putprop (Lisp_Object obj, Lisp_Object prop, - Lisp_Object value); -static int extent_remprop (Lisp_Object obj, Lisp_Object prop); -static Lisp_Object extent_plist (Lisp_Object obj); - -DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("extent", extent, - mark_extent, - print_extent, - /* NOTE: If you declare a - finalization method here, - it will NOT be called. - Shaft city. */ - 0, - extent_equal, extent_hash, - extent_getprop, extent_putprop, - extent_remprop, extent_plist, - struct extent); - static Lisp_Object -mark_extent (Lisp_Object obj, void (*markobj) (Lisp_Object)) +mark_extent (Lisp_Object obj) { struct extent *extent = XEXTENT (obj); - ((markobj) (extent_object (extent))); - ((markobj) (extent_no_chase_normal_field (extent, face))); + mark_object (extent_object (extent)); + mark_object (extent_no_chase_normal_field (extent, face)); return extent->plist; } @@ -2960,11 +2950,9 @@ print_extent_1 (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) if (extent_detached_p (ext)) strcpy (bp, "detached"); else - { - Bufpos from = XINT (Fextent_start_position (obj)); - Bufpos to = XINT (Fextent_end_position (obj)); - sprintf (bp, "%d, %d", from, to); - } + sprintf (bp, "%ld, %ld", + (long) XINT (Fextent_start_position (obj)), + (long) XINT (Fextent_end_position (obj))); bp += strlen (bp); *bp++ = (extent_end_open_p (anc) ? ')': ']'); if (!NILP (extent_end_glyph (anc))) *bp++ = '*'; @@ -2993,7 +2981,7 @@ print_extent_1 (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) write_c_string (" ", printcharfun); } - sprintf (buf, "0x%lx", (unsigned long int) ext); + sprintf (buf, "0x%lx", (long) ext); write_c_string (buf, printcharfun); } @@ -3002,9 +2990,9 @@ print_extent (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) { if (escapeflag) { - CONST char *title = ""; - CONST char *name = ""; - CONST char *posttitle = ""; + const char *title = ""; + const char *name = ""; + const char *posttitle = ""; Lisp_Object obj2 = Qnil; /* Destroyed extents have 't' in the object field, causing @@ -3040,8 +3028,8 @@ print_extent (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag) if (!EXTENT_LIVE_P (XEXTENT (obj))) error ("printing unreadable object #"); else - error ("printing unreadable object #", - XEXTENT (obj)); + error ("printing unreadable object #", + (long) XEXTENT (obj)); } if (!EXTENT_LIVE_P (XEXTENT (obj))) @@ -3104,13 +3092,13 @@ properties_equal (EXTENT e1, EXTENT e2, int depth) } static int -extent_equal (Lisp_Object o1, Lisp_Object o2, int depth) +extent_equal (Lisp_Object obj1, Lisp_Object obj2, int depth) { - struct extent *e1 = XEXTENT (o1); - struct extent *e2 = XEXTENT (o2); + struct extent *e1 = XEXTENT (obj1); + struct extent *e2 = XEXTENT (obj2); return (extent_start (e1) == extent_start (e2) && - extent_end (e1) == extent_end (e2) && + extent_end (e1) == extent_end (e2) && internal_equal (extent_object (e1), extent_object (e2), depth + 1) && properties_equal (extent_ancestor (e1), extent_ancestor (e2), depth)); @@ -3126,6 +3114,13 @@ extent_hash (Lisp_Object obj, int depth) internal_hash (extent_object (e), depth + 1)); } +static const struct lrecord_description extent_description[] = { + { XD_LISP_OBJECT, offsetof (struct extent, object) }, + { XD_LISP_OBJECT, offsetof (struct extent, flags.face) }, + { XD_LISP_OBJECT, offsetof (struct extent, plist) }, + { XD_END } +}; + static Lisp_Object extent_getprop (Lisp_Object obj, Lisp_Object prop) { @@ -3156,6 +3151,8 @@ extent_remprop (Lisp_Object obj, Lisp_Object prop) || 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) @@ -3173,7 +3170,7 @@ extent_remprop (Lisp_Object obj, Lisp_Object prop) return -1; } - return external_remprop (&ext->plist, prop, 0, ERROR_ME); + return external_remprop (extent_plist_addr (ext), prop, 0, ERROR_ME); } static Lisp_Object @@ -3182,6 +3179,20 @@ extent_plist (Lisp_Object obj) return Fextent_properties (obj); } +DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("extent", extent, + mark_extent, + print_extent, + /* NOTE: If you declare a + finalization method here, + it will NOT be called. + Shaft city. */ + 0, + extent_equal, extent_hash, + extent_description, + extent_getprop, extent_putprop, + extent_remprop, extent_plist, + struct extent); + /************************************************************************/ /* basic extent accessors */ @@ -3663,7 +3674,7 @@ copy_extent (EXTENT original, Bytind from, Bytind to, Lisp_Object object) one. */ struct extent_auxiliary *data = alloc_lcrecord_type (struct extent_auxiliary, - lrecord_extent_auxiliary); + &lrecord_extent_auxiliary); copy_lcrecord (data, XEXTENT_AUXILIARY (XCAR (original->plist))); XSETEXTENT_AUXILIARY (XCAR (e->plist), data); @@ -4602,6 +4613,99 @@ process_extents_for_deletion (Lisp_Object object, Bytind from, ME_END_CLOSED | ME_MIGHT_MODIFY_EXTENTS); } +/* ------------------------------- */ +/* report_extent_modification() */ +/* ------------------------------- */ +struct report_extent_modification_closure { + Lisp_Object buffer; + Bufpos start, end; + int afterp; + int speccount; +}; + +static Lisp_Object +report_extent_modification_restore (Lisp_Object buffer) +{ + if (current_buffer != XBUFFER (buffer)) + Fset_buffer (buffer); + return Qnil; +} + +static int +report_extent_modification_mapper (EXTENT extent, void *arg) +{ + struct report_extent_modification_closure *closure = + (struct report_extent_modification_closure *)arg; + Lisp_Object exobj, startobj, endobj; + Lisp_Object hook = (closure->afterp + ? extent_after_change_functions (extent) + : extent_before_change_functions (extent)); + if (NILP (hook)) + return 0; + + XSETEXTENT (exobj, extent); + XSETINT (startobj, closure->start); + XSETINT (endobj, closure->end); + + /* Now that we are sure to call elisp, set up an unwind-protect so + inside_change_hook gets restored in case we throw. Also record + 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, Qnil). This is because + map_extents_bytind() unbinds before, and with a smaller + speccount. The additional unbind_to() in + report_extent_modification() would cause XEmacs to abort. */ + if (closure->speccount == -1) + { + closure->speccount = specpdl_depth (); + record_unwind_protect (report_extent_modification_restore, + Fcurrent_buffer ()); + } + + /* The functions will expect closure->buffer to be the current + buffer, so change it if it isn't. */ + if (current_buffer != XBUFFER (closure->buffer)) + Fset_buffer (closure->buffer); + + /* #### It's a shame that we can't use any of the existing run_hook* + functions here. This is so because all of them work with + symbols, to be able to retrieve default values of local hooks. + + + #### Idea: we could set up a dummy symbol, and call the hook + functions on *that*. */ + + if (!CONSP (hook) || EQ (XCAR (hook), Qlambda)) + call3 (hook, exobj, startobj, endobj); + else + { + Lisp_Object tail; + EXTERNAL_LIST_LOOP (tail, hook) + /* #### Shouldn't this perform the same Fset_buffer() check as + above? */ + call3 (XCAR (tail), exobj, startobj, endobj); + } + return 0; +} + +void +report_extent_modification (Lisp_Object buffer, Bufpos start, Bufpos end, + int afterp) +{ + struct report_extent_modification_closure closure; + + closure.buffer = buffer; + closure.start = start; + closure.end = end; + closure.afterp = afterp; + closure.speccount = -1; + + map_extents (start, end, report_extent_modification_mapper, (void *)&closure, + buffer, NULL, ME_MIGHT_CALL_ELISP); +} + /************************************************************************/ /* extent properties */ @@ -4645,7 +4749,7 @@ memoize_extent_face_internal (Lisp_Object list) on the keys so the memoization works correctly. Note that we canonicalize things so that the keys in the - hashtable (the external lists) always contain symbols and + hash table (the external lists) always contain symbols and the values (the internal lists) always contain face objects. We also maintain a "reverse" table that maps from the internal @@ -4895,7 +4999,7 @@ symbol_to_glyph_layout (Lisp_Object layout_obj) if (EQ (layout_obj, Qwhitespace)) return GL_WHITESPACE; if (EQ (layout_obj, Qtext)) return GL_TEXT; - signal_simple_error ("unknown glyph layout type", layout_obj); + signal_simple_error ("Unknown glyph layout type", layout_obj); return GL_TEXT; /* unreached */ } @@ -4903,13 +5007,13 @@ static Lisp_Object set_extent_glyph_1 (Lisp_Object extent_obj, Lisp_Object glyph, int endp, Lisp_Object layout_obj) { - EXTENT extent = decode_extent (extent_obj, DE_MUST_HAVE_BUFFER); + EXTENT extent = decode_extent (extent_obj, 0); glyph_layout layout = symbol_to_glyph_layout (layout_obj); - /* Make sure we've actually been given a glyph or it's nil (meaning - we're deleting a glyph from an extent). */ + /* Make sure we've actually been given a valid glyph or it's nil + (meaning we're deleting a glyph from an extent). */ if (!NILP (glyph)) - CHECK_GLYPH (glyph); + CHECK_BUFFER_GLYPH (glyph); set_extent_glyph (extent, glyph, endp, layout); return glyph; @@ -5201,6 +5305,10 @@ The following symbols have predefined meanings: 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); + else if (EQ (property, Qafter_change_functions)) + set_extent_after_change_functions (e, value); else if (EQ (property, Qmouse_face)) Fset_extent_mouse_face (extent, value); /* Obsolete: */ @@ -5218,23 +5326,15 @@ The following symbols have predefined meanings: Fset_extent_begin_glyph (extent, value, Qnil); else if (EQ (property, Qend_glyph)) Fset_extent_end_glyph (extent, value, Qnil); - else if (EQ (property, Qstart_open) || - EQ (property, Qend_open) || - EQ (property, Qstart_closed) || - EQ (property, Qend_closed)) - { - int start_open = -1, end_open = -1; - if (EQ (property, Qstart_open)) - start_open = !NILP (value); - else if (EQ (property, Qend_open)) - end_open = !NILP (value); - /* Support (but don't document...) the obvious antonyms. */ - else if (EQ (property, Qstart_closed)) - start_open = NILP (value); - else - end_open = NILP (value); - set_extent_openness (e, start_open, end_open); - } + else if (EQ (property, Qstart_open)) + set_extent_openness (e, !NILP (value), -1); + else if (EQ (property, Qend_open)) + set_extent_openness (e, -1, !NILP (value)); + /* Support (but don't document...) the obvious *_closed antonyms. */ + else if (EQ (property, Qstart_closed)) + set_extent_openness (e, NILP (value), -1); + else if (EQ (property, Qend_closed)) + set_extent_openness (e, -1, NILP (value)); else { if (EQ (property, Qkeymap)) @@ -5280,18 +5380,21 @@ See `set-extent-property' for the built-in property names. { EXTENT e = decode_extent (extent, 0); - if (EQ (property, Qdetached)) + if (EQ (property, Qdetached)) return extent_detached_p (e) ? Qt : Qnil; else if (EQ (property, Qdestroyed)) return !EXTENT_LIVE_P (e) ? Qt : Qnil; -#define RETURN_FLAG(flag) return extent_normal_field (e, flag) ? Qt : Qnil - else if (EQ (property, Qstart_open)) RETURN_FLAG (start_open); - else if (EQ (property, Qend_open)) RETURN_FLAG (end_open); - else if (EQ (property, Qunique)) RETURN_FLAG (unique); - else if (EQ (property, Qduplicable)) RETURN_FLAG (duplicable); - else if (EQ (property, Qdetachable)) RETURN_FLAG (detachable); -#undef RETURN_FLAG - /* Support (but don't document...) the obvious antonyms. */ + else if (EQ (property, Qstart_open)) + return extent_normal_field (e, start_open) ? Qt : Qnil; + else if (EQ (property, Qend_open)) + return extent_normal_field (e, end_open) ? Qt : Qnil; + else if (EQ (property, Qunique)) + return extent_normal_field (e, unique) ? Qt : Qnil; + else if (EQ (property, Qduplicable)) + return extent_normal_field (e, duplicable) ? Qt : Qnil; + else if (EQ (property, Qdetachable)) + return extent_normal_field (e, detachable) ? Qt : Qnil; + /* Support (but don't document...) the obvious *_closed antonyms. */ else if (EQ (property, Qstart_closed)) return extent_start_open_p (e) ? Qnil : Qt; else if (EQ (property, Qend_closed)) @@ -5306,6 +5409,10 @@ See `set-extent-property' for the built-in property names. return Fextent_face (extent); else if (EQ (property, Qinitial_redisplay_function)) return extent_initial_redisplay_function (e); + else if (EQ (property, Qbefore_change_functions)) + return extent_before_change_functions (e); + else if (EQ (property, Qafter_change_functions)) + return extent_after_change_functions (e); else if (EQ (property, Qmouse_face)) return Fextent_mouse_face (extent); /* Obsolete: */ @@ -5382,6 +5489,14 @@ Do not modify this list; use `set-extent-property' instead. 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); @@ -5636,12 +5751,10 @@ add_string_extents_mapper (EXTENT extent, void *arg) struct add_string_extents_arg *closure = (struct add_string_extents_arg *) arg; Bytecount start = extent_endpoint_bytind (extent, 0) - closure->from; - Bytecount end = extent_endpoint_bytind (extent, 1) - closure->from; + Bytecount end = extent_endpoint_bytind (extent, 1) - closure->from; if (extent_duplicable_p (extent)) { - EXTENT e; - start = max (start, 0); end = min (end, closure->length); @@ -5652,7 +5765,7 @@ add_string_extents_mapper (EXTENT extent, void *arg) !run_extent_copy_function (extent, start + closure->from, end + closure->from)) return 0; - e = copy_extent (extent, start, end, closure->string); + copy_extent (extent, start, end, closure->string); } return 0; @@ -5777,25 +5890,21 @@ copy_string_extents_mapper (EXTENT extent, void *arg) { struct copy_string_extents_arg *closure = (struct copy_string_extents_arg *) arg; - Bytecount old_start, old_end; - Bytecount new_start, new_end; + Bytecount old_start, old_end, new_start, new_end; old_start = extent_endpoint_bytind (extent, 0); - old_end = extent_endpoint_bytind (extent, 1); + old_end = extent_endpoint_bytind (extent, 1); old_start = max (closure->old_pos, old_start); - old_end = min (closure->old_pos + closure->length, old_end); + old_end = min (closure->old_pos + closure->length, old_end); if (old_start >= old_end) return 0; new_start = old_start + closure->new_pos - closure->old_pos; - new_end = old_end + closure->new_pos - closure->old_pos; + new_end = old_end + closure->new_pos - closure->old_pos; - copy_extent (extent, - old_start + closure->new_pos - closure->old_pos, - old_end + closure->new_pos - closure->old_pos, - closure->new_string); + copy_extent (extent, new_start, new_end, closure->new_string); return 0; } @@ -6395,7 +6504,7 @@ Used as the `paste-function' property of `text-prop' extents. prop = Fextent_property (extent, Qtext_prop, Qnil); if (NILP (prop)) - signal_simple_error ("internal error: no text-prop", extent); + signal_simple_error ("Internal error: no text-prop", extent); val = Fextent_property (extent, prop, Qnil); #if 0 /* removed by bill perry, 2/9/97 @@ -6403,7 +6512,7 @@ Used as the `paste-function' property of `text-prop' extents. ** with a value of Qnil. This is bad bad bad. */ if (NILP (val)) - signal_simple_error_2 ("internal error: no text-prop", + signal_simple_error_2 ("Internal error: no text-prop", extent, prop); #endif Fput_text_property (from, to, prop, val, Qnil); @@ -6568,6 +6677,10 @@ compute_buffer_extent_usage (struct buffer *b, struct overhead_stats *ovstats) void syms_of_extents (void) { + INIT_LRECORD_IMPLEMENTATION (extent); + INIT_LRECORD_IMPLEMENTATION (extent_info); + INIT_LRECORD_IMPLEMENTATION (extent_auxiliary); + defsymbol (&Qextentp, "extentp"); defsymbol (&Qextent_live_p, "extent-live-p"); @@ -6607,8 +6720,6 @@ syms_of_extents (void) defsymbol (&Qwhitespace, "whitespace"); /* Qtext defined in general.c */ - defsymbol (&Qglyph_invisible, "glyph-invisible"); - defsymbol (&Qpaste_function, "paste-function"); defsymbol (&Qcopy_function, "copy-function"); @@ -6685,8 +6796,26 @@ syms_of_extents (void) } void +reinit_vars_of_extents (void) +{ + extent_auxiliary_defaults.begin_glyph = Qnil; + extent_auxiliary_defaults.end_glyph = Qnil; + extent_auxiliary_defaults.parent = Qnil; + extent_auxiliary_defaults.children = Qnil; + extent_auxiliary_defaults.priority = 0; + extent_auxiliary_defaults.invisible = Qnil; + extent_auxiliary_defaults.read_only = Qnil; + extent_auxiliary_defaults.mouse_face = Qnil; + extent_auxiliary_defaults.initial_redisplay_function = Qnil; + extent_auxiliary_defaults.before_change_functions = Qnil; + extent_auxiliary_defaults.after_change_functions = Qnil; +} + +void vars_of_extents (void) { + reinit_vars_of_extents (); + DEFVAR_INT ("mouse-highlight-priority", &mouse_highlight_priority /* The priority to use for the mouse-highlighting pseudo-extent that is used to highlight extents with the `mouse-face' attribute set. @@ -6695,7 +6824,7 @@ See `set-extent-priority'. /* Set mouse-highlight-priority (which ends up being used both for the mouse-highlighting pseudo-extent and the primary selection extent) to a very high value because very few extents should override it. - 1000 gives lots of room below it for different-prioritied extents. + 1000 gives lots of room below it for different-prioritized extents. 10 doesn't. ediff, for example, likes to use priorities around 100. --ben */ mouse_highlight_priority = /* 10 */ 1000; @@ -6713,30 +6842,20 @@ functions `get-text-property' or `get-char-property' are called. Vextent_face_reusable_list = Fcons (Qnil, Qnil); staticpro (&Vextent_face_reusable_list); - - extent_auxiliary_defaults.begin_glyph = Qnil; - extent_auxiliary_defaults.end_glyph = Qnil; - extent_auxiliary_defaults.parent = Qnil; - extent_auxiliary_defaults.children = Qnil; - extent_auxiliary_defaults.priority = 0; - extent_auxiliary_defaults.invisible = Qnil; - extent_auxiliary_defaults.read_only = Qnil; - extent_auxiliary_defaults.mouse_face = Qnil; - extent_auxiliary_defaults.initial_redisplay_function = Qnil; } void complex_vars_of_extents (void) { staticpro (&Vextent_face_memoize_hash_table); - /* The memoize hash-table maps from lists of symbols to lists of + /* The memoize hash table maps from lists of symbols to lists of faces. It needs to be `equal' to implement the memoization. The reverse table maps in the other direction and just needs to do `eq' comparison because the lists of faces are already memoized. */ Vextent_face_memoize_hash_table = - make_lisp_hashtable (100, HASHTABLE_VALUE_WEAK, HASHTABLE_EQUAL); + make_lisp_hash_table (100, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL); staticpro (&Vextent_face_reverse_memoize_hash_table); Vextent_face_reverse_memoize_hash_table = - make_lisp_hashtable (100, HASHTABLE_KEY_WEAK, HASHTABLE_EQ); + make_lisp_hash_table (100, HASH_TABLE_KEY_WEAK, HASH_TABLE_EQ); }