xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 380:8626e4521993 r21-2-5

Import from CVS: tag r21-2-5

author	cvs
date	Mon, 13 Aug 2007 11:07:10 +0200
parents	6240c7796c7a
children	74fd4e045ea6

comparison

equal deleted inserted replaced

-:76b7d63099ad
+:8626e4521993
 #include "elhash.h"
 #include "extents.h"
 #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"
 char *ptr = ga->array;
 int real_gap_loc;
 int old_gap_size;
 /* If we have to get more space, get enough to last a while.  We use
-a geometric progession that saves on realloc space. */
+a geometric progression that saves on realloc space. */
 increment += 100 + ga->numels / 8;
 ptr = (char *) xrealloc (ptr,
 			   (ga->numels + ga->gapsize + increment)*ga->elsize);
 if (ptr == 0)
 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->begin_glyph);
-((markobj) (data->end_glyph));
+markobj (data->end_glyph);
-((markobj) (data->invisible));
+markobj (data->invisible);
-((markobj) (data->children));
+markobj (data->children);
-((markobj) (data->read_only));
+markobj (data->read_only);
-((markobj) (data->mouse_face));
+markobj (data->mouse_face);
-((markobj) (data->initial_redisplay_function));
+markobj (data->initial_redisplay_function);
-((markobj) (data->before_change_functions));
+markobj (data->before_change_functions);
-((markobj) (data->after_change_functions));
+markobj (data->after_change_functions);
 return data->parent;
 }
 DEFINE_LRECORD_IMPLEMENTATION ("extent-auxiliary", extent_auxiliary,
 mark_extent_auxiliary, internal_object_printer,
 static void soe_invalidate (Lisp_Object obj);
 static Lisp_Object
 mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
-struct extent_info *data =
+struct extent_info *data = (struct extent_info *) XEXTENT_INFO (obj);
-(struct extent_info *) XEXTENT_INFO (obj);
 int i;
-Extent_List *list;
+Extent_List *list = data->extents;
 /* Vbuffer_defaults and Vbuffer_local_symbols are buffer-like
 objects that are created specially and never have their extent
 list initialized (or rather, it is set to zero in
 nuke_all_buffer_slots()).  However, these objects get
 garbage-collected so we have to deal.
 (Also the list can be zero when we're dealing with a destroyed
 buffer.) */
-list = data->extents;
 if (list)
 {
 for (i = 0; i < extent_list_num_els (list); i++)
 	{
 	  struct extent *extent = extent_list_at (list, i, 0);
 	  Lisp_Object exobj;
 	  XSETEXTENT (exobj, extent);
-	  ((markobj) (exobj));
+	  markobj (exobj);
 	}
 }
 return Qnil;
 }
 we change an extent in generated-modeline-string, this changes
 its parent, which is in `modeline-format', so we should
 force the modeline to be updated.  But how to determine whether
 a string is a `generated-modeline-string'?  Looping through
 all buffers is not very efficient.  Should we add all
