xemacs-beta: src/extents.c comparison

comparison src/extents.c @ 185:3d6bfa290dbd r20-3b19

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	e121b013d1f0
children	489f57a838ef

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 int mouse_highlight_priority;
 Lisp_Object Qextentp;
 Lisp_Object Qextent_live_p;
-Lisp_Object Qend_closed;
-Lisp_Object Qstart_open;
 Lisp_Object Qall_extents_closed;
 Lisp_Object Qall_extents_open;
 Lisp_Object Qall_extents_closed_open;
 Lisp_Object Qall_extents_open_closed;
 Lisp_Object Qstart_in_region;
 /* If we have to get more space, get enough to last a while.  We use
 a geometric progession that saves on realloc space. */
 increment += 100 + ga->numels / 8;
-ptr = xrealloc (ptr,
+ptr = (char *) xrealloc (ptr,
-		  (ga->numels + ga->gapsize + increment)*ga->elsize);
+			   (ga->numels + ga->gapsize + increment)*ga->elsize);
 if (ptr == 0)
 memory_full ();
 ga->array = ptr;
 real_gap_loc = ga->gap;
 {
 m = gap_array_marker_freelist;
 gap_array_marker_freelist = gap_array_marker_freelist->next;
 }
 else
-m = (Gap_Array_Marker *) xmalloc (sizeof (*m));
+m = xnew (Gap_Array_Marker);
 m->pos = GAP_ARRAY_ARRAY_TO_MEMORY_POS (ga, pos);
 m->next = ga->markers;
 ga->markers = m;
 return m;
 GAP_ARRAY_MEMORY_TO_ARRAY_POS (ga, (m)->pos)
 static Gap_Array *
 make_gap_array (int elsize)
 {
-Gap_Array *ga = (Gap_Array *) xmalloc (sizeof(*ga));
+Gap_Array *ga = xnew_and_zero (Gap_Array);
-memset (ga, 0, sizeof(*ga));
 ga->elsize = elsize;
 return ga;
 }
 static void
 {
 m = extent_list_marker_freelist;
 extent_list_marker_freelist = extent_list_marker_freelist->next;
 }
 else
