xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 272:c5d627a313b1 r21-0b34

Import from CVS: tag r21-0b34

author	cvs
date	Mon, 13 Aug 2007 10:28:48 +0200
parents	157b30c96d03
children	6330739388db

comparison

equal deleted inserted replaced

-:c7b7086b0a39
+:c5d627a313b1
 #include "faces.h"
 #include "frame.h"
 #include "glyphs.h"
 #include "hash.h"
 #include "insdel.h"
+#include "keymap.h"
 #include "opaque.h"
 #include "process.h"
 #include "redisplay.h"
 /* ------------------------------- */
 /* ------------------------------- */
 /*    auxiliary extent structure   */
 /* ------------------------------- */
 struct extent_auxiliary extent_auxiliary_defaults;
-MAC_DEFINE (EXTENT, MTancestor_extent)
-MAC_DEFINE (EXTENT, MTaux_extent)
-MAC_DEFINE (EXTENT, MTplist_extent)
-MAC_DEFINE (EXTENT, MTensure_extent)
-MAC_DEFINE (EXTENT, MTset_extent)
 /* ------------------------------- */
 /*     buffer-extent primitives    */
 /* ------------------------------- */
 Lisp_Object Vextent_face_reverse_memoize_hash_table;
 Lisp_Object Vextent_face_reusable_list;
 /* FSFmacs bogosity */
 Lisp_Object Vdefault_text_properties;
+EXFUN (Fextent_properties, 1);
+EXFUN (Fset_extent_property, 3);
 /************************************************************************/
 /*                       Generalized gap array                          */
 /************************************************************************/
 {
 Gap_Array *ga = endp ? el->end : el->start;
 int left = 0, right = GAP_ARRAY_NUM_ELS (ga);
 int oldfoundpos, foundpos;
 int found;
-EXTENT e;
 while (left != right)
 {
 /* RIGHT might not point to a valid extent (i.e. it's at the end
 	 of the list), so NEWPOS must round down. */
 unsigned int newpos = (left + right) >> 1;
-e = EXTENT_GAP_ARRAY_AT (ga, newpos);
+EXTENT e = EXTENT_GAP_ARRAY_AT (ga, (int) newpos);
 if (endp ? EXTENT_E_LESS (e, extent) : EXTENT_LESS (e, extent))
 	left = newpos+1;
 else
 	right = newpos;
 /* Now we're at the beginning of all equal extents. */
 found = 0;
 oldfoundpos = foundpos = left;
 while (foundpos < GAP_ARRAY_NUM_ELS (ga))
 {
-e = EXTENT_GAP_ARRAY_AT (ga, foundpos);
+EXTENT e = EXTENT_GAP_ARRAY_AT (ga, foundpos);
 if (e == extent)
 	{
 	  found = 1;
 	  break;
 	}
 /************************************************************************/
 /*                       Auxiliary extent structure                     */
 /************************************************************************/
-static Lisp_Object mark_extent_auxiliary (Lisp_Object obj,
-					  void (*markobj) (Lisp_Object));
-DEFINE_LRECORD_IMPLEMENTATION ("extent-auxiliary", extent_auxiliary,
-mark_extent_auxiliary, internal_object_printer,
-			       0, 0, 0, struct extent_auxiliary);
 static Lisp_Object
 mark_extent_auxiliary (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct extent_auxiliary *data = XEXTENT_AUXILIARY (obj);
 ((markobj) (data->begin_glyph));
 ((markobj) (data->mouse_face));
 ((markobj) (data->initial_redisplay_function));
 return data->parent;
 }
+DEFINE_LRECORD_IMPLEMENTATION ("extent-auxiliary", extent_auxiliary,
+mark_extent_auxiliary, internal_object_printer,
+			       0, 0, 0, struct extent_auxiliary);
 void
 allocate_extent_auxiliary (EXTENT ext)
 {
-Lisp_Object extent_aux = Qnil;
+Lisp_Object extent_aux;
 struct extent_auxiliary *data =
 alloc_lcrecord_type (struct extent_auxiliary, lrecord_extent_auxiliary);
 copy_lcrecord (data, &extent_auxiliary_defaults);
 XSETEXTENT_AUXILIARY (extent_aux, data);
 static struct stack_of_extents *allocate_soe (void);
 static void free_soe (struct stack_of_extents *soe);
 static void soe_invalidate (Lisp_Object obj);
-static Lisp_Object mark_extent_info (Lisp_Object obj,
-				     void (*markobj) (Lisp_Object));
-static void finalize_extent_info (void *header, int for_disksave);
-DEFINE_LRECORD_IMPLEMENTATION ("extent-info", extent_info,
-mark_extent_info, internal_object_printer,
-			       finalize_extent_info, 0, 0,
-			       struct extent_info);
 static Lisp_Object
 mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct extent_info *data =
 (struct extent_info *) XEXTENT_INFO (obj);
 if (list)
 {
 for (i = 0; i < extent_list_num_els (list); i++)
 	{
 	  struct extent *extent = extent_list_at (list, i, 0);
-	  Lisp_Object exobj = Qnil;
+	  Lisp_Object exobj;
 	  XSETEXTENT (exobj, extent);
 	  ((markobj) (exobj));
 	}
 }
 free_extent_list (data->extents);
 data->extents = 0;
 }
 }
+DEFINE_LRECORD_IMPLEMENTATION ("extent-info", extent_info,
+mark_extent_info, internal_object_printer,
+			       finalize_extent_info, 0, 0,
+			       struct extent_info);
 static Lisp_Object
 allocate_extent_info (void)
 {
-Lisp_Object extent_info = Qnil;
+Lisp_Object extent_info;
 struct extent_info *data =
 alloc_lcrecord_type (struct extent_info, lrecord_extent_info);
 XSETEXTENT_INFO (extent_info, data);
 data->extents = allocate_extent_list ();
 static Lisp_Object
 decode_buffer_or_string (Lisp_Object object)
 {
 if (NILP (object))
 XSETBUFFER (object, current_buffer);
+else if (BUFFERP (object))
+CHECK_LIVE_BUFFER (object);
+else if (STRINGP (object))
+;
 else
-CHECK_LIVE_BUFFER_OR_STRING (object);
+dead_wrong_type_argument (Qbuffer_or_string_p, object);
 return object;
 }
 EXTENT
 extent_ancestor_1 (EXTENT e)
 e = XEXTENT (XEXTENT_AUXILIARY (XCAR (e->plist))->parent);
 }
 return e;
 }
-/* Given an extent object (string or buffer or nil), return its extent info.  This may be
+/* Given an extent object (string or buffer or nil), return its extent info.
-0 for a string. */
+This may be 0 for a string. */
 static struct extent_info *
 buffer_or_string_extent_info (Lisp_Object object)
 {
 if (STRINGP (object))
 Lisp_Object extent;
 char buf[200];
 XSETEXTENT (extent, e);
 print_extent_1 (buf, extent);
-printf ("%s", buf);
+fputs (buf, stdout);
 }
 static void
 soe_dump (Lisp_Object obj)
 {
 {
 printf (endp ? "SOE end:" : "SOE start:");
 for (i = 0; i < extent_list_num_els (sel); i++)
 	{
 	  EXTENT e = extent_list_at (sel, i, endp);
-	  printf ("\t");
+	  putchar ('\t');
 	  print_extent_2 (e);
 	}
-printf ("\n");
+putchar ('\n');
 }
-printf ("\n");
+putchar ('\n');
 }
 #endif
 /* Insert EXTENT into OBJ's stack of extents, if necessary. */
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents (obj);
 #ifdef SOE_DEBUG
 printf ("Inserting into SOE: ");
 print_extent_2 (extent);
-printf ("\n");
+putchar ('\n');
 #endif
 if (!soe || soe->pos < extent_start (extent) ||
 soe->pos > extent_end (extent))
 {
 #ifdef SOE_DEBUG
 #endif
 return;
 }
 extent_list_insert (soe->extents, extent);
 #ifdef SOE_DEBUG
-printf ("SOE afterwards is:\n");
+puts ("SOE afterwards is:");
 soe_dump (obj);
 #endif
 }
 /* Delete EXTENT from OBJ's stack of extents, if necessary. */
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents (obj);
 #ifdef SOE_DEBUG
 printf ("Deleting from SOE: ");
 print_extent_2 (extent);