-`generated-modeline-string' strings to a hashtable?
+`generated-modeline-string' strings to a hash table?
 Maybe efficiency is not the greatest concern here and there's
 no big loss in looping over the buffers. */
 return;
 {
 {
 Lisp_Object obj = extent_object (extent);
 Endpoint_Index start, end, exs, exe;
 int start_open, end_open;
 unsigned int all_extents_flags = flags & ME_ALL_EXTENTS_MASK;
-unsigned int in_region_flags = flags & ME_IN_REGION_MASK;
+unsigned int in_region_flags   = flags & ME_IN_REGION_MASK;
 int retval;
 /* A zero-length region is treated as closed-closed. */
 if (from == to)
 {
 flags |= ME_END_CLOSED;
 flags &= ~ME_START_OPEN;
 }
-switch (all_extents_flags)
-{
-case ME_ALL_EXTENTS_CLOSED:
-start_open = end_open = 0; break;
-case ME_ALL_EXTENTS_OPEN:
-start_open = end_open = 1; break;
-case ME_ALL_EXTENTS_CLOSED_OPEN:
-start_open = 0; end_open = 1; break;
-case ME_ALL_EXTENTS_OPEN_CLOSED:
-start_open = 1; end_open = 0; break;
-default:
-start_open = extent_start_open_p (extent);
-end_open = extent_end_open_p (extent);
-break;
-}
 /* So is a zero-length extent. */
 if (extent_start (extent) == extent_end (extent))
-start_open = end_open = 0;
+start_open = 0, end_open = 0;
+/* `all_extents_flags' will almost always be zero. */
+else if (all_extents_flags == 0)
+{
+start_open = extent_start_open_p (extent);
+end_open   = extent_end_open_p   (extent);
+}
+else
+switch (all_extents_flags)
+{
+case ME_ALL_EXTENTS_CLOSED:      start_open = 0, end_open = 0; break;
+case ME_ALL_EXTENTS_OPEN:        start_open = 1, end_open = 1; break;
+case ME_ALL_EXTENTS_CLOSED_OPEN: start_open = 0, end_open = 1; break;
+case ME_ALL_EXTENTS_OPEN_CLOSED: start_open = 1, end_open = 0; break;
+default: abort(); break;
+}
 start = buffer_or_string_bytind_to_startind (obj, from,
 					       flags & ME_START_OPEN);
 end = buffer_or_string_bytind_to_endind (obj, to, ! (flags & ME_END_CLOSED));
 exs = memind_to_startind (extent_start (extent), start_open);
-exe = memind_to_endind (extent_end (extent), end_open);
+exe = memind_to_endind   (extent_end   (extent), end_open);
 /* It's easy to determine whether an extent lies *outside* the
 region -- just determine whether it's completely before
 or completely after the region.  Reject all such extents, so
 we're now left with only the extents that overlap the region.
 if (exs > end || exe < start)
 return 0;
 /* See if any further restrictions are called for. */
-switch (in_region_flags)
+/* in_region_flags will almost always be zero. */
-{
+if (in_region_flags == 0)
-case ME_START_IN_REGION:
+retval = 1;
-retval = start <= exs && exs <= end; break;
+else
-case ME_END_IN_REGION:
+switch (in_region_flags)
-retval = start <= exe && exe <= end; break;
+{
-case ME_START_AND_END_IN_REGION:
+case ME_START_IN_REGION:
-retval = start <= exs && exe <= end; break;
+	retval = start <= exs && exs <= end; break;
-case ME_START_OR_END_IN_REGION:
+case ME_END_IN_REGION:
-retval = (start <= exs && exs <= end) || (start <= exe && exe <= end);
+	retval = start <= exe && exe <= end; break;
-break;
+case ME_START_AND_END_IN_REGION:
-default:
+	retval = start <= exs && exe <= end; break;
-retval = 1; break;
+case ME_START_OR_END_IN_REGION:
-}
+	retval = (start <= exs && exs <= end) || (start <= exe && exe <= end);
+	break;
+default:
+	abort(); break;
+}
 return flags & ME_NEGATE_IN_REGION ? !retval : retval;
 }
 struct map_extents_struct
 {
 	      /* zeroing isn't really necessary; we only deref `priority'
 		 and `face' */
 	      xzero (dummy_lhe_extent);
 	      set_extent_priority (&dummy_lhe_extent,
 				   mouse_highlight_priority);
-	      /* Need to break up thefollowing expression, due to an */
+	      /* Need to break up the following expression, due to an */
 	      /* error in the Digital UNIX 3.2g C compiler (Digital */
 	      /* UNIX Compiler Driver 3.11). */
 	      f = extent_mouse_face (lhe);
 	      extent_face (&dummy_lhe_extent) = f;
 	      Dynarr_add (ef->extents, &dummy_lhe_extent);
 static Lisp_Object
 mark_extent (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
 struct extent *extent = XEXTENT (obj);
-((markobj) (extent_object (extent)));
+markobj (extent_object (extent));
-((markobj) (extent_no_chase_normal_field (extent, face)));
+markobj (extent_no_chase_normal_field (extent, face));
 return extent->plist;
 }
 static void
 print_extent_1 (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 if (NILP (v)) continue;
 print_internal (XCAR (tail), printcharfun, escapeflag);
 write_c_string (" ", printcharfun);
 }
-sprintf (buf, "0x%lx", (unsigned long int) ext);
+sprintf (buf, "0x%lx", (long) ext);
 write_c_string (buf, printcharfun);
 }
 static void
 print_extent (Lisp_Object obj, Lisp_Object printcharfun, int escapeflag)
 if (print_readably)
 	{
 	  if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	    error ("printing unreadable object #<destroyed extent>");
 	  else
-	    error ("printing unreadable object #<extent 0x%p>",
+	    error ("printing unreadable object #<extent 0x%lx>",
-		   XEXTENT (obj));
+		   (long) XEXTENT (obj));
 	}
 if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	write_c_string ("#<destroyed extent", printcharfun);
 else
 			 extent_no_chase_plist (e2),
 			 0, 0, depth + 1);
 }
 static int
