#define lisp_h_MISCP(x) (SMOB_TYPEP (x, lisp_misc_tag))
#define lisp_h_NILP(x) (scm_is_lisp_false (x))
#define lisp_h_SET_SYMBOL_VAL(sym, v) \
- (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value = (v))
-#define lisp_h_SYMBOL_CONSTANT_P(sym) (XSYMBOL (sym)->constant)
+ (eassert (SYMBOL_REDIRECT (sym) == SYMBOL_PLAINVAL), \
+ scm_c_vector_set_x (sym, 4, v))
+#define lisp_h_SYMBOL_CONSTANT_P(sym) (SYMBOL_CONSTANT (XSYMBOL (sym)))
#define lisp_h_SYMBOL_VAL(sym) \
- (eassert ((sym)->redirect == SYMBOL_PLAINVAL), (sym)->val.value)
+ (eassert (SYMBOL_REDIRECT (sym) == SYMBOL_PLAINVAL), \
+ scm_c_vector_ref (sym, 4))
#define lisp_h_SYMBOLP(x) \
(x && (scm_is_symbol (x) || EQ (x, Qnil) || EQ (x, Qt)))
#define lisp_h_VECTORLIKEP(x) (SMOB_TYPEP (x, lisp_vectorlike_tag))
extern Lisp_Object plist_module;
extern Lisp_Object Qt, Qnil, Qt_, Qnil_;
-INLINE struct Lisp_Symbol *
+typedef Lisp_Object sym_t;
+
+INLINE sym_t
XSYMBOL (Lisp_Object a)
{
Lisp_Object tem;
if (EQ (a, Qnil)) a = Qnil_;
eassert (SYMBOLP (a));
tem = scm_variable_ref (scm_module_lookup (symbol_module, a));
- return scm_to_pointer (tem);
+ return tem;
}
/* Pseudovector types. */
#define XSETFASTINT(a, b) ((a) = make_natnum (b))
#define XSETVECTOR(a, b) ((a) = (b)->header.self)
#define XSETSTRING(a, b) ((a) = (b)->self)
-#define XSETSYMBOL(a, b) ((a) = (b)->self)
+#define XSETSYMBOL(a, b) ((a) = scm_c_vector_ref (b, 0))
#define XSETMISC(a, b) (a) = ((union Lisp_Misc *) (b))->u_any.self
/* Pseudovector types. */
struct Lisp_Symbol
{
- Lisp_Object self;
+ Lisp_Object self_;
/* Indicates where the value can be found:
0 : it's a plain var, the value is in the `value' field.
1 : it's a varalias, the value is really in the `alias' symbol.
2 : it's a localized var, the value is in the `blv' object.
3 : it's a forwarding variable, the value is in `forward'. */
- ENUM_BF (symbol_redirect) redirect : 3;
+ ENUM_BF (symbol_redirect) redirect_ : 3;
/* Non-zero means symbol is constant, i.e. changing its value
should signal an error. If the value is 3, then the var
can be changed, but only by `defconst'. */
- unsigned constant : 2;
+ unsigned constant_ : 2;
/* True means that this variable has been explicitly declared
special (with `defvar' etc), and shouldn't be lexically bound. */
- bool_bf declared_special : 1;
-
- /* True if pointed to from purespace and hence can't be GC'd. */
- bool_bf pinned : 1;
+ bool_bf declared_special_ : 1;
/* Value of the symbol or Qunbound if unbound. Which alternative of the
union is used depends on the `redirect' field above. */
union {
- Lisp_Object value;
- struct Lisp_Symbol *alias;
- struct Lisp_Buffer_Local_Value *blv;
- union Lisp_Fwd *fwd;
- } val;
+ Lisp_Object value_;
+ sym_t alias_;
+ struct Lisp_Buffer_Local_Value *blv_;
+ union Lisp_Fwd *fwd_;
+ };
};
-/* Value is name of symbol. */
+#define SYMBOL_SELF(sym) (scm_c_vector_ref (sym, 0))
+#define SET_SYMBOL_SELF(sym, v) (scm_c_vector_set_x (sym, 0, v))
+#define SYMBOL_REDIRECT(sym) (XINT (scm_c_vector_ref (sym, 1)))
+#define SET_SYMBOL_REDIRECT(sym, v) (scm_c_vector_set_x (sym, 1, make_number (v)))
+#define SYMBOL_CONSTANT(sym) (XINT (scm_c_vector_ref (sym, 2)))
+#define SET_SYMBOL_CONSTANT(sym, v) (scm_c_vector_set_x (sym, 2, make_number (v)))
+#define SYMBOL_DECLARED_SPECIAL(sym) (XINT (scm_c_vector_ref (sym, 3)))
+#define SET_SYMBOL_DECLARED_SPECIAL(sym, v) (scm_c_vector_set_x (sym, 3, make_number (v)))
-LISP_MACRO_DEFUN (SYMBOL_VAL, Lisp_Object, (struct Lisp_Symbol *sym), (sym))
+/* Value is name of symbol. */
-INLINE struct Lisp_Symbol *
-SYMBOL_ALIAS (struct Lisp_Symbol *sym)
+INLINE sym_t
+SYMBOL_ALIAS (sym_t sym)
{
- eassert (sym->redirect == SYMBOL_VARALIAS);
- return sym->val.alias;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_VARALIAS);
+ return scm_c_vector_ref (sym, 4);
}
INLINE struct Lisp_Buffer_Local_Value *
-SYMBOL_BLV (struct Lisp_Symbol *sym)
+SYMBOL_BLV (sym_t sym)
{
- eassert (sym->redirect == SYMBOL_LOCALIZED);
- return sym->val.blv;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_LOCALIZED);
+ return scm_to_pointer (scm_c_vector_ref (sym, 4));
}
INLINE union Lisp_Fwd *
-SYMBOL_FWD (struct Lisp_Symbol *sym)
+SYMBOL_FWD (sym_t sym)
{
- eassert (sym->redirect == SYMBOL_FORWARDED);
- return sym->val.fwd;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_FORWARDED);
+ return scm_to_pointer (scm_c_vector_ref (sym, 4));
}
LISP_MACRO_DEFUN_VOID (SET_SYMBOL_VAL,
- (struct Lisp_Symbol *sym, Lisp_Object v), (sym, v))
+ (sym_t sym, Lisp_Object v), (sym, v))
INLINE void
-SET_SYMBOL_ALIAS (struct Lisp_Symbol *sym, struct Lisp_Symbol *v)
+SET_SYMBOL_ALIAS (sym_t sym, sym_t v)
{
- eassert (sym->redirect == SYMBOL_VARALIAS);
- sym->val.alias = v;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_VARALIAS);
+ scm_c_vector_set_x (sym, 4, v);
}
INLINE void
-SET_SYMBOL_BLV (struct Lisp_Symbol *sym, struct Lisp_Buffer_Local_Value *v)
+SET_SYMBOL_BLV (sym_t sym, struct Lisp_Buffer_Local_Value *v)
{
- eassert (sym->redirect == SYMBOL_LOCALIZED);
- sym->val.blv = v;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_LOCALIZED);
+ scm_c_vector_set_x (sym, 4, scm_from_pointer (v, NULL));
}
INLINE void
-SET_SYMBOL_FWD (struct Lisp_Symbol *sym, union Lisp_Fwd *v)
+SET_SYMBOL_FWD (sym_t sym, union Lisp_Fwd *v)
{
- eassert (sym->redirect == SYMBOL_FORWARDED);
- sym->val.fwd = v;
+ eassert (SYMBOL_REDIRECT (sym) == SYMBOL_FORWARDED);
+ scm_c_vector_set_x (sym, 4, scm_from_pointer (v, NULL));
}
INLINE Lisp_Object
#define DEFSYM(sym, name) \
do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (false)
+LISP_MACRO_DEFUN (SYMBOL_VAL, Lisp_Object, (sym_t sym), (sym))
+
\f
/***********************************************************************
Hash Tables
extern intmax_t cons_to_signed (Lisp_Object, intmax_t, intmax_t);
extern uintmax_t cons_to_unsigned (Lisp_Object, uintmax_t);
-extern struct Lisp_Symbol *indirect_variable (struct Lisp_Symbol *);
+extern sym_t indirect_variable (sym_t );
extern _Noreturn void args_out_of_range (Lisp_Object, Lisp_Object);
extern _Noreturn void args_out_of_range_3 (Lisp_Object, Lisp_Object,
Lisp_Object);
extern Lisp_Object do_symval_forwarding (union Lisp_Fwd *);
extern void set_internal (Lisp_Object, Lisp_Object, Lisp_Object, bool);
extern void syms_of_data (void);
-extern void swap_in_global_binding (struct Lisp_Symbol *);
+extern void swap_in_global_binding (sym_t );
/* Defined in cmds.c */
extern void syms_of_cmds (void);
extern void mark_specpdl (void);
extern void get_backtrace (Lisp_Object array);
Lisp_Object backtrace_top_function (void);
-extern bool let_shadows_buffer_binding_p (struct Lisp_Symbol *symbol);
+extern bool let_shadows_buffer_binding_p (sym_t symbol);
extern bool let_shadows_global_binding_p (Lisp_Object symbol);
extern _Noreturn SCM abort_to_prompt (SCM, SCM);
extern SCM call_with_prompt (SCM, SCM, SCM);