2015-01-10 Paul Eggert <eggert@cs.ucla.edu>
+ Port to 32-bit --with-wide-int
+ * make-docfile.c (write_globals): Define and use symbols like
+ iQnil (a small integer, like 0) rather than aQnil (an address
+ constant).
+
Port to 32-bit Sun C 5.12 sparc
* make-docfile.c (close_emacs_globals): Align lispsym to GCALIGNMENT.
The alignment is required on all platforms; it just happens to have
if (ga->type != gb->type)
return ga->type - gb->type;
- /* Consider "nil" to be the least, so that aQnil is firat. That
+ /* Consider "nil" to be the least, so that iQnil is zero. That
way, Qnil's internal representation is zero, which is a bit faster. */
if (ga->type == SYMBOL)
{
}
else if (globals[i].type == SYMBOL)
printf (("DEFINE_LISP_SYMBOL_BEGIN (%s)\n"
- "#define a%s (&lispsym[%d])\n"
- "#define %s make_lisp_symbol (a%s)\n"
- "DEFINE_LISP_SYMBOL_END (a%s)\n\n"),
+ "#define i%s %d\n"
+ "#define %s builtin_lisp_symbol (i%s)\n"
+ "DEFINE_LISP_SYMBOL_END (%s)\n\n"),
globals[i].name, globals[i].name, symnum++,
globals[i].name, globals[i].name, globals[i].name);
else
2015-01-10 Paul Eggert <eggert@cs.ucla.edu>
+ Port to 32-bit --with-wide-int
+ Prefer symbol indexes to struct Lisp_Symbol * casted and then
+ widened, as the latter had trouble with GCC on Fedora 21 when
+ configured --with-wide-int and when used in static initializers.
+ * alloc.c (garbage_collect_1, which_symbols):
+ * lread.c (init_obarray):
+ Prefer builtin_lisp_symbol when it can be used.
+ * dispextern.h (struct image_type.type):
+ * font.c (font_property_table.key):
+ * frame.c (struct frame_parm_table.sym):
+ * keyboard.c (scroll_bar_parts, struct event_head):
+ * xdisp.c (struct props.name):
+ Use the index of a builtin symbol rather than its address.
+ All uses changed.
+ * lisp.h (TAG_SYMPTR, XSYMBOL_INIT): Remove, replacing with ...
+ (TAG_SYMOFFSET, SYMBOL_INDEX): ... new macros that deal with
+ symbol indexes rather than pointers, and which work better on MSB
+ hosts because they shift right before tagging. All uses changed.
+ (DEFINE_LISP_SYMBOL_BEGIN, DEFINE_LISP_SYMBOL_END):
+ No longer noops on wide-int hosts, since they work now.
+ (builtin_lisp_symbol): New function.
+
Port to HAVE_FREETYPE && !HAVE_XFT
* dispextern.h (struct face.extra) [HAVE_FREETYPE && !HAVE_XFT]:
* font.h (syms_of_xftfont) [HAVE_FREETYPE && !HAVE_XFT]:
mark_buffer (&buffer_local_symbols);
for (i = 0; i < ARRAYELTS (lispsym); i++)
- mark_object (make_lisp_symbol (&lispsym[i]));
+ mark_object (builtin_lisp_symbol (i));
for (i = 0; i < staticidx; i++)
mark_object (*staticvec[i]);
{
for (int i = 0; i < ARRAYELTS (lispsym); i++)
{
- Lisp_Object sym = make_lisp_symbol (&lispsym[i]);
+ Lisp_Object sym = builtin_lisp_symbol (i);
if (symbol_uses_obj (sym, obj))
{
found = Fcons (sym, found);
struct image_type
{
- /* A symbol uniquely identifying the image type, e.g., 'jpeg'. */
- struct Lisp_Symbol *type;
+ /* Index of a symbol uniquely identifying the image type, e.g., 'jpeg'. */
+ int type;
/* Check that SPEC is a valid image specification for the given
image type. Value is true if SPEC is valid. */
values. */
static const struct
{
- /* Pointer to the key symbol. */
- struct Lisp_Symbol *key;
+ /* Index of the key symbol. */
+ int key;
/* Function to validate PROP's value VAL, or NULL if any value is
ok. The value is VAL or its regularized value if VAL is valid,
and Qerror if not. */
Lisp_Object (*validator) (Lisp_Object prop, Lisp_Object val);
} font_property_table[] =
- { { XSYMBOL_INIT (QCtype), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCfoundry), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCfamily), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCadstyle), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCregistry), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCweight), font_prop_validate_style },
- { XSYMBOL_INIT (QCslant), font_prop_validate_style },
- { XSYMBOL_INIT (QCwidth), font_prop_validate_style },
- { XSYMBOL_INIT (QCsize), font_prop_validate_non_neg },
- { XSYMBOL_INIT (QCdpi), font_prop_validate_non_neg },
- { XSYMBOL_INIT (QCspacing), font_prop_validate_spacing },
- { XSYMBOL_INIT (QCavgwidth), font_prop_validate_non_neg },
+ { { SYMBOL_INDEX (QCtype), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCfoundry), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCfamily), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCadstyle), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCregistry), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCweight), font_prop_validate_style },
+ { SYMBOL_INDEX (QCslant), font_prop_validate_style },
+ { SYMBOL_INDEX (QCwidth), font_prop_validate_style },
+ { SYMBOL_INDEX (QCsize), font_prop_validate_non_neg },
+ { SYMBOL_INDEX (QCdpi), font_prop_validate_non_neg },
+ { SYMBOL_INDEX (QCspacing), font_prop_validate_spacing },
+ { SYMBOL_INDEX (QCavgwidth), font_prop_validate_non_neg },
/* The order of the above entries must match with enum
font_property_index. */
- { XSYMBOL_INIT (QClang), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCscript), font_prop_validate_symbol },
- { XSYMBOL_INIT (QCotf), font_prop_validate_otf }
+ { SYMBOL_INDEX (QClang), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCscript), font_prop_validate_symbol },
+ { SYMBOL_INDEX (QCotf), font_prop_validate_otf }
};
/* Return an index number of font property KEY or -1 if KEY is not an
int i;
for (i = 0; i < ARRAYELTS (font_property_table); i++)
- if (EQ (key, make_lisp_symbol (font_property_table[i].key)))
+ if (EQ (key, builtin_lisp_symbol (font_property_table[i].key)))
return i;
return -1;
}
if (NILP (val))
return val;
if (NILP (prop))
- prop = make_lisp_symbol (font_property_table[idx].key);
+ prop = builtin_lisp_symbol (font_property_table[idx].key);
else
{
idx = get_font_prop_index (prop);
struct frame_parm_table {
const char *name;
- struct Lisp_Symbol *sym;
+ int sym;
};
static const struct frame_parm_table frame_parms[] =
{
- {"auto-raise", XSYMBOL_INIT (Qauto_raise)},
- {"auto-lower", XSYMBOL_INIT (Qauto_lower)},
- {"background-color", 0},
- {"border-color", XSYMBOL_INIT (Qborder_color)},
- {"border-width", XSYMBOL_INIT (Qborder_width)},
- {"cursor-color", XSYMBOL_INIT (Qcursor_color)},
- {"cursor-type", XSYMBOL_INIT (Qcursor_type)},
- {"font", 0},
- {"foreground-color", 0},
- {"icon-name", XSYMBOL_INIT (Qicon_name)},
- {"icon-type", XSYMBOL_INIT (Qicon_type)},
- {"internal-border-width", XSYMBOL_INIT (Qinternal_border_width)},
- {"right-divider-width", XSYMBOL_INIT (Qright_divider_width)},
- {"bottom-divider-width", XSYMBOL_INIT (Qbottom_divider_width)},
- {"menu-bar-lines", XSYMBOL_INIT (Qmenu_bar_lines)},
- {"mouse-color", XSYMBOL_INIT (Qmouse_color)},
- {"name", XSYMBOL_INIT (Qname)},
- {"scroll-bar-width", XSYMBOL_INIT (Qscroll_bar_width)},
- {"scroll-bar-height", XSYMBOL_INIT (Qscroll_bar_height)},
- {"title", XSYMBOL_INIT (Qtitle)},
- {"unsplittable", XSYMBOL_INIT (Qunsplittable)},
- {"vertical-scroll-bars", XSYMBOL_INIT (Qvertical_scroll_bars)},
- {"horizontal-scroll-bars", XSYMBOL_INIT (Qhorizontal_scroll_bars)},
- {"visibility", XSYMBOL_INIT (Qvisibility)},
- {"tool-bar-lines", XSYMBOL_INIT (Qtool_bar_lines)},
- {"scroll-bar-foreground", XSYMBOL_INIT (Qscroll_bar_foreground)},
- {"scroll-bar-background", XSYMBOL_INIT (Qscroll_bar_background)},
- {"screen-gamma", XSYMBOL_INIT (Qscreen_gamma)},
- {"line-spacing", XSYMBOL_INIT (Qline_spacing)},
- {"left-fringe", XSYMBOL_INIT (Qleft_fringe)},
- {"right-fringe", XSYMBOL_INIT (Qright_fringe)},
- {"wait-for-wm", XSYMBOL_INIT (Qwait_for_wm)},
- {"fullscreen", XSYMBOL_INIT (Qfullscreen)},
- {"font-backend", XSYMBOL_INIT (Qfont_backend)},
- {"alpha", XSYMBOL_INIT (Qalpha)},
- {"sticky", XSYMBOL_INIT (Qsticky)},
- {"tool-bar-position", XSYMBOL_INIT (Qtool_bar_position)},
+ {"auto-raise", SYMBOL_INDEX (Qauto_raise)},
+ {"auto-lower", SYMBOL_INDEX (Qauto_lower)},
+ {"background-color", -1},
+ {"border-color", SYMBOL_INDEX (Qborder_color)},
+ {"border-width", SYMBOL_INDEX (Qborder_width)},
+ {"cursor-color", SYMBOL_INDEX (Qcursor_color)},
+ {"cursor-type", SYMBOL_INDEX (Qcursor_type)},
+ {"font", -1},
+ {"foreground-color", -1},
+ {"icon-name", SYMBOL_INDEX (Qicon_name)},
+ {"icon-type", SYMBOL_INDEX (Qicon_type)},
+ {"internal-border-width", SYMBOL_INDEX (Qinternal_border_width)},
+ {"right-divider-width", SYMBOL_INDEX (Qright_divider_width)},
+ {"bottom-divider-width", SYMBOL_INDEX (Qbottom_divider_width)},
+ {"menu-bar-lines", SYMBOL_INDEX (Qmenu_bar_lines)},
+ {"mouse-color", SYMBOL_INDEX (Qmouse_color)},
+ {"name", SYMBOL_INDEX (Qname)},
+ {"scroll-bar-width", SYMBOL_INDEX (Qscroll_bar_width)},
+ {"scroll-bar-height", SYMBOL_INDEX (Qscroll_bar_height)},
+ {"title", SYMBOL_INDEX (Qtitle)},
+ {"unsplittable", SYMBOL_INDEX (Qunsplittable)},
+ {"vertical-scroll-bars", SYMBOL_INDEX (Qvertical_scroll_bars)},
+ {"horizontal-scroll-bars", SYMBOL_INDEX (Qhorizontal_scroll_bars)},
+ {"visibility", SYMBOL_INDEX (Qvisibility)},
+ {"tool-bar-lines", SYMBOL_INDEX (Qtool_bar_lines)},
+ {"scroll-bar-foreground", SYMBOL_INDEX (Qscroll_bar_foreground)},
+ {"scroll-bar-background", SYMBOL_INDEX (Qscroll_bar_background)},
+ {"screen-gamma", SYMBOL_INDEX (Qscreen_gamma)},
+ {"line-spacing", SYMBOL_INDEX (Qline_spacing)},
+ {"left-fringe", SYMBOL_INDEX (Qleft_fringe)},
+ {"right-fringe", SYMBOL_INDEX (Qright_fringe)},
+ {"wait-for-wm", SYMBOL_INDEX (Qwait_for_wm)},
+ {"fullscreen", SYMBOL_INDEX (Qfullscreen)},
+ {"font-backend", SYMBOL_INDEX (Qfont_backend)},
+ {"alpha", SYMBOL_INDEX (Qalpha)},
+ {"sticky", SYMBOL_INDEX (Qsticky)},
+ {"tool-bar-position", SYMBOL_INDEX (Qtool_bar_position)},
};
#ifdef HAVE_WINDOW_SYSTEM
for (i = 0; i < ARRAYELTS (frame_parms); i++)
{
- Lisp_Object v = (frame_parms[i].sym
- ? make_lisp_symbol (frame_parms[i].sym)
- : intern_c_string (frame_parms[i].name));
+ Lisp_Object v = (frame_parms[i].sym < 0
+ ? intern_c_string (frame_parms[i].name)
+ : builtin_lisp_symbol (frame_parms[i].sym));
Fput (v, Qx_frame_parameter, make_number (i));
}
}
define_image_type (struct image_type *type)
{
struct image_type *p = NULL;
- struct Lisp_Symbol *new_type = type->type;
- bool type_valid = 1;
+ int new_type = type->type;
+ bool type_valid = true;
block_input ();
{
#if defined HAVE_NTGUI && defined WINDOWSNT
/* If we failed to load the library before, don't try again. */
- Lisp_Object tested = Fassq (make_lisp_symbol (new_type), Vlibrary_cache);
+ Lisp_Object tested = Fassq (builtin_lisp_symbol (new_type),
+ Vlibrary_cache);
if (CONSP (tested) && NILP (XCDR (tested)))
- type_valid = 0;
+ type_valid = false;
else
#endif
{
type_valid = type->init ();
- CACHE_IMAGE_TYPE (make_lisp_symbol (new_type),
+ CACHE_IMAGE_TYPE (builtin_lisp_symbol (new_type),
type_valid ? Qt : Qnil);
}
}
/* Do image transformations and compute masks, unless we
don't have the image yet. */
- if (!EQ (make_lisp_symbol (img->type->type), Qpostscript))
+ if (!EQ (builtin_lisp_symbol (img->type->type), Qpostscript))
postprocess_image (f, img);
}
static struct image_type xbm_type =
{
- XSYMBOL_INIT (Qxbm),
+ SYMBOL_INDEX (Qxbm),
xbm_image_p,
xbm_load,
x_clear_image,
static struct image_type xpm_type =
{
- XSYMBOL_INIT (Qxpm),
+ SYMBOL_INDEX (Qxpm),
xpm_image_p,
xpm_load,
x_clear_image,
static struct image_type pbm_type =
{
- XSYMBOL_INIT (Qpbm),
+ SYMBOL_INDEX (Qpbm),
pbm_image_p,
pbm_load,
x_clear_image,
static struct image_type png_type =
{
- XSYMBOL_INIT (Qpng),
+ SYMBOL_INDEX (Qpng),
png_image_p,
png_load,
x_clear_image,
static struct image_type jpeg_type =
{
- XSYMBOL_INIT (Qjpeg),
+ SYMBOL_INDEX (Qjpeg),
jpeg_image_p,
jpeg_load,
x_clear_image,
static struct image_type tiff_type =
{
- XSYMBOL_INIT (Qtiff),
+ SYMBOL_INDEX (Qtiff),
tiff_image_p,
tiff_load,
x_clear_image,
static struct image_type gif_type =
{
- XSYMBOL_INIT (Qgif),
+ SYMBOL_INDEX (Qgif),
gif_image_p,
gif_load,
gif_clear_image,
static struct image_type imagemagick_type =
{
- XSYMBOL_INIT (Qimagemagick),
+ SYMBOL_INDEX (Qimagemagick),
imagemagick_image_p,
imagemagick_load,
imagemagick_clear_image,
static struct image_type svg_type =
{
- XSYMBOL_INIT (Qsvg),
+ SYMBOL_INDEX (Qsvg),
svg_image_p,
svg_load,
x_clear_image,
static struct image_type gs_type =
{
- XSYMBOL_INIT (Qpostscript),
+ SYMBOL_INDEX (Qpostscript),
gs_image_p,
gs_load,
gs_clear_image,
"drag-n-drop"
};
-/* An array of scroll bar parts, indexed by an enum scroll_bar_part value.
- Note that Qnil corresponds to scroll_bar_nowhere and should not appear
- in Lisp events. */
-static struct Lisp_Symbol *const scroll_bar_parts[] = {
- XSYMBOL_INIT (Qnil), XSYMBOL_INIT (Qabove_handle), XSYMBOL_INIT (Qhandle),
- XSYMBOL_INIT (Qbelow_handle), XSYMBOL_INIT (Qup), XSYMBOL_INIT (Qdown),
- XSYMBOL_INIT (Qtop), XSYMBOL_INIT (Qbottom), XSYMBOL_INIT (Qend_scroll),
- XSYMBOL_INIT (Qratio), XSYMBOL_INIT (Qbefore_handle),
- XSYMBOL_INIT (Qhorizontal_handle), XSYMBOL_INIT (Qafter_handle),
- XSYMBOL_INIT (Qleft), XSYMBOL_INIT (Qright), XSYMBOL_INIT (Qleftmost),
- XSYMBOL_INIT (Qrightmost), XSYMBOL_INIT (Qend_scroll), XSYMBOL_INIT (Qratio)
+/* An array of symbol indexes of scroll bar parts, indexed by an enum
+ scroll_bar_part value. Note that Qnil corresponds to
+ scroll_bar_nowhere and should not appear in Lisp events. */
+static short const scroll_bar_parts[] = {
+ SYMBOL_INDEX (Qnil), SYMBOL_INDEX (Qabove_handle), SYMBOL_INDEX (Qhandle),
+ SYMBOL_INDEX (Qbelow_handle), SYMBOL_INDEX (Qup), SYMBOL_INDEX (Qdown),
+ SYMBOL_INDEX (Qtop), SYMBOL_INDEX (Qbottom), SYMBOL_INDEX (Qend_scroll),
+ SYMBOL_INDEX (Qratio), SYMBOL_INDEX (Qbefore_handle),
+ SYMBOL_INDEX (Qhorizontal_handle), SYMBOL_INDEX (Qafter_handle),
+ SYMBOL_INDEX (Qleft), SYMBOL_INDEX (Qright), SYMBOL_INDEX (Qleftmost),
+ SYMBOL_INDEX (Qrightmost), SYMBOL_INDEX (Qend_scroll), SYMBOL_INDEX (Qratio)
};
/* A vector, indexed by button number, giving the down-going location
{
return list5 (ev->frame_or_window, type, Fcons (ev->x, ev->y),
make_number (ev->timestamp),
- make_lisp_symbol (scroll_bar_parts[ev->part]));
+ builtin_lisp_symbol (scroll_bar_parts[ev->part]));
}
/* Given a struct input_event, build the lisp event which represents
{
Lisp_Object part_sym;
- part_sym = make_lisp_symbol (scroll_bar_parts[part]);
+ part_sym = builtin_lisp_symbol (scroll_bar_parts[part]);
return list2 (Qscroll_bar_movement,
list5 (bar_window,
Qvertical_scroll_bar,
/* This type's only use is in syms_of_keyboard, to put properties on the
event header symbols. */
-struct event_head {
- struct Lisp_Symbol *var;
- struct Lisp_Symbol *kind;
+struct event_head
+{
+ short var;
+ short kind;
};
-
-
static const struct event_head head_table[] = {
- {XSYMBOL_INIT (Qmouse_movement), XSYMBOL_INIT (Qmouse_movement)},
- {XSYMBOL_INIT (Qscroll_bar_movement), XSYMBOL_INIT (Qmouse_movement)},
+ {SYMBOL_INDEX (Qmouse_movement), SYMBOL_INDEX (Qmouse_movement)},
+ {SYMBOL_INDEX (Qscroll_bar_movement), SYMBOL_INDEX (Qmouse_movement)},
/* Some of the event heads. */
- {XSYMBOL_INIT (Qswitch_frame), XSYMBOL_INIT (Qswitch_frame)},
+ {SYMBOL_INDEX (Qswitch_frame), SYMBOL_INDEX (Qswitch_frame)},
- {XSYMBOL_INIT (Qfocus_in), XSYMBOL_INIT (Qfocus_in)},
- {XSYMBOL_INIT (Qfocus_out), XSYMBOL_INIT (Qfocus_out)},
- {XSYMBOL_INIT (Qdelete_frame), XSYMBOL_INIT (Qdelete_frame)},
- {XSYMBOL_INIT (Qiconify_frame), XSYMBOL_INIT (Qiconify_frame)},
- {XSYMBOL_INIT (Qmake_frame_visible), XSYMBOL_INIT (Qmake_frame_visible)},
+ {SYMBOL_INDEX (Qfocus_in), SYMBOL_INDEX (Qfocus_in)},
+ {SYMBOL_INDEX (Qfocus_out), SYMBOL_INDEX (Qfocus_out)},
+ {SYMBOL_INDEX (Qdelete_frame), SYMBOL_INDEX (Qdelete_frame)},
+ {SYMBOL_INDEX (Qiconify_frame), SYMBOL_INDEX (Qiconify_frame)},
+ {SYMBOL_INDEX (Qmake_frame_visible), SYMBOL_INDEX (Qmake_frame_visible)},
/* `select-window' should be handled just like `switch-frame'
in read_key_sequence. */
- {XSYMBOL_INIT (Qselect_window), XSYMBOL_INIT (Qswitch_frame)}
+ {SYMBOL_INDEX (Qselect_window), SYMBOL_INDEX (Qswitch_frame)}
};
void
for (i = 0; i < ARRAYELTS (head_table); i++)
{
const struct event_head *p = &head_table[i];
- Lisp_Object var = make_lisp_symbol (p->var);
- Lisp_Object kind = make_lisp_symbol (p->kind);
+ Lisp_Object var = builtin_lisp_symbol (p->var);
+ Lisp_Object kind = builtin_lisp_symbol (p->kind);
Fput (var, Qevent_kind, kind);
Fput (var, Qevent_symbol_elements, list1 (var));
}
#define TAG_PTR(tag, ptr) \
((USE_LSB_TAG ? (tag) : (EMACS_UINT) (tag) << VALBITS) + (uintptr_t) (ptr))
-/* Yield an integer that tags PTR as a symbol. */
-#define TAG_SYMPTR(ptr) \
+/* Yield an integer that contains a symbol tag along with OFFSET.
+ OFFSET should be the offset in bytes from 'lispsym' to the symbol. */
+#define TAG_SYMOFFSET(offset) \
TAG_PTR (Lisp_Symbol, \
- ((uintptr_t) ((char *) (ptr) - (char *) lispsym) \
- >> (USE_LSB_TAG ? 0 : GCTYPEBITS)))
+ ((uintptr_t) (offset) >> (USE_LSB_TAG ? 0 : GCTYPEBITS)))
/* Declare extern constants for Lisp symbols. These can be helpful
when using a debugger like GDB, on older platforms where the debug
- format does not represent C macros. However, they don't work with
- GCC if INTPTR_MAX != EMACS_INT_MAX. */
-#if EMACS_INT_MAX == INTPTR_MAX
-# define DEFINE_LISP_SYMBOL_BEGIN(name) \
- DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name)
-# define DEFINE_LISP_SYMBOL_END(name) \
- DEFINE_GDB_SYMBOL_END (LISP_INITIALLY (TAG_SYMPTR (name)))
-#else
-# define DEFINE_LISP_SYMBOL_BEGIN(name) /* empty */
-# define DEFINE_LISP_SYMBOL_END(name) /* empty */
-#endif
+ format does not represent C macros. */
+#define DEFINE_LISP_SYMBOL_BEGIN(name) \
+ DEFINE_GDB_SYMBOL_BEGIN (Lisp_Object, name)
+#define DEFINE_LISP_SYMBOL_END(name) \
+ DEFINE_GDB_SYMBOL_END (LISP_INITIALLY (TAG_SYMOFFSET (i##name \
+ * sizeof *lispsym)))
#include "globals.h"
return XUNTAG (a, Lisp_String);
}
-/* XSYMBOL_INIT (Qfoo) is like XSYMBOL (Qfoo), except it is valid in
- static initializers, and SYM must be a C-defined symbol. */
-#define XSYMBOL_INIT(sym) a##sym
+/* The index of the C-defined Lisp symbol SYM.
+ This can be used in a static initializer. */
+#define SYMBOL_INDEX(sym) i##sym
INLINE struct Lisp_Float *
XFLOAT (Lisp_Object a)
INLINE Lisp_Object
make_lisp_symbol (struct Lisp_Symbol *sym)
{
- Lisp_Object a = XIL (TAG_SYMPTR (sym));
+ Lisp_Object a = XIL (TAG_SYMOFFSET ((char *) sym - (char *) lispsym));
eassert (XSYMBOL (a) == sym);
return a;
}
+INLINE Lisp_Object
+builtin_lisp_symbol (int index)
+{
+ return make_lisp_symbol (lispsym + index);
+}
+
INLINE Lisp_Object
make_lisp_proc (struct Lisp_Process *p)
{
staticpro (&initial_obarray);
for (int i = 0; i < ARRAYELTS (lispsym); i++)
- define_symbol (make_lisp_symbol (&lispsym[i]), defsym_name[i]);
+ define_symbol (builtin_lisp_symbol (i), defsym_name[i]);
DEFSYM (Qunbound, "unbound");
struct props
{
- /* The name of the property. */
- struct Lisp_Symbol *name;
+ /* The symbol index of the name of the property. */
+ short name;
/* A unique index for the property. */
enum prop_idx idx;
static struct props it_props[] =
{
- {XSYMBOL_INIT (Qfontified), FONTIFIED_PROP_IDX, handle_fontified_prop},
+ {SYMBOL_INDEX (Qfontified), FONTIFIED_PROP_IDX, handle_fontified_prop},
/* Handle `face' before `display' because some sub-properties of
`display' need to know the face. */
- {XSYMBOL_INIT (Qface), FACE_PROP_IDX, handle_face_prop},
- {XSYMBOL_INIT (Qdisplay), DISPLAY_PROP_IDX, handle_display_prop},
- {XSYMBOL_INIT (Qinvisible), INVISIBLE_PROP_IDX, handle_invisible_prop},
- {XSYMBOL_INIT (Qcomposition), COMPOSITION_PROP_IDX, handle_composition_prop},
- {NULL, 0, NULL}
+ {SYMBOL_INDEX (Qface), FACE_PROP_IDX, handle_face_prop},
+ {SYMBOL_INDEX (Qdisplay), DISPLAY_PROP_IDX, handle_display_prop},
+ {SYMBOL_INDEX (Qinvisible), INVISIBLE_PROP_IDX, handle_invisible_prop},
+ {SYMBOL_INDEX (Qcomposition), COMPOSITION_PROP_IDX, handle_composition_prop},
+ {0, 0, NULL}
};
/* Value is the position described by X. If X is a marker, value is
/* Get properties here. */
for (p = it_props; p->handler; ++p)
- values_here[p->idx] = textget (iv->plist, make_lisp_symbol (p->name));
+ values_here[p->idx] = textget (iv->plist,
+ builtin_lisp_symbol (p->name));
/* Look for an interval following iv that has different
properties. */
for (p = it_props; p->handler; ++p)
{
Lisp_Object new_value = textget (next_iv->plist,
- make_lisp_symbol (p->name));
+ builtin_lisp_symbol (p->name));
if (!EQ (values_here[p->idx], new_value))
break;
}