+2012-08-07 Dmitry Antipov <dmantipov@yandex.ru>
+
+ * coccinelle/overlay.cocci, coccinelle/symbol.cocci: Remove.
+
2012-08-02 Paul Eggert <eggert@cs.ucla.edu>
Port to Solaris 8.
+++ /dev/null
-// Change direct access to Lisp_Object fields of struct
-// Lisp_Overlay to MVAR. Beginning M denotes "misc", and
-// MVAR is likely to be used for other second-class objects.
-@@
-struct Lisp_Overlay *V;
-Lisp_Object O;
-@@
-(
-- V->start
-+ MVAR (V, start)
-|
-- V->end
-+ MVAR (V, end)
-|
-- V->plist
-+ MVAR (V, plist)
-
-|
-
-- XOVERLAY (O)->start
-+ MVAR (XOVERLAY (O), start)
-|
-- XOVERLAY (O)->end
-+ MVAR (XOVERLAY (O), end)
-|
-- XOVERLAY (O)->plist
-+ MVAR (XOVERLAY (O), plist)
-)
+++ /dev/null
-// Change direct access to Lisp_Object fields of struct Lisp_Symbol to SVAR.
-@@
-struct Lisp_Symbol *S;
-Lisp_Object O;
-@@
-(
-- S->xname
-+ SVAR (S, xname)
-|
-- S->val.value
-+ SVAR (S, val.value)
-|
-- S->function
-+ SVAR (S, function)
-|
-- S->plist
-+ SVAR (S, plist)
-
-|
-
-- XSYMBOL (O)->xname
-+ SVAR (XSYMBOL (O), xname)
-|
-- XSYMBOL (O)->val.value
-+ SVAR (XSYMBOL (O), val.value)
-|
-- XSYMBOL (O)->function
-+ SVAR (XSYMBOL (O), function)
-|
-- XSYMBOL (O)->plist
-+ SVAR (XSYMBOL (O), plist)
-)
define xprintsym
xgetptr $arg0
set $sym = (struct Lisp_Symbol *) $ptr
- xgetptr $sym->xname_
+ xgetptr $sym->name
set $sym_name = (struct Lisp_String *) $ptr
xprintstr $sym_name
end
# $ptr is NULL in temacs
if ($ptr != 0)
set $tem = (struct Lisp_Symbol *) $ptr
- xgetptr $tem->xname_
+ xgetptr $tem->name
set $tem = (struct Lisp_String *) $ptr
set $tem = (char *) $tem->data
silent
xgetptr globals.f_Vinitial_window_system
set $tem = (struct Lisp_Symbol *) $ptr
- xgetptr $tem->xname_
+ xgetptr $tem->name
set $tem = (struct Lisp_String *) $ptr
set $tem = (char *) $tem->data
# If we are running in synchronous mode, we want a chance to look
+2012-08-07 Dmitry Antipov <dmantipov@yandex.ru>
+
+ Revert and cleanup Lisp_Cons, Lisp_Misc and Lisp_Symbol things.
+ * lisp.h (struct Lisp_Symbol): Change xname to meaningful
+ name since all xname users are fixed long time ago. Do not
+ use INTERNAL_FIELD.
+ (set_symbol_name, set_symbol_function, set_symbol_plist):
+ (set_symbol_next, set_overlay_plist): New function.
+ (struct Lisp_Cons): Do not use INTERNAL_FIELD.
+ (struct Lisp_Overlay): Likewise.
+ (CVAR, MVAR, SVAR): Remove.
+ * alloc.c, buffer.c, buffer.h, bytecode.c, cmds.c, data.c:
+ * doc.c, eval.c, fns.c, keyboard.c, lread.c, nsselect.m:
+ * xterm.c: Adjust users.
+ * .gdbinit: Change to use name field of struct Lisp_Symbol
+ where appropriate.
+
2012-08-07 Dmitry Antipov <dmantipov@yandex.ru>
Basic functions to set Lisp_Object and pointer slots of intervals.
{
ptr->u.chain = cons_free_list;
#if GC_MARK_STACK
- CVAR (ptr, car) = Vdead;
+ ptr->car = Vdead;
#endif
cons_free_list = ptr;
consing_since_gc -= sizeof *ptr;
MALLOC_UNBLOCK_INPUT;
p = XSYMBOL (val);
- SVAR (p, xname) = name;
- SVAR (p, plist) = Qnil;
+ set_symbol_name (val, name);
+ set_symbol_plist (val, Qnil);
p->redirect = SYMBOL_PLAINVAL;
SET_SYMBOL_VAL (p, Qunbound);
- SVAR (p, function) = Qunbound;
- p->next = NULL;
+ set_symbol_function (val, Qunbound);
+ set_symbol_next (val, NULL);
p->gcmarkbit = 0;
p->interned = SYMBOL_UNINTERNED;
p->constant = 0;
overlay = allocate_misc (Lisp_Misc_Overlay);
OVERLAY_START (overlay) = start;
OVERLAY_END (overlay) = end;
- OVERLAY_PLIST (overlay) = plist;
+ set_overlay_plist (overlay, plist);
XOVERLAY (overlay)->next = NULL;
return overlay;
}
&& offset < (CONS_BLOCK_SIZE * sizeof b->conses[0])
&& (b != cons_block
|| offset / sizeof b->conses[0] < cons_block_index)
- && !EQ (CVAR ((struct Lisp_Cons *) p, car), Vdead));
+ && !EQ (((struct Lisp_Cons *) p)->car, Vdead));
}
else
return 0;
&& offset < (SYMBOL_BLOCK_SIZE * sizeof b->symbols[0])
&& (b != symbol_block
|| offset / sizeof b->symbols[0] < symbol_block_index)
- && !EQ (SVAR (((struct Lisp_Symbol *)p), function), Vdead));
+ && !EQ (((struct Lisp_Symbol *)p)->function, Vdead));
}
else
return 0;
for (; ptr && !ptr->gcmarkbit; ptr = ptr->next)
{
ptr->gcmarkbit = 1;
- mark_object (MVAR (ptr, start));
- mark_object (MVAR (ptr, end));
- mark_object (MVAR (ptr, plist));
+ mark_object (ptr->start);
+ mark_object (ptr->end);
+ mark_object (ptr->plist);
}
}
break;
CHECK_ALLOCATED_AND_LIVE (live_symbol_p);
ptr->gcmarkbit = 1;
- mark_object (SVAR (ptr, function));
- mark_object (SVAR (ptr, plist));
+ mark_object (ptr->function);
+ mark_object (ptr->plist);
switch (ptr->redirect)
{
case SYMBOL_PLAINVAL: mark_object (SYMBOL_VAL (ptr)); break;
break;
default: abort ();
}
- if (!PURE_POINTER_P (XSTRING (SVAR (ptr, xname))))
- MARK_STRING (XSTRING (SVAR (ptr, xname)));
- MARK_INTERVAL_TREE (STRING_INTERVALS (SVAR (ptr, xname)));
+ if (!PURE_POINTER_P (XSTRING (ptr->name)))
+ MARK_STRING (XSTRING (ptr->name));
+ MARK_INTERVAL_TREE (STRING_INTERVALS (ptr->name));
ptr = ptr->next;
if (ptr)
CHECK_ALLOCATED_AND_LIVE (live_cons_p);
CONS_MARK (ptr);
/* If the cdr is nil, avoid recursion for the car. */
- if (EQ (CVAR (ptr, u.cdr), Qnil))
+ if (EQ (ptr->u.cdr, Qnil))
{
- obj = CVAR (ptr, car);
+ obj = ptr->car;
cdr_count = 0;
goto loop;
}
- mark_object (CVAR (ptr, car));
- obj = CVAR (ptr, u.cdr);
+ mark_object (ptr->car);
+ obj = ptr->u.cdr;
cdr_count++;
if (cdr_count == mark_object_loop_halt)
abort ();
cblk->conses[pos].u.chain = cons_free_list;
cons_free_list = &cblk->conses[pos];
#if GC_MARK_STACK
- CVAR (cons_free_list, car) = Vdead;
+ cons_free_list->car = Vdead;
#endif
}
else
/* Check if the symbol was created during loadup. In such a case
it might be pointed to by pure bytecode which we don't trace,
so we conservatively assume that it is live. */
- int pure_p = PURE_POINTER_P (XSTRING (sym->s.INTERNAL_FIELD (xname)));
+ int pure_p = PURE_POINTER_P (XSTRING (sym->s.name));
if (!sym->s.gcmarkbit && !pure_p)
{
sym->s.next = symbol_free_list;
symbol_free_list = &sym->s;
#if GC_MARK_STACK
- SVAR (symbol_free_list, function) = Vdead;
+ symbol_free_list->function = Vdead;
#endif
++this_free;
}
{
++num_used;
if (!pure_p)
- UNMARK_STRING (XSTRING (sym->s.INTERNAL_FIELD (xname)));
+ UNMARK_STRING (XSTRING (sym->s.name));
sym->s.gcmarkbit = 0;
}
}
XSETSYMBOL (tem, sym);
val = find_symbol_value (tem);
if (EQ (val, obj)
- || EQ (SVAR (sym, function), obj)
- || (!NILP (SVAR (sym, function))
- && COMPILEDP (SVAR (sym, function))
- && EQ (AREF (SVAR (sym, function), COMPILED_BYTECODE), obj))
+ || EQ (sym->function, obj)
+ || (!NILP (sym->function)
+ && COMPILEDP (sym->function)
+ && EQ (AREF (sym->function, COMPILED_BYTECODE), obj))
|| (!NILP (val)
&& COMPILEDP (val)
&& EQ (AREF (val, COMPILED_BYTECODE), obj)))
Lisp_Object overlay, start, end;
struct Lisp_Marker *m;
- eassert (MARKERP (MVAR (list, start)));
- m = XMARKER (MVAR (list, start));
+ eassert (MARKERP (list->start));
+ m = XMARKER (list->start);
start = build_marker (b, m->charpos, m->bytepos);
XMARKER (start)->insertion_type = m->insertion_type;
- eassert (MARKERP (MVAR (list, end)));
- m = XMARKER (MVAR (list, end));
+ eassert (MARKERP (list->end));
+ m = XMARKER (list->end);
end = build_marker (b, m->charpos, m->bytepos);
XMARKER (end)->insertion_type = m->insertion_type;
- overlay = build_overlay (start, end, Fcopy_sequence (MVAR (list, plist)));
+ overlay = build_overlay (start, end, Fcopy_sequence (list->plist));
if (tail)
tail = tail->next = XOVERLAY (overlay);
else
static void
drop_overlay (struct buffer *b, struct Lisp_Overlay *ov)
{
- eassert (b == XBUFFER (Fmarker_buffer (MVAR (ov, start))));
- modify_overlay (b, marker_position (MVAR (ov, start)),
- marker_position (MVAR (ov, end)));
- Fset_marker (MVAR (ov, start), Qnil, Qnil);
- Fset_marker (MVAR (ov, end), Qnil, Qnil);
+ eassert (b == XBUFFER (Fmarker_buffer (ov->start)));
+ modify_overlay (b, marker_position (ov->start),
+ marker_position (ov->end));
+ Fset_marker (ov->start, Qnil, Qnil);
+ Fset_marker (ov->end, Qnil, Qnil);
}
{
CHECK_OVERLAY (overlay);
- return Fcopy_sequence (MVAR (XOVERLAY (overlay), plist));
+ return Fcopy_sequence (XOVERLAY (overlay)->plist);
}
\f
(Lisp_Object overlay, Lisp_Object prop)
{
CHECK_OVERLAY (overlay);
- return lookup_char_property (MVAR (XOVERLAY (overlay), plist), prop, 0);
+ return lookup_char_property (XOVERLAY (overlay)->plist, prop, 0);
}
DEFUN ("overlay-put", Foverlay_put, Soverlay_put, 3, 3, 0,
buffer = Fmarker_buffer (OVERLAY_START (overlay));
- for (tail = MVAR (XOVERLAY (overlay), plist);
+ for (tail = XOVERLAY (overlay)->plist;
CONSP (tail) && CONSP (XCDR (tail));
tail = XCDR (XCDR (tail)))
if (EQ (XCAR (tail), prop))
}
/* It wasn't in the list, so add it to the front. */
changed = !NILP (value);
- MVAR (XOVERLAY (overlay), plist)
- = Fcons (prop, Fcons (value, MVAR (XOVERLAY (overlay), plist)));
+ set_overlay_plist
+ (overlay, Fcons (prop, Fcons (value, XOVERLAY (overlay)->plist)));
found:
if (! NILP (buffer))
{
/* Return the marker that stands for where OV starts in the buffer. */
-#define OVERLAY_START(OV) MVAR (XOVERLAY (OV), start)
+#define OVERLAY_START(OV) XOVERLAY (OV)->start
/* Return the marker that stands for where OV ends in the buffer. */
-#define OVERLAY_END(OV) MVAR (XOVERLAY (OV), end)
+#define OVERLAY_END(OV) XOVERLAY (OV)->end
/* Return the plist of overlay OV. */
-#define OVERLAY_PLIST(OV) MVAR (XOVERLAY (OV), plist)
+#define OVERLAY_PLIST(OV) XOVERLAY (OV)->plist
/* Return the actual buffer position for the marker P.
We assume you know which buffer it's pointing into. */
&& !EQ (val, Qunbound)
&& !XSYMBOL (sym)->redirect
&& !SYMBOL_CONSTANT_P (sym))
- SVAR (XSYMBOL (sym), val.value) = val;
+ SET_SYMBOL_VAL (XSYMBOL (sym), val);
else
{
BEFORE_POTENTIAL_GC ();
and the hook has a non-nil `no-self-insert' property,
return right away--don't really self-insert. */
if (SYMBOLP (sym) && ! NILP (sym)
- && ! NILP (SVAR (XSYMBOL (sym), function))
- && SYMBOLP (SVAR (XSYMBOL (sym), function)))
+ && ! NILP (XSYMBOL (sym)->function)
+ && SYMBOLP (XSYMBOL (sym)->function))
{
Lisp_Object prop;
- prop = Fget (SVAR (XSYMBOL (sym), function),
- intern ("no-self-insert"));
+ prop = Fget (XSYMBOL (sym)->function, intern ("no-self-insert"));
if (! NILP (prop))
return 1;
}
(register Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
- return (EQ (SVAR (XSYMBOL (symbol), function), Qunbound) ? Qnil : Qt);
+ return EQ (XSYMBOL (symbol)->function, Qunbound) ? Qnil : Qt;
}
DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0,
CHECK_SYMBOL (symbol);
if (NILP (symbol) || EQ (symbol, Qt))
xsignal1 (Qsetting_constant, symbol);
- SVAR (XSYMBOL (symbol), function) = Qunbound;
+ set_symbol_function (symbol, Qunbound);
return symbol;
}
(register Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
- if (!EQ (SVAR (XSYMBOL (symbol), function), Qunbound))
- return SVAR (XSYMBOL (symbol), function);
+ if (!EQ (XSYMBOL (symbol)->function, Qunbound))
+ return XSYMBOL (symbol)->function;
xsignal1 (Qvoid_function, symbol);
}
(register Lisp_Object symbol)
{
CHECK_SYMBOL (symbol);
- return SVAR (XSYMBOL (symbol), plist);
+ return XSYMBOL (symbol)->plist;
}
DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0,
if (NILP (symbol) || EQ (symbol, Qt))
xsignal1 (Qsetting_constant, symbol);
- function = SVAR (XSYMBOL (symbol), function);
+ function = XSYMBOL (symbol)->function;
if (!NILP (Vautoload_queue) && !EQ (function, Qunbound))
Vautoload_queue = Fcons (Fcons (symbol, function), Vautoload_queue);
if (CONSP (function) && EQ (XCAR (function), Qautoload))
Fput (symbol, Qautoload, XCDR (function));
- SVAR (XSYMBOL (symbol), function) = definition;
+ set_symbol_function (symbol, definition);
/* Handle automatic advice activation. */
- if (CONSP (SVAR (XSYMBOL (symbol), plist))
+ if (CONSP (XSYMBOL (symbol)->plist)
&& !NILP (Fget (symbol, Qad_advice_info)))
{
call2 (Qad_activate_internal, symbol, Qnil);
- definition = SVAR (XSYMBOL (symbol), function);
+ definition = XSYMBOL (symbol)->function;
}
return definition;
}
(register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
{
CHECK_SYMBOL (symbol);
- if (CONSP (SVAR (XSYMBOL (symbol), function))
- && EQ (XCAR (SVAR (XSYMBOL (symbol), function)), Qautoload))
+ if (CONSP (XSYMBOL (symbol)->function)
+ && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload))
LOADHIST_ATTACH (Fcons (Qt, symbol));
if (!NILP (Vpurify_flag)
/* If `definition' is a keymap, immutable (and copying) is wrong. */
(register Lisp_Object symbol, Lisp_Object newplist)
{
CHECK_SYMBOL (symbol);
- SVAR (XSYMBOL (symbol), plist) = newplist;
+ set_symbol_plist (symbol, newplist);
return newplist;
}
{
if (!SYMBOLP (hare) || EQ (hare, Qunbound))
break;
- hare = SVAR (XSYMBOL (hare), function);
+ hare = XSYMBOL (hare)->function;
if (!SYMBOLP (hare) || EQ (hare, Qunbound))
break;
- hare = SVAR (XSYMBOL (hare), function);
+ hare = XSYMBOL (hare)->function;
- tortoise = SVAR (XSYMBOL (tortoise), function);
+ tortoise = XSYMBOL (tortoise)->function;
if (EQ (hare, tortoise))
xsignal1 (Qcyclic_function_indirection, object);
/* Optimize for no indirection. */
result = object;
if (SYMBOLP (result) && !EQ (result, Qunbound)
- && (result = SVAR (XSYMBOL (result), function), SYMBOLP (result)))
+ && (result = XSYMBOL (result)->function, SYMBOLP (result)))
result = indirect_function (result);
if (!EQ (result, Qunbound))
return result;
defsubr (&Ssubr_arity);
defsubr (&Ssubr_name);
- SVAR (XSYMBOL (Qwholenump), function) = SVAR (XSYMBOL (Qnatnump), function);
+ set_symbol_function (Qwholenump, XSYMBOL (Qnatnump)->function);
DEFVAR_LISP ("most-positive-fixnum", Vmost_positive_fixnum,
doc: /* The largest value that is representable in a Lisp integer. */);
{
/* Don't use indirect_function here, or defaliases will apply their
docstrings to the base functions (Bug#2603). */
- Lisp_Object fun = SYMBOLP (obj) ? SVAR (XSYMBOL (obj), function) : obj;
+ Lisp_Object fun = SYMBOLP (obj) ? XSYMBOL (obj)->function : obj;
/* The type determines where the docstring is stored. */
tem = Fassq (sym, environment);
if (NILP (tem))
{
- def = SVAR (XSYMBOL (sym), function);
+ def = XSYMBOL (sym)->function;
if (!EQ (def, Qunbound))
continue;
}
CHECK_STRING (file);
/* If function is defined and not as an autoload, don't override. */
- if (!EQ (SVAR (XSYMBOL (function), function), Qunbound)
- && !(CONSP (SVAR (XSYMBOL (function), function))
- && EQ (XCAR (SVAR (XSYMBOL (function), function)), Qautoload)))
+ if (!EQ (XSYMBOL (function)->function, Qunbound)
+ && !(CONSP (XSYMBOL (function)->function)
+ && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
return Qnil;
if (NILP (Vpurify_flag))
/* Optimize for no indirection. */
fun = original_fun;
if (SYMBOLP (fun) && !EQ (fun, Qunbound)
- && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun)))
+ && (fun = XSYMBOL (fun)->function, SYMBOLP (fun)))
fun = indirect_function (fun);
if (SUBRP (fun))
/* Optimize for no indirection. */
if (SYMBOLP (fun) && !EQ (fun, Qunbound)
- && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun)))
+ && (fun = XSYMBOL (fun)->function, SYMBOLP (fun)))
fun = indirect_function (fun);
if (EQ (fun, Qunbound))
{
/* Optimize for no indirection. */
fun = original_fun;
if (SYMBOLP (fun) && !EQ (fun, Qunbound)
- && (fun = SVAR (XSYMBOL (fun), function), SYMBOLP (fun)))
+ && (fun = XSYMBOL (fun)->function, SYMBOLP (fun)))
fun = indirect_function (fun);
if (SUBRP (fun))
(Lisp_Object symbol, Lisp_Object propname)
{
CHECK_SYMBOL (symbol);
- return Fplist_get (SVAR (XSYMBOL (symbol), plist), propname);
+ return Fplist_get (XSYMBOL (symbol)->plist, propname);
}
DEFUN ("plist-put", Fplist_put, Splist_put, 3, 3, 0,
(Lisp_Object symbol, Lisp_Object propname, Lisp_Object value)
{
CHECK_SYMBOL (symbol);
- SVAR (XSYMBOL (symbol), plist)
- = Fplist_put (SVAR (XSYMBOL (symbol), plist), propname, value);
+ set_symbol_plist
+ (symbol, Fplist_put (XSYMBOL (symbol)->plist, propname, value));
return value;
}
\f
|| !internal_equal (OVERLAY_END (o1), OVERLAY_END (o2),
depth + 1, props))
return 0;
- o1 = MVAR (XOVERLAY (o1), plist);
- o2 = MVAR (XOVERLAY (o2), plist);
+ o1 = XOVERLAY (o1)->plist;
+ o2 = XOVERLAY (o2)->plist;
goto tail_recurse;
}
if (MARKERP (o1))
(such as lmenu.el set it up), check if the
original command matches the cached command. */
&& !(SYMBOLP (def)
- && EQ (tem, SVAR (XSYMBOL (def), function)))))
+ && EQ (tem, XSYMBOL (def)->function))))
keys = Qnil;
}
/* Handle a symbol whose function definition is a keymap
or an array. */
if (SYMBOLP (next) && !NILP (Ffboundp (next))
- && (ARRAYP (SVAR (XSYMBOL (next), function))
- || KEYMAPP (SVAR (XSYMBOL (next), function))))
- next = Fautoload_do_load (SVAR (XSYMBOL (next), function), next, Qnil);
+ && (ARRAYP (XSYMBOL (next)->function)
+ || KEYMAPP (XSYMBOL (next)->function)))
+ next = Fautoload_do_load (XSYMBOL (next)->function, next, Qnil);
/* If the keymap gives a function, not an
array, then call the function with one arg and use
#define CHECK_TYPE(ok, Qxxxp, x) \
do { if (!(ok)) wrong_type_argument (Qxxxp, (x)); } while (0)
-/* Lisp fields are usually hidden from most code and accessed
- via special macros. Only select pieces of code, like the GC,
- are allowed to use INTERNAL_FIELD directly. Objects which
- aren't using this convention should be fixed. */
+/* Deprecated and will be removed soon. */
#define INTERNAL_FIELD(field) field ## _
#define CHECK_STRING_OR_BUFFER(x) \
CHECK_TYPE (STRINGP (x) || BUFFERP (x), Qbuffer_or_string_p, x)
-/* Most code should use this macro to
- access Lisp fields in struct Lisp_Cons. */
-
-#define CVAR(cons, field) ((cons)->INTERNAL_FIELD (field))
-
struct Lisp_Cons
{
/* Car of this cons cell. */
- Lisp_Object INTERNAL_FIELD (car);
+ Lisp_Object car;
union
{
/* Cdr of this cons cell. */
- Lisp_Object INTERNAL_FIELD (cdr);
+ Lisp_Object cdr;
/* Used to chain conses on a free list. */
struct Lisp_Cons *chain;
fields are not accessible as lvalues. (What if we want to switch to
a copying collector someday? Cached cons cell field addresses may be
invalidated at arbitrary points.) */
-#define XCAR_AS_LVALUE(c) (CVAR (XCONS (c), car))
-#define XCDR_AS_LVALUE(c) (CVAR (XCONS (c), u.cdr))
+#define XCAR_AS_LVALUE(c) (XCONS (c)->car)
+#define XCDR_AS_LVALUE(c) (XCONS (c)->u.cdr)
/* Use these from normal code. */
#define XCAR(c) LISP_MAKE_RVALUE (XCAR_AS_LVALUE (c))
SYMBOL_FORWARDED = 3
};
-/* Most code should use this macro to access
- Lisp fields in struct Lisp_Symbol. */
-
-#define SVAR(sym, field) ((sym)->INTERNAL_FIELD (field))
-
struct Lisp_Symbol
{
unsigned gcmarkbit : 1;
special (with `defvar' etc), and shouldn't be lexically bound. */
unsigned declared_special : 1;
- /* The symbol's name, as a Lisp string.
- The name "xname" is used to intentionally break code referring to
- the old field "name" of type pointer to struct Lisp_String. */
- Lisp_Object INTERNAL_FIELD (xname);
+ /* The symbol's name, as a Lisp string. */
+ Lisp_Object name;
/* Value of the symbol or Qunbound if unbound. Which alternative of the
union is used depends on the `redirect' field above. */
union {
- Lisp_Object INTERNAL_FIELD (value);
+ Lisp_Object value;
struct Lisp_Symbol *alias;
struct Lisp_Buffer_Local_Value *blv;
union Lisp_Fwd *fwd;
} val;
/* Function value of the symbol or Qunbound if not fboundp. */
- Lisp_Object INTERNAL_FIELD (function);
+ Lisp_Object function;
/* The symbol's property list. */
- Lisp_Object INTERNAL_FIELD (plist);
+ Lisp_Object plist;
/* Next symbol in obarray bucket, if the symbol is interned. */
struct Lisp_Symbol *next;
/* Value is name of symbol. */
-#define SYMBOL_VAL(sym) \
- (eassert ((sym)->redirect == SYMBOL_PLAINVAL), SVAR (sym, val.value))
-#define SYMBOL_ALIAS(sym) \
+#define SYMBOL_VAL(sym) \
+ (eassert ((sym)->redirect == SYMBOL_PLAINVAL), sym->val.value)
+#define SYMBOL_ALIAS(sym) \
(eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias)
-#define SYMBOL_BLV(sym) \
+#define SYMBOL_BLV(sym) \
(eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv)
-#define SYMBOL_FWD(sym) \
+#define SYMBOL_FWD(sym) \
(eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd)
-#define SET_SYMBOL_VAL(sym, v) \
- (eassert ((sym)->redirect == SYMBOL_PLAINVAL), SVAR (sym, val.value) = (v))
-#define SET_SYMBOL_ALIAS(sym, v) \
+#define SET_SYMBOL_VAL(sym, v) \
+ (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
+#define SET_SYMBOL_ALIAS(sym, v) \
(eassert ((sym)->redirect == SYMBOL_VARALIAS), (sym)->val.alias = (v))
-#define SET_SYMBOL_BLV(sym, v) \
+#define SET_SYMBOL_BLV(sym, v) \
(eassert ((sym)->redirect == SYMBOL_LOCALIZED), (sym)->val.blv = (v))
-#define SET_SYMBOL_FWD(sym, v) \
+#define SET_SYMBOL_FWD(sym, v) \
(eassert ((sym)->redirect == SYMBOL_FORWARDED), (sym)->val.fwd = (v))
-#define SYMBOL_NAME(sym) \
- LISP_MAKE_RVALUE (SVAR (XSYMBOL (sym), xname))
+#define SYMBOL_NAME(sym) XSYMBOL (sym)->name
/* Value is non-zero if SYM is an interned symbol. */
-#define SYMBOL_INTERNED_P(sym) \
- (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
+#define SYMBOL_INTERNED_P(sym) \
+ (XSYMBOL (sym)->interned != SYMBOL_UNINTERNED)
/* Value is non-zero if SYM is interned in initial_obarray. */
-#define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
- (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
+#define SYMBOL_INTERNED_IN_INITIAL_OBARRAY_P(sym) \
+ (XSYMBOL (sym)->interned == SYMBOL_INTERNED_IN_INITIAL_OBARRAY)
/* Value is non-zero if symbol is considered a constant, i.e. its
value cannot be changed (there is an exception for keyword symbols,
whose value can be set to the keyword symbol itself). */
-#define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
+#define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
-#define DEFSYM(sym, name) \
+#define DEFSYM(sym, name) \
do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
\f
static double const DEFAULT_REHASH_SIZE = 1.5;
-/* Most code should use this macro to access
- Lisp fields in a different misc objects. */
-
-#define MVAR(misc, field) ((misc)->INTERNAL_FIELD (field))
-
/* These structures are used for various misc types. */
struct Lisp_Misc_Any /* Supertype of all Misc types. */
unsigned gcmarkbit : 1;
int spacer : 15;
struct Lisp_Overlay *next;
- Lisp_Object INTERNAL_FIELD (start);
- Lisp_Object INTERNAL_FIELD (end);
- Lisp_Object INTERNAL_FIELD (plist);
+ Lisp_Object start;
+ Lisp_Object end;
+ Lisp_Object plist;
};
/* Hold a C pointer for later use.
gc_aset (h->index, idx, val);
}
+/* Use these functions to set Lisp_Object
+ or pointer slots of struct Lisp_Symbol. */
+
+LISP_INLINE void
+set_symbol_name (Lisp_Object sym, Lisp_Object name)
+{
+ XSYMBOL (sym)->name = name;
+}
+
+LISP_INLINE void
+set_symbol_function (Lisp_Object sym, Lisp_Object function)
+{
+ XSYMBOL (sym)->function = function;
+}
+
+LISP_INLINE void
+set_symbol_plist (Lisp_Object sym, Lisp_Object plist)
+{
+ XSYMBOL (sym)->plist = plist;
+}
+
+LISP_INLINE void
+set_symbol_next (Lisp_Object sym, struct Lisp_Symbol *next)
+{
+ XSYMBOL (sym)->next = next;
+}
+
+/* Set overlay's property list. */
+
+LISP_INLINE void
+set_overlay_plist (Lisp_Object overlay, Lisp_Object plist)
+{
+ XOVERLAY (overlay)->plist = plist;
+}
+
/* Defined in data.c. */
extern Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound;
extern Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
ptr = aref_addr (obarray, XINT(tem));
if (SYMBOLP (*ptr))
- XSYMBOL (sym)->next = XSYMBOL (*ptr);
+ set_symbol_next (sym, XSYMBOL (*ptr));
else
- XSYMBOL (sym)->next = 0;
+ set_symbol_next (sym, NULL);
*ptr = sym;
return sym;
}
XSETSYMBOL (following, XSYMBOL (tail)->next);
if (EQ (following, tem))
{
- XSYMBOL (tail)->next = XSYMBOL (following)->next;
+ set_symbol_next (tail, XSYMBOL (following)->next);
break;
}
}
/* Fmake_symbol inits fields of new symbols with Qunbound and Qnil,
so those two need to be fixed manually. */
SET_SYMBOL_VAL (XSYMBOL (Qunbound), Qunbound);
- SVAR (XSYMBOL (Qunbound), function) = Qunbound;
- SVAR (XSYMBOL (Qunbound), plist) = Qnil;
- /* XSYMBOL (Qnil)->function = Qunbound; */
+ set_symbol_function (Qunbound, Qunbound);
+ set_symbol_plist (Qunbound, Qnil);
SET_SYMBOL_VAL (XSYMBOL (Qnil), Qnil);
XSYMBOL (Qnil)->constant = 1;
XSYMBOL (Qnil)->declared_special = 1;
- SVAR (XSYMBOL (Qnil), plist) = Qnil;
+ set_symbol_plist (Qnil, Qnil);
Qt = intern_c_string ("t");
SET_SYMBOL_VAL (XSYMBOL (Qt), Qt);
void
defsubr (struct Lisp_Subr *sname)
{
- Lisp_Object sym;
+ Lisp_Object sym, tem;
sym = intern_c_string (sname->symbol_name);
XSETTYPED_PVECTYPE (sname, size, PVEC_SUBR);
- XSETSUBR (SVAR (XSYMBOL (sym), function), sname);
+ XSETSUBR (tem, sname);
+ set_symbol_function (sym, tem);
}
#ifdef NOTDEF /* Use fset in subr.el now! */
if (EQ (sym, QPRIMARY)) return NXPrimaryPboard;
if (EQ (sym, QSECONDARY)) return NXSecondaryPboard;
if (EQ (sym, QTEXT)) return NSStringPboardType;
- return [NSString stringWithUTF8String: SSDATA (SVAR (XSYMBOL (sym), xname))];
+ return [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (sym))];
}
static NSPasteboard *
terminal->kboard->next_kboard = all_kboards;
all_kboards = terminal->kboard;
- if (!EQ (SVAR (XSYMBOL (Qvendor_specific_keysyms), function), Qunbound))
+ if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
{
char *vendor = ServerVendor (dpy);
projects / emacs.git / commitdiff