xemacs-beta: src/rangetab.c comparison

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

Import from CVS: tag r20-3b19

author	cvs
date	Mon, 13 Aug 2007 09:55:28 +0200
parents	8eaf7971accc
children	c5d627a313b1

comparison

equal deleted inserted replaced

-:bcd2674570bf
+:3d6bfa290dbd
 /* Written by Ben Wing, August 1995. */
 #include <config.h>
 #include "lisp.h"
+typedef struct range_table_entry range_table_entry;
 struct range_table_entry
 {
 EMACS_INT first;
 EMACS_INT last;
 Lisp_Object val;
 };
-typedef struct range_table_entry_dynarr_type
+typedef struct
 {
-Dynarr_declare (struct range_table_entry);
+Dynarr_declare (range_table_entry);
 } range_table_entry_dynarr;
 struct Lisp_Range_Table
 {
 struct lcrecord_header header;
 struct Lisp_Range_Table *rt2 = XRANGE_TABLE (obj2);
 int i;
 if (Dynarr_length (rt1->entries) != Dynarr_length (rt2->entries))
 return 0;
 for (i = 0; i < Dynarr_length (rt1->entries); i++)
 {
 struct range_table_entry *rte1 = Dynarr_atp (rt1->entries, i);
 struct range_table_entry *rte2 = Dynarr_atp (rt2->entries, i);
 	hash = HASH2 (hash,
 		      range_table_entry_hash (Dynarr_atp (rt->entries, i),
 					      depth));
 return hash;
 }
 /* just pick five elements scattered throughout the array.
 A slightly better approach would be to offset by some
 noise factor from the points chosen below. */
 for (i = 0; i < 5; i++)
 hash = HASH2 (hash, range_table_entry_hash (Dynarr_atp (rt->entries,
 static Lisp_Object
 get_range_table (EMACS_INT pos, int nentries, struct range_table_entry *tab,
 		 Lisp_Object default_)
 {
 int left = 0, right = nentries;
 /* binary search for the entry.  Based on similar code in
 extent_list_locate(). */
 while (left != right)
 {
 /* RIGHT might not point to a valid entry (i.e. it's at the end
 You can manipulate it using `put-range-table', `get-range-table',
 `remove-range-table', and `clear-range-table'.
 */
 ())
 {
-struct Lisp_Range_Table *rt;
 Lisp_Object obj;
+struct Lisp_Range_Table *rt = alloc_lcrecord_type (struct Lisp_Range_Table,
-rt = (struct Lisp_Range_Table *)
+						     lrecord_range_table);
-alloc_lcrecord (sizeof (struct Lisp_Range_Table), lrecord_range_table);
+rt->entries = Dynarr_new (range_table_entry);
-rt->entries = Dynarr_new (struct range_table_entry);
 XSETRANGE_TABLE (obj, rt);
 return obj;
 }
 DEFUN ("copy-range-table", Fcopy_range_table, 1, 1, 0, /*
 struct Lisp_Range_Table *rt, *rtnew;
 Lisp_Object obj = Qnil;
 CHECK_RANGE_TABLE (old_table);
 rt = XRANGE_TABLE (old_table);
-rtnew = (struct Lisp_Range_Table *)
-alloc_lcrecord (sizeof (struct Lisp_Range_Table), lrecord_range_table);
+rtnew = alloc_lcrecord_type (struct Lisp_Range_Table, lrecord_range_table);
-rtnew->entries = Dynarr_new (struct range_table_entry);
+rtnew->entries = Dynarr_new (range_table_entry);
 Dynarr_add_many (rtnew->entries, Dynarr_atp (rt->entries, 0),
 		   Dynarr_length (rt->entries));
 XSETRANGE_TABLE (obj, rtnew);
 return obj;
 else if (entry->first < first && entry->last > last)
 	/* looks like:
 	         [ NEW ]
 	       [ EXISTING ]
 	 */
 	/* need to split this one in two. */
 	{
 	  struct range_table_entry insert_me_too;
 	  insert_me_too.first = last + 1;
 	  insert_me_too.last = entry->last;
 	  insert_me_too.val = entry->val;
 	  entry->last = first - 1;
 	  Dynarr_insert_many (rt->entries, &insert_me_too, 1, i + 1);
 	}
 else if (entry->last > last)
 	{
 	  /* looks like:
 	       [ NEW ]
 	         [ EXISTING ]
 	   */
 	  /* truncate the start off of it. */
 }
 /* Someone asked us to delete the range, not insert it. */
 if (UNBOUNDP (val))
 return;
 /* Now insert the new entry, maybe at the end. */
 if (insert_me_here < 0)
 insert_me_here = i;
 {
 struct range_table_entry insert_me;
 insert_me.first = first;
 insert_me.last = last;
 insert_me.val = val;
 Dynarr_insert_many (rt->entries, &insert_me, 1, insert_me_here);
 }
 /* Now see if we can combine this entry with adjacent ones just
 before or after. */
 if (insert_me_here > 0)
 {
 struct range_table_entry *entry = Dynarr_atp (rt->entries,
 						    insert_me_here - 1);
 if (EQ (val, entry->val) && entry->last == first - 1)
 data = Fcar (Fcdr (data)); /* skip over 'data keyword */
 while (!NILP (data))
 	{
 	  Lisp_Object range = Fcar (data);
 	  Lisp_Object val = Fcar (Fcdr (data));
 	  data = Fcdr (Fcdr (data));
 	  if (CONSP (range))
 	    Fput_range_table (Fcar (range), Fcar (Fcdr (range)), val,
 			      rangetab);
 	  else
 for modifying a unified range table.  The only operations
 you can do to unified range tables are
 -- look up a value
 -- retrieve all the ranges in an iterative fashion
 */
 /* The format of a unified range table is as follows:
 -- The first byte contains the number of bytes to skip to find the
 struct unified_range_table
 {
 int nentries;
 struct range_table_entry first;
 };
 /* Return size in bytes needed to store the data in a range table. */
 int
 unified_range_table_bytes_needed (Lisp_Object rangetab)
 {
 return ((* ((unsigned char *) unrangetab + 1))
 	  + ((* ((unsigned char *) unrangetab + 2)) << 8)
 	  + ((* ((unsigned char *) unrangetab + 3)) << 16));
 }
 /* Make sure the table is aligned, and move it around if it's not. */
 static void
 align_the_damn_table (void *unrangetab)
 {
 void *cur_dest = (char *) unrangetab + * (char *) unrangetab;
 #if LONGBITS == 64
 /* memmove() works in the presence of overlapping data. */
 memmove (new_dest, cur_dest, count);
 * (char *) unrangetab = (char) ((char *) new_dest - (char *) unrangetab);
 }
 }
 /* Look up a value in a unified range table. */
 Lisp_Object
 unified_range_table_lookup (void *unrangetab, EMACS_INT pos,
 			    Lisp_Object default_)

Mercurial > hg > xemacs-beta

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