-m = (Extent_List_Marker *) xmalloc (sizeof (*m));
+m = xnew (Extent_List_Marker);
 m->m = gap_array_make_marker (endp ? el->end : el->start, pos);
 m->endp = endp;
 m->next = el->markers;
 el->markers = m;
 gap_array_marker_pos ((mkr)->endp ? (el)->end : (el)->start, (mkr)->m)
 static Extent_List *
 allocate_extent_list (void)
 {
-Extent_List *el = (Extent_List *) xmalloc (sizeof(*el));
+Extent_List *el = xnew (Extent_List);
 el->start = make_gap_array (sizeof(EXTENT));
 el->end = make_gap_array (sizeof(EXTENT));
 el->markers = 0;
 return el;
 }
 			       0, 0, 0, struct extent_auxiliary);
 static Lisp_Object
 mark_extent_auxiliary (Lisp_Object obj, void (*markobj) (Lisp_Object))
 {
-struct extent_auxiliary *data =
+struct extent_auxiliary *data = XEXTENT_AUXILIARY (obj);
-(struct extent_auxiliary *) XEXTENT_AUXILIARY (obj);
 ((markobj) (data->begin_glyph));
 ((markobj) (data->end_glyph));
 ((markobj) (data->invisible));
 ((markobj) (data->children));
 ((markobj) (data->read_only));
 void
 allocate_extent_auxiliary (EXTENT ext)
 {
 Lisp_Object extent_aux = Qnil;
 struct extent_auxiliary *data =
-alloc_lcrecord (sizeof (struct extent_auxiliary),
+alloc_lcrecord_type (struct extent_auxiliary, lrecord_extent_auxiliary);
-		    lrecord_extent_auxiliary);
 copy_lcrecord (data, &extent_auxiliary_defaults);
 XSETEXTENT_AUXILIARY (extent_aux, data);
 ext->plist = Fcons (extent_aux, ext->plist);
 ext->flags.has_aux = 1;
 static Lisp_Object
 allocate_extent_info (void)
 {
 Lisp_Object extent_info = Qnil;
 struct extent_info *data =
-alloc_lcrecord (sizeof (struct extent_info),
+alloc_lcrecord_type (struct extent_info, lrecord_extent_info);
-		    lrecord_extent_info);
 XSETEXTENT_INFO (extent_info, data);
 data->extents = allocate_extent_list ();
 data->soe = 0;
 return extent_info;
 }
 static struct stack_of_extents *
 allocate_soe (void)
 {
-struct stack_of_extents *soe =
+struct stack_of_extents *soe = xnew_and_zero (struct stack_of_extents);
-malloc_type_and_zero (struct stack_of_extents);
 soe->extents = allocate_extent_list ();
 soe->pos = -1;
 return soe;
 }
 /*  adjust_extents_for_deletion()  */
 /* ------------------------------- */
 struct adjust_extents_for_deletion_arg
 {
-extent_dynarr *list;
+EXTENT_dynarr *list;
 };
 static int
 adjust_extents_for_deletion_mapper (EXTENT extent, void *arg)
 {
 Stack_Of_Extents *soe = buffer_or_string_stack_of_extents (object);
 #ifdef ERROR_CHECK_EXTENTS
 sledgehammer_extent_check (object);
 #endif
-closure.list = (extent_dynarr *) Dynarr_new (EXTENT);
+closure.list = Dynarr_new (EXTENT);
 /* We're going to be playing weird games below with extents and the SOE
 and such, so compute the list now of all the extents that we're going
 to muck with.  If we do the mapping and adjusting together, things can
 get all screwed up. */
 }
 struct extent_fragment *
 extent_fragment_new (Lisp_Object buffer_or_string, struct frame *frm)
 {
-struct extent_fragment *ef = (struct extent_fragment *)
+struct extent_fragment *ef = xnew_and_zero (struct extent_fragment);
-xmalloc (sizeof (struct extent_fragment));
-memset (ef, 0, sizeof (*ef));
 ef->object = buffer_or_string;
 ef->frm = frm;
 ef->extents = Dynarr_new (EXTENT);
-ef->begin_glyphs = Dynarr_new (struct glyph_block);
+ef->begin_glyphs = Dynarr_new (glyph_block);
-ef->end_glyphs = Dynarr_new (struct glyph_block);
+ef->end_glyphs   = Dynarr_new (glyph_block);
 return ef;
 }
 void
 return -1;
 return extent_priority (foo) > extent_priority (bar);
 }
 static void
-extent_fragment_sort_by_priority (extent_dynarr *extarr)
+extent_fragment_sort_by_priority (EXTENT_dynarr *extarr)
 {
 int i;
 /* Sort our copy of the stack by extent_priority.  We use a bubble
 sort here because it's going to be faster than qsort() for small
 if (print_readably)
 	{
 	  if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	    error ("printing unreadable object #<destroyed extent>");
 	  else
-	    error ("printing unreadable object #<extent 0x%lx>",
+	    error ("printing unreadable object #<extent 0x%p>",
-		   (long)XEXTENT (obj));
+		   XEXTENT (obj));
 	}
 if (!EXTENT_LIVE_P (XEXTENT (obj)))
 	write_c_string ("#<destroyed extent", printcharfun);
 else
 	{
-	  char *buf = alloca (strlen (title) + strlen (name)
+	  char *buf = (char *)
-			      + strlen (posttitle));
+	    alloca (strlen (title) + strlen (name) + strlen (posttitle) + 1);
 	  write_c_string ("#<extent ", printcharfun);
 	  print_extent_1 (obj, printcharfun, escapeflag);
 	  write_c_string (extent_detached_p (XEXTENT (obj))
 			  ? " from " : " in ", printcharfun);
 	  sprintf (buf, "%s%s%s", title, name, posttitle);
 DEFUN ("next-extent", Fnext_extent, 1, 1, 0, /*
 Find next extent after EXTENT.
 If EXTENT is a buffer return the first extent in the buffer; likewise
 for strings.
-Extents in a buffer are ordered in what is called the \"display\"
+Extents in a buffer are ordered in what is called the "display"
 order, which sorts by increasing start positions and then by *decreasing*
 end positions.
 If you want to perform an operation on a series of extents, use
 `map-extents' instead of this function; it is much more efficient.
 The primary use of this function should be to enumerate all the
 }
 #ifdef DEBUG_XEMACS
 DEFUN ("next-e-extent", Fnext_e_extent, 1, 1, 0, /*
-Find next extent after EXTENT using the \"e\" order.
+Find next extent after EXTENT using the "e" order.
 If EXTENT is a buffer return the first extent in the buffer; likewise
 for strings.
 */
 (extent))
 {
 XSETEXTENT (val, next);
 return val;
 }
 DEFUN ("previous-e-extent", Fprevious_e_extent, 1, 1, 0, /*
-Find last extent before EXTENT using the \"e\" order.
+Find last extent before EXTENT using the "e" order.
 If EXTENT is a buffer return the last extent in the buffer; likewise
 for strings.
 This function is analogous to `next-e-extent'.
 */
 (extent))
 /************************************************************************/
 DEFUN ("extent-parent", Fextent_parent, 1, 1, 0, /*
 Return the parent (if any) of EXTENT.
 If an extent has a parent, it derives all its properties from that extent
-and has no properties of its own. (The only \"properties\" that the
+and has no properties of its own. (The only "properties" that the
 extent keeps are the buffer/string it refers to and the start and end
 points.) It is possible for an extent's parent to itself have a parent.
 */
 (extent))
 /* do I win the prize for the strangest split infinitive? */
 {
 /* also need to copy the aux struct.  It won't work for
 	 this extent to share the same aux struct as the original
 	 one. */
 struct extent_auxiliary *data =
-	alloc_lcrecord (sizeof (struct extent_auxiliary),
+	alloc_lcrecord_type (struct extent_auxiliary,
-			lrecord_extent_auxiliary);
+			     lrecord_extent_auxiliary);
 copy_lcrecord (data, XEXTENT_AUXILIARY (XCAR (original->plist)));
 XSETEXTENT_AUXILIARY (XCAR (e->plist), data);
 }
 XSETEXTENT (extent_obj, closure.best_match);
 return extent_obj;
 }
 DEFUN ("extent-at", Fextent_at, 1, 5, 0, /*
-Find \"smallest\" extent at POS in OBJECT having PROPERTY set.
+Find "smallest" extent at POS in OBJECT having PROPERTY set.
-Normally, an extent is \"at\" POS if it overlaps the region (POS, POS+1);
+Normally, an extent is "at" POS if it overlaps the region (POS, POS+1);
 i.e. if it covers the character after POS. (However, see the definition
-of AT-FLAG.) \"Smallest\" means the extent that comes last in the display
+of AT-FLAG.) "Smallest" means the extent that comes last in the display
 order; this normally means the extent whose start position is closest to
 POS.  See `next-extent' for more information.
 OBJECT specifies a buffer or string and defaults to the current buffer.
 PROPERTY defaults to nil, meaning that any extent will do.
 Properties are attached to extents with `set-extent-property', which see.
 DEFUN ("get-text-property", Fget_text_property, 2, 4, 0, /*
 Returns 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\"
+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'.
 See also `get-char-property'.
 */
 (pos, prop, object, at_flag))
 DEFUN ("get-char-property", Fget_char_property, 2, 4, 0, /*
 Returns 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\"
+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.
 See also `get-text-property'.
 */
 (pos, prop, object, at_flag))

Mercurial > hg > xemacs-beta

comparison src/extents.c @ 185:3d6bfa290dbd r20-3b19