#include "faces.h"
#include "frame.h"
#include "glyphs.h"
-#include "hash.h"
#include "insdel.h"
#include "keymap.h"
#include "opaque.h"
Gap_Array_Marker *markers;
} Gap_Array;
-Gap_Array_Marker *gap_array_marker_freelist;
+static Gap_Array_Marker *gap_array_marker_freelist;
/* Convert a "memory position" (i.e. taking the gap into account) into
the address of the element at (i.e. after) that position. "Memory
Extent_List_Marker *markers;
} Extent_List;
-Extent_List_Marker *extent_list_marker_freelist;
+static Extent_List_Marker *extent_list_marker_freelist;
#define EXTENT_LESS_VALS(e,st,nd) ((extent_start (e) < (st)) || \
((extent_start (e) == (st)) && \
Lisp_Object Qwhitespace;
/* Qtext defined in general.c */
-/* partially used in redisplay */
-Lisp_Object Qglyph_invisible;
-
Lisp_Object Qcopy_function;
Lisp_Object Qpaste_function;
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,
allocate_extent_list (void)
{
Extent_List *el = xnew (Extent_List);
- el->start = make_gap_array (sizeof(EXTENT));
- el->end = make_gap_array (sizeof(EXTENT));
+ el->start = make_gap_array (sizeof (EXTENT));
+ el->end = make_gap_array (sizeof (EXTENT));
el->markers = 0;
return el;
}
/************************************************************************/
static Lisp_Object
-mark_extent_auxiliary (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_extent_auxiliary (Lisp_Object obj)
{
struct extent_auxiliary *data = XEXTENT_AUXILIARY (obj);
- ((markobj) (data->begin_glyph));
- ((markobj) (data->end_glyph));
- ((markobj) (data->invisible));
- ((markobj) (data->children));
- ((markobj) (data->read_only));
- ((markobj) (data->mouse_face));
- ((markobj) (data->initial_redisplay_function));
- ((markobj) (data->before_change_functions));
- ((markobj) (data->after_change_functions));
+ mark_object (data->begin_glyph);
+ mark_object (data->end_glyph);
+ mark_object (data->invisible);
+ mark_object (data->children);
+ mark_object (data->read_only);
+ mark_object (data->mouse_face);
+ mark_object (data->initial_redisplay_function);
+ mark_object (data->before_change_functions);
+ mark_object (data->after_change_functions);
return data->parent;
}
DEFINE_LRECORD_IMPLEMENTATION ("extent-auxiliary", extent_auxiliary,
mark_extent_auxiliary, internal_object_printer,
- 0, 0, 0, struct extent_auxiliary);
+ 0, 0, 0, 0, struct extent_auxiliary);
void
allocate_extent_auxiliary (EXTENT ext)
{
Lisp_Object extent_aux;
struct extent_auxiliary *data =
- alloc_lcrecord_type (struct extent_auxiliary, lrecord_extent_auxiliary);
+ alloc_lcrecord_type (struct extent_auxiliary, &lrecord_extent_auxiliary);
copy_lcrecord (data, &extent_auxiliary_defaults);
XSETEXTENT_AUXILIARY (extent_aux, data);
static void soe_invalidate (Lisp_Object obj);
static Lisp_Object
-mark_extent_info (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_extent_info (Lisp_Object obj)
{
- struct extent_info *data =
- (struct extent_info *) XEXTENT_INFO (obj);
+ struct extent_info *data = (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
(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++)
Lisp_Object exobj;
XSETEXTENT (exobj, extent);
- ((markobj) (exobj));
+ mark_object (exobj);
}
}
DEFINE_LRECORD_IMPLEMENTATION ("extent-info", extent_info,
mark_extent_info, internal_object_printer,
- finalize_extent_info, 0, 0,
+ finalize_extent_info, 0, 0, 0,
struct extent_info);
\f
static Lisp_Object
{
Lisp_Object extent_info;
struct extent_info *data =
- alloc_lcrecord_type (struct extent_info, lrecord_extent_info);
+ alloc_lcrecord_type (struct extent_info, &lrecord_extent_info);
XSETEXTENT_INFO (extent_info, data);
data->extents = allocate_extent_list ();
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;
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. */
flags &= ~ME_START_OPEN;
}
- switch (all_extents_flags)
+ /* So is a zero-length extent. */
+ if (extent_start (extent) == extent_end (extent))
+ start_open = 0, end_open = 0;
+ /* `all_extents_flags' will almost always be zero. */
+ else if (all_extents_flags == 0)
{
- 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;
+ end_open = extent_end_open_p (extent);
}
-
- /* So is a zero-length extent. */
- if (extent_start (extent) == extent_end (extent))
- start_open = end_open = 0;
+ 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
return 0;
/* See if any further restrictions are called for. */
- switch (in_region_flags)
- {
- case ME_START_IN_REGION:
- retval = start <= exs && exs <= end; break;
- case ME_END_IN_REGION:
- retval = start <= exe && exe <= end; break;
- case ME_START_AND_END_IN_REGION:
- retval = start <= exs && exe <= end; break;
- case ME_START_OR_END_IN_REGION:
- retval = (start <= exs && exs <= end) || (start <= exe && exe <= end);
- break;
- default:
- retval = 1; break;
- }
+ /* in_region_flags will almost always be zero. */
+ if (in_region_flags == 0)
+ retval = 1;
+ else
+ switch (in_region_flags)
+ {
+ case ME_START_IN_REGION:
+ retval = start <= exs && exs <= end; break;
+ case ME_END_IN_REGION:
+ retval = start <= exe && exe <= end; break;
+ case ME_START_AND_END_IN_REGION:
+ retval = start <= exs && exe <= end; 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;
}
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 objects. They are similar to the functions for other
lrecord objects. allocate_extent() is in alloc.c, not here. */
-static Lisp_Object mark_extent (Lisp_Object, void (*) (Lisp_Object));
+static Lisp_Object mark_extent (Lisp_Object);
static int extent_equal (Lisp_Object, Lisp_Object, int depth);
static unsigned long extent_hash (Lisp_Object obj, int depth);
static void print_extent (Lisp_Object obj, Lisp_Object printcharfun,
static int extent_remprop (Lisp_Object obj, Lisp_Object prop);
static Lisp_Object extent_plist (Lisp_Object obj);
+static const struct lrecord_description extent_description[] = {
+ { XD_LISP_OBJECT, offsetof (struct extent, object) },
+ { XD_LISP_OBJECT, offsetof (struct extent, flags.face) },
+ { XD_LISP_OBJECT, offsetof (struct extent, plist) },
+ { XD_END }
+};
+
DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("extent", extent,
mark_extent,
print_extent,
Shaft city. */
0,
extent_equal, extent_hash,
+ extent_description,
extent_getprop, extent_putprop,
extent_remprop, extent_plist,
struct extent);
static Lisp_Object
-mark_extent (Lisp_Object obj, void (*markobj) (Lisp_Object))
+mark_extent (Lisp_Object obj)
{
struct extent *extent = XEXTENT (obj);
- ((markobj) (extent_object (extent)));
- ((markobj) (extent_no_chase_normal_field (extent, face)));
+ mark_object (extent_object (extent));
+ mark_object (extent_no_chase_normal_field (extent, face));
return extent->plist;
}
if (extent_detached_p (ext))
strcpy (bp, "detached");
else
- {
- Bufpos from = XINT (Fextent_start_position (obj));
- Bufpos to = XINT (Fextent_end_position (obj));
- sprintf (bp, "%d, %d", from, to);
- }
+ sprintf (bp, "%ld, %ld",
+ (long) XINT (Fextent_start_position (obj)),
+ (long) XINT (Fextent_end_position (obj)));
bp += strlen (bp);
*bp++ = (extent_end_open_p (anc) ? ')': ']');
if (!NILP (extent_end_glyph (anc))) *bp++ = '*';
write_c_string (" ", printcharfun);
}
- sprintf (buf, "0x%lx", (unsigned long int) ext);
+ sprintf (buf, "0x%lx", (long) ext);
write_c_string (buf, printcharfun);
}
if (!EXTENT_LIVE_P (XEXTENT (obj)))
error ("printing unreadable object #<destroyed extent>");
else
- error ("printing unreadable object #<extent 0x%p>",
- XEXTENT (obj));
+ error ("printing unreadable object #<extent 0x%lx>",
+ (long) XEXTENT (obj));
}
if (!EXTENT_LIVE_P (XEXTENT (obj)))
}
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 *e2 = XEXTENT (o2);
+ struct extent *e1 = XEXTENT (obj1);
+ 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));
return -1;
}
- return external_remprop (&ext->plist, prop, 0, ERROR_ME);
+ return external_remprop (extent_plist_addr (ext), prop, 0, ERROR_ME);
}
static Lisp_Object
one. */
struct extent_auxiliary *data =
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);
int speccount;
};
-/* This juggling with the pointer to another file's global variable is
- kind of yucky. Perhaps I should just export the variable. */
-static int *inside_change_hook_pointer;
-
static Lisp_Object
report_extent_modification_restore (Lisp_Object buffer)
{
- *inside_change_hook_pointer = 0;
if (current_buffer != XBUFFER (buffer))
Fset_buffer (buffer);
return Qnil;
/* Now that we are sure to call elisp, set up an unwind-protect so
inside_change_hook gets restored in case we throw. Also record
the current buffer, in case we change it. Do the recording only
- once. */
+ once.
+
+ One confusing thing here is that our caller never actually calls
+ unbind_to (closure.speccount, Qnil). This is because
+ map_extents_bytind() unbinds before, and with a smaller
+ speccount. The additional unbind_to() in
+ report_extent_modification() would cause XEmacs to abort. */
if (closure->speccount == -1)
{
closure->speccount = specpdl_depth ();
/* #### It's a shame that we can't use any of the existing run_hook*
functions here. This is so because all of them work with
symbols, to be able to retrieve default values of local hooks.
- <sigh> */
+ <sigh>
+
+ #### Idea: we could set up a dummy symbol, and call the hook
+ functions on *that*. */
if (!CONSP (hook) || EQ (XCAR (hook), Qlambda))
call3 (hook, exobj, startobj, endobj);
{
Lisp_Object tail;
EXTERNAL_LIST_LOOP (tail, hook)
+ /* #### Shouldn't this perform the same Fset_buffer() check as
+ above? */
call3 (XCAR (tail), exobj, startobj, endobj);
}
return 0;
void
report_extent_modification (Lisp_Object buffer, Bufpos start, Bufpos end,
- int *inside, int afterp)
+ int afterp)
{
struct report_extent_modification_closure closure;
closure.afterp = afterp;
closure.speccount = -1;
- inside_change_hook_pointer = inside;
- *inside = 1;
-
map_extents (start, end, report_extent_modification_mapper, (void *)&closure,
buffer, NULL, ME_MIGHT_CALL_ELISP);
-
- if (closure.speccount == -1)
- *inside = 0;
- else
- {
- /* We mustn't unbind when closure.speccount != -1 because
- map_extents_bytind has already done that. */
- assert (*inside == 0);
- }
}
\f
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
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 */
}
EXTENT extent = decode_extent (extent_obj, DE_MUST_HAVE_BUFFER);
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). */
+ /* Make sure we've actually been given a valid glyph or it's nil
+ (meaning we're deleting a glyph from an extent). */
if (!NILP (glyph))
- CHECK_GLYPH (glyph);
+ CHECK_BUFFER_GLYPH (glyph);
set_extent_glyph (extent, glyph, endp, layout);
return 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) ||
- EQ (property, Qend_open) ||
- EQ (property, Qstart_closed) ||
- EQ (property, Qend_closed))
- {
- int start_open = -1, end_open = -1;
- if (EQ (property, Qstart_open))
- start_open = !NILP (value);
- else if (EQ (property, Qend_open))
- 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, Qstart_open))
+ set_extent_openness (e, !NILP (value), -1);
+ else if (EQ (property, Qend_open))
+ set_extent_openness (e, -1, !NILP (value));
+ /* Support (but don't document...) the obvious *_closed antonyms. */
+ else if (EQ (property, Qstart_closed))
+ set_extent_openness (e, NILP (value), -1);
+ else if (EQ (property, Qend_closed))
+ set_extent_openness (e, -1, NILP (value));
else
{
if (EQ (property, Qkeymap))
{
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)) RETURN_FLAG (start_open);
- else if (EQ (property, Qend_open)) RETURN_FLAG (end_open);
- else if (EQ (property, Qunique)) RETURN_FLAG (unique);
- else if (EQ (property, Qduplicable)) RETURN_FLAG (duplicable);
- else if (EQ (property, Qdetachable)) RETURN_FLAG (detachable);
-#undef RETURN_FLAG
- /* Support (but don't document...) the obvious antonyms. */
+ else if (EQ (property, Qstart_open))
+ return extent_normal_field (e, start_open) ? Qt : Qnil;
+ else if (EQ (property, Qend_open))
+ return extent_normal_field (e, end_open) ? Qt : Qnil;
+ else if (EQ (property, Qunique))
+ return extent_normal_field (e, unique) ? Qt : Qnil;
+ else if (EQ (property, Qduplicable))
+ 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))
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_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;
{
struct copy_string_extents_arg *closure =
(struct copy_string_extents_arg *) arg;
- Bytecount old_start, old_end;
- Bytecount new_start, new_end;
+ Bytecount old_start, old_end, 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,
- old_start + closure->new_pos - closure->old_pos,
- old_end + closure->new_pos - closure->old_pos,
- closure->new_string);
+ copy_extent (extent, new_start, new_end, closure->new_string);
return 0;
}
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
** 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);
defsymbol (&Qwhitespace, "whitespace");
/* Qtext defined in general.c */
- defsymbol (&Qglyph_invisible, "glyph-invisible");
-
defsymbol (&Qpaste_function, "paste-function");
defsymbol (&Qcopy_function, "copy-function");
}
void
+reinit_vars_of_extents (void)
+{
+ extent_auxiliary_defaults.begin_glyph = Qnil;
+ extent_auxiliary_defaults.end_glyph = Qnil;
+ extent_auxiliary_defaults.parent = Qnil;
+ extent_auxiliary_defaults.children = Qnil;
+ extent_auxiliary_defaults.priority = 0;
+ extent_auxiliary_defaults.invisible = Qnil;
+ extent_auxiliary_defaults.read_only = Qnil;
+ extent_auxiliary_defaults.mouse_face = Qnil;
+ extent_auxiliary_defaults.initial_redisplay_function = Qnil;
+ extent_auxiliary_defaults.before_change_functions = Qnil;
+ extent_auxiliary_defaults.after_change_functions = Qnil;
+}
+
+void
vars_of_extents (void)
{
+ reinit_vars_of_extents ();
+
DEFVAR_INT ("mouse-highlight-priority", &mouse_highlight_priority /*
The priority to use for the mouse-highlighting pseudo-extent
that is used to highlight extents with the `mouse-face' attribute set.
/* 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;
Vextent_face_reusable_list = Fcons (Qnil, Qnil);
staticpro (&Vextent_face_reusable_list);
-
- extent_auxiliary_defaults.begin_glyph = Qnil;
- extent_auxiliary_defaults.end_glyph = Qnil;
- extent_auxiliary_defaults.parent = Qnil;
- extent_auxiliary_defaults.children = Qnil;
- extent_auxiliary_defaults.priority = 0;
- extent_auxiliary_defaults.invisible = Qnil;
- extent_auxiliary_defaults.read_only = Qnil;
- extent_auxiliary_defaults.mouse_face = Qnil;
- extent_auxiliary_defaults.initial_redisplay_function = Qnil;
- extent_auxiliary_defaults.before_change_functions = Qnil;
- extent_auxiliary_defaults.after_change_functions = Qnil;
}
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);
}
projects / chise / xemacs-chise.git.1 / blobdiff