-printf ("\n");
+putchar ('\n');
 #endif
 if (!soe || soe->pos < extent_start (extent) ||
 soe->pos > extent_end (extent))
 {
 #ifdef SOE_DEBUG
-printf ("(not needed)\n\n");
+puts ("(not needed)\n");
 #endif
 return;
 }
 extent_list_delete (soe->extents, extent);
 #ifdef SOE_DEBUG
-printf ("SOE afterwards is:\n");
+puts ("SOE afterwards is:");
 soe_dump (obj);
 #endif
 }
 /* Move OBJ's stack of extents to lie over the specified position. */
 endp = 1;
 }
 else
 {
 #ifdef SOE_DEBUG
-printf ("(not needed)\n\n");
+puts ("(not needed)\n");
 #endif
 return;
 }
 /* For DIRECTION = 1: Any extent that overlaps POS is either in the
 }
 }
 soe->pos = pos;
 #ifdef SOE_DEBUG
-printf ("SOE afterwards is:\n");
+puts ("SOE afterwards is:");
 soe_dump (obj);
 #endif
 }
 static void
 if (!NILP (extent_face        (anc)) ||
 !NILP (extent_begin_glyph (anc)) ||
 !NILP (extent_end_glyph   (anc)) ||
 !NILP (extent_mouse_face  (anc)) ||
 !NILP (extent_invisible   (anc)) ||
 !NILP (extent_initial_redisplay_function (anc)) ||
 invisibility_change)
 extent_changed_for_redisplay (extent, descendants_too,
 				  invisibility_change);
 }
 static EXTENT
 extent_next (EXTENT e)
 {
 Extent_List *el = extent_extent_list (e);
 int foundp;
-int pos;
+int pos = extent_list_locate (el, e, 0, &foundp);
-pos = extent_list_locate (el, e, 0, &foundp);
 assert (foundp);
 return real_extent_at_forward (el, pos+1, 0);
 }
 #ifdef DEBUG_XEMACS
 static EXTENT
 extent_e_next (EXTENT e)
 {
 Extent_List *el = extent_extent_list (e);
 int foundp;
-int pos;
+int pos = extent_list_locate (el, e, 1, &foundp);
-pos = extent_list_locate (el, e, 1, &foundp);
 assert (foundp);
 return real_extent_at_forward (el, pos+1, 1);
 }
 #endif
 static EXTENT
 extent_previous (EXTENT e)
 {
 Extent_List *el = extent_extent_list (e);
 int foundp;
-int pos;
+int pos = extent_list_locate (el, e, 0, &foundp);
-pos = extent_list_locate (el, e, 0, &foundp);
 assert (foundp);
 return real_extent_at_backward (el, pos-1, 0);
 }
 #ifdef DEBUG_XEMACS
 static EXTENT
 extent_e_previous (EXTENT e)
 {
 Extent_List *el = extent_extent_list (e);
 int foundp;
-int pos;
+int pos = extent_list_locate (el, e, 1, &foundp);
-pos = extent_list_locate (el, e, 1, &foundp);
 assert (foundp);
 return real_extent_at_backward (el, pos-1, 1);
 }
 #endif
 Furthermore, the results might be a little less sensible than
 the logic below. */
 static void