-extent_equal (Lisp_Object o1, Lisp_Object o2, int depth)
+extent_equal (Lisp_Object obj1, Lisp_Object obj2, int depth)
 {
-struct extent *e1 = XEXTENT (o1);
+struct extent *e1 = XEXTENT (obj1);
-struct extent *e2 = XEXTENT (o2);
+struct extent *e2 = XEXTENT (obj2);
 return
 (extent_start (e1) == extent_start (e2) &&
-extent_end (e1) == extent_end (e2) &&
+extent_end   (e1) == extent_end   (e2) &&
 internal_equal (extent_object (e1), extent_object (e2), depth + 1) &&
 properties_equal (extent_ancestor (e1), extent_ancestor (e2),
 		       depth));
 }
 /* To do the memoization, we use a hash table mapping from
 external lists to internal lists.  We do `equal' comparisons
 on the keys so the memoization works correctly.
 Note that we canonicalize things so that the keys in the
-hashtable (the external lists) always contain symbols and
+hash table (the external lists) always contain symbols and
 the values (the internal lists) always contain face objects.
 We also maintain a "reverse" table that maps from the internal
 lists to the external equivalents.  The idea here is twofold:
 if (EQ (layout_obj, Qoutside_margin)) return GL_OUTSIDE_MARGIN;
 if (EQ (layout_obj, Qinside_margin))	return GL_INSIDE_MARGIN;
 if (EQ (layout_obj, Qwhitespace))	return GL_WHITESPACE;
 if (EQ (layout_obj, Qtext))		return GL_TEXT;
-signal_simple_error ("unknown glyph layout type", layout_obj);
+signal_simple_error ("Unknown glyph layout type", layout_obj);
 return GL_TEXT; /* unreached */
 }
 static Lisp_Object
 set_extent_glyph_1 (Lisp_Object extent_obj, Lisp_Object glyph, int endp,
 Fset_extent_begin_glyph_layout (extent, value);
 else if (EQ (property, Qbegin_glyph))
 Fset_extent_begin_glyph (extent, value, Qnil);
 else if (EQ (property, Qend_glyph))
 Fset_extent_end_glyph (extent, value, Qnil);
-else if (EQ (property, Qstart_open) ||
+else if (EQ (property, Qstart_open))
-	   EQ (property, Qend_open) ||
+set_extent_openness (e, !NILP (value), -1);
-	   EQ (property, Qstart_closed) ||
+else if (EQ (property, Qend_open))
-	   EQ (property, Qend_closed))
+set_extent_openness (e, -1, !NILP (value));
-{
+/* Support (but don't document...) the obvious *_closed antonyms. */
-int start_open = -1, end_open = -1;
+else if (EQ (property, Qstart_closed))
-if (EQ (property, Qstart_open))
+set_extent_openness (e, NILP (value), -1);
-	start_open = !NILP (value);
+else if (EQ (property, Qend_closed))
-else if (EQ (property, Qend_open))
+set_extent_openness (e, -1, NILP (value));
-	end_open = !NILP (value);
-/* Support (but don't document...) the obvious antonyms. */
-else if (EQ (property, Qstart_closed))
-	start_open = NILP (value);
-else
-	end_open = NILP (value);
-set_extent_openness (e, start_open, end_open);
-}
 else
 {
 if (EQ (property, Qkeymap))
 	while (!NILP (value) && NILP (Fkeymapp (value)))
 	  value = wrong_type_argument (Qkeymapp, value);
 */
 (extent, property, default_))
 {
 EXTENT e = decode_extent (extent, 0);
-if      (EQ (property, Qdetached))
+if (EQ (property, Qdetached))
 return extent_detached_p (e) ? Qt : Qnil;
 else if (EQ (property, Qdestroyed))
 return !EXTENT_LIVE_P (e) ? Qt : Qnil;
-#define RETURN_FLAG(flag) return extent_normal_field (e, flag) ? Qt : Qnil
+else if (EQ (property, Qstart_open))
-else if (EQ (property, Qstart_open))	 RETURN_FLAG (start_open);
+return extent_normal_field (e, start_open) ? Qt : Qnil;
-else if (EQ (property, Qend_open))	 RETURN_FLAG (end_open);
+else if (EQ (property, Qend_open))
-else if (EQ (property, Qunique))	 RETURN_FLAG (unique);
+return extent_normal_field (e, end_open) ? Qt : Qnil;
-else if (EQ (property, Qduplicable))	 RETURN_FLAG (duplicable);
+else if (EQ (property, Qunique))
-else if (EQ (property, Qdetachable))	 RETURN_FLAG (detachable);
+return extent_normal_field (e, unique) ? Qt : Qnil;
-#undef RETURN_FLAG
+else if (EQ (property, Qduplicable))
-/* Support (but don't document...) the obvious antonyms. */
+return extent_normal_field (e, duplicable) ? Qt : Qnil;
+else if (EQ (property, Qdetachable))
+return extent_normal_field (e, detachable) ? Qt : Qnil;
+/* Support (but don't document...) the obvious *_closed antonyms. */
 else if (EQ (property, Qstart_closed))
 return extent_start_open_p (e) ? Qnil : Qt;
 else if (EQ (property, Qend_closed))
 return extent_end_open_p (e) ? Qnil : Qt;
 else if (EQ (property, Qpriority))
 {
 /* This function can GC */
 struct add_string_extents_arg *closure =
 (struct add_string_extents_arg *) arg;
 Bytecount start = extent_endpoint_bytind (extent, 0) - closure->from;
-Bytecount end = extent_endpoint_bytind (extent, 1) - closure->from;
+Bytecount end   = extent_endpoint_bytind (extent, 1) - closure->from;
 if (extent_duplicable_p (extent))
 {
-EXTENT e;
 start = max (start, 0);
 end = min (end, closure->length);
 /* Run the copy-function to give an extent the option of
 	 not being copied into the string (or kill ring).
 	 */
 if (extent_duplicable_p (extent) &&
 	  !run_extent_copy_function (extent, start + closure->from,
 				     end + closure->from))
 	return 0;
-e = copy_extent (extent, start, end, closure->string);
+copy_extent (extent, start, end, closure->string);
 }
 return 0;
 }
 static int
 copy_string_extents_mapper (EXTENT extent, void *arg)
 {
 struct copy_string_extents_arg *closure =
 (struct copy_string_extents_arg *) arg;
-Bytecount old_start, old_end;
+Bytecount old_start, old_end, new_start, new_end;
-Bytecount new_start, new_end;
 old_start = extent_endpoint_bytind (extent, 0);
-old_end = extent_endpoint_bytind (extent, 1);
+old_end   = extent_endpoint_bytind (extent, 1);
 old_start = max (closure->old_pos, old_start);
-old_end = min (closure->old_pos + closure->length, old_end);
+old_end   = min (closure->old_pos + closure->length, old_end);
 if (old_start >= old_end)
 return 0;
 new_start = old_start + closure->new_pos - closure->old_pos;
-new_end = old_end + closure->new_pos - closure->old_pos;
+new_end   = old_end   + closure->new_pos - closure->old_pos;
-copy_extent (extent,
+copy_extent (extent, new_start, new_end, closure->new_string);
-	       old_start + closure->new_pos - closure->old_pos,
-	       old_end + closure->new_pos - closure->old_pos,
-	       closure->new_string);
 return 0;
 }
 /* The string NEW_STRING was partially constructed from OLD_STRING.
 In particular, the section of length LEN starting at NEW_POS in
 /* This function can GC */
 Lisp_Object prop, val;
 prop = Fextent_property (extent, Qtext_prop, Qnil);
 if (NILP (prop))
-signal_simple_error ("internal error: no text-prop", extent);
+signal_simple_error ("Internal error: no text-prop", extent);
 val = Fextent_property (extent, prop, Qnil);
 #if 0
 /* removed by bill perry, 2/9/97
 ** This little bit of code would not allow you to have a text property
 ** with a value of Qnil.  This is bad bad bad.
 */
 if (NILP (val))
-signal_simple_error_2 ("internal error: no text-prop",
+signal_simple_error_2 ("Internal error: no text-prop",
 			   extent, prop);
 #endif
 Fput_text_property (from, to, prop, val, Qnil);
 return Qnil; /* important! */
 }
 See `set-extent-priority'.
 */ );
 /* Set mouse-highlight-priority (which ends up being used both for the
 mouse-highlighting pseudo-extent and the primary selection extent)
 to a very high value because very few extents should override it.
-1000 gives lots of room below it for different-prioritied extents.
+1000 gives lots of room below it for different-prioritized extents.
 10 doesn't. ediff, for example, likes to use priorities around 100.
 --ben */
 mouse_highlight_priority = /* 10 */ 1000;
 DEFVAR_LISP ("default-text-properties", &Vdefault_text_properties /*
 void
 complex_vars_of_extents (void)
 {
 staticpro (&Vextent_face_memoize_hash_table);
-/* The memoize hash-table maps from lists of symbols to lists of
+/* The memoize hash table maps from lists of symbols to lists of
 faces.  It needs to be `equal' to implement the memoization.
 The reverse table maps in the other direction and just needs
 to do `eq' comparison because the lists of faces are already
 memoized. */
 Vextent_face_memoize_hash_table =
-make_lisp_hashtable (100, HASHTABLE_VALUE_WEAK, HASHTABLE_EQUAL);
+make_lisp_hash_table (100, HASH_TABLE_VALUE_WEAK, HASH_TABLE_EQUAL);
 staticpro (&Vextent_face_reverse_memoize_hash_table);
 Vextent_face_reverse_memoize_hash_table =
-make_lisp_hashtable (100, HASHTABLE_KEY_WEAK, HASHTABLE_EQ);
+make_lisp_hash_table (100, HASH_TABLE_KEY_WEAK, HASH_TABLE_EQ);
 }

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 380:8626e4521993 r21-2-5