home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / lucid / lemacs-19.6 / src / extents.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-03-13  |  86.9 KB  |  3,119 lines
  1. /* This file is part of GNU Emacs.
  2.  
  3. GNU Emacs is free software; you can redistribute it and/or modify
  4. it under the terms of the GNU General Public License as published by
  5. the Free Software Foundation; either version 1, or (at your option)
  6. any later version.
  7.  
  8. GNU Emacs is distributed in the hope that it will be useful,
  9. but WITHOUT ANY WARRANTY; without even the implied warranty of
  10. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11. GNU General Public License for more details.
  12.  
  13. You should have received a copy of the GNU General Public License
  14. along with GNU Emacs; see the file COPYING.  If not, write to
  15. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  16.  
  17. #include "config.h"
  18. #include "lisp.h"
  19. #include "buffer.h" 
  20. #include "process.h"
  21.  
  22. #include "xterm.h"     /* for struct x_bitmap in set_extent_glyph_1() */
  23.  
  24. #include "extents.h"
  25. #include "faces.h"
  26. #include "hash.h"
  27.  
  28. #ifdef ENERGIZE
  29. #include <editorreq.h>
  30. #include <X11/Intrinsic.h> /* for "Boolean" typedef, believe it or not... */
  31. #include "extents-data.h"
  32. #endif
  33.  
  34. /************** Typedefs and Structs ***********************/
  35.  
  36. struct slow_map_extents_arg
  37. {
  38.   Lisp_Object map_arg;
  39.   Lisp_Object map_routine;
  40. };
  41.  
  42. struct replicate_extents_struct
  43. {
  44.   int from;
  45.   int length;
  46.   struct buffer *buf;
  47.   Lisp_Object head;
  48.   Lisp_Object nconc_cell;
  49. };
  50.  
  51. /* not used at the moment */   
  52. struct process_extents_for_insertion_struct
  53. {
  54.   int opoint;
  55.   int length;
  56.   struct buffer *buf;
  57. };
  58.    
  59. struct process_extents_for_deletion_struct
  60. {
  61.   int start;
  62.   int end;
  63.   int destroy_included_extents;
  64. };
  65.  
  66. struct extent_at_struct
  67. {
  68.   EXTENT best_match;
  69.   int flag;
  70. };
  71.  
  72.  
  73. /************** Functions ***********************/
  74. extern DUP make_extent_replica (void);
  75.  
  76. /*extern Lisp_Object list_sort 
  77. (Lisp_Object list, Lisp_Object lisp_arg, 
  78.  int (*pred_fn)(Lisp_Object x, Lisp_Object y, Lisp_Object arg));*/
  79.  
  80. void map_extents (int from, int to, elisp_emf efn, emf fn, void *arg, 
  81.                   struct buffer *buf, int closed_end);
  82.  
  83. static void soe_push (EXTENT extent, struct buffer *b);
  84. static void soe_delq (EXTENT extent, struct buffer *b);
  85. static void soe_clear (struct buffer *b);
  86.  
  87. void init_buffer_cached_stack (struct buffer *b);
  88. void free_buffer_cached_stack (struct buffer *b);
  89.  
  90. static EXTENT_FRAGMENT befa_internal (int pos, struct buffer *buf);
  91. EXTENT_FRAGMENT buffer_extent_fragment_at (int pos, struct buffer *buf,
  92.                                            struct screen *s);
  93.  
  94. static void add_to_replicas_lists (c_hashtable table, Lisp_Object dup_list, 
  95.                                    int offset, int length);
  96.  
  97.  
  98. /************** Macros ***********************/
  99.  
  100. #define max(A,B) ((A) > (B) ? (A) : (B))
  101. #define min(A,B) ((A) <= (B) ? (A) : (B))
  102.  
  103. #define MAX_INT ((long) 0x7fffffff)
  104.    
  105. #define BUFNAME(buf) &(XSTRING(buf->name)->data[0])
  106. #define SYMNAME(sym) &(XSYMBOL(sym)->name->data[0])
  107.  
  108. /* if buf is the one in the cache, invalidate the cache -- used in
  109.    places where changes to extents list occur that might not affect 
  110.    the buffer modiff */
  111. #define CHECK_RESET_EXTENT_FRAGMENT(x) \
  112. {if (((char *) extent_fragment.buf) == ((char *)(x))) \
  113.   {extent_fragment.buf = 0; Vextent_fragment_buffer = Qnil;}}
  114.  
  115. #define EXTENT_LESS_VALS(e,st,nd) (((e)->start < (st)) || \
  116.                    (((e)->start == (st)) && \
  117.                    ((e)->end > (nd))))
  118.  
  119. #define EXTENT_LESS(e,x) EXTENT_LESS_VALS(e, (x)->start, (x)->end)
  120.  
  121. #define EXTENT_LESS_EQ(e,x) (((e)->start < (x)->start) || \
  122.                  (((e)->start == (x)->start) && \
  123.                  ((e)->end >= (x)->end)))
  124.  
  125. #define EXTENT_E_LESS_VALS(e,st,nd) (((e)->end < (nd)) || \
  126.                      (((e)->end == (nd)) && \
  127.                      ((e)->start < (st))))
  128.  
  129. #define EXTENT_E_LESS(e,x) EXTENT_E_LESS_VALS(e,(x)->start,(x)->end)
  130.  
  131. #define EXTENT_OVER_INDEX(e,i) ((((e)->start <= (i)) && ((e)->end > (i))) || \
  132.                 (((e)->start == (i)) && ((e)->end == (i))))
  133.   
  134. #define EXTENT_PAST_INDEX(e,i) (((e)->end > (i)) || \
  135.                 ((((e)->start == (i)) && ((e)->end == (i)))))
  136.  
  137. /************** Variables ***********************/
  138.  
  139. Lisp_Object Vlast_highlighted_extent;
  140.  
  141. static Lisp_Object Vextent_fragment_buffer;
  142. static struct extent_fragment extent_fragment;
  143. static struct extent_fragment default_extent_fragment;
  144.  
  145. int extent_cache_invalid;    /* set this to force a recomputation */
  146.  
  147.  
  148.  
  149. /*********************************
  150.   EXTENTS.C INTERNAL UTILITIES
  151.   *******************************/
  152.  
  153. static void
  154. check_from_to (int from, int to, struct buffer* buf)
  155. { 
  156.   if ((from < BUF_BEG (buf)) || (from > BUF_Z (buf))) 
  157.     error ("Bad buffer position %d for buffer %s", 
  158.            from, BUFNAME(buf)); 
  159.   if ((to < BUF_BEG (buf)) || (to > BUF_Z (buf))) 
  160.     error ("Bad buffer position %d for buffer %s", 
  161.        to, BUFNAME(buf));
  162. } 
  163.  
  164. static int
  165. adjust_extent_index (int i, int from, int to, int amount)
  166. {
  167.   /* Some sanity checking */
  168.   if (amount > 0)
  169.     {
  170.       if (i > to && i < to + amount)
  171.     abort ();
  172.     }
  173.   else 
  174.     {
  175.       if (i > from + amount && i < from)
  176.     abort ();
  177.     }
  178.  
  179.   if (i >= from && i <= to)
  180.     i += amount;
  181.  
  182.   return i;
  183. }
  184.  
  185. static int
  186. extent_index_to_buffer_pos (int i, struct buffer *buf)
  187. {
  188.   if (i > BUF_GPT (buf) + BUF_GAP_SIZE (buf))
  189.     i -= BUF_GAP_SIZE (buf);
  190.   else if (i > BUF_GPT (buf))
  191.     i = BUF_GPT (buf);
  192.  
  193.   if ((i < BUF_BEG (buf)) || (i > BUF_Z (buf)))
  194.     abort();
  195.   else
  196.     return i;
  197. }
  198.  
  199. static int
  200. buffer_pos_to_extent_index (int pos, struct buffer *buf)
  201. {
  202.   if ((pos < BUF_BEG (buf)) || (pos > BUF_Z (buf)))
  203.     abort();
  204.   else if (pos <= BUF_GPT (buf))
  205.     return pos;
  206.   else 
  207.     return (pos + BUF_GAP_SIZE (buf));
  208. }
  209.  
  210. static int
  211. extent_index_offset (int index, int offset, struct buffer *buf)
  212. {
  213.   int pos = extent_index_to_buffer_pos (index, buf);
  214.   return buffer_pos_to_extent_index (pos + offset, buf);
  215. }
  216.  
  217. static EXTENT 
  218. buffer_starting_extent (int index, struct buffer *buf)
  219. {
  220.   struct stack_of_extents *soe = buf->cached_stack;
  221.   EXTENT first_extent = NULL;
  222.   EXTENT ext;
  223.   int i;
  224.  
  225.   /* no extents on the buffer */
  226.   if (!EXTENTP (buf->extents))
  227.     return NULL;
  228.   
  229.   first_extent = XEXTENT (buf->extents);
  230.  
  231.   /* no cache or cache not valid */
  232.   if (!soe || soe->buf_index <= 0)
  233.     return first_extent;
  234.  
  235.   /* index is after the cached values */
  236.   if (index >= soe->buf_index)
  237.     {
  238.       ext = NULL;
  239.       for (i = 0; i < soe->stack_index; i++)
  240.     if (soe->stack [i]->end > index)
  241.       {
  242.         ext = soe->stack [i];
  243.         break;
  244.       }
  245.       if (!ext)
  246.     ext = soe->previous_extent;
  247.       return ext ? ext : first_extent;
  248.     }
  249.  
  250.   /* index is before the cached values */
  251.  
  252.   /* The extent which is before the first one in the 
  253.      cache is a good starting point for backing up
  254.      previous extent. */
  255.   if (soe->stack_index)
  256.     ext = soe->stack [0];
  257.   else
  258.     /* if there is nothing in the cache the previous extent
  259.        can be used */
  260.     ext = soe->previous_extent;
  261.  
  262.   /* no previous extent in the cache */
  263.   if (!ext)
  264.     return first_extent;
  265.     
  266.   /* previous is closer to index than to the beginning of the buffer */
  267.   if ((ext->end / 2) < index)
  268.     {
  269.       EXTENT starting_one = ext;
  270.  
  271.       while (ext && ext->end >= index)
  272.     {
  273.           ext = ext->e_previous;
  274.           if (ext && ext->start < starting_one->start)
  275.         starting_one = ext;
  276.         }
  277.       starting_one = starting_one->previous;
  278.       return (ext && starting_one) ? starting_one : first_extent;
  279.     }
  280.  
  281.   /* default */
  282.   return first_extent;
  283. }
  284.  
  285.  
  286. void
  287. adjust_extents (int from, int to, int amount, struct buffer* buf)
  288. {
  289.   EXTENT current;
  290.  
  291.   if (NILP (buf->extents))
  292.     return;
  293.   else if (!EXTENTP (buf->extents))
  294.     abort ();
  295.  
  296.   current = buffer_starting_extent (from, buf);
  297.   
  298.   CHECK_RESET_EXTENT_FRAGMENT (buf);
  299.   
  300.   while (current)
  301.     {
  302.       if (current->end < from)
  303.     ;
  304.       else if (current->start <= to)
  305.     {
  306.       current->start = adjust_extent_index (current->start, from, to,
  307.                         amount);
  308.       if (current->end <= to)
  309.         current->end = adjust_extent_index (current->end, from, to,
  310.                         amount);
  311.     }
  312.       else 
  313.     break;
  314.       
  315.       if (current == current->next) abort ();
  316.       current = current->next;
  317.     }
  318.   
  319.   if (buf->cached_stack
  320.       && buf->cached_stack->buf_index > 0
  321.       && buf->cached_stack->buf_index > from
  322.       && buf->cached_stack->buf_index <= to)
  323.     buf->cached_stack->buf_index += amount;
  324. }
  325.  
  326. struct end_points
  327. {
  328.   int start;
  329.   int end;
  330. };
  331.  
  332. static int
  333. verify_extent_mf (EXTENT extent, void *arg)
  334. {
  335.   struct end_points* ep = (struct end_points*)arg;
  336.   
  337.   if ((EXTENT_FLAGS(extent) & EF_WRITE_PROTECT)
  338.       && (extent->end > ep->start)
  339.       && (extent->start <= ep->end))
  340.     {
  341.       error ("Attempt to modify a read-only region");
  342.       return 1;
  343.     }
  344.   else
  345.     return 0;
  346. }
  347.  
  348. #ifdef ENERGIZE
  349. extern int inside_parse_buffer; /* total kludge */
  350. #endif
  351.  
  352. void
  353. verify_extent_modification (struct buffer *buf, int from, int to)
  354. {
  355.   struct end_points ep;
  356.  
  357.   check_from_to (from, to, buf);
  358.   ep.start = buffer_pos_to_extent_index (from, buf);
  359.   ep.end = buffer_pos_to_extent_index (to, buf);
  360.  
  361.   if (inside_undo ||
  362. #ifdef ENERGIZE
  363.       inside_parse_buffer ||
  364. #endif
  365.       NILP (buf->extents))
  366.     return;
  367.   else if (!EXTENTP (buf->extents))
  368.     abort();
  369.   else
  370.     map_extents (from, to, 0, verify_extent_mf, (void*)&ep, buf, 0);
  371. }
  372.  
  373. /* At the moment only this function, buffer_extent_fragment_at(), 
  374.    update_cache_forward(), map_extents() and adjust_extents (),
  375.    know how to "cdr" down a list of extents. 
  376.    See the comment at map_extents() for information 
  377.    about the ordering rule. */
  378. static void 
  379. splice_extent_into_buffer (EXTENT extent, Lisp_Object buffer)
  380. {
  381.   Lisp_Object extents_root;
  382.   Lisp_Object extent_obj;
  383.   struct buffer *buf = XBUFFER(buffer);
  384.  
  385.   CHECK_BUFFER (buffer, 0);  
  386.   CHECK_RESET_EXTENT_FRAGMENT (buf);
  387.    
  388.   XSET (extent_obj, Lisp_Extent, extent);
  389.  
  390.   init_buffer_cached_stack (buf);
  391.  
  392.   extents_root = buf->extents;
  393.  
  394.   if (NILP (extents_root))
  395.     buf->extents = extent_obj;
  396.   else if (!EXTENTP (extents_root))
  397.     abort();
  398.   else
  399.     {
  400.       int start = extent->start;
  401.       int end = extent->end;
  402.       EXTENT tmp = buffer_starting_extent (start, buf);
  403.       EXTENT prev = (tmp ? tmp->previous : 0);
  404.  
  405.       while (tmp && EXTENT_LESS_VALS (tmp, start, end))
  406.         {
  407.           prev = tmp;
  408.           tmp = tmp->next;
  409.       if (prev == tmp) abort ();
  410.         }
  411.  
  412.       if (!tmp && !prev)
  413.         abort();
  414.  
  415.       if (prev)
  416.         { 
  417.           EXTENT caboose = prev->next;
  418.       if (extent == prev) abort ();
  419.       if (extent == caboose) abort ();
  420.           prev->next = extent; 
  421.           extent->previous = prev; 
  422.           extent->next = caboose; 
  423.           if (caboose)
  424.             caboose->previous = extent;
  425.         }
  426.       else 
  427.         {
  428.           EXTENT engine = tmp->previous;
  429.           if (engine)
  430.             engine->next = tmp;
  431.       if (extent == tmp) abort ();
  432.           extent->previous = engine; 
  433.           extent->next = tmp; 
  434.           tmp->previous = extent; 
  435.  
  436.       buf->extents = extent_obj;
  437.         }
  438.  
  439.       if (!tmp)        /* one of these exists; pick one */
  440.         tmp = prev;
  441.  
  442.       /* if tmp (some arbitrary extent in the middle of nowhere but likely
  443.      to be close to where we want to be) is before the extents we want
  444.      to insert between (in e order) then go forward
  445.        */
  446.       if (EXTENT_E_LESS_VALS (tmp, start, end))
  447.     {
  448.       prev = tmp->e_previous;
  449.       while (tmp && EXTENT_E_LESS_VALS (tmp, start, end))
  450.         {
  451.           prev = tmp;
  452.           tmp = tmp->e_next;
  453.           if (prev == tmp) abort ();
  454.         }
  455.     }
  456.       else    /* go backward */
  457.         {
  458.           prev = tmp;
  459.       while (prev && !EXTENT_E_LESS_VALS (prev, start, end))
  460.             {
  461.           /* we always go into this loop at least once */
  462.               tmp = prev;
  463.               prev = tmp->e_previous;
  464.             }
  465.       if (prev == tmp) abort ();
  466.         }
  467.  
  468.       if (!tmp && !prev)
  469.         abort();
  470.  
  471.       if (prev)
  472.         { 
  473.           EXTENT caboose = prev->e_next;
  474.       if (extent == prev) abort ();
  475.       if (extent == caboose) abort ();
  476.           prev->e_next = extent; 
  477.           extent->e_previous = prev; 
  478.           extent->e_next = caboose; 
  479.           if (caboose)
  480.             caboose->e_previous = extent;
  481.         }
  482.       else 
  483.         {
  484.           EXTENT engine = tmp->e_previous;
  485.           if (engine)
  486.             engine->e_next = tmp;
  487.       if (extent == tmp) abort ();
  488.           extent->e_previous = engine; 
  489.           extent->e_next = tmp; 
  490.           tmp->e_previous = extent; 
  491.         }
  492.     }
  493.  
  494.   soe_push (extent, buf);
  495.   CLEAR_EXTENT_FLAG (extent, EF_DETACHED);
  496. }
  497.  
  498. static void set_extent_flags (EXTENT extent);
  499. static void set_extent_attributes_index (EXTENT extent);
  500.  
  501. static void
  502. restore_extent_state (EXTENT extent)
  503. {
  504.   set_extent_flags (extent);
  505.   set_extent_attributes_index (extent);
  506. }
  507.  
  508. static Lisp_Object
  509. make_extent_internal (int from, int to, Lisp_Object buffer, void *data)
  510. {
  511.   EXTENT extent;
  512.   Lisp_Object extent_obj = Qnil;
  513.   struct buffer *buf = XBUFFER (buffer);
  514.  
  515.   CHECK_BUFFER (buffer, 0);  
  516.   check_from_to (from, to, buf);
  517.    
  518.   if ((from < 0) || (to < from))
  519.     error ("START == %d, END == %d -- bad start/end for extent",
  520.            from, to);
  521.  
  522.   if (NILP (buf->name))
  523.     error ("Can't put an extent in a killed buffer");
  524.  
  525.   if ((from < BUF_BEG(buf)) || (to > BUF_Z(buf)))
  526.     error ("START == %d, END == %d -- bad start/end for extent in buffer %s",
  527.            from, to, BUFNAME(buf));
  528.     
  529.   extent = make_extent();
  530.   XSET(extent_obj, Lisp_Extent, extent);
  531.  
  532.   extent->buffer = buffer;
  533.   extent->flags = 0;
  534.   extent->priority = 0;
  535.  
  536. #ifdef ENERGIZE
  537.   if (data)
  538.     {
  539.       Energize_Extent_Data *ext = (Energize_Extent_Data *) data;
  540.       set_energize_extent_data (extent, data);
  541.       if (ext->extent)
  542.     abort ();
  543.       ext->extent = extent_obj;
  544.     }
  545. #endif
  546.  
  547.   extent->start = buffer_pos_to_extent_index (from, buf);
  548.   extent->end = buffer_pos_to_extent_index (to, buf);
  549.  
  550.   splice_extent_into_buffer (extent, buffer);
  551.  
  552.   restore_extent_state (extent);
  553.   return extent_obj;
  554. }
  555.  
  556.  
  557. static int 
  558. extent_endpoint (EXTENT extent, int endp)
  559. {
  560.   int i = (endp)?(extent->end):(extent->start);
  561.   if (EXTENT_DESTROYED_P (extent))
  562.     return -1;
  563.   else if (EXTENT_DETACHED_P (extent))
  564.     return 0;
  565.   else if (BUFFERP (extent->buffer))
  566.     return extent_index_to_buffer_pos (i, XBUFFER(extent->buffer));
  567.   else
  568.     return i;
  569. }
  570.  
  571. static void
  572. set_extent_flags (EXTENT extent)
  573. {
  574. #ifdef ENERGIZE
  575.   Energize_Extent_Data *ext = energize_extent_data (extent);
  576. #endif
  577.  
  578.   /* clear every flag except the EF_DETACHED flag */
  579.   if (EXTENT_DESTROYED_P (extent))
  580.     return;
  581.   else if (EXTENT_DETACHED_P (extent))
  582.     extent->flags = EF_DETACHED;
  583.   else
  584.     extent->flags = 0;
  585.  
  586. #ifdef ENERGIZE
  587.   if (ext)
  588.     {
  589.       switch (ext->extentType)
  590.     {
  591.     case CEAttribute:
  592.       break;
  593.  
  594.     case CEAbbreviation:
  595.       break;
  596.  
  597.     case CEWriteProtect:
  598.       SET_EXTENT_FLAG (extent, EF_WRITE_PROTECT);
  599.       break;
  600.           
  601.     case CEGeneric:
  602.       if (ext->u.generic.gData->id)
  603.         SET_EXTENT_FLAG (extent, EF_MENU);
  604.       if (ext->u.generic.gData->glyph)
  605.         {
  606.           SET_EXTENT_FLAG (extent, EF_END_GLYPH);
  607.           extent->end_glyph = ext->u.generic.gData->glyph;
  608.           BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  609.         }
  610.       if (ext->u.generic.gData->cl && ext->u.generic.gData->cl->glyph)
  611.         {
  612.           SET_EXTENT_FLAG (extent, EF_START_GLYPH);
  613.           extent->begin_glyph = ext->u.generic.gData->cl->glyph;
  614.           BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  615.         }
  616.       if (ext->u.generic.gData->cl && 
  617.           (ext->u.generic.gData->cl->flags & CCElectric))
  618.         SET_EXTENT_FLAG (extent, EF_HIGHLIGHT);
  619.       if (ext->u.generic.gData->cl && 
  620.           (ext->u.generic.gData->cl->flags & CCWarnModified))
  621.         SET_EXTENT_FLAG (extent, EF_WARN_MODIFY);
  622.       if (ext->u.generic.gData->cl && 
  623.           (ext->u.generic.gData->cl->flags & CCColumn))
  624.         SET_EXTENT_FLAG (extent, EF_COLUMN);
  625.       SET_EXTENT_FLAG (extent, EF_DUPLICABLE);
  626.       break;
  627.           
  628.     default:
  629.       break;
  630.     }
  631.     }
  632. #endif /* ENERGIZE */
  633. }
  634.  
  635. static void
  636. set_extent_attributes_index (EXTENT extent)
  637. {
  638. #ifdef ENERGIZE
  639.   Energize_Extent_Data *ext = energize_extent_data (extent);
  640.   int graphic_attributes;
  641.  
  642.   if (!ext) 
  643.     extent->attr_index = -1;
  644.   else
  645.     {
  646.       extern Lisp_Object Venergize_attributes_mapping;
  647.       Lisp_Object face;
  648.  
  649.       switch (ext->extentType)
  650.         {
  651.         case CEAttribute:
  652.           graphic_attributes = ext->u.attr.attrValue;
  653.           break;
  654.       
  655.         case CEGeneric:
  656.           graphic_attributes = ext->u.generic.gData->attribute;
  657.           break;
  658.       
  659.         case CEWriteProtect:
  660.           /* this type has NO display attributes */
  661.           extent->attr_index = -1;
  662.           return;
  663.       
  664.         default:
  665.           graphic_attributes = GA_NO_CHANGE;
  666.         }
  667.   
  668.       if (graphic_attributes >= GA_MAX) 
  669.         graphic_attributes = GA_NO_CHANGE;
  670.  
  671.       /* The Venergize_attributes_mapping global is an A-list of the form
  672.      ((<kernel attribute number> <attribute name> . <emacs face id>)..)
  673.      It is initialized by connect-to-energize in energize-init.el. */
  674.       if (CONSP (Venergize_attributes_mapping))
  675.     {
  676.       face = Fassq (graphic_attributes, Venergize_attributes_mapping);
  677.       if (CONSP (face))
  678.         {
  679.           face = XCONS(face)->cdr;
  680.           if (CONSP (face))
  681.         {
  682.           face = XCONS(face)->cdr;
  683.           if (FIXNUMP (face))
  684.             graphic_attributes = XINT (face);
  685.         }
  686.         }
  687.     }
  688.       extent->attr_index = graphic_attributes;
  689.     }
  690. #else /* ! ENERGIZE */
  691.   extent->attr_index = -1;
  692. #endif /* ! ENERGIZE */
  693.   return;
  694. }
  695.  
  696. #ifdef ENERGIZE
  697. extern unsigned long generic_id_for_extent (Energize_Extent_Data *);
  698.  
  699. static unsigned long
  700. extent_to_generic_id (Lisp_Object extent_obj)
  701. {
  702.   if (!EXTENTP (extent_obj)) 
  703.     return 0;
  704.   else 
  705.     {
  706.       Energize_Extent_Data *ext =
  707.     energize_extent_data (XEXTENT (extent_obj));
  708.       return generic_id_for_extent (ext);
  709.     }
  710. }
  711. #endif /* ENERGIZE */
  712.  
  713.  
  714. /*********************************
  715.   EXTENTS.C EXTERNAL UTILITIES
  716.   *******************************/
  717.  
  718. void 
  719. detach_extent (EXTENT extent) 
  720. { 
  721.   EXTENT prev = extent->previous; 
  722.   EXTENT next = extent->next; 
  723.   EXTENT e_prev = extent->e_previous; 
  724.   EXTENT e_next = extent->e_next; 
  725.   struct buffer *buf = XBUFFER(extent->buffer);
  726.   Lisp_Object obj_extent = buf->extents;
  727.  
  728.   CHECK_RESET_EXTENT_FRAGMENT (buf);
  729.  
  730.   soe_delq (extent, buf);
  731.  
  732.   if (XEXTENT (obj_extent) == extent)
  733.     {
  734.       if (next)
  735.         XSET (obj_extent, Lisp_Extent, next);
  736.       else
  737.         obj_extent = Qnil;
  738.       
  739.       XBUFFER (extent->buffer)->extents = obj_extent;
  740.     }
  741.  
  742.   if (prev) 
  743.     {
  744.       prev->next = next; 
  745.       extent->previous = 0;
  746.     }
  747.   if (next) 
  748.     {
  749.       next->previous = prev; 
  750.       extent->next = 0; 
  751.     }
  752.  
  753.  
  754.   if (e_prev) 
  755.     {
  756.       if (e_next == e_prev) abort ();
  757.       e_prev->e_next = e_next; 
  758.       extent->e_previous = 0;
  759.     }
  760.   if (e_next) 
  761.     {
  762.       if (e_next == e_prev) abort ();
  763.       e_next->e_previous = e_prev; 
  764.       extent->e_next = 0; 
  765.     }
  766.  
  767.   SET_EXTENT_FLAG (extent, EF_DETACHED);
  768.  
  769.   extent->start = 0;
  770.   extent->end = 0;
  771. }
  772.  
  773. #ifdef ENERGIZE
  774. extern void energize_extent_finalization (EXTENT);
  775. #endif
  776.  
  777. static void 
  778. destroy_extent (EXTENT extent) 
  779. { 
  780.   detach_extent (extent);
  781. #ifdef ENERGIZE
  782.   energize_extent_finalization (extent);
  783. #endif
  784.   extent->flags = EF_DESTROYED;
  785.   extent->start = 0;
  786.   extent->end = 0;
  787.   extent->next = 0;
  788.   extent->previous = 0;
  789.   extent->e_next = 0;
  790.   extent->e_previous = 0;
  791.   extent->user_data = Qnil;
  792.   extent->attr_index = 0;
  793.   extent->buffer = Qnil;
  794. }
  795.  
  796. static void   
  797. update_extent (EXTENT extent, int from, int to, int set_endpoints,
  798.            struct buffer *buf)
  799. {
  800.   if ((!BUFFERP (extent->buffer)) ||
  801.       (XBUFFER(extent->buffer) != buf))
  802.     error ("extent 0x%x not part of specified buffer %s", extent, 
  803.            BUFNAME (buf));
  804.  
  805.   if (set_endpoints)
  806.     {
  807.       check_from_to (from, to, buf);
  808.       
  809.       /* most of the time the extent doesn't need to be changed -- the
  810.      big problem is that the kernel actually doesn't know what is going
  811.      all too often */
  812.       if ((from < to) && ((EXTENT_FLAGS (extent) & EF_DETACHED) ||
  813.               (extent_endpoint (extent, 0) != from) ||
  814.               (extent_endpoint (extent, 1) != to)))
  815.     {
  816.       int new_start = buffer_pos_to_extent_index (from, buf);
  817.       int new_end = buffer_pos_to_extent_index (to, buf);
  818.       Lisp_Object buffer;
  819.       XSET (buffer, Lisp_Buffer, buf);
  820.       
  821.       detach_extent (extent);
  822.       extent->start = new_start;
  823.       extent->end = new_end;
  824.       splice_extent_into_buffer (extent, buffer);
  825.     }
  826.     }
  827.  
  828.   restore_extent_state (extent);
  829.   return;
  830. }
  831.  
  832. #ifdef ENERGIZE
  833.  
  834. /* creates a new extent or update an old one for ext in binfo and returns it */
  835. Lisp_Object
  836. make_extent_for_data (BufferInfo *binfo, Energize_Extent_Data *ext,
  837.               int from, int to, int set_endpoints)
  838. {
  839.   Lisp_Object extent_obj;
  840.   Lisp_Object buffer = binfo->emacs_buffer;
  841.   struct buffer *b = XBUFFER (buffer);
  842.   
  843.   to = min (to, BUF_Z (b));
  844.   from = min (from, to);
  845.   
  846.   if (extent_obj = ext->extent)
  847.     update_extent (XEXTENT (extent_obj), from, to, set_endpoints,
  848.            XBUFFER (buffer));
  849.   else
  850.     extent_obj = make_extent_internal (from, to, buffer, ext);
  851.   
  852.   SET_EXTENT_FLAG (XEXTENT (extent_obj), EF_DUPLICABLE);
  853.  
  854.   return extent_obj;
  855. }
  856.  
  857. #endif /* ENERGIZE */
  858.  
  859.  
  860. /*********************************
  861.   EXTENTS.C MAPPING FUNCTIONS
  862.   *******************************/
  863.  
  864.  
  865. /* Apply a function to each extent overlapping [from, to) (or [from, to],
  866.    if the closed_end arg is non-zero) in buffer. If the function ever
  867.    returns a non-zero value, quit immediately.  At the moment only this
  868.    function, buffer_extent_fragment_at(), update_cache_forward(), 
  869.    adjust_extents () and splice_extent_into_buffer() 
  870.    knows how to "cdr" down a list of extents.
  871.    Extents are ordered with increasing start position and then decreasing
  872.    end position. (This is what might be called "display order" -- if extent
  873.    A occurs after extent B, then the display attributes of extent A
  874.    override those of extent B in the region covered by both A and B. Note
  875.    that multiple extents with the same start and end postions may be in any
  876.    order.) Part of this comment is duplicated at update_cache_forward().*/
  877. void
  878. map_extents 
  879. (int from, int to, elisp_emf efn, emf fn, void *arg, struct buffer *buf, 
  880.  int closed_end)
  881. {
  882.   Lisp_Object extents_root = buf->extents;
  883.   int start;
  884.   int end;
  885.  
  886.   if ((from > to) || (NILP (extents_root)))
  887.     return;
  888.   
  889.   /* making an error here is wrong as this can be called from within
  890.      * make_gap () during which the buffer state is incoherent, ie the new
  891.      * GPT is already set but the new Z is not. 
  892.      * This is a little scary, maybe the function that updates the
  893.      * extents when the gap is moved should not call map_extents. 
  894.      * --Matthieu. */
  895.   /* check_from_to(from, to, buf); */
  896.   /* We silently return if mapping out of the buffer valid positions */
  897.   if ((from < BUF_BEG (buf)) || (from > BUF_Z (buf))
  898.       || (to < BUF_BEG (buf)) || (to > BUF_Z (buf)))
  899.     return;
  900.  
  901.   start = buffer_pos_to_extent_index (from, buf);
  902.   if (closed_end)
  903.     {
  904.       if (to == BUF_Z(buf))
  905.         end = buffer_pos_to_extent_index (to, buf) + 1;
  906.       else
  907.         end = buffer_pos_to_extent_index (to + 1, buf);
  908.     }
  909.   else
  910.     end = buffer_pos_to_extent_index (to, buf);
  911.  
  912.   if (!EXTENTP (extents_root))
  913.     abort();
  914.   else 
  915.     {
  916.       EXTENT tmp = buffer_starting_extent (start, buf);
  917.       EXTENT next;
  918.  
  919.       if (efn)
  920.         while (tmp)
  921.           {
  922.             /* this lets the map function be delete_extent, too */
  923.             next = tmp->next;
  924.         if (next == tmp) abort ();
  925.             if (tmp->end < start)
  926.               tmp = next;
  927.             else if (tmp->start < end)
  928.               {
  929.                 Lisp_Object tmp_obj;
  930.                 XSET (tmp_obj, Lisp_Extent, tmp);
  931.                 if ((*efn)(tmp_obj, arg))
  932.                   return;
  933.                 tmp = next; 
  934.               }
  935.             else 
  936.               return;
  937.           }
  938.       else
  939.         while (tmp)
  940.           {
  941.             /* this lets the map function be delete_extent, too */
  942.             next = tmp->next;
  943.         if (next == tmp) abort ();
  944.             if (tmp->end < start)
  945.               tmp = next;
  946.             else if (tmp->start < end)
  947.               {
  948.                 if ((*fn)(tmp, arg))
  949.                   return;
  950.               }
  951.             else 
  952.               return;
  953.    
  954.             tmp = next;
  955.           }
  956.     }
  957.   return;
  958. }
  959.  
  960. static int
  961. slow_map_extents_function (Lisp_Object extent_obj, void *arg)
  962. {
  963.   struct slow_map_extents_arg *slow_arg =
  964.     (struct slow_map_extents_arg *) arg;
  965.   if (NILP (call2 (slow_arg->map_routine, extent_obj, slow_arg->map_arg)))
  966.     return 0;
  967.   else
  968.     return 1;
  969. }
  970.  
  971. DEFUN ("map-extents", Fmap_extents, Smap_extents, 1, 6, 0,
  972.        "Usage: (map-extents FUNCTION BUFFER FROM TO MAPARG) \n\
  973. Map FUNCTION over the extents which overlap region in BUFFER starting at\n\
  974.  FROM and ending at TO.  FUNCTION is called with arguments (extent, MAPARG).\n\
  975. All arguments except FUNCTION are optional, with FROM, TO, MAPARG, and\n\
  976.  BUFFER defaulting to the beginning of BUFFER, the end of BUFFER, NIL, and\n\
  977.  current buffer, respectively.\n\
  978. If the function returns non-nil, then map-extents returns immediately.\n\
  979. map-extents always returns nil.")
  980.   (function, buffer, from, to, maparg, closed_end)
  981.   Lisp_Object function, buffer, from, to, maparg, closed_end;
  982. {
  983.   elisp_emf map_funct;
  984.   int closed;
  985.   
  986.   if (!NILP (closed_end))
  987.     closed = 1;
  988.   else 
  989.     closed = 0;
  990.  
  991.   if (NILP (buffer)) XSET (buffer, Lisp_Buffer, current_buffer);
  992.   CHECK_BUFFER (buffer, 0);
  993.   
  994.  
  995.   if (NILP (from)) XSET (from, Lisp_Int, BUF_BEG (XBUFFER (buffer)));
  996.   if (NILP (to)) XSET (to, Lisp_Int, BUF_Z (XBUFFER (buffer)));
  997.   CHECK_FIXNUM (from, 1);
  998.   CHECK_FIXNUM (to, 2);
  999.   check_from_to (XINT(from), XINT(to), (XBUFFER (buffer)));
  1000.   if (XINT(from) > XINT (to))
  1001.     error ("MAP-EXTENTS args FROM (== %d) and TO (== %d) are inconsistent.",
  1002.            XINT (from), XINT (to));
  1003.   
  1004.   if (SUBRP (function))
  1005.     {
  1006.       map_funct = (elisp_emf) XSUBR (function)->function;
  1007.       map_extents (XINT (from), XINT (to), map_funct, 0,
  1008.                    (void *)maparg, XBUFFER(buffer), closed);
  1009.     }
  1010.   else
  1011.     {
  1012.       struct slow_map_extents_arg sma_space;
  1013.       sma_space.map_arg = maparg;
  1014.       sma_space.map_routine = function;
  1015.       map_funct = slow_map_extents_function;
  1016.       map_extents 
  1017.         (XINT (from), XINT (to), map_funct, 0, (void *) &sma_space, 
  1018.          XBUFFER(buffer), closed);
  1019.     }
  1020.   
  1021.   return Qnil;
  1022. }
  1023.  
  1024.  
  1025. /*********************************
  1026.   EXTENTS.C GRAPHICAL DISPLAY
  1027.   *******************************/
  1028. static int
  1029. extent_highlightable_p (Lisp_Object extent_obj)
  1030. {
  1031.  return (EXTENTP (extent_obj) && 
  1032.          (EXTENT_FLAGS (XEXTENT (extent_obj)) & EF_HIGHLIGHT));
  1033. }
  1034.  
  1035. /* The display code looks into the Vlast_highlighted_extent variable to 
  1036.    correctly display highlighted extents. NOTE: When we have extents
  1037.    that are either open or closed at either end, we will need to
  1038.    figure out the endpoints of the call to redisplay_no_change() 
  1039.    accordingly. */
  1040. static Lisp_Object
  1041. do_highlight (Lisp_Object extent_obj, int flag)
  1042. {
  1043.   if (((Vlast_highlighted_extent == extent_obj) && !NILP(flag)) ||
  1044.       (NILP (Vlast_highlighted_extent) && NILP (flag)))
  1045.     return Qnil;
  1046.   else
  1047.     {
  1048.       Lisp_Object old_parent = 
  1049.         (EXTENTP (Vlast_highlighted_extent))?
  1050.           (XEXTENT(Vlast_highlighted_extent)->buffer):Qnil;
  1051.       Lisp_Object new_parent = 
  1052.         (EXTENTP (extent_obj))?(XEXTENT(extent_obj)->buffer):Qnil;
  1053.  
  1054.       if (BUFFERP (old_parent))
  1055.         {
  1056.           Vlast_highlighted_extent = Qnil;
  1057.           BUF_FACECHANGE (XBUFFER (old_parent))++;
  1058.           windows_or_buffers_changed++;
  1059.         }
  1060.  
  1061.       if ((BUFFERP (new_parent)) &&
  1062.           !NILP (flag))
  1063.         {
  1064.           Vlast_highlighted_extent = extent_obj;
  1065.           BUF_FACECHANGE (XBUFFER (new_parent))++;
  1066.           windows_or_buffers_changed++;
  1067.         }
  1068.       else
  1069.         Vlast_highlighted_extent = Qnil;
  1070.     }
  1071.   return Qnil;
  1072. }
  1073.  
  1074. DEFUN ("highlight-extent", Fhighlight_extent, Shighlight_extent, 1, 2, 0,
  1075.  "If EXTENT is `highlightable' (has the 'highlight property) then highlight\n\
  1076. it (by using merging it with 'highlight face.)  If FLAG is nil, then\n\
  1077. unhighlight it instead.")
  1078.      (extent_obj, flag)
  1079.      Lisp_Object extent_obj, flag;
  1080. {
  1081.   if (NILP (extent_obj))
  1082.     return do_highlight (Qnil, Qnil);
  1083.   else if (!extent_highlightable_p (extent_obj))
  1084.     return Qnil;
  1085.   else
  1086.     return do_highlight (extent_obj, flag);
  1087. }
  1088.  
  1089.  
  1090. DEFUN ("force-highlight-extent", Fforce_highlight_extent, 
  1091.        Sforce_highlight_extent, 1, 2, 0,
  1092.  "Highlight any EXTENT if FLAG is not nil, else unhighlight it.\n\
  1093. This is the same as `highlight-extent', except that it will work even\n\
  1094. on extents without the 'highlight property.")
  1095.      (extent_obj, flag)
  1096.      Lisp_Object extent_obj, flag;
  1097. {
  1098.   if (NILP (extent_obj))
  1099.     return do_highlight (Qnil, Qnil);
  1100.   else if (!EXTENTP (extent_obj))
  1101.     return Qnil;
  1102.   else
  1103.     return do_highlight (extent_obj, flag);
  1104. }
  1105.  
  1106.  
  1107. /*********************************
  1108.   EXTENTS.C DATATYPE FUNCTIONS
  1109.   *******************************/
  1110.  
  1111. GLYPH
  1112. extent_glyph_at (EXTENT extent, int pos, int endp)
  1113. {
  1114.   if (! extent)
  1115.     return 0;
  1116.   else if (! BUFFERP (extent->buffer))
  1117.     return 0;
  1118.   else if (endp && pos == (extent_endpoint (extent, 1) - 1))
  1119.     return extent->end_glyph;
  1120.   else if (!endp && pos == extent_endpoint (extent, 0))
  1121.     return extent->begin_glyph;
  1122.   else
  1123.     return 0;
  1124. }
  1125.  
  1126. DEFUN ("extent-start-position", Fextent_start_position, 
  1127.        Sextent_start_position, 1, 1, 0,
  1128.        "Return start position of EXTENT.")
  1129.      (extent_obj)
  1130.      Lisp_Object extent_obj;
  1131. {
  1132.   CHECK_EXTENT (extent_obj, 0);
  1133.   return make_number (extent_endpoint (XEXTENT(extent_obj), 0));
  1134. }
  1135.  
  1136.  
  1137. DEFUN ("extent-end-position", Fextent_end_position, 
  1138.        Sextent_end_position, 1, 1, 0,
  1139.        "Return first position after EXTENT.")
  1140.      (extent_obj)
  1141.      Lisp_Object extent_obj;
  1142. {
  1143.   CHECK_EXTENT (extent_obj, 0);
  1144.   return make_number (extent_endpoint (XEXTENT(extent_obj), 1));
  1145. }
  1146.  
  1147. DEFUN ("extent-length", Fextent_length, Sextent_length, 1, 1, 0,
  1148.        "Return length of EXTENT in characters.")
  1149.      (extent_obj)
  1150.      Lisp_Object extent_obj;
  1151. {
  1152.   CHECK_EXTENT (extent_obj, 0);
  1153.   return make_number (extent_endpoint (XEXTENT(extent_obj), 1) - 
  1154.                       extent_endpoint (XEXTENT(extent_obj), 0));
  1155. }
  1156.  
  1157. DEFUN ("extent-buffer", Fextent_buffer, Sextent_buffer, 1, 1, 0,
  1158.        "Return buffer of EXTENT.")
  1159.      (extent_obj)
  1160.      Lisp_Object extent_obj;
  1161. {
  1162.   CHECK_EXTENT (extent_obj, 0);
  1163.   return (XEXTENT(extent_obj)->buffer);
  1164. }
  1165.  
  1166.  
  1167. #ifdef ENERGIZE 
  1168.  
  1169. DEFUN ("extent-to-generic-id", Fextent_to_generic_id, Sextent_to_generic_id,
  1170.        1, 1, 0, "Return Energize ID of buffer of EXTENT.")
  1171.      (extent_obj)
  1172.      Lisp_Object extent_obj;
  1173. {
  1174.   unsigned long gid;
  1175.   extern Lisp_Object word_to_lisp ();
  1176.   CHECK_EXTENT (extent_obj, 0);
  1177.   gid = extent_to_generic_id (extent_obj);
  1178.   return word_to_lisp (gid);
  1179. }
  1180.  
  1181. #endif
  1182.  
  1183.  
  1184. /*********************************
  1185.   EXTENTS.C FLAGS INFO
  1186.   *******************************/
  1187.  
  1188. /* Does this extent have a lineinfo-column glyph */   
  1189. int
  1190. glyph_in_column_p (Lisp_Object extent_obj)
  1191. {
  1192.   CHECK_EXTENT (extent_obj, 0);
  1193.   return !!(EXTENT_FLAGS(XEXTENT(extent_obj)) & EF_COLUMN);
  1194. }
  1195.  
  1196. /* This is the only place `PT' is an lvalue in all of emacs. */
  1197.  
  1198. static void
  1199. set_point_internal (charno)
  1200.      int charno;
  1201. {
  1202.   point = charno;
  1203.   if (charno > GPT)
  1204.     charno += GAP_SIZE;
  1205.   XMARKER (current_buffer->point_marker)->bufpos = charno;
  1206. }
  1207.  
  1208. void
  1209. set_point (position)
  1210.      int position;
  1211. {
  1212.   int opoint = point;
  1213.  
  1214.   if (position == opoint)
  1215.     return;
  1216.   else if (position > Z)
  1217.     abort();
  1218.  
  1219.   if (position > ZV || position < BEGV)
  1220.     abort ();
  1221.  
  1222.   set_point_internal (position);
  1223.  
  1224.   if (!current_buffer->extents)
  1225.     abort();
  1226.  
  1227.   /* NOTE: We used to run "class hooks" at this point, and we
  1228.      will want to run extent hooks here in the future, both for
  1229.      point-entered and point-exited. */
  1230. }
  1231.  
  1232. void
  1233. set_buffer_point (buffer, position)
  1234.      struct buffer *buffer;
  1235.      int position;
  1236. {
  1237.   if (buffer == current_buffer)
  1238.     set_point (position);
  1239.   else
  1240.     {
  1241.       int count = specpdl_depth;
  1242.       record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
  1243.       internal_set_buffer (buffer);
  1244.       set_point (position);
  1245.       unbind_to (count, Qnil);
  1246.     }
  1247. }
  1248.  
  1249. /* Don't have invisible extents at the moment */
  1250. int
  1251. last_visible_position (int opoint, struct buffer *buf)
  1252. {
  1253.   return opoint;
  1254. }
  1255.  
  1256. static int
  1257. extent_at_mf (EXTENT extent, void *arg)
  1258. {
  1259.   struct extent_at_struct *eas_ptr = (struct extent_at_struct *) arg;
  1260.  
  1261.   if ((eas_ptr->flag == 0) || (EXTENT_FLAGS (extent) & eas_ptr->flag))
  1262.     {
  1263.       EXTENT current = eas_ptr->best_match;
  1264.  
  1265.       if (!current)
  1266.         eas_ptr->best_match = extent;
  1267.       else if (current->start > extent->start)
  1268.         return 0;
  1269.       /* we return the "last" best fit, instead of the first --
  1270.      this is because then the glyph closest to two equivalent
  1271.      extents corresponds to the "extent-at" the text just past
  1272.      that same glyph */
  1273.       else if (EXTENT_LESS_EQ (current, extent))
  1274.         eas_ptr->best_match = extent;
  1275.     }
  1276.  
  1277.   return 0;
  1278. }
  1279.  
  1280. /* find "smallest" matching extent containing pos -- (flag == 0) means 
  1281.    all extents match, else (EXTENT_FLAGS (extent) & flag) must be true;
  1282.    for more than one matching extent with precisely the same endpoints,
  1283.    we choose the last extent in the extents_list */
  1284. EXTENT
  1285. extent_at (int pos, struct buffer *buf, int flag)
  1286. {
  1287.   if (NILP (buf->extents))
  1288.     return 0;
  1289.   else if (!EXTENTP (buf->extents))
  1290.     abort();
  1291.   else
  1292.     {
  1293.       struct extent_at_struct eas;
  1294.       eas.best_match = 0;
  1295.       eas.flag = flag;
  1296.       
  1297.       map_extents (pos, pos, 0, extent_at_mf, (void *) &eas, buf, 1);
  1298.       return eas.best_match;
  1299.     }
  1300. }
  1301.  
  1302. DEFUN ("make-extent", Fmake_extent, Smake_extent, 2, 3, 0,
  1303.        "Make extent for range [FROM, TO) in BUFFER -- BUFFER defaults to \n\
  1304. current buffer.  Insertions at point TO will be outside of the extent;\n\
  1305. insertions at FROM will be inside the extent (and the extent will grow.)")
  1306.   (from, to, buffer)
  1307.    Lisp_Object from, to, buffer;
  1308. {
  1309.   Lisp_Object extent_obj;
  1310.   CHECK_FIXNUM (from, 0);
  1311.   CHECK_FIXNUM (to, 0);
  1312.   if (NILP (buffer))
  1313.     XSET (buffer, Lisp_Buffer, current_buffer);
  1314.   CHECK_BUFFER (buffer, 0);
  1315.   extent_obj = make_extent_internal (XINT(from), XINT(to), buffer, 0);
  1316.   return extent_obj;
  1317. }
  1318.  
  1319. DEFUN ("delete-extent", Fdelete_extent, Sdelete_extent, 1, 1, 0,
  1320.  "Remove EXTENT from its buffer; this does not modify the buffer's text,\n\
  1321. only its display properties.")
  1322.   (extent_obj)
  1323.    Lisp_Object extent_obj;
  1324. {
  1325.   EXTENT extent;
  1326.  
  1327.   CHECK_EXTENT (extent_obj, 0);
  1328.   extent = XEXTENT (extent_obj);
  1329.  
  1330.   if (NILP (XBUFFER (extent->buffer)->name))
  1331.     error ("Deleting extent in killed buffer");
  1332.  
  1333.   BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  1334.   windows_or_buffers_changed++;
  1335.   destroy_extent (extent);
  1336.   return Qnil;
  1337. }
  1338.  
  1339. DEFUN ("update-extent", Fupdate_extent, Supdate_extent, 3, 3, 0,
  1340.        "Set the endpoints of EXTENT to START, END.")
  1341.   (extent_obj, start, end)
  1342.    Lisp_Object extent_obj, start, end;
  1343. {
  1344.   EXTENT extent = XEXTENT (extent_obj);
  1345.   int from = XINT (start);
  1346.   int to = XINT (end);
  1347.  
  1348.   CHECK_EXTENT (extent_obj, 0);
  1349.   CHECK_FIXNUM (start, 1);
  1350.   CHECK_FIXNUM (end, 2);
  1351.  
  1352.   if (!BUFFERP (extent->buffer)
  1353.       || NILP (XBUFFER (extent->buffer)->name))
  1354.     error ("EXTENT arg to UPDATE-EXTENT doesn't belong to a buffer");
  1355.  
  1356.   check_from_to (from, to, XBUFFER (extent->buffer));
  1357.       
  1358.   if (from > to)
  1359.     error ("Bad START (== %d) and END (== %d) args to UPDATE-EXTENT", from, to);
  1360.  
  1361.   detach_extent (extent);
  1362.   extent->start = buffer_pos_to_extent_index (from, XBUFFER (extent->buffer));
  1363.   extent->end = buffer_pos_to_extent_index (to, XBUFFER (extent->buffer));
  1364.   splice_extent_into_buffer (extent, extent->buffer);
  1365.  
  1366.   BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  1367.   windows_or_buffers_changed++;
  1368.  
  1369.   return extent_obj;
  1370. }
  1371.  
  1372.  
  1373. DEFUN ("set-extent-attribute", Fset_extent_attribute, 
  1374.        Sset_extent_attribute, 2, 2, 0,
  1375.  "Make EXTENT have ATTRIBUTE.\n\
  1376. ATTRIBUTE must be one of the following symbols:\n\
  1377. \n\
  1378.     highlight        highlight when the mouse moves over it\n\
  1379.     write-protected    text within this extent will be unmodifyable\n\
  1380.     invisible        don't display the text in this region\n\
  1381.     unhighlight        turn off `highlight'\n\
  1382.     writable        turn off `write-protected'\n\
  1383.     visible        turn off `invisible'")
  1384.   (extent_obj, attr)
  1385.    Lisp_Object extent_obj, attr;
  1386. {
  1387.   EXTENT extent = XEXTENT (extent_obj);
  1388.  
  1389.   CHECK_EXTENT (extent_obj, 0);
  1390.   
  1391.   if (!BUFFERP (extent->buffer)
  1392.       || NILP (XBUFFER (extent->buffer)->name))
  1393.     error ("EXTENT arg to SET-EXTENT-ATTRIBUTE doesn't belong to a buffer");
  1394.  
  1395.   if (FIXNUMP (attr))
  1396.     {
  1397.       int attr_num = XINT (attr);
  1398.       if (attr_num < 0)
  1399.         attr_num = -1;
  1400.       else if (attr_num >= GA_MAX) 
  1401.         attr_num = GA_NO_CHANGE;
  1402.       extent->attr_index = attr_num;
  1403.     }
  1404.   else if (SYMBOLP (attr))
  1405.     {
  1406.       if (EQ (intern ("highlight"), attr))
  1407.         { SET_EXTENT_FLAG (extent, EF_HIGHLIGHT); }
  1408.       else if (EQ (intern ("unhighlight"), attr))
  1409.         { CLEAR_EXTENT_FLAG (extent, EF_HIGHLIGHT); }
  1410.       else if (EQ (intern ("write-protected"), attr))
  1411.         { SET_EXTENT_FLAG (extent, EF_WRITE_PROTECT); }
  1412.       else if (EQ (intern ("writable"), attr))
  1413.         { CLEAR_EXTENT_FLAG (extent, EF_WRITE_PROTECT); }
  1414.       else if (EQ (intern ("invisible"), attr))
  1415.         { SET_EXTENT_FLAG (extent, EF_INVISIBLE); }
  1416.       else if (EQ (intern ("visible"), attr))
  1417.         { CLEAR_EXTENT_FLAG (extent, EF_INVISIBLE); }
  1418.       else if (EQ (intern ("duplicable"), attr))
  1419.         { SET_EXTENT_FLAG (extent, EF_DUPLICABLE); }
  1420.       else if (EQ (intern ("non-duplicable"), attr))
  1421.         { CLEAR_EXTENT_FLAG (extent, EF_DUPLICABLE); }
  1422.       else
  1423.         error ("Unknown attribute argument, %s, to set-extent-attribute.", 
  1424.                SYMNAME (attr));
  1425.     }
  1426.   else
  1427.     error ("Unknown type of attribute argument to SET-EXTENT-ATTRIBUTE.");
  1428.  
  1429.   BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  1430.   windows_or_buffers_changed++;
  1431.  
  1432.   return extent_obj;
  1433. }
  1434.  
  1435.  
  1436. DEFUN ("extent-attributes", Fextent_attributes, Sextent_attributes, 1, 2, 0,
  1437.  "Return a list of attributes of EXTENT.\n\
  1438. This list may contain any or none of the following symbols:\n\
  1439. \n\
  1440.     highlight        highlight when the mouse moves over it\n\
  1441.     write-protected    text within this extent will be unmodifyable\n\
  1442.     invisible        don't display the text in this region\n\
  1443.     begin-glyph        there is a begin-glyph\n\
  1444.     end-glyph        there is an end-glyph\n\
  1445.     detached        the text around the extent has been deleted\
  1446. ")
  1447.   (extent_obj, raw_p)
  1448.    Lisp_Object extent_obj, raw_p;
  1449. {
  1450.   Lisp_Object result = Qnil;
  1451.   EXTENT extent = XEXTENT (extent_obj);
  1452.   CHECK_EXTENT (extent_obj, 0);
  1453.  
  1454.   if (!NILP (raw_p))
  1455.     return make_number (extent->attr_index);
  1456.  
  1457.   if (EXTENT_FLAG_P (extent, EF_HIGHLIGHT))
  1458.     result = Fcons (intern ("highlight"), result);
  1459.   if (EXTENT_FLAG_P (extent, EF_WRITE_PROTECT))
  1460.     result = Fcons (intern ("write-protected"), result);
  1461.   if (EXTENT_FLAG_P (extent, EF_INVISIBLE))
  1462.     result = Fcons (intern ("invisible"), result);
  1463.   if (EXTENT_FLAG_P (extent, EF_START_GLYPH))
  1464.     result = Fcons (intern ("begin-glyph"), result);
  1465.   if (EXTENT_FLAG_P (extent, EF_END_GLYPH))
  1466.     result = Fcons (intern ("end-glyph"), result);
  1467.   if (EXTENT_FLAG_P (extent, EF_MENU))
  1468.     result = Fcons (intern ("menu"), result);
  1469.   if (EXTENT_FLAG_P (extent, EF_START_OPEN))
  1470.     result = Fcons (intern ("start-open"), result);
  1471.   if (EXTENT_FLAG_P (extent, EF_END_OPEN))
  1472.     result = Fcons (intern ("end-open"), result);
  1473.   if (EXTENT_FLAG_P (extent, EF_COLUMN))
  1474.     result = Fcons (intern ("column"), result);
  1475.   if (EXTENT_FLAG_P (extent, EF_DETACHED))
  1476.     result = Fcons (intern ("detached"), result);
  1477.   if (EXTENT_FLAG_P (extent, EF_WARN_MODIFY))
  1478.     result = Fcons (intern ("warn-modify"), result);
  1479.   if (!EXTENT_FLAG_P (extent, EF_DUPLICABLE))
  1480.     result = Fcons (intern ("non-duplicable"), result);
  1481.   return result;
  1482. }
  1483.  
  1484.  
  1485. extern struct x_pixmap *x_get_pixmap (Lisp_Object, char *hash_suffix);
  1486.  
  1487. static void
  1488. set_extent_glyph_1 (Lisp_Object extent_obj, Lisp_Object glyph, int endp)
  1489. {
  1490.   int change_p;
  1491.   int which = (endp ? EF_END_GLYPH : EF_START_GLYPH);
  1492.   EXTENT extent = XEXTENT (extent_obj);
  1493.   CHECK_EXTENT (extent_obj, 0);
  1494.   
  1495.   if (!BUFFERP (extent->buffer)
  1496.       || NILP (XBUFFER (extent->buffer)->name))
  1497.     error ("extent doesn't belong to a buffer");
  1498.  
  1499.   if (NILP (glyph))
  1500.     {
  1501.       change_p = !EXTENT_FLAG_P (extent, which);
  1502.       CLEAR_EXTENT_FLAG (extent, which);
  1503.       if (endp)
  1504.     extent->end_glyph = 0;
  1505.       else
  1506.     extent->begin_glyph = 0;
  1507.     }
  1508.   else
  1509.     {
  1510.       struct x_pixmap *p;
  1511.       CHECK_STRING (glyph, 0);
  1512.       p = x_get_pixmap (glyph, 0);
  1513.       change_p = (!EXTENT_FLAG_P (extent, which) ||
  1514.           extent->begin_glyph != p->glyph_id);
  1515.       SET_EXTENT_FLAG (extent, which);
  1516.       if (endp)
  1517.     extent->end_glyph = p->glyph_id;
  1518.       else
  1519.     extent->begin_glyph = p->glyph_id;
  1520.     }
  1521.   if (change_p)
  1522.     {
  1523.       BUF_FACECHANGE (XBUFFER (extent->buffer))++;
  1524.       windows_or_buffers_changed++;
  1525.     }
  1526. }
  1527.  
  1528. DEFUN ("set-extent-begin-glyph", Fset_extent_begin_glyph, 
  1529.        Sset_extent_begin_glyph, 2, 2, 0,
  1530.  "Display a bitmap at the beginning of the given extent.\n\
  1531. The begin-glyph should be a string naming a bitmap file (or nil.)")
  1532.   (extent_obj, begin_glyph)
  1533.    Lisp_Object extent_obj, begin_glyph;
  1534. {
  1535.   set_extent_glyph_1 (extent_obj, begin_glyph, 0);
  1536.   return extent_obj;
  1537. }
  1538.  
  1539.  
  1540. DEFUN ("set-extent-end-glyph", Fset_extent_end_glyph, 
  1541.        Sset_extent_end_glyph, 2, 2, 0,
  1542.  "Display a bitmap at the end of the given extent.\n\
  1543. The end-glyph should be a string naming a bitmap file (or nil.)")
  1544.   (extent_obj, end_glyph)
  1545.    Lisp_Object extent_obj, end_glyph;
  1546. {
  1547.   set_extent_glyph_1 (extent_obj, end_glyph, 1);
  1548.   return extent_obj;
  1549. }
  1550.  
  1551.  
  1552. DEFUN ("extent-data", Fextent_data, Sextent_data, 1, 1, 0,
  1553.  "Return the user data associated with the given extent.\n\
  1554. Set this using the `set-extent-data' function.")
  1555.     (extent)
  1556.     Lisp_Object extent;
  1557. {
  1558.   CHECK_EXTENT (extent, 0);
  1559.   return XEXTENT (extent)->user_data;
  1560. }
  1561.  
  1562. DEFUN ("set-extent-data", Fset_extent_data, Sset_extent_data, 2, 2, 0,
  1563.  "Set the user data slot of the given extent.\n\
  1564. Access this using the `extent-data' function.")
  1565.     (extent, data)
  1566.     Lisp_Object extent, data;
  1567. {
  1568.   CHECK_EXTENT (extent, 0);
  1569. #ifdef ENERGIZE
  1570.   if (energize_extent_data (XEXTENT (extent)))
  1571.     error ("thou shalt not change the user-data of Energize extents");
  1572. #endif
  1573.   XEXTENT (extent)->user_data = data;
  1574.   return data;
  1575. }
  1576.  
  1577. DEFUN ("extent-priority", Fextent_priority, Sextent_priority, 1, 1, 0,
  1578.   "Returns the display priority of EXTENT; see `set-extent-priority'.")
  1579.      (extent)
  1580.      Lisp_Object extent;
  1581. {
  1582.   CHECK_EXTENT (extent, 0);
  1583.   return make_number (XEXTENT (extent)->priority);
  1584. }
  1585.  
  1586. DEFUN ("set-extent-priority", Fset_extent_priority, Sset_extent_priority,
  1587.        2, 2, 0,
  1588.   "Changes the display priority of EXTENT.\n\
  1589. When the extent attributes are being merged for display, the priority\n\
  1590. is used to determine which extent takes precedence in the event of a\n\
  1591. conflict (two extents whose faces both specify font, for example: the\n\
  1592. font of the extent with the higher priority will be used.)\n\
  1593. Extents are created with priority 0; priorities may be negative.")
  1594.     (extent, pri)
  1595.     Lisp_Object extent, pri;
  1596. {
  1597.   int p;
  1598.   CHECK_EXTENT (extent, 0);
  1599.   CHECK_FIXNUM (pri, 0);
  1600.   p = XINT (pri);
  1601.   if (p < -0x8000 || p > 0x7fff)    /* must fit in a short */
  1602.     error ("extent priority out of range");
  1603.   XEXTENT (extent)->priority = p;
  1604.   return pri;
  1605. }
  1606.  
  1607. DEFUN ("extent-at", Fextent_at, Sextent_at, 1, 3, 0,
  1608.        "Find \"smallest\" extent at POS in BUFFER having FLAG set.  BUFFER\n\
  1609. defaults to the current buffer, FLAG defaults to nil, meaning that any\n\
  1610. extent will do. Possible values for FLAG are nil, 'menu, 'highlight,\n\
  1611. 'invisible, and 'write-protected. Returns nil if there is no matching\n\
  1612. extent at POS.")
  1613.   (pos, buffer, flag)
  1614.    Lisp_Object pos, buffer, flag;
  1615. {
  1616.   int position;
  1617.   int flag_to_check = 0;
  1618.   Lisp_Object extent_obj = Qnil;
  1619.   EXTENT extent;
  1620.  
  1621.   if (NILP (buffer))
  1622.     XSET (buffer, Lisp_Buffer, current_buffer);
  1623.  
  1624.   CHECK_FIXNUM_COERCE_MARKER (pos, 0);
  1625.   CHECK_BUFFER (buffer, 1);
  1626.   position = XINT (pos);
  1627.   check_from_to (position, position, XBUFFER (buffer));
  1628.  
  1629.   if (!NILP (flag))
  1630.     {
  1631.       CHECK_SYMBOL (flag, 2);
  1632.  
  1633.       if (EQ (intern ("menu"), flag))
  1634.         flag_to_check = EF_MENU;
  1635.       else if (EQ (intern ("highlight"), flag))
  1636.         flag_to_check = EF_HIGHLIGHT;
  1637.       else if (EQ (intern ("write-protected"), flag))
  1638.         flag_to_check = EF_WRITE_PROTECT;
  1639.       else if (EQ (intern ("start-glyph"), flag))
  1640.         flag_to_check = EF_START_GLYPH;
  1641.       else if (EQ (intern ("end-glyph"), flag))
  1642.         flag_to_check = EF_END_GLYPH;
  1643.       else if (EQ (intern ("invisible"), flag))
  1644.         flag_to_check = EF_INVISIBLE;
  1645.       else if (EQ (intern ("duplicable"), flag))
  1646.         flag_to_check = EF_DUPLICABLE;
  1647.       else
  1648.         error ("%s is unknown flag argument for extent-at", SYMNAME (flag));
  1649.     }
  1650.  
  1651.   if (extent = extent_at (position, XBUFFER (buffer), flag_to_check))
  1652.     XSET (extent_obj, Lisp_Extent, extent);
  1653.  
  1654.   return extent_obj;
  1655. }
  1656.  
  1657. DEFUN ("next-extent", Fnext_extent, Snext_extent, 1, 1, 0,
  1658.        "Find next extent after EXTENT. If EXTENT is a buffer\n\
  1659. return the first extent in the buffer.")
  1660.   (extent_obj)
  1661.    Lisp_Object extent_obj;
  1662. {
  1663.   if (BUFFERP (extent_obj))
  1664.     return XBUFFER (extent_obj)->extents;
  1665.   else if (EXTENTP (extent_obj))
  1666.     {
  1667.       Lisp_Object return_val = Qnil;
  1668.       EXTENT next = XEXTENT(extent_obj)->next;
  1669.  
  1670.       if (next == XEXTENT (extent_obj)) abort ();
  1671.       if (next)
  1672.         XSET (return_val, Lisp_Extent, next);
  1673.       return return_val;
  1674.     }
  1675.   else
  1676.     return Qnil;
  1677. }
  1678.  
  1679. #if 0
  1680.  
  1681. /* There are 2 total orders on extents in a buffer -- the normal
  1682.    (or "display") order, and the "e-order". This returns the
  1683.    "next extent" in the e-ordering.  This might be a temporary function
  1684.    or it might be permanent. */
  1685.  
  1686. DEFUN ("next-e-extent", Fnext_e_extent, Snext_e_extent, 1, 1, 0,
  1687.        "Find next extent after EXTENT using the \"e\" order. If \n\
  1688. EXTENT is a buffer, return the first extent in the buffer.")
  1689.   (extent_obj)
  1690.    Lisp_Object extent_obj;
  1691. {
  1692.   if (BUFFERP (extent_obj))
  1693.     {
  1694.       Lisp_Object return_val;
  1695.       EXTENT tmp;
  1696.  
  1697.       if (EXTENTP (XBUFFER (extent_obj)->extents))
  1698.         tmp = XEXTENT (XBUFFER (extent_obj)->extents);
  1699.       else
  1700.         return Qnil;
  1701.  
  1702.       while (tmp->e_previous)
  1703.         tmp = tmp->e_previous;
  1704.  
  1705.       XSET (return_val, Lisp_Extent, tmp);
  1706.       return return_val;
  1707.     }
  1708.   else if (EXTENTP (extent_obj))
  1709.     {
  1710.       Lisp_Object return_val = Qnil;
  1711.       EXTENT next = XEXTENT(extent_obj)->e_next;
  1712.  
  1713.       if (next)
  1714.         XSET (return_val, Lisp_Extent, next);
  1715.       return return_val;
  1716.     }
  1717.   else
  1718.     return Qnil;
  1719. }
  1720.  
  1721.  
  1722. /* Purportedly temporary debugging function -- turns a stack of
  1723.    extents into something that can be looked at in elisp. For
  1724.    a detailed explanation of a stack of extents, see below. */
  1725.  
  1726. static Lisp_Object
  1727. soe_to_lisp (struct stack_of_extents *soe, struct buffer *buf)
  1728. {
  1729.   if (!soe || 
  1730.       (soe->buf_index <= 0))
  1731.     return Qnil;
  1732.   else
  1733.     {
  1734.       Lisp_Object struct_vec = Fmake_vector (make_number (6), 
  1735.                                              make_number (0));
  1736.       Lisp_Object *struct_v = &(XVECTOR (struct_vec)->contents[0]);
  1737.       Lisp_Object stack_vec = Fmake_vector (make_number (soe->stack_index),
  1738.                                             make_number (0));
  1739.       Lisp_Object *stack_v = &(XVECTOR (stack_vec)->contents[0]);
  1740.  
  1741.       struct_v[0] = intern (":PRIOR-EXTENT");
  1742.       if (soe->previous_extent)
  1743.         XSET(struct_v[1], Lisp_Extent, soe->previous_extent);
  1744.       else
  1745.         struct_v[1] = Qnil;
  1746.     
  1747.       struct_v[2] = intern (":BUFFER-POS");
  1748.       XSET(struct_v[3], Lisp_Int, 
  1749.            extent_index_to_buffer_pos (soe->buf_index, buf));
  1750.     
  1751.       struct_v[4] = intern (":STACK");
  1752.       struct_v[5] = stack_vec;
  1753.  
  1754.       {
  1755.         int i;
  1756.       
  1757.         for (i = 0; i < soe->stack_index; i++)
  1758.           {
  1759.             EXTENT tmp = soe->stack[i];
  1760.  
  1761.             if (tmp)
  1762.               {
  1763.                 XSET(stack_v[i], Lisp_Extent, tmp);
  1764.               }
  1765.             else 
  1766.               stack_v[i] = Qnil;
  1767.           }
  1768.       }
  1769.  
  1770.       return struct_vec;
  1771.     }
  1772. }
  1773.  
  1774. /* Elisp interface for debugging stacks of extents */
  1775. DEFUN ("stack-of-extents", Fstack_of_extents, 
  1776.        Sstack_of_extents, 1, 2, 0,
  1777.        "Return stack of extents for BUFFER. Optional arg POSITION supplied\n\
  1778. means compute the correct stack of extents for POSITION in BUFFER.")
  1779.   (buffer, position)
  1780.    Lisp_Object buffer, position;
  1781. {
  1782.   Lisp_Object return_value = Qnil;
  1783.   struct stack_of_extents *soe;
  1784.   struct buffer *buf = XBUFFER (buffer);
  1785.   CHECK_BUFFER (buffer, 0);
  1786.   if (!NILP (position))
  1787.     {
  1788.       struct stack_of_extents *tmp = buf->cached_stack;
  1789.       int pos;
  1790.       CHECK_FIXNUM (position, 1);
  1791.       pos = XINT (position);
  1792.       if ((pos < BUF_BEG(buf)) || (BUF_Z (buf) < pos))
  1793.         error ("Bad position %d for buffer %s", pos, BUFNAME (buf));
  1794.       
  1795.       buf->cached_stack = 0;
  1796.       init_buffer_cached_stack (buf);
  1797.       befa_internal (pos, buf);
  1798.       soe = buf->cached_stack;
  1799.       buf->cached_stack = tmp;
  1800.     }
  1801.   else
  1802.     soe = buf->cached_stack;
  1803.       
  1804.   if (!soe)
  1805.     return Qnil;
  1806.   else
  1807.     return_value = soe_to_lisp (soe, buf);
  1808.   
  1809.   if (soe && (soe != buf->cached_stack))
  1810.     {
  1811.       EXTENT *tmp_stack = soe->stack;
  1812.       soe->stack = 0;
  1813.       if (tmp_stack)
  1814.         free (tmp_stack);
  1815.       free (soe);
  1816.     }
  1817.  
  1818.   return return_value;
  1819. }
  1820.  
  1821. #endif
  1822.  
  1823. /* Debugging and test function -- maybe permanent. */
  1824. /* Return 0 if stack is correct, 1 if stack has been cleared (which
  1825.    is not incorrect but isn't good news), and -1 if it is provably
  1826.    incorrect. */
  1827. #if 0
  1828. int verify_buffer_stack (struct buffer *buf)
  1829. {
  1830.   struct stack_of_extents *soe;
  1831.  
  1832.   if (!buf)
  1833.     buf = current_buffer;
  1834.  
  1835.   soe = buf->cached_stack;
  1836.  
  1837.   if (!soe)
  1838.     {
  1839.       if (EXTENTP (buf->extents))
  1840.         return -1;
  1841.       else if (buf->extents == Qnil)
  1842.         return 0;
  1843.       else
  1844.         abort ();
  1845.     }
  1846.   else if (soe->buf_index <= 0)
  1847.     return 1;
  1848.   else
  1849.     {
  1850.       int pos = extent_index_to_buffer_pos (soe->buf_index, buf);
  1851.       int return_value;
  1852.       buf->cached_stack = 0;
  1853.       init_buffer_cached_stack (buf);
  1854.       befa_internal (pos, buf);
  1855.       
  1856.       return_value = memcmp ((char *) soe, (char *) buf->cached_stack,
  1857.                  sizeof (*soe));
  1858.       if (!return_value)
  1859.         return_value = 
  1860.           memcmp ((char *) soe->stack, (char *) buf->cached_stack->stack, 
  1861.           soe->stack_index * sizeof (EXTENT));
  1862.       if (return_value)
  1863.         return_value = -1;
  1864.       free_buffer_cached_stack (buf);
  1865.       buf->cached_stack = soe;
  1866.       return return_value;
  1867.     }
  1868. }
  1869. #endif
  1870.  
  1871. /* Long comment: 
  1872.  
  1873.    A "Stack Of Extents" (abbreviated SOE) is a data structure that is
  1874.    an abbreviated version of an extent_fragment.  However, unlike the
  1875.    extent_fragment, of which there are really only 2, which are used
  1876.    by redisplay, and which are supposed to be FAST to manage, every
  1877.    buffer with extents has an SOE, these are supposed to be robust,
  1878.    and they don't have to be that fast to manage. What an SOE does is
  1879.    cache the information needed to try to find, given a buffer index
  1880.    I, some extent E which is "before" I in the display order (meaning
  1881.    that E doesn't include I, and any extent E' that does include I is
  1882.    "greater than" E in the display order). The purpose of this is to
  1883.    make functions like Fextent_at() and buffer_extent_fragment_at() be
  1884.    as fast at the bottom of a buffer as they are at the top, no matter
  1885.    how many extents the buffer has. (We may want to consider having
  1886.    detach_extent() and splice_extent_into_buffer() update the SOE,
  1887.    too, so that updating extents will be faster and adding extents "in
  1888.    order" will be as fast as adding them in "reverse order" is.)
  1889.  
  1890.    The two orderings of extents in a buffer, normal (or display) order
  1891.    and e-order, are defined by macros at the top of the file.
  1892.    Basically, though, normal order sorts by increasing start index and
  1893.    e-order by increasing end index.
  1894.  
  1895.    The components of an SOE are the buffer index, the vector of
  1896.    extents (in display order) that lie over that index, and the
  1897.    "previous extent", which is the last extent in the e-order whose
  1898.    end index is <= the given buffer index and which is NOT over the
  1899.    buffer index (if the extent has 0 length, it will be over the index
  1900.    if the start and end values equal the index).
  1901.  
  1902.    An SOE is "cleared" or invalidated iff the buffer index value is <=
  1903.    0, since this is never a legal buffer index -- this clearing is
  1904.    done by soe_clear(), and is called any time the SOE can't get
  1905.    updated properly. 
  1906.  
  1907.    Each time an extent is spliced into the buffer, an attempt is made
  1908.    to "push" it onto the SOE (which means that we examine the new
  1909.    extent to see if it goes over that buffer index or if it should
  1910.    replace the previous extent).  When an extent is detached, we
  1911.    similarly attempt to delq it from the SOE.
  1912.  
  1913.    Any call to the function befa_internal() changes the SOE to use the
  1914.    new buffer index via soe_duplicate(). The function
  1915.    process_extents_for_deletion() may change the endpoints of extents,
  1916.    of adjust the buffer index, so it calls soe_prune(). This function
  1917.    removes any extents that are not over the buffer index, and
  1918.    corrects the previous extent value.
  1919.  
  1920.    There are also init and free functions for the SOE, called by
  1921.    splice_extent_into_buffer() and Fkill_buffer, respectively.
  1922.  
  1923.  
  1924.  
  1925.    Finally, what's the point of all of this? The point is that given
  1926.    an index I, the set S of extents over I, and the previous extent P,
  1927.    it is possible to compute an extent before an index I' (before in
  1928.    the display order). If I' >= I, this is just P (which can be easily
  1929.    recomputed from S[0] if S exists and P does not -- see
  1930.    soe_prune()).  If I' < I, then consider the interval [E, P] of
  1931.    extents in the e-order such that E is the first extent with end
  1932.    index less than I'. Then the minimum (in the normal order) E' of
  1933.    these extents is either strictly before I' or is the "top of the
  1934.    stack at" I', and in the latter case, E'->previous is before I'.
  1935.  
  1936.    The proof is left as an exercise for the readers.
  1937.  */
  1938.  
  1939. static void soe_push (EXTENT extent, struct buffer *b)
  1940. {
  1941.   struct stack_of_extents *soe = b->cached_stack;
  1942.   if (soe)
  1943.     {
  1944.       int index = soe->buf_index;
  1945.       int on_stack = 0;
  1946.  
  1947.       if (index <= 0)
  1948.     {
  1949.       soe_clear(b);
  1950.       return;
  1951.     }
  1952.       else if (EXTENT_OVER_INDEX (extent, index))
  1953.     on_stack = 1;
  1954.  
  1955.       if (on_stack)
  1956.     {
  1957.       if (soe->stack_index == soe->stack_length)
  1958.         {
  1959.           soe->stack_length *= 2;
  1960.           soe->stack = 
  1961.         (EXTENT*)xrealloc (soe->stack, 
  1962.                    soe->stack_length * sizeof (EXTENT));
  1963.         }
  1964.  
  1965.       if (soe->stack_index == 0)
  1966.         {
  1967.           soe->stack[0] = extent;
  1968.           soe->stack_index = 1;
  1969.         }
  1970.       else
  1971.         {
  1972.           EXTENT *cef, *cef_bound, *cef_copy, *cef_put_here;
  1973.  
  1974.           /* make sure that this guy isn't in the stack already */
  1975.           soe_delq (extent, b);
  1976.       
  1977.           cef = soe->stack;
  1978.           cef_copy = cef;
  1979.           cef_bound = cef + soe->stack_index;
  1980.           cef_put_here = cef_bound;
  1981.  
  1982.           while (cef < cef_bound)
  1983.         {
  1984.           if (EXTENT_LESS (extent, *cef))
  1985.             {
  1986.               cef_put_here = cef;
  1987.               break;
  1988.             }
  1989.           cef++;
  1990.         }
  1991.   
  1992.           cef = cef_bound;
  1993.           while (cef > cef_put_here)
  1994.         {
  1995.           *cef = *(cef - 1);
  1996.           cef--;
  1997.         }
  1998.           *cef_put_here = extent;
  1999.           soe->stack_index++;
  2000.         }
  2001.     }
  2002.       else if (extent->end < index)
  2003.     {
  2004.       EXTENT prev = soe->previous_extent;
  2005.       if (!prev || EXTENT_E_LESS (prev, extent))
  2006.         soe->previous_extent = extent;
  2007.     }
  2008.     }
  2009. }
  2010.  
  2011. static void soe_duplicate (int index, EXTENT *copy_from, int copy_from_size, 
  2012.                EXTENT trial_prev, struct buffer *b)
  2013. {
  2014.   struct stack_of_extents *soe = b->cached_stack;
  2015.  
  2016.   if (!soe)
  2017.     return;
  2018.  
  2019.   if (copy_from_size > 0)
  2020.     {
  2021.       if (soe->stack_length < copy_from_size)
  2022.     {
  2023.       soe->stack_length = copy_from_size + 1;
  2024.       soe->stack = 
  2025.             (EXTENT*)xrealloc (soe->stack, 
  2026.                                soe->stack_length * sizeof (EXTENT));
  2027.     }
  2028.       memcpy ((char *) soe->stack, (char *) copy_from,
  2029.           copy_from_size * sizeof (EXTENT));
  2030.  
  2031.       trial_prev = soe->stack[0];
  2032.     }
  2033.   
  2034.   soe->stack_index = copy_from_size;
  2035.   soe->buf_index = index;
  2036.  
  2037.   if (!trial_prev || !EXTENT_PAST_INDEX (trial_prev, index))
  2038.     trial_prev = 0;
  2039.  
  2040.   while (trial_prev && EXTENT_PAST_INDEX (trial_prev, index))
  2041.     trial_prev = trial_prev->e_previous;
  2042.  
  2043.   if (!trial_prev)
  2044.     soe_clear(b);
  2045.   else
  2046.     soe->previous_extent = trial_prev;
  2047. }
  2048.  
  2049.  
  2050. static void
  2051. soe_delq (EXTENT extent, struct buffer *b)
  2052. {
  2053.   struct stack_of_extents *soe = b->cached_stack;
  2054.   if (soe)
  2055.     {
  2056.       EXTENT* cef = soe->stack;
  2057.       EXTENT* cef_copy = cef;
  2058.       EXTENT* cef_bound = cef + soe->stack_index;
  2059.       int found = 0;
  2060.  
  2061.       while (cef < cef_bound)
  2062.     {
  2063.       if (extent == *cef)
  2064.         {
  2065.           *cef = 0;
  2066.           found++;
  2067.         }
  2068.       cef++;
  2069.     }
  2070.   
  2071.       if (found > 0)
  2072.     {
  2073.       cef = cef_copy; 
  2074.       while (cef < cef_bound)
  2075.         {
  2076.           if (*cef)
  2077.         {
  2078.           *cef_copy = *cef;
  2079.           cef_copy++;
  2080.         }
  2081.           cef++;
  2082.         }
  2083.  
  2084.       soe->stack_index = cef_copy - soe->stack;
  2085.     }
  2086.  
  2087.       if (extent == soe->previous_extent)
  2088.     soe->previous_extent = extent->e_previous;
  2089.     }
  2090. }
  2091.  
  2092. void 
  2093. init_buffer_cached_stack (struct buffer *b)
  2094. {
  2095.   if (!b->cached_stack)
  2096.     {
  2097.       int default_stack_size = 10;
  2098.       struct stack_of_extents *new =
  2099.         (struct stack_of_extents *) 
  2100.           xmalloc (sizeof (struct stack_of_extents));
  2101.       memset ((char *) new, 0, sizeof (struct stack_of_extents));
  2102.       new->stack_length = default_stack_size;
  2103.       new->stack = (EXTENT *) xmalloc (default_stack_size * sizeof (EXTENT));
  2104.       b->cached_stack = new;
  2105.     }
  2106. }
  2107.  
  2108. static void
  2109. soe_clear (struct buffer *b)
  2110. {
  2111.   struct stack_of_extents *soe = b->cached_stack;
  2112.   if (soe)
  2113.     {
  2114.       soe->stack_index = 0;
  2115.       soe->buf_index = 0;
  2116.       soe->previous_extent = 0;
  2117.     }
  2118. }
  2119.  
  2120. static void
  2121. soe_prune (struct buffer *b)
  2122. {
  2123.   struct stack_of_extents *soe = b->cached_stack;
  2124.  
  2125.   if (!soe)
  2126.     return;
  2127.   
  2128.   if (soe->buf_index <= 0)
  2129.     {
  2130.       soe_clear(b);
  2131.       return;
  2132.     }
  2133.   else
  2134.     {
  2135.       EXTENT* cef = soe->stack;
  2136.       EXTENT* cef_copy = cef;
  2137.       EXTENT* cef_bound = cef + soe->stack_index;
  2138.       int index = soe->buf_index;
  2139.       int removedp = 0;
  2140.  
  2141.       while (cef < cef_bound)
  2142.     {
  2143.       EXTENT extent = *cef;
  2144.       if (!EXTENT_OVER_INDEX (extent, index))
  2145.         {
  2146.           *cef = 0;
  2147.           removedp = 1;
  2148.         }
  2149.       cef++;
  2150.     }
  2151.   
  2152.       if (removedp)
  2153.     {
  2154.       cef = cef_copy; 
  2155.       while (cef < cef_bound)
  2156.         {
  2157.           if (*cef)
  2158.         {
  2159.           *cef_copy = *cef;
  2160.           cef_copy++;
  2161.         }
  2162.           cef++;
  2163.         }
  2164.  
  2165.       soe->stack_index = cef_copy - soe->stack;
  2166.     }
  2167.     }
  2168.  
  2169.   {
  2170.     EXTENT prev;
  2171.     int index = soe->buf_index;
  2172.  
  2173.     if (soe->stack_index > 0)
  2174.       prev = soe->stack[0];
  2175.     else
  2176.       prev = soe->previous_extent;
  2177.  
  2178.     while (prev && EXTENT_PAST_INDEX (prev, index))
  2179.       prev = prev->e_previous;
  2180.     if (prev)
  2181.       soe->previous_extent = prev;
  2182.     else
  2183.       soe_clear (b);
  2184.   }
  2185. }
  2186.  
  2187. void
  2188. free_buffer_cached_stack (struct buffer *b)
  2189. {
  2190.   struct stack_of_extents *tmp = b->cached_stack;
  2191.   b->cached_stack = 0;
  2192.   if (tmp)
  2193.     {
  2194.       EXTENT *tmp_stack = tmp->stack;
  2195.       tmp->stack = 0;
  2196.       if (tmp_stack)
  2197.         xfree (tmp_stack);
  2198.       xfree (tmp);
  2199.     }
  2200. }
  2201.  
  2202. /* This function assumes that ef is correct and up to date, and then
  2203.    ef->start_index is incremented and ef->first_extent_past_stack is either
  2204.    0'd or certified correct, and then this function is called. This
  2205.    function removes all extents from the extents_stack that are "too small"
  2206.    (the only way the can be invalid here, since if they were "too big" now,
  2207.    then they would have been "too big" when ef->start_index was smaller).
  2208.    In particular, ef->extents_stack will be correct unless there are 
  2209.    "bigger extents" than those in the stack that remain to be pushed on it.
  2210.    
  2211.    At the same time, it sets ef->end_index to be the minimum of all of the
  2212.    end indicies of the extents left in the stack, if any, and the
  2213.    start_index of ef->first_extent_past_stack, if that exists. If none of
  2214.    these exist, the ef->end_index is set to be the max index of the buffer.
  2215.    This value of ef->end_index is at least as large as the correct value
  2216.    for ef->buffer and given ef->start_index, and it is correct if the
  2217.    extents_stack is complete and the value of ef->first_extent_past_stack
  2218.    passed in is correct. */
  2219.    
  2220. static void
  2221. cleanup_old_stack (EXTENT_FRAGMENT ef)
  2222. {
  2223.   EXTENT* cef = ef->extents_stack;
  2224.   EXTENT* cef_copy = cef;
  2225.   EXTENT* cef_bound = cef + ef->number_of_extents;
  2226.   int new_start = ef->start_index;
  2227.   int min_for_end = 
  2228.     (ef->first_extent_past_stack)?
  2229.       (ef->first_extent_past_stack->start):MAX_INT;
  2230.  
  2231.   while (cef < cef_bound)
  2232.     {
  2233.       int end = (*cef)->end;
  2234.       int start = (*cef)->start;
  2235.    
  2236.       /* flush any extent ending too soon, which includes any extent ending
  2237.          before this point or any extent of positive length ending AT this
  2238.          point */
  2239.       if ((end < new_start) ||
  2240.           ((end == new_start) && (start < end)))
  2241.     *cef = 0;
  2242.       /* if the extent wasn't flushed and is of positive length,
  2243.          then if it ends before our min so far, use this as the
  2244.          new min */
  2245.       else if ((end < min_for_end) && (start < end))
  2246.     min_for_end = end;
  2247.       cef++;
  2248.     }
  2249.   
  2250.     cef = cef_copy; 
  2251.     while (cef < cef_bound)
  2252.     {
  2253.       if (*cef)
  2254.     {
  2255.           *cef_copy = *cef;
  2256.           cef_copy++;
  2257.     }
  2258.       cef++;
  2259.     }
  2260.  
  2261.   ef->end_index = min_for_end;
  2262.   ef->number_of_extents = cef_copy - ef->extents_stack;
  2263. }
  2264.  
  2265. /* Long comment:
  2266.    
  2267.    This function updates the cached ef to "surround" the new buf_index 
  2268.    that is promised to be == the current ef->end_index. The on
  2269.  
  2270.    Extents are ordered with increasing start position and then decreasing
  2271.    end position. (This is what might be called "display order" -- if extent
  2272.    A occurs after extent B, then the display attributes of extent A
  2273.    override those of extent B in the region covered by both A and B. Note
  2274.    that multiple extents with the same start and end postions may be in any
  2275.    order.)
  2276.  
  2277.    The extents_stack has the extents that are "over" a given buffer
  2278.    index in the same order as in the buffer's extent list. The state
  2279.    coming in might look like this:
  2280.  
  2281.  
  2282.    extents_stack |
  2283.                  v
  2284.  
  2285.    [.......................................)
  2286.    [............................)
  2287.        [...........................)
  2288.        [.....................)
  2289.             [...........................)
  2290.                              |  <<-------  buf_index required to be this
  2291.             [________________)  <<-------  fragment boundaries
  2292.  
  2293.                                                     first_extent_past_stack |
  2294.                                                                             v
  2295.                                                     [........................)
  2296.  
  2297.                              [__)  new fragment boundaries
  2298.    
  2299.    If there is no first_extent_past_stack, then we just prune the 
  2300.    extents_stack as described below, and if there are no extents over
  2301.    the buf_index, the new fragment goes from buf_index to the end of
  2302.    the buffer. 
  2303.    
  2304.    Otherwise, the first_extent_past_stack is guaranteed to have its
  2305.    start index be >= buf_index of the fragment.
  2306.  
  2307.    If the first_extent_past_stack start is > buf_index, then the
  2308.    first_extent_past_stack will still be the same after the update.  In
  2309.    that case all that is needed is to update the extents_stack by deleting
  2310.    anything that "fell off the end", set the new start_index to the
  2311.    buf_index and compute the new end_index. (In the special case where
  2312.    there is one extent in the extents_stack, this calculation is easy,
  2313.    since that means that the new stack is empty and the new end_index for
  2314.    the fragment is next->start. If the extents_stack is empty, then
  2315.    the caller of this function is broken and we abort().)
  2316.  
  2317.    The remaining case is when the first_extent_past_stack starts at
  2318.    buf_index. If there are extents in the stack, then we need to remove all
  2319.    of the ones that have fallen off the end.  After that
  2320.    first_extent_past_stack gets pushed, and we look for any other extents
  2321.    that need pushing. While we are doing this, we need to figure out where
  2322.    the new fragment ends, and what the new first_extent_past_stack is. (We
  2323.    could consider optimizing the case of their being one extent in the
  2324.    stack
  2325.  
  2326.  
  2327.    NOTE: At the moment only this function, buffer_extent_fragment_at(),
  2328.    splice_extent_into_buffer(), adjust_extents () and map_extents() 
  2329.    know how to "cdr" down a list of extents. */
  2330.  
  2331. static EXTENT_FRAGMENT
  2332. update_cache_forward (EXTENT_FRAGMENT ef, int buf_index, struct buffer* buf)
  2333. {
  2334.   /* Incrementally update the cache forward.  This has to be FAST. */
  2335.   EXTENT next = ef->first_extent_past_stack;
  2336.  
  2337.   ef->start_index = buf_index;
  2338.  
  2339.   if (!next)
  2340.     {
  2341.       /* ef->first_extent_past_stack is correct here, because there
  2342.          isn't any */
  2343.       if (ef->number_of_extents == 1)
  2344.         {
  2345.           /* easy case for updating stack */
  2346.           ef->number_of_extents = 0;   
  2347.       ef->end_index = MAX_INT;
  2348.         }
  2349.       else if (ef->number_of_extents == 0)
  2350.         abort();
  2351.       else
  2352.         /* this will fix ef->end_index, since ef->first_extent_past_stack
  2353.            is correctly 0 and there are no more extents to add to the stack */
  2354.         cleanup_old_stack (ef);
  2355.    
  2356.       /* the stack, ef->start_index, and ef->end_index are all
  2357.          correct, so just wrap_up */   
  2358.       goto wrap_up;
  2359.     }
  2360.   else if (buf_index < next->start)
  2361.     {
  2362.       /* ef->first_extent_past_stack is correct here, because it  won't
  2363.          change as the result of this operation */
  2364.       if (ef->number_of_extents == 1)
  2365.         {
  2366.           /* easy case for updating stack -- moving into a "hole" between
  2367.              extents */
  2368.           ef->number_of_extents = 0;
  2369.           ef->end_index = next->start;
  2370.         }
  2371.       else if (ef->number_of_extents == 0)
  2372.         abort();
  2373.       else
  2374.         /* the stack will add nothing new, because
  2375.            ef->first_extent_past_stack is too big to go on the stack, and
  2376.            so it is correct, too -- this means that call will set
  2377.            ef->end_index to be == correct value; see comment for
  2378.            cleanup_old_stack() */
  2379.         cleanup_old_stack (ef);
  2380.  
  2381.       /* the stack, ef->start_index, and ef->end_index are all
  2382.          correct, so just wrap_up */   
  2383.       goto wrap_up;   
  2384.     }
  2385.   else if (ef->number_of_extents > 0)
  2386.     {
  2387.       /* ef->first_extent_past_stack wrong here, because it is next,
  2388.          and next is going onto the stack -- the stack is wrong, too */
  2389.       ef->first_extent_past_stack = 0;
  2390.       /* this will set ef->end_index to be >= correct value; see
  2391.          comment for function */
  2392.       cleanup_old_stack (ef);
  2393.     }
  2394.   else 
  2395.     /* stack is empty so needs no pruning, and we know that next->end
  2396.        is at least as big as the fragment end_index */
  2397.     ef->end_index = next->end;
  2398.  
  2399.   /* If we get to this point, ef->start_index is correct,
  2400.      ef->end_index is >= the correct value, and
  2401.      ef->first_extent_past_stack is completely wrong */
  2402.  
  2403.   {
  2404.     /* retain last extent to be pushed on the stack */
  2405.     EXTENT last;
  2406.     do
  2407.       {
  2408.         if (ef->number_of_extents == ef->extents_stack_length)
  2409.           {
  2410.             ef->extents_stack_length *= 2;
  2411.             ef->extents_stack =
  2412.               (EXTENT*)xrealloc (ef->extents_stack,
  2413.                                  ef->extents_stack_length * sizeof (EXTENT));
  2414.           }
  2415.         ef->extents_stack [ef->number_of_extents] = next;
  2416.         ef->number_of_extents += 1;
  2417.  
  2418.         last = next;
  2419.         next = next->next;
  2420.     if (next == last) abort ();
  2421.     if (next && next->previous != last) abort ();
  2422.       }
  2423.     while (next && (next->start == buf_index));
  2424.  
  2425.     /* make sure that ef->end_index is correct, since we may have
  2426.        come into this function with a value that is too big -- 
  2427.        recall that since the end values of the extents are
  2428.        decreasing while the start value stay the same, last->end
  2429.        has the smallest "end" of all things pushed onto the stack */
  2430.     if (last->end < ef->end_index)
  2431.       ef->end_index = last->end;
  2432.     if (next &&
  2433.         (next->start < ef->end_index))
  2434.       ef->end_index = next->start;
  2435.   }
  2436.   ef->first_extent_past_stack = next;
  2437.  
  2438.  wrap_up:
  2439.   ef->from = extent_index_to_buffer_pos (ef->start_index, buf);
  2440.   ef->to = 
  2441.     ((ef->end_index == MAX_INT)?MAX_INT:
  2442.      extent_index_to_buffer_pos (ef->end_index, buf));
  2443.   return ef;
  2444. }
  2445.  
  2446.  
  2447. /* Find extent fragment at pos in buf. NOTE: At the moment only this
  2448.    function, update_cache_forward(), splice_extent_into_buffer(), 
  2449.    adjust_extents () and map_extents() 
  2450.    know how to "cdr" down a list of extents. See the comment
  2451.    at map_extents() for information about the ordering rule. */
  2452.  
  2453. static EXTENT_FRAGMENT
  2454. befa_internal (int pos, struct buffer *buf)
  2455. {
  2456.   EXTENT_FRAGMENT ef;
  2457.   EXTENT current;
  2458.   EXTENT trial_prev = 0;
  2459.   int buf_index;
  2460.   int new_start;
  2461.   int new_end;
  2462.  
  2463.   buf_index = buffer_pos_to_extent_index (pos, buf);
  2464.   ef = &extent_fragment;
  2465.  
  2466.   current = buffer_starting_extent (buf_index, buf);
  2467.   
  2468.   new_start = buffer_pos_to_extent_index (BUF_BEG(buf), buf);
  2469.   new_end = MAX_INT;
  2470.   ef->number_of_extents = 0;
  2471.  
  2472.   /* Find all of the extents "over" this fragment, and at the same time
  2473.      find the "first_extent_past_stack" for the fragment and the 
  2474.      start_index. */
  2475.   while (current && 
  2476.          (current->start <= buf_index))
  2477.     {
  2478.       trial_prev = current;
  2479.  
  2480.       if ((current->end <= buf_index) && (current->end > new_start))
  2481.         {
  2482.           new_start = current->end;
  2483.         }
  2484.       /* we repeat some code in this clause and the next to save tests */
  2485.       else if (current->end > buf_index)
  2486.     {
  2487.           if (current->start > new_start)
  2488.             new_start = current->start;   
  2489.           if (current->end < new_end)
  2490.             new_end = current->end;
  2491.  
  2492.       if (ef->number_of_extents == ef->extents_stack_length)
  2493.         {
  2494.           ef->extents_stack_length *= 2;
  2495.           ef->extents_stack =
  2496.         (EXTENT*)xrealloc (ef->extents_stack,
  2497.                    ef->extents_stack_length * sizeof (EXTENT));
  2498.         }
  2499.       ef->extents_stack [ef->number_of_extents] = current;
  2500.       ef->number_of_extents += 1;
  2501.     }
  2502.       /* we repeat some code in this clause and the last to save tests */   
  2503.       else if ((current->end == current->start) && (current->end == buf_index))
  2504.     {
  2505.           new_end = new_start = buf_index;
  2506.  
  2507.       if (ef->number_of_extents == ef->extents_stack_length)
  2508.         {
  2509.           ef->extents_stack_length *= 2;
  2510.           ef->extents_stack =
  2511.         (EXTENT*)xrealloc (ef->extents_stack,
  2512.                    ef->extents_stack_length * sizeof (EXTENT));
  2513.         }
  2514.       ef->extents_stack [ef->number_of_extents] = current;
  2515.       ef->number_of_extents += 1;
  2516.     }
  2517.         
  2518.       if (current == current->next) abort ();
  2519.       current = current->next;
  2520.     }
  2521.  
  2522.   /* Check the end_index for this fragment. */
  2523.   if (current && 
  2524.       (current->start < new_end))
  2525.     new_end = current->start;
  2526.   
  2527.   XSET (Vextent_fragment_buffer, Lisp_Buffer, buf);
  2528.   ef->buf = buf;
  2529.   ef->modiff = BUF_MODIFF (buf);
  2530.   ef->face_change = BUF_FACECHANGE (buf);
  2531.   ef->first_extent_past_stack = current;
  2532.   ef->start_index = new_start;
  2533.   ef->end_index = new_end;
  2534.   ef->from = extent_index_to_buffer_pos (new_start, buf);
  2535.   ef->to = 
  2536.     (new_end == MAX_INT)?MAX_INT:extent_index_to_buffer_pos (new_end, buf);
  2537.  
  2538.   soe_duplicate (buf_index, ef->extents_stack, 
  2539.                  ef->number_of_extents, trial_prev, buf);
  2540.  
  2541.   return ef;
  2542. }
  2543.  
  2544. EXTENT_FRAGMENT
  2545. buffer_extent_fragment_at (int pos, struct buffer *buf, struct screen *s)
  2546. {
  2547.   int cache_valid;
  2548.   EXTENT_FRAGMENT ef;
  2549.   int buf_index;
  2550.  
  2551.   if (NILP (buf->extents))
  2552.     {
  2553.       Vextent_fragment_buffer = Qnil;
  2554.       extent_fragment.buf = 0;
  2555.       default_extent_fragment.from = BUF_BEG (buf);
  2556.       default_extent_fragment.to = MAX_INT;
  2557.       return &default_extent_fragment;
  2558.     }
  2559.   else if (!EXTENTP (buf->extents))
  2560.     abort ();
  2561.  
  2562.   buf_index = buffer_pos_to_extent_index (pos, buf);
  2563.   ef = &extent_fragment;
  2564.   cache_valid = (!extent_cache_invalid &&
  2565.          (buf == ef->buf) && 
  2566.                  (BUF_MODIFF(buf) == ef->modiff) &&
  2567.          (BUF_FACECHANGE (buf) == ef->face_change));
  2568.  
  2569.   if (cache_valid)
  2570.     {
  2571.       if (buf_index == ef->end_index)
  2572.     ef = update_cache_forward (ef, buf_index, buf); /* 99% of the time */
  2573.       else if ((pos >= extent_fragment.from) && (pos < extent_fragment.to))
  2574.     return ef;
  2575.       else 
  2576.     ef = befa_internal (pos, buf);
  2577.     }
  2578.   else 
  2579.     ef = befa_internal (pos, buf);
  2580.  
  2581.   setup_extent_fragment_face_ptr (s, ef);
  2582.   extent_cache_invalid = 0;
  2583.   return ef;
  2584. }
  2585.  
  2586. static void
  2587. init_extent_fragment ()
  2588. {
  2589.   int l = 30;
  2590.  
  2591.   memset ((char *) &extent_fragment, 0, sizeof (extent_fragment));
  2592.   extent_fragment.extents_stack_length = l;
  2593.   extent_fragment.extents_stack = (EXTENT *) xmalloc (l * sizeof (EXTENT));
  2594.  
  2595.   memset ((char *) &default_extent_fragment, 0,
  2596.       sizeof (default_extent_fragment));
  2597.   extent_cache_invalid = 1;
  2598. }
  2599.  
  2600. /* Modify all of the extents as required for the insertion. At the
  2601.    moment this function does nothing, but eventually it probably should
  2602.    adjust the endpoints of the extents that touch point in a manner that
  2603.    takes the the opened/closed property of the endpoint into account. */
  2604. void 
  2605. process_extents_for_insertion (int opoint, int length, struct buffer *buf)
  2606. {
  2607.   return;
  2608. }
  2609.    
  2610. static int   
  2611. process_extents_for_deletion_mf (EXTENT extent, void *arg)
  2612. {
  2613.   struct process_extents_for_deletion_struct *peds_ptr = 
  2614.     (struct process_extents_for_deletion_struct *) arg;
  2615.   
  2616.   if ((peds_ptr->start <= extent->start) && (extent->end <= peds_ptr->end))
  2617.     {
  2618.       if (peds_ptr->destroy_included_extents)
  2619.         destroy_extent (extent);
  2620.       else
  2621.         detach_extent (extent);
  2622.     }
  2623.   else if (peds_ptr->destroy_included_extents)
  2624.     return 0;
  2625.   /* the extent completely contains the deleted range, so we don't need to
  2626.      do anything about it */
  2627.   else if ((extent->start < peds_ptr->start) && (peds_ptr->end < extent->end))
  2628.     return 0;
  2629.   else
  2630.     /* these characters are going away, so the extent must be shortened 
  2631.        appropriately -- this code should probably do something about
  2632.        opened/closed endpoints, too */
  2633.     {
  2634.       int max_start = max (extent->start, peds_ptr->start);
  2635.       int min_end = min (extent->end, peds_ptr->end);
  2636.       /* this test is really unneeded, since map_extents() promises the
  2637.          two "spans of text" will overlap but it's cheap and
  2638.          I'm nervous */
  2639.       if (max_start < min_end)
  2640.         {
  2641.           if (max_start == extent->start)
  2642.             extent->start = min_end;
  2643.           else
  2644.             extent->end = max_start;
  2645.         }
  2646.     }
  2647.   return 0;
  2648. }
  2649.  
  2650. /* Delete all of the extents that are completely inside the range [from,
  2651.    to). Eventually, this function should also adjust the endpoints of the
  2652.    extents that overlap the about to be deleted range in a manner that
  2653.    takes the the opened/closed property of the endpoint into account.
  2654.    NOTE: This function must either preserve the internal ordering of the
  2655.    extents automatically or it must explicitly fix that ordering before
  2656.    quitting. At the moment the ordering is preserved automatically.
  2657.    [from to) is the range of POSITIONs being deleted and [start end) is the
  2658.    INDEX values of the gap when the deletion is completed.
  2659.    */
  2660. void process_extents_for_deletion (int from, int to, int start, int end,
  2661.                    struct buffer *buf)
  2662. {
  2663.   if (NILP (buf->extents))
  2664.     return;
  2665.   else if (!EXTENTP (buf->extents))
  2666.     abort();
  2667.   else
  2668.     {
  2669.       struct process_extents_for_deletion_struct peds;   
  2670.  
  2671.       check_from_to (from, to, buf);
  2672.  
  2673.       /* start and end don't need to be turned into index values because
  2674.          they are already -- from and to are buffer positions */
  2675.       peds.start = start;
  2676.       peds.end = end;
  2677.       peds.destroy_included_extents = 0;
  2678.       /* Need to do a map_extent with closed_end so that the extent
  2679.      just beginning or ending on the old gap are processed too.
  2680.      --Matthieu. */
  2681.       map_extents (from, to, 0, process_extents_for_deletion_mf,
  2682.                    (void *) &peds, buf, 1);
  2683.  
  2684.       if (buf->cached_stack
  2685.       && (buf->cached_stack->buf_index >= start)
  2686.       && (buf->cached_stack->buf_index < end))
  2687.     buf->cached_stack->buf_index = start;
  2688.       soe_prune (buf);
  2689.     }
  2690. }
  2691.  
  2692. void
  2693. process_extents_for_destruction (int from, int to, struct buffer *buf)
  2694. {
  2695.   if (NILP (buf->extents))
  2696.     return;
  2697.   else if (!EXTENTP (buf->extents))
  2698.     abort();
  2699.   else
  2700.     {
  2701.       struct process_extents_for_deletion_struct peds;   
  2702.  
  2703.       check_from_to (from, to, buf);
  2704.  
  2705.       peds.start = buffer_pos_to_extent_index (from, buf);
  2706.       peds.end = buffer_pos_to_extent_index (to, buf);
  2707.       peds.destroy_included_extents = 1;
  2708.       /* Need to do a map_extent with closed_end so that the extent
  2709.          just beginning or ending on the old gap are processed too.
  2710.          --Matthieu. */
  2711.       map_extents (from, to, 0, process_extents_for_deletion_mf,
  2712.                    (void *) &peds, buf, 1);
  2713.     }
  2714. }
  2715.  
  2716.  
  2717. static int
  2718. replicate_extents_mf (EXTENT extent, void *arg)
  2719. {
  2720.   struct replicate_extents_struct *res_ptr = 
  2721.     (struct replicate_extents_struct *) arg;
  2722.   Lisp_Object head = res_ptr->head;
  2723.   Lisp_Object tail = res_ptr->nconc_cell;
  2724.   int start = 
  2725.     extent_index_to_buffer_pos (extent->start, res_ptr->buf) - res_ptr->from;
  2726.   int end = 
  2727.     extent_index_to_buffer_pos (extent->end, res_ptr->buf) - res_ptr->from;
  2728.   
  2729.   if (EXTENT_FLAG_P (extent, EF_DUPLICABLE))
  2730.     {
  2731.       start = max (start, 0);
  2732.       end = min (end, res_ptr->length);
  2733.  
  2734.       /* this test should probably never fail, but I'm a bit confused at the
  2735.      moment */
  2736.       if ((start < end) || 
  2737.       ((start == end) && (extent->start == extent->end)))
  2738.     {
  2739.       Lisp_Object new_cell;   
  2740.       Lisp_Object replica;
  2741.       DUP dup = make_extent_replica ();
  2742.  
  2743.       XSET (replica, Lisp_Extent_Replica, dup);
  2744.       XSET (dup->extent, Lisp_Extent, extent);
  2745.       dup->start = start;
  2746.       dup->end = end;
  2747.       new_cell = Fcons (replica, Qnil);
  2748.    
  2749.       if (NILP (head))
  2750.         res_ptr->head = new_cell;
  2751.       else
  2752.         Fsetcdr (tail, new_cell);
  2753.       res_ptr->nconc_cell = new_cell;
  2754.     }
  2755.     }  
  2756.   return 0;
  2757. }
  2758.  
  2759. Lisp_Object 
  2760. replicate_extents (int opoint, int length, struct buffer *buf)
  2761. {
  2762.   if (NILP (buf->extents))
  2763.     return Qnil;
  2764.   else if (!EXTENTP (buf->extents))
  2765.     abort();
  2766.   else
  2767.     {
  2768.       struct replicate_extents_struct res;
  2769.       res.from = opoint;
  2770.       res.length = length;
  2771.       res.head = Qnil;
  2772.       res.buf = buf;
  2773.       res.nconc_cell = 0;
  2774.       map_extents (opoint, opoint + length, 0, replicate_extents_mf, 
  2775.                    (void *) &res, buf, 0);
  2776.       return res.head;
  2777.     }
  2778. }
  2779.  
  2780. /* We have just inserted a string of size "length" at "opoint" -- we have
  2781.    the contents of the extents slot of the string on hand, and we now need
  2782.    to do "whatever" is necessary to make the extents in the buffer be
  2783.    correctly updated. If there are no extents on the string, then that is
  2784.    nothing. If there are extents and we are inside_undo, then the extents
  2785.    argument is taken as revealed truth and the state of the buffer extents
  2786.    must be restored so that the function above would return the same string
  2787.    extents if this corresponding string were to be deleted. If we are not
  2788.    inside undo then we just splice in those extents that correspond to
  2789.    deleted extents.
  2790.  
  2791.    Note: At the moment we ONLY handle the case of the dup_list argument
  2792.    be a list of extent_replicas.
  2793.    */
  2794.  
  2795. void 
  2796. splice_in_extent_replicas (int opoint, int length, 
  2797.                            Lisp_Object dup_list, struct buffer *buf)
  2798. {
  2799.   if ((!NILP(buf->extents) && (!EXTENTP (buf->extents))) || 
  2800.       (!NILP (dup_list) && (!CONSP (dup_list))))
  2801.     abort();
  2802.   if (NILP (dup_list))   
  2803.     return;
  2804.   else if (inside_undo)
  2805.     {
  2806.       Lisp_Object tail;
  2807.       int base_start = buffer_pos_to_extent_index (opoint, buf);
  2808.       int base_end = buffer_pos_to_extent_index (opoint + length, buf);
  2809.  
  2810.       for (tail = dup_list; !NILP (tail); tail = Fcdr (tail))
  2811.         {
  2812.           Lisp_Object current_replica = Fcar (tail);
  2813.           /* only process replicas at the moment */
  2814.           if (EXTENT_REPLICA_P (current_replica)) 
  2815.             {
  2816.               DUP dup = XDUP (current_replica);
  2817.               EXTENT extent = XEXTENT (dup->extent);
  2818.               int new_start = base_start + dup->start;
  2819.               int new_end = base_start + dup->end;
  2820.  
  2821.               if (EXTENT_DESTROYED_P (extent))
  2822.                 continue;
  2823.  
  2824.               /* paranoid testing which will go away eventually */
  2825.               if ((!EXTENTP (dup->extent)) ||
  2826.                   (XBUFFER (extent->buffer) != buf))
  2827.                 abort ();
  2828.               
  2829.               if (EXTENT_FLAGS (extent) & EF_DETACHED)
  2830.                 {
  2831.                   int from = extent_index_to_buffer_pos (new_start, buf);
  2832.                   int to = extent_index_to_buffer_pos (new_end, buf);
  2833.                   update_extent (extent, from, to, 1, buf);
  2834.                 }
  2835.               else if
  2836.                 ((extent->start > extent_index_offset (base_end, 1, buf)) ||
  2837.                  (extent->end < extent_index_offset (base_start, -1, buf)))
  2838.                 error ("extent 0x%x is all fouled up wrt. dup 0x%x",
  2839.                        extent, dup);
  2840.               else
  2841.                 {
  2842.                   /* this should be safe because if you delete some text
  2843.                      all of the extents that were effected stay in the
  2844.                      same order, so when you restore what was removed
  2845.                      they should still be in the correct order */
  2846.                   extent->start = min (new_start, extent->start);
  2847.                   extent->end = max (new_end, extent->end);
  2848.           soe_push (extent, buf);
  2849.                 }
  2850.             }
  2851.         }
  2852.     }
  2853.   else
  2854.     {
  2855.       Lisp_Object tail;
  2856.       int base_start = buffer_pos_to_extent_index (opoint, buf);
  2857. /*      int base_end = buffer_pos_to_extent_index (opoint + length, buf); */
  2858.  
  2859.       for (tail = dup_list; !NILP (tail); tail = Fcdr (tail))
  2860.         {
  2861.           Lisp_Object current_replica = Fcar (tail);
  2862.           /* only process replicas at the moment */
  2863.           if (EXTENT_REPLICA_P (current_replica)) 
  2864.             {
  2865.               DUP dup = XDUP (current_replica);
  2866.               EXTENT extent = XEXTENT (dup->extent);
  2867.               int new_start = base_start + dup->start;
  2868.               int new_end = base_start + dup->end;
  2869.  
  2870.               if (EXTENT_DESTROYED_P (extent))
  2871.                 continue;
  2872.  
  2873.               /* paranoid testing which will go away eventually */
  2874.               if ((!EXTENTP (dup->extent)))
  2875.                 abort ();
  2876.  
  2877.           /* Energize extents like topleve-forms can only be pasted 
  2878.            * in the buffer they come from.  This should be parametrized
  2879.            * in the generic extent objects.  Right now just silently
  2880.            * skip the extents if it's not from the same buffer.
  2881.            * --Matthieu */
  2882.           if (XBUFFER (extent->buffer) != buf)
  2883.         continue;
  2884.  
  2885.               if (EXTENT_FLAGS (extent) & EF_DETACHED)
  2886.                 {
  2887.                   int from = extent_index_to_buffer_pos (new_start, buf);
  2888.                   int to = extent_index_to_buffer_pos (new_end, buf);
  2889.                   update_extent (extent, from, to, 1, buf);
  2890.                 }
  2891.               else if (extent->end < new_start - 1)
  2892.                 continue;
  2893.               else if (extent->start > new_end + 1)
  2894.                 continue;
  2895.               else
  2896.                 {
  2897.                   int from = 
  2898.                     extent_index_to_buffer_pos 
  2899.                       (min (new_start, extent->start), buf);
  2900.                   int to = 
  2901.                     extent_index_to_buffer_pos 
  2902.                       (max (new_end, extent->end), buf);
  2903.                   update_extent (extent, from, to, 1, buf);   
  2904.                 }
  2905.             }
  2906.         }
  2907.     }
  2908. }
  2909.  
  2910.  
  2911. /* Merge dup_list[i] into a list of replicas -- if a dup
  2912.    in listi "overlaps at the end" matches a dup from listi+1 that "overlaps
  2913.    at the beginning", merge them into one contiguous dup in the returned
  2914.    list. It is weird and probably bogus if a "detached dup" doesn't merge 
  2915.    entirely, but it isn't an error. */
  2916.    
  2917. static void merge_replicas_concating_mf (void *, void *, void *);
  2918. static void merge_replicas_pruning_mf   (void *, void *, void *);
  2919.  
  2920. Lisp_Object 
  2921. merge_replicas (int number_of_lists, struct merge_replicas_struct *vec)
  2922. {
  2923.   c_hashtable table = 0;
  2924.   Lisp_Object cells_vec[2];
  2925.   int i;
  2926.  
  2927.   cells_vec[0] = Qnil;
  2928.   cells_vec[1] = Qnil;
  2929.  
  2930.   for (i = 0; i < number_of_lists; i++)
  2931.     {
  2932.       Lisp_Object dup_list = vec[i].dup_list;
  2933.       int offset = vec[i].entry_offset;
  2934.       int length = vec[i].entry_length;
  2935.  
  2936.       if (!NILP (dup_list))
  2937.         {
  2938.           if (!table)
  2939.             table = make_hashtable (10);
  2940.           add_to_replicas_lists (table, dup_list, offset, length);
  2941.         }
  2942.     }
  2943.  
  2944.   if (table)
  2945.     {
  2946.       maphash (merge_replicas_pruning_mf, table, (void *) table);
  2947.       maphash (merge_replicas_concating_mf, table, (void *) &(cells_vec[0]));
  2948.       free_hashtable (table);
  2949.     }
  2950.   return (cells_vec[0]);
  2951. }
  2952.  
  2953. static void 
  2954. add_to_replicas_lists (c_hashtable table, Lisp_Object dup_list,
  2955.                int offset, int length)
  2956. {
  2957.   Lisp_Object tail;
  2958.   for (tail = dup_list; !NILP (tail); tail = Fcdr(tail))
  2959.     {
  2960.       Lisp_Object current_replica = Fcar (tail);
  2961.       if (EXTENT_REPLICA_P (current_replica)) 
  2962.         {
  2963.           DUP dup = XDUP (current_replica);
  2964.           EXTENT extent = XEXTENT (dup->extent);
  2965.           Lisp_Object pre_existing_cell;
  2966.           Lisp_Object tmp;
  2967.           DUP new_dup;
  2968.  
  2969.           if (EXTENT_DESTROYED_P (extent))
  2970.             continue;
  2971.  
  2972.           new_dup = make_extent_replica ();
  2973.           memcpy ((char *) new_dup, (char *) dup, sizeof (*dup));
  2974.           new_dup->start += offset;
  2975.           new_dup->end += offset;
  2976.    
  2977.           /* paranoid testing which will go away eventually */
  2978.           if (!EXTENTP (dup->extent))
  2979.             abort ();
  2980.               
  2981.           if (!gethash ((void *) extent, table, (void **) &pre_existing_cell))
  2982.             pre_existing_cell = Qnil;
  2983.    
  2984.           XSET (tmp, Lisp_Extent_Replica, new_dup);
  2985.           tmp = Fcons (tmp, pre_existing_cell);
  2986.           puthash ((void *)extent, (void *) tmp, table);
  2987.         }
  2988.     }
  2989. }
  2990.  
  2991. static void 
  2992. merge_replicas_concating_mf (void *key, void *contents, void *arg)
  2993. {
  2994.   extern Lisp_Object nconc2();
  2995.   Lisp_Object extent_cell = (Lisp_Object) contents;
  2996.   Lisp_Object *cells_vec = (Lisp_Object *) arg;
  2997.  
  2998.   if (NILP (cells_vec[0]))
  2999.     cells_vec[0] = extent_cell;
  3000.   else
  3001.     nconc2 (cells_vec[1], extent_cell);
  3002.  
  3003.   cells_vec[1] = extent_cell;
  3004.   return;
  3005. }
  3006.  
  3007. static int 
  3008. mrp_pred (Lisp_Object x, Lisp_Object y, Lisp_Object dummy)
  3009. {
  3010.   DUP dup1 = XDUP(x);
  3011.   DUP dup2 = XDUP(y);
  3012.  
  3013.   if (dup1->start < dup2->start)
  3014.     return 1;
  3015.   else if (dup1->start == dup2->start)
  3016.     {
  3017.       if (dup1->end <= dup2->end)
  3018.         return 1;
  3019.       else
  3020.         return -1;
  3021.     }
  3022.   return -1;
  3023. }
  3024.    
  3025. static void 
  3026. merge_replicas_pruning_mf (void *key, void *contents, void *arg)
  3027. {
  3028.   Lisp_Object dup_list = (Lisp_Object) contents;
  3029.   c_hashtable table = (c_hashtable) arg;
  3030.  
  3031.   if (NILP (dup_list))
  3032.     return;
  3033.    
  3034.   /* sort and merge the dup_list */
  3035.   dup_list = list_sort (dup_list, Qnil, mrp_pred);
  3036.   {
  3037.     Lisp_Object current = dup_list;
  3038.     Lisp_Object tail = Fcdr (dup_list);
  3039.     DUP current_dup = XDUP (Fcar (current));
  3040.     DUP tail_dup = XDUP(Fcar (tail));
  3041.  
  3042.     while (!NILP (tail))
  3043.       {
  3044.         tail_dup = XDUP(Fcar (tail));   
  3045.  
  3046.         if (tail_dup->start <= current_dup->end - 1)
  3047.           {
  3048.             current_dup->end = max (tail_dup->end, current_dup->end);
  3049.             Fsetcdr (current, Fcdr (tail));
  3050.           }
  3051.         else
  3052.           {
  3053.             current = tail;
  3054.             current_dup = XDUP (Fcar (current));
  3055.           }
  3056.    
  3057.         tail = Fcdr (tail);
  3058.       }
  3059.   }
  3060.    
  3061.   /* now put back the munged list */
  3062.   puthash (key, (void *) dup_list, table);
  3063.   return;
  3064. }
  3065.  
  3066.  
  3067. void
  3068. syms_of_extents() 
  3069. {
  3070.   defsubr(&Sextent_length);
  3071.   defsubr(&Sextent_start_position);
  3072.   defsubr(&Sextent_end_position);
  3073.   defsubr(&Sextent_buffer);
  3074. #ifdef ENERGIZE
  3075.   defsubr(&Sextent_to_generic_id);
  3076. #endif
  3077.   defsubr(&Smap_extents);
  3078.   defsubr(&Shighlight_extent);
  3079.   defsubr(&Sforce_highlight_extent);
  3080.   defsubr(&Sextent_at);
  3081.  
  3082.   defsubr(&Smake_extent);
  3083.   defsubr(&Snext_extent);
  3084.   defsubr(&Sdelete_extent);
  3085.   defsubr(&Supdate_extent);
  3086.   defsubr(&Sset_extent_attribute);
  3087.   defsubr(&Sextent_attributes);
  3088.   defsubr(&Sset_extent_begin_glyph);
  3089.   defsubr(&Sset_extent_end_glyph);
  3090.   defsubr(&Sextent_data);
  3091.   defsubr(&Sset_extent_data);
  3092.   defsubr(&Sextent_priority);
  3093.   defsubr(&Sset_extent_priority);
  3094. #if 0
  3095.   defsubr(&Snext_e_extent);
  3096.   defsubr(&Sstack_of_extents);
  3097. #endif
  3098.  
  3099.   Ffset (intern ("set-extent-endpoints"), intern ("update-extent"));
  3100.  
  3101. /*  DEFVAR_LISP ("   last-highlighted-extent", &Vlast_highlighted_extent,
  3102.                "Last highlighted extent; don't touch this kluge.");
  3103. */
  3104.   staticpro (&Vlast_highlighted_extent);
  3105.  
  3106.   Vlast_highlighted_extent = Qnil;
  3107.  
  3108. /*
  3109.   DEFVAR_LISP ("   buffer-of-current-extent-fragment", 
  3110.                &Vextent_fragment_buffer,
  3111.                "Buffer for current extent fragment -- this is a GC hack.");
  3112. */
  3113.   staticpro (&Vextent_fragment_buffer);
  3114.  
  3115.   Vextent_fragment_buffer = Qnil;
  3116.  
  3117.   init_extent_fragment ();
  3118. }
  3119.