-map_extents_bytind (Bytind from, Bytind to,
+map_extents_bytind (Bytind from, Bytind to, map_extents_fun fn, void *arg,
-		    int (*fn) (EXTENT extent, void *arg), void *arg,
 		    Lisp_Object obj, EXTENT after, unsigned int flags)
 {
 Memind st, en; /* range we're mapping over */
 EXTENT range = 0; /* extent for this, if ME_MIGHT_MODIFY_TEXT */
 Extent_List *el = 0; /* extent list we're iterating over */
 	extent_list_delete_marker (el, posm);
 }
 }
 void
-map_extents (Bufpos from, Bufpos to, int (*fn) (EXTENT extent, void *arg),
+map_extents (Bufpos from, Bufpos to, map_extents_fun fn,
 	     void *arg, Lisp_Object obj, EXTENT after, unsigned int flags)
 {
 map_extents_bytind (buffer_or_string_bufpos_to_bytind (obj, from),
 		      buffer_or_string_bufpos_to_bytind (obj, to), fn, arg,
 		      obj, after, flags);
 	{
 	  Lisp_Object glyph = extent_begin_glyph (e);
 	  struct glyph_block gb;
 	  gb.glyph = glyph;
-	  gb.extent = Qnil;
 	  XSETEXTENT (gb.extent, e);
 	  Dynarr_add (ef->begin_glyphs, gb);
 	}
 }
 	{
 	  Lisp_Object glyph = extent_end_glyph (e);
 	  struct glyph_block gb;
 	  gb.glyph = glyph;
-	  gb.extent = Qnil;
 	  XSETEXTENT (gb.extent, e);
 	  Dynarr_add (ef->end_glyphs, gb);
 	}
 }
 	  if (!NILP (extent_face (e)))
 	    Dynarr_add (ef->extents, e);
 	  if (e == lhe)
 	    {
 	      Lisp_Object f;
-	      /* memset isn't really necessary; we only deref `priority'
+	      /* zeroing isn't really necessary; we only deref `priority'
 		 and `face' */
-	      memset (&dummy_lhe_extent, 0, sizeof (dummy_lhe_extent));
+	      xzero (dummy_lhe_extent);
 	      set_extent_priority (&dummy_lhe_extent,
 				   mouse_highlight_priority);
 	      /* Need to break up thefollowing expression, due to an */
 	      /* error in the Digital UNIX 3.2g C compiler (Digital */
 	      /* UNIX Compiler Driver 3.11). */
 	      !extent_in_red_event_p(e))
 	    {
 	      Lisp_Object function = extent_initial_redisplay_function (e);
 	      Lisp_Object obj;
-	      /* printf("initial redisplay function called!\n "); */
+	      /* printf ("initial redisplay function called!\n "); */
-	      /* print_extent_2(e);
+	      /* print_extent_2 (e);
-	         printf("\n"); */
+	         printf ("\n"); */
 	      /* FIXME: One should probably inhibit the displaying of
 		 this extent to reduce flicker */
 	      extent_in_red_event_p(e) = 1;
 	      /* call the function */
 	      XSETEXTENT(obj,e);
 	      if(!NILP(function))
 	         Fenqueue_eval_event(function,obj);
 	    }
 /* Retrieve the ancestor and use it, for faster retrieval of properties */
 if (!NILP (extent_begin_glyph (anc))) *bp++ = '*';
 *bp++ = (extent_start_open_p (anc) ? '(': '[');
 if (extent_detached_p (ext))
-sprintf (bp, "detached");
+strcpy (bp, "detached");
 else
 {
 Bufpos from = XINT (Fextent_start_position (obj));
 Bufpos to = XINT (Fextent_end_position (obj));
 sprintf (bp, "%d, %d", from, to);
 else
 return make_int (extent_endpoint_bufpos (extent, endp));
 }
 DEFUN ("extentp", Fextentp, 1, 1, 0, /*
-T if OBJECT is an extent.
+Return t if OBJECT is an extent.
 */
 (object))
 {
-if (EXTENTP (object))
+return EXTENTP (object) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("extent-live-p", Fextent_live_p, 1, 1, 0, /*
-T if OBJECT is an extent and the extent has not been destroyed.
+Return t if OBJECT is an extent that has not been destroyed.
 */
 (object))
 {
-if (EXTENTP (object) && EXTENT_LIVE_P (XEXTENT (object)))
+return EXTENTP (object) && EXTENT_LIVE_P (XEXTENT (object)) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("extent-detached-p", Fextent_detached_p, 1, 1, 0, /*
-T if EXTENT is detached.
+Return t if EXTENT is detached.
 */
 (extent))
 {
-if (extent_detached_p (decode_extent (extent, 0)))
+return extent_detached_p (decode_extent (extent, 0)) ? Qt : Qnil;
-return Qt;
-return Qnil;
 }
 DEFUN ("extent-object", Fextent_object, 1, 1, 0, /*
-Return object (buffer or string) EXTENT refers to.
+Return object (buffer or string) that EXTENT refers to.
 */
 (extent))
 {
 return extent_object (decode_extent (extent, 0));
 }
 }
 static void
 set_extent_openness (EXTENT extent, int start_open, int end_open)
 {
-if (start_open == -1)
+if (start_open != -1)
-start_open = extent_start_open_p (extent);
+extent_start_open_p (extent) = start_open;
-if (end_open == -1)
+if (end_open != -1)
-end_open = extent_end_open_p (extent);
+extent_end_open_p (extent) = end_open;
-extent_start_open_p (extent) = start_open;
-extent_end_open_p (extent) = end_open;
 /* changing the open/closedness of an extent does not affect
 redisplay. */
 }
 static EXTENT
 static void
 destroy_extent (EXTENT extent)
 {
 Lisp_Object rest, nextrest, children;
-Lisp_Object extent_obj = Qnil;
+Lisp_Object extent_obj;
 if (!extent_detached_p (extent))
 extent_detach (extent);
 /* disassociate the extent from its children and parent */
 children = extent_children (extent);
 FROM and TO are nil, and in this case BUFFER-OR-STRING defaults to nil,
 meaning the extent is in no buffer and no string.
 */
 (from, to, buffer_or_string))
 {
-Lisp_Object extent_obj = Qnil;
+Lisp_Object extent_obj;
 Lisp_Object obj;
 obj = decode_buffer_or_string (buffer_or_string);
 if (NILP (from) && NILP (to))
 {
 	  in_region_specified = 1;
 	}
 /* I do so love that conditional operator ... */
 retval |=
-	EQ (sym, Qend_closed) ? ME_END_CLOSED :
+	EQ (sym, Qend_closed)		   ? ME_END_CLOSED :
-	EQ (sym, Qstart_open) ? ME_START_OPEN :
+	EQ (sym, Qstart_open)		   ? ME_START_OPEN :
-	EQ (sym, Qall_extents_closed) ? ME_ALL_EXTENTS_CLOSED :
+	EQ (sym, Qall_extents_closed)	   ? ME_ALL_EXTENTS_CLOSED :
-	EQ (sym, Qall_extents_open) ? ME_ALL_EXTENTS_OPEN :
+	EQ (sym, Qall_extents_open)	   ? ME_ALL_EXTENTS_OPEN :
 	EQ (sym, Qall_extents_closed_open) ? ME_ALL_EXTENTS_CLOSED_OPEN :
 	EQ (sym, Qall_extents_open_closed) ? ME_ALL_EXTENTS_OPEN_CLOSED :
-	EQ (sym, Qstart_in_region) ? ME_START_IN_REGION :
+	EQ (sym, Qstart_in_region)	   ? ME_START_IN_REGION :
-	EQ (sym, Qend_in_region) ? ME_END_IN_REGION :
+	EQ (sym, Qend_in_region)	   ? ME_END_IN_REGION :
 	EQ (sym, Qstart_and_end_in_region) ? ME_START_AND_END_IN_REGION :
-	EQ (sym, Qstart_or_end_in_region) ? ME_START_OR_END_IN_REGION :
+	EQ (sym, Qstart_or_end_in_region)  ? ME_START_OR_END_IN_REGION :
-	EQ (sym, Qnegate_in_region) ? ME_NEGATE_IN_REGION :
+	EQ (sym, Qnegate_in_region)	   ? ME_NEGATE_IN_REGION :
 	(signal_simple_error ("Invalid `map-extents' flag", sym), 0);
 flags = XCDR (flags);
 }
 return retval;
 This is equivalent to whether `map-extents' would visit EXTENT when called
 with these args.
 */
 (extent, from, to, flags))
 {
-EXTENT ext;
-Lisp_Object obj;
 Bytind start, end;
+EXTENT ext = decode_extent (extent, DE_MUST_BE_ATTACHED);
-ext = decode_extent (extent, DE_MUST_BE_ATTACHED);
+Lisp_Object obj = extent_object (ext);
-obj = extent_object (ext);
 get_buffer_or_string_range_byte (obj, from, to, &start, &end, GB_ALLOW_NIL |
 				   GB_ALLOW_PAST_ACCESSIBLE);
-if (extent_in_region_p (ext, start, end, decode_map_extents_flags (flags)))
+return extent_in_region_p (ext, start, end, decode_map_extents_flags (flags)) ?
-return Qt;
+Qt : Qnil;
-return Qnil;
 }
 struct slow_map_extents_arg
 {
 Lisp_Object map_arg;
 	return 0;
 }
 closure->result = call2 (closure->map_routine, extent_obj,
 			   closure->map_arg);
-if (NILP (closure->result))
+return !NILP (closure->result);
-return 0;
-else
-return 1;
 }
 DEFUN ("map-extents", Fmap_extents, 1, 8, 0, /*
 Map FUNCTION over the extents which overlap a region in OBJECT.
 OBJECT is normally a buffer or string but could be an extent (see below).
 */
 closure->start_min = -1;	/* no need for this any more */
 closure->prev_start = extent_endpoint_bytind (extent, 0);
 closure->prev_end = extent_endpoint_bytind (extent, 1);
-if (NILP (closure->result))
+return !NILP (closure->result);
-return 0;
-else
-return 1;
 }
 DEFUN ("map-extent-children", Fmap_extent_children, 1, 8, 0, /*
 Map FUNCTION over the extents in the region from FROM to TO.
 FUNCTION is called with arguments (extent, MAPARG).  See `map-extents'
 };
 static enum extent_at_flag
 decode_extent_at_flag (Lisp_Object at_flag)
 {
-enum extent_at_flag fl;
 if (NILP (at_flag))
-fl = EXTENT_AT_AFTER;
+return EXTENT_AT_AFTER;
-else
-{
+CHECK_SYMBOL (at_flag);
-CHECK_SYMBOL (at_flag);
+if (EQ (at_flag, Qafter))  return EXTENT_AT_AFTER;
-if (EQ (at_flag, Qafter))
+if (EQ (at_flag, Qbefore)) return EXTENT_AT_BEFORE;
-	fl = EXTENT_AT_AFTER;
+if (EQ (at_flag, Qat))     return EXTENT_AT_AT;
-else if (EQ (at_flag, Qbefore))
-	fl = EXTENT_AT_BEFORE;
+signal_simple_error ("Invalid AT-FLAG in `extent-at'", at_flag);
-else if (EQ (at_flag, Qat))
+return EXTENT_AT_AFTER; /* unreached */
-	fl = EXTENT_AT_AT;
-else
-	signal_simple_error ("Invalid AT-FLAG in `extent-at'", at_flag);
-}
-return fl;
 }
 static int
 extent_at_mapper (EXTENT e, void *arg)
 {
 static Lisp_Object
 extent_at_bytind (Bytind position, Lisp_Object object, Lisp_Object property,
 		  EXTENT before, enum extent_at_flag at_flag)
 {
 struct extent_at_arg closure;
-Lisp_Object extent_obj = Qnil;
+Lisp_Object extent_obj;
 /* it might be argued that invalid positions should cause
 errors, but the principle of least surprise dictates that
 nil should be returned (extent-at is often used in
 response to a mouse event, and in many cases previous events
 	     (memoize_extent_face_internal (value)));
 return value;
 }
 /* Do we need a lisp-level function ? */
-DEFUN ("set-extent-initial-redisplay-function", Fset_extent_initial_redisplay_function,
+DEFUN ("set-extent-initial-redisplay-function",
-2,2,0,/*
+Fset_extent_initial_redisplay_function, 2,2,0,/*
 Note: This feature is experimental!
 Set initial-redisplay-function of EXTENT to the function
 FUNCTION.
 The first time the EXTENT is (re)displayed, an eval event will be
 dispatched calling FUNCTION with EXTENT as its only argument.
 */
 (extent, function))
 {
 EXTENT e = decode_extent(extent, DE_MUST_BE_ATTACHED);
 e = extent_ancestor (e);  /* Is this needed? Macro also does chasing!*/
 set_extent_initial_redisplay_function(e,function);
 extent_in_red_event_p(e) = 0;  /* If the function changed we can spawn
-				new events */
+				    new events */
 extent_changed_for_redisplay(e,1,0); /* Do we need to mark children too ?*/
 return function;
 }
 DEFUN ("extent-face", Fextent_face, 1, 1, 0, /*
 Return the name of the face in which EXTENT is displayed, or nil
 if the extent's face is unspecified.  This might also return a list
 of face names.
 */
 (extent))
 {
 Lisp_Object face;
 return orig_face;
 }
 void
 set_extent_glyph (EXTENT extent, Lisp_Object glyph, int endp,
-		  unsigned int layout)
+		  glyph_layout layout)
 {
 extent = extent_ancestor (extent);
 if (!endp)
 {
 extent_changed_for_redisplay (extent, 1, 0);
 }
 static Lisp_Object
-glyph_layout_to_symbol (unsigned int layout)
+glyph_layout_to_symbol (glyph_layout layout)
 {
 switch (layout)
 {
-case GL_TEXT: return Qtext;
+case GL_TEXT:	    return Qtext;
 case GL_OUTSIDE_MARGIN: return Qoutside_margin;
-case GL_INSIDE_MARGIN: return Qinside_margin;
+case GL_INSIDE_MARGIN:  return Qinside_margin;
-case GL_WHITESPACE: return Qwhitespace;
+case GL_WHITESPACE:	    return Qwhitespace;
-default: abort ();
+default:
-}
+abort ();
-return Qnil;	/* shut up compiler */
+return Qnil; /* unreached */
 }
+}
-static unsigned int
+static glyph_layout
 symbol_to_glyph_layout (Lisp_Object layout_obj)
 {
-unsigned int layout = 0;
 if (NILP (layout_obj))
-layout = GL_TEXT;
+return GL_TEXT;
-else
-{
+CHECK_SYMBOL (layout_obj);
-CHECK_SYMBOL (layout_obj);
+if (EQ (layout_obj, Qoutside_margin)) return GL_OUTSIDE_MARGIN;
-if (EQ (Qoutside_margin, layout_obj))
+if (EQ (layout_obj, Qinside_margin))	return GL_INSIDE_MARGIN;
-	layout = GL_OUTSIDE_MARGIN;
+if (EQ (layout_obj, Qwhitespace))	return GL_WHITESPACE;
-else if (EQ (Qinside_margin, layout_obj))
+if (EQ (layout_obj, Qtext))		return GL_TEXT;
-	layout = GL_INSIDE_MARGIN;
-else if (EQ (Qwhitespace, layout_obj))
+signal_simple_error ("unknown glyph layout type", layout_obj);
-	layout = GL_WHITESPACE;
+return GL_TEXT; /* unreached */
-else if (EQ (Qtext, layout_obj))
-	layout = GL_TEXT;
-else
-	signal_simple_error ("unknown glyph layout type", layout_obj);
-}
-return layout;
 }
 static Lisp_Object
 set_extent_glyph_1 (Lisp_Object extent_obj, Lisp_Object glyph, int endp,
 		    Lisp_Object layout_obj)
 {
 EXTENT extent = decode_extent (extent_obj, DE_MUST_HAVE_BUFFER);
-unsigned int layout = symbol_to_glyph_layout (layout_obj);
+glyph_layout layout = symbol_to_glyph_layout (layout_obj);
 /* Make sure we've actually been given a glyph or it's nil (meaning
 we're deleting a glyph from an extent). */
 if (!NILP (glyph))
 CHECK_GLYPH (glyph);
 EXTENT e = decode_extent (extent, 0);
 return glyph_layout_to_symbol (extent_end_glyph_layout (e));
 }
 DEFUN ("set-extent-priority", Fset_extent_priority, 2, 2, 0, /*
-Changes the display priority of EXTENT.
+Set the display priority of EXTENT to PRIORITY (an integer).
 When the extent attributes are being merged for display, the priority
 is used to determine which extent takes precedence in the event of a
 conflict (two extents whose faces both specify font, for example: the
 font of the extent with the higher priority will be used).
 Extents are created with priority 0; priorities may be negative.
 */
-(extent, pri))
+(extent, priority))
 {
 EXTENT e = decode_extent (extent, 0);
-CHECK_INT (pri);
+CHECK_INT (priority);
 e = extent_ancestor (e);
-set_extent_priority (e, XINT (pri));
+set_extent_priority (e, XINT (priority));
 extent_maybe_changed_for_redisplay (e, 1, 0);
-return pri;
+return priority;
 }
 DEFUN ("extent-priority", Fextent_priority, 1, 1, 0, /*
 Return the display priority of EXTENT; see `set-extent-priority'.
 */
 plist = Fcopy_sequence (plist);
 Fcanonicalize_plist (plist, Qnil);
 while (!NILP (plist))
 {
-property = Fcar (plist);
+property = Fcar (plist); plist = Fcdr (plist);
-value = Fcar (Fcdr (plist));
+value    = Fcar (plist); plist = Fcdr (plist);
-plist = Fcdr (Fcdr (plist));
 Fset_extent_property (extent, property, value);
 }
 UNGCPRO;
 return Qnil;
 }
 return extent_begin_glyph (e);
 else if (EQ (property, Qend_glyph))
 return extent_end_glyph (e);
 else
 {
-Lisp_Object value;
+Lisp_Object value = external_plist_get (extent_plist_addr (e),
+					      property, 0, ERROR_ME);
-value = external_plist_get (extent_plist_addr (e), property, 0,
+return UNBOUNDP (value) ? default_ : value;
-				  ERROR_ME);
-if (UNBOUNDP (value))
-	return default_;
-return value;
 }
 }
 DEFUN ("extent-properties", Fextent_properties, 1, 1, 0, /*
 Return a property list of the attributes of the given extent.
 Do not modify this list; use `set-extent-property' instead.
 */
 (extent))
 {
 EXTENT e, anc;
-Lisp_Object result, face, anc_obj = Qnil;
+Lisp_Object result, face, anc_obj;
+enum glyph_layout layout;
 CHECK_EXTENT (extent);
 e = XEXTENT (extent);
 if (!EXTENT_LIVE_P (e))
-return Fcons (Qdestroyed, Fcons (Qt, Qnil));
+return cons3 (Qdestroyed, Qt, Qnil);
 anc = extent_ancestor (e);
 XSETEXTENT (anc_obj, anc);
 /* For efficiency, use the ancestor for all properties except detached */
 result = extent_plist_slot (anc);
-face = Fextent_face (anc_obj);
-if (!NILP (face))
+if (!NILP (face = Fextent_face (anc_obj)))
-result = Fcons (Qface, Fcons (face, result));
+result = cons3 (Qface, face, result);
-face = Fextent_mouse_face (anc_obj);
-if (!NILP (face))
+if (!NILP (face = Fextent_mouse_face (anc_obj)))
-result = Fcons (Qmouse_face, Fcons (face, result));
+result = cons3 (Qmouse_face, face, result);
-/* For now continue to include this for backwards compatibility. */
+if ((layout = extent_begin_glyph_layout (anc)) != GL_TEXT)
-if (extent_begin_glyph_layout (anc) != GL_TEXT)
+{
-result = Fcons (Qglyph_layout,
+Lisp_Object sym = glyph_layout_to_symbol (layout);
-		    glyph_layout_to_symbol (extent_begin_glyph_layout (anc)));
+result = cons3 (Qglyph_layout,       sym, result); /* compatibility */
+result = cons3 (Qbegin_glyph_layout, sym, result);
-if (extent_begin_glyph_layout (anc) != GL_TEXT)
+}
-result = Fcons (Qbegin_glyph_layout,
-		    glyph_layout_to_symbol (extent_begin_glyph_layout (anc)));
+if ((layout = extent_end_glyph_layout (anc)) != GL_TEXT)
-if (extent_end_glyph_layout (anc) != GL_TEXT)
+result = cons3 (Qend_glyph_layout, glyph_layout_to_symbol (layout), result);
-result = Fcons (Qend_glyph_layout,
-		    glyph_layout_to_symbol (extent_end_glyph_layout (anc)));
 if (!NILP (extent_end_glyph (anc)))
-result = Fcons (Qend_glyph, Fcons (extent_end_glyph (anc), result));
+result = cons3 (Qend_glyph, extent_end_glyph (anc), result);
 if (!NILP (extent_begin_glyph (anc)))
-result = Fcons (Qbegin_glyph, Fcons (extent_begin_glyph (anc), result));
+result = cons3 (Qbegin_glyph, extent_begin_glyph (anc), result);
 if (extent_priority (anc) != 0)
-result = Fcons (Qpriority, Fcons (make_int (extent_priority (anc)),
+result = cons3 (Qpriority, make_int (extent_priority (anc)), result);
-				      result));
 if (!NILP (extent_initial_redisplay_function (anc)))
-result = Fcons (Qinitial_redisplay_function, Fcons (extent_initial_redisplay_function (anc), result));
+result = cons3 (Qinitial_redisplay_function,
+		    extent_initial_redisplay_function (anc), result);
 if (!NILP (extent_invisible (anc)))
-result = Fcons (Qinvisible, Fcons (extent_invisible (anc), result));
+result = cons3 (Qinvisible, extent_invisible (anc), result);
 if (!NILP (extent_read_only (anc)))
-result = Fcons (Qread_only, Fcons (extent_read_only (anc), result));
+result = cons3 (Qread_only, extent_read_only (anc), result);
-#define CONS_FLAG(flag, sym) if (extent_normal_field (anc, flag)) \
+if  (extent_normal_field (anc, end_open))
-result = Fcons (sym, Fcons (Qt, result))
+result = cons3 (Qend_open, Qt, result);
-CONS_FLAG (end_open, Qend_open);
-CONS_FLAG (start_open, Qstart_open);
+if  (extent_normal_field (anc, start_open))
-CONS_FLAG (detachable, Qdetachable);
+result = cons3 (Qstart_open, Qt, result);
-CONS_FLAG (duplicable, Qduplicable);
-CONS_FLAG (unique, Qunique);
+if  (extent_normal_field (anc, detachable))
-#undef CONS_FLAG
+result = cons3 (Qdetachable, Qt, result);
+if  (extent_normal_field (anc, duplicable))
+result = cons3 (Qduplicable, Qt, result);
+if  (extent_normal_field (anc, unique))
+result = cons3 (Qunique, Qt, result);
 /* detached is not an inherited property */
 if (extent_detached_p (e))
-result = Fcons (Qdetached, Fcons (Qt, result));
+result = cons3 (Qdetached, Qt, result);
 return result;
 }
 return val;
 }
 }
 DEFUN ("get-text-property", Fget_text_property, 2, 4, 0, /*
-Returns the value of the PROP property at the given position.
+Return the value of the PROP property at the given position.
 Optional arg OBJECT specifies the buffer or string to look in, and
 defaults to the current buffer.
 Optional arg AT-FLAG controls what it means for a property to be "at"
 a position, and has the same meaning as in `extent-at'.
 This examines only those properties added with `put-text-property'.
 {
 return get_text_property_1 (pos, prop, object, at_flag, 1);
 }
 DEFUN ("get-char-property", Fget_char_property, 2, 4, 0, /*
-Returns the value of the PROP property at the given position.
+Return the value of the PROP property at the given position.
 Optional arg OBJECT specifies the buffer or string to look in, and
 defaults to the current buffer.
 Optional arg AT-FLAG controls what it means for a property to be "at"
 a position, and has the same meaning as in `extent-at'.
 This examines properties on all extents.
 	     openness.  We are setting the endpoint to be the same as
 	     that of the extent we're about to remove, and we assume
 	     (the invariant mentioned above) that extent has the
 	     proper endpoint setting, so we just use it. */
 	  set_extent_openness (te, new_start != e_start ?
-			       extent_start_open_p (e) : -1,
+			       (int) extent_start_open_p (e) : -1,
 			       new_end != e_end ?
-			       extent_end_open_p (e) : -1);
+			       (int) extent_end_open_p (e) : -1);
 	  closure->changed_p = 1;
 	}
 extent_detach (e);
 }
 else if (e_end <= end)
 /* If we made it through the loop without reusing an extent
 (and we want there to be one) make it now.
 */
 if (!NILP (value) && NILP (closure.the_extent))
 {
-Lisp_Object extent = Qnil;
+Lisp_Object extent;
 XSETEXTENT (extent, make_extent_internal (object, start, end));
 closure.changed_p = 1;
 Fset_extent_property (extent, Qtext_prop, prop);
 Fset_extent_property (extent, prop, value);
 DEFUN ("add-nonduplicable-text-properties",
 Fadd_nonduplicable_text_properties, 3, 4, 0, /*
 Add nonduplicable properties to the characters from START to END.
-(The properties will not be copied when the characters are copied.)
+\(The properties will not be copied when the characters are copied.)
 The third argument PROPS is a property list specifying the property values
 to add.  The optional fourth argument, OBJECT, is the buffer or string
 containing the text and defaults to the current buffer.  Returns t if
 any property was changed, nil otherwise.
 */
 syms_of_extents (void)
 {
 defsymbol (&Qextentp, "extentp");
 defsymbol (&Qextent_live_p, "extent-live-p");
-defsymbol (&Qend_closed, "end-closed");
-defsymbol (&Qstart_open, "start-open");
 defsymbol (&Qall_extents_closed, "all-extents-closed");
 defsymbol (&Qall_extents_open, "all-extents-open");
 defsymbol (&Qall_extents_closed_open, "all-extents-closed-open");
 defsymbol (&Qall_extents_open_closed, "all-extents-open-closed");
 defsymbol (&Qstart_in_region, "start-in-region");
 defsymbol (&Qduplicable, "duplicable");
 defsymbol (&Qdetachable, "detachable");
 defsymbol (&Qpriority, "priority");
 defsymbol (&Qmouse_face, "mouse-face");
 defsymbol (&Qinitial_redisplay_function,"initial-redisplay-function");
 defsymbol (&Qglyph_layout, "glyph-layout");	/* backwards compatibility */
 defsymbol (&Qbegin_glyph_layout, "begin-glyph-layout");
-defsymbol (&Qbegin_glyph_layout, "end-glyph-layout");
+defsymbol (&Qend_glyph_layout, "end-glyph-layout");
 defsymbol (&Qoutside_margin, "outside-margin");
 defsymbol (&Qinside_margin, "inside-margin");
 defsymbol (&Qwhitespace, "whitespace");
 /* Qtext defined in general.c */
 DEFSUBR (Fextent_detached_p);
 DEFSUBR (Fextent_start_position);
 DEFSUBR (Fextent_end_position);
 DEFSUBR (Fextent_object);
 DEFSUBR (Fextent_length);
-#if 0
-DEFSUBR (Fstack_of_extents);
-#endif
 DEFSUBR (Fmake_extent);
 DEFSUBR (Fcopy_extent);
 DEFSUBR (Fdelete_extent);
 DEFSUBR (Fdetach_extent);

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 272:c5d627a313b1 r21-0b34