summaryrefslogtreecommitdiff
path: root/libguile/symbols.c
diff options
context:
space:
mode:
Diffstat (limited to 'libguile/symbols.c')
-rw-r--r--libguile/symbols.c781
1 files changed, 781 insertions, 0 deletions
diff --git a/libguile/symbols.c b/libguile/symbols.c
new file mode 100644
index 000000000..4a6dd6065
--- /dev/null
+++ b/libguile/symbols.c
@@ -0,0 +1,781 @@
+/* Copyright (C) 1995,1996 Free Software Foundation, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2, or (at your option)
+ * any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this software; see the file COPYING. If not, write to
+ * the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * As a special exception, the Free Software Foundation gives permission
+ * for additional uses of the text contained in its release of GUILE.
+ *
+ * The exception is that, if you link the GUILE library with other files
+ * to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public License.
+ * Your use of that executable is in no way restricted on account of
+ * linking the GUILE library code into it.
+ *
+ * This exception does not however invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public License.
+ *
+ * This exception applies only to the code released by the
+ * Free Software Foundation under the name GUILE. If you copy
+ * code from other Free Software Foundation releases into a copy of
+ * GUILE, as the General Public License permits, the exception does
+ * not apply to the code that you add in this way. To avoid misleading
+ * anyone as to the status of such modified files, you must delete
+ * this exception notice from them.
+ *
+ * If you write modifications of your own for GUILE, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ */
+
+
+#include <stdio.h>
+#include "_scm.h"
+
+
+
+
+/* NUM_HASH_BUCKETS is the number of symbol scm_hash table buckets.
+ */
+#define NUM_HASH_BUCKETS 137
+
+
+
+
+/* {Symbols}
+ */
+
+#ifdef __STDC__
+unsigned long
+scm_strhash (unsigned char *str, scm_sizet len, unsigned long n)
+#else
+unsigned long
+scm_strhash (str, len, n)
+ unsigned char *str;
+ scm_sizet len;
+ unsigned long n;
+#endif
+{
+ if (len > 5)
+ {
+ scm_sizet i = 5;
+ unsigned long h = 264 % n;
+ while (i--)
+ h = ((h << 8) + ((unsigned) (scm_downcase[str[h % len]]))) % n;
+ return h;
+ }
+ else
+ {
+ scm_sizet i = len;
+ unsigned long h = 0;
+ while (i)
+ h = ((h << 8) + ((unsigned) (scm_downcase[str[--i]]))) % n;
+ return h;
+ }
+}
+
+int scm_symhash_dim = NUM_HASH_BUCKETS;
+
+
+/* scm_sym2vcell
+ * looks up the symbol in the symhash table.
+ */
+#ifdef __STDC__
+SCM
+scm_sym2vcell (SCM sym, SCM thunk, SCM definep)
+#else
+SCM
+scm_sym2vcell (sym, thunk, definep)
+ SCM sym;
+ SCM thunk;
+ SCM definep;
+#endif
+{
+ if (SCM_NIMP(thunk))
+ {
+ SCM var = scm_apply (thunk, sym, scm_cons(definep, scm_listofnull));
+
+ if (var == SCM_BOOL_F)
+ return SCM_BOOL_F;
+ else
+ {
+ if (SCM_IMP(var) || !SCM_VARIABLEP (var))
+ scm_wta (sym, "strangely interned symbol? ", "");
+ return SCM_VARVCELL (var);
+ }
+ }
+ else
+ {
+ SCM lsym;
+ SCM * lsymp;
+ SCM z;
+ scm_sizet scm_hash = scm_strhash (SCM_UCHARS (sym), (scm_sizet) SCM_LENGTH (sym),
+ (unsigned long) scm_symhash_dim);
+
+ SCM_DEFER_INTS;
+ for (lsym = SCM_VELTS (scm_symhash)[scm_hash]; SCM_NIMP (lsym); lsym = SCM_CDR (lsym))
+ {
+ z = SCM_CAR (lsym);
+ if (SCM_CAR (z) == sym)
+ {
+ SCM_ALLOW_INTS;
+ return z;
+ }
+ }
+
+ for (lsym = *(lsymp = &SCM_VELTS (scm_weak_symhash)[scm_hash]);
+ SCM_NIMP (lsym);
+ lsym = *(lsymp = &SCM_CDR (lsym)))
+ {
+ z = SCM_CAR (lsym);
+ if (SCM_CAR (z) == sym)
+ {
+ if (definep)
+ {
+ *lsymp = SCM_CDR (lsym);
+ SCM_SETCDR (lsym, SCM_VELTS(scm_symhash)[scm_hash]);
+ SCM_VELTS(scm_symhash)[scm_hash] = lsym;
+ }
+ SCM_ALLOW_INTS;
+ return z;
+ }
+ }
+ SCM_ALLOW_INTS;
+ return scm_wta (sym, "uninterned symbol? ", "");
+ }
+}
+
+/* scm_sym2ovcell
+ * looks up the symbol in an arbitrary obarray (defaulting to scm_symhash).
+ */
+#ifdef __STDC__
+SCM
+scm_sym2ovcell_soft (SCM sym, SCM obarray)
+#else
+SCM
+scm_sym2ovcell_soft (sym, obarray)
+ SCM sym;
+ SCM obarray;
+#endif
+{
+ SCM lsym, z;
+ scm_sizet scm_hash;
+
+ scm_hash = scm_strhash (SCM_UCHARS (sym),
+ (scm_sizet) SCM_LENGTH (sym),
+ SCM_LENGTH (obarray));
+ SCM_REDEFER_INTS;
+ for (lsym = SCM_VELTS (obarray)[scm_hash];
+ SCM_NIMP (lsym);
+ lsym = SCM_CDR (lsym))
+ {
+ z = SCM_CAR (lsym);
+ if (SCM_CAR (z) == sym)
+ {
+ SCM_REALLOW_INTS;
+ return z;
+ }
+ }
+ SCM_REALLOW_INTS;
+ return SCM_BOOL_F;
+}
+
+#ifdef __STDC__
+SCM
+scm_sym2ovcell (SCM sym, SCM obarray)
+#else
+SCM
+scm_sym2ovcell (sym, obarray)
+ SCM sym;
+ SCM obarray;
+#endif
+{
+ SCM answer;
+ answer = scm_sym2ovcell_soft (sym, obarray);
+ if (answer != SCM_BOOL_F)
+ return answer;
+ scm_wta (sym, "uninterned symbol? ", "");
+ return SCM_UNSPECIFIED; /* not reached */
+}
+
+#ifdef __STDC__
+SCM
+scm_intern_obarray_soft (char *name, scm_sizet len, SCM obarray, int softness)
+#else
+SCM
+scm_intern_obarray_soft (name, len, obarray, softness)
+ char *name;
+ scm_sizet len;
+ SCM obarray;
+ int softness;
+#endif
+{
+ SCM lsym;
+ SCM z;
+ register scm_sizet i;
+ register unsigned char *tmp;
+ scm_sizet scm_hash;
+
+ SCM_REDEFER_INTS;
+
+ i = len;
+ tmp = (unsigned char *) name;
+
+ if (obarray == SCM_BOOL_F)
+ {
+ scm_hash = scm_strhash (tmp, i, 1019);
+ goto uninterned_symbol;
+ }
+
+ scm_hash = scm_strhash (tmp, i, SCM_LENGTH(obarray));
+
+ if (softness == -1)
+ goto mustintern_symbol;
+
+ retry_new_obarray:
+ for (lsym = SCM_VELTS (obarray)[scm_hash]; SCM_NIMP (lsym); lsym = SCM_CDR (lsym))
+ {
+ z = SCM_CAR (lsym);
+ z = SCM_CAR (z);
+ tmp = SCM_UCHARS (z);
+ if (SCM_LENGTH (z) != len)
+ goto trynext;
+ for (i = len; i--;)
+ if (((unsigned char *) name)[i] != tmp[i])
+ goto trynext;
+ {
+ SCM a;
+ a = SCM_CAR (lsym);
+ SCM_REALLOW_INTS;
+ return a;
+ }
+ trynext:;
+ }
+
+ if (obarray == scm_symhash)
+ {
+ obarray = scm_weak_symhash;
+ goto retry_new_obarray;
+ }
+
+ uninterned_symbol:
+ if (softness)
+ {
+ SCM_REALLOW_INTS;
+ return SCM_BOOL_F;
+ }
+
+ mustintern_symbol:
+ lsym = scm_makfromstr (name, len, SCM_SYMBOL_SLOTS);
+
+ SCM_SETLENGTH (lsym, (long) len, scm_tc7_msymbol);
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (lsym) = SCM_BOOL_F;
+ SCM_SYMBOL_HASH (lsym) = scm_hash;
+ if (obarray == SCM_BOOL_F)
+ {
+ SCM answer;
+ SCM_REALLOW_INTS;
+ SCM_NEWCELL (answer);
+ SCM_DEFER_INTS;
+ SCM_CAR (answer) = lsym;
+ SCM_CDR (answer) = SCM_UNDEFINED;
+ SCM_REALLOW_INTS;
+ return answer;
+ }
+ else
+ {
+ SCM a;
+ SCM b;
+
+ SCM_NEWCELL (a);
+ SCM_NEWCELL (b);
+ SCM_SETCAR (a, lsym);
+ SCM_SETCDR (a, SCM_UNDEFINED);
+ SCM_SETCAR (b, a);
+ SCM_SETCDR (b, SCM_VELTS(obarray)[scm_hash]);
+ SCM_VELTS(obarray)[scm_hash] = b;
+ SCM_REALLOW_INTS;
+ return SCM_CAR (b);
+ }
+}
+
+#ifdef __STDC__
+SCM
+scm_intern_obarray (char *name, scm_sizet len, SCM obarray)
+#else
+SCM
+scm_intern_obarray (name, len, obarray)
+ char *name;
+ scm_sizet len;
+ SCM obarray;
+#endif
+{
+ return scm_intern_obarray_soft (name, len, obarray, 0);
+}
+
+
+#ifdef __STDC__
+SCM
+scm_intern (char *name, scm_sizet len)
+#else
+SCM
+scm_intern (name, len)
+ char *name;
+ scm_sizet len;
+#endif
+{
+ return scm_intern_obarray (name, len, scm_symhash);
+}
+
+#ifdef __STDC__
+SCM
+scm_intern0 (char * name)
+#else
+SCM
+scm_intern0 (name)
+ char * name;
+#endif
+{
+ return scm_intern (name, strlen (name));
+}
+
+
+#ifdef __STDC__
+SCM
+scm_sysintern (char *name, SCM val)
+#else
+SCM
+scm_sysintern (name, val)
+ char *name;
+ SCM val;
+#endif
+{
+ SCM easy_answer;
+ SCM_DEFER_INTS;
+ easy_answer = scm_intern_obarray_soft (name, strlen (name), scm_symhash, 1);
+ if (SCM_NIMP (easy_answer))
+ {
+ SCM_CDR (easy_answer) = val;
+ SCM_ALLOW_INTS;
+ return easy_answer;
+ }
+ else
+ {
+ SCM lsym;
+ scm_sizet len = strlen (name);
+ register unsigned char *tmp = (unsigned char *) name;
+ scm_sizet scm_hash = scm_strhash (tmp, len, (unsigned long) scm_symhash_dim);
+ SCM_NEWCELL (lsym);
+ SCM_SETLENGTH (lsym, (long) len, scm_tc7_ssymbol);
+ SCM_SETCHARS (lsym, name);
+ lsym = scm_cons (lsym, val);
+ SCM_VELTS (scm_symhash)[scm_hash] = scm_cons (lsym, SCM_VELTS (scm_symhash)[scm_hash]);
+ SCM_ALLOW_INTS;
+ return lsym;
+ }
+}
+
+
+SCM_PROC(s_symbol_p, "symbol?", 1, 0, 0, scm_symbol_p);
+#ifdef __STDC__
+SCM
+scm_symbol_p(SCM x)
+#else
+SCM
+scm_symbol_p(x)
+ SCM x;
+#endif
+{
+ if SCM_IMP(x) return SCM_BOOL_F;
+ return SCM_SYMBOLP(x) ? SCM_BOOL_T : SCM_BOOL_F;
+}
+
+SCM_PROC(s_symbol_to_string, "symbol->string", 1, 0, 0, scm_symbol_to_string);
+#ifdef __STDC__
+SCM
+scm_symbol_to_string(SCM s)
+#else
+SCM
+scm_symbol_to_string(s)
+ SCM s;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_to_string);
+ return scm_makfromstr(SCM_CHARS(s), (scm_sizet)SCM_LENGTH(s), 0);
+}
+
+
+SCM_PROC(s_string_to_symbol, "string->symbol", 1, 0, 0, scm_string_to_symbol);
+#ifdef __STDC__
+SCM
+scm_string_to_symbol(SCM s)
+#else
+SCM
+scm_string_to_symbol(s)
+ SCM s;
+#endif
+{
+ SCM vcell;
+ SCM answer;
+
+ SCM_ASSERT(SCM_NIMP(s) && SCM_ROSTRINGP(s), s, SCM_ARG1, s_string_to_symbol);
+ vcell = scm_intern(SCM_ROCHARS(s), (scm_sizet)SCM_LENGTH(s));
+ answer = SCM_CAR (vcell);
+ if (SCM_TYP7 (answer) == scm_tc7_msymbol)
+ {
+ if (SCM_REGULAR_STRINGP (s))
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (answer) = SCM_BOOL_F;
+ else
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (answer) = SCM_BOOL_T;
+ }
+ return answer;
+}
+
+
+SCM_PROC(s_string_to_obarray_symbol, "string->obarray-symbol", 2, 1, 0, scm_string_to_obarray_symbol);
+#ifdef __STDC__
+SCM
+scm_string_to_obarray_symbol(SCM o, SCM s, SCM softp)
+#else
+SCM
+scm_string_to_obarray_symbol(o, s, softp)
+ SCM o;
+ SCM s;
+ SCM softp;
+#endif
+{
+ SCM vcell;
+ SCM answer;
+ int softness;
+
+ SCM_ASSERT(SCM_NIMP(s) && SCM_ROSTRINGP(s), s, SCM_ARG2, s_string_to_obarray_symbol);
+ SCM_ASSERT((o == SCM_BOOL_F) || (o == SCM_BOOL_T) || (SCM_NIMP(o) && SCM_VECTORP(o)),
+ o, SCM_ARG1, s_string_to_obarray_symbol);
+
+ softness = ((softp != SCM_UNDEFINED) && (softp != SCM_BOOL_F));
+ /* iron out some screwy calling conventions */
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ else if (o == SCM_BOOL_T)
+ o = SCM_BOOL_F;
+
+ vcell = scm_intern_obarray_soft (SCM_ROCHARS(s), (scm_sizet)SCM_ROLENGTH(s), o, softness);
+ if (vcell == SCM_BOOL_F)
+ return vcell;
+ answer = SCM_CAR (vcell);
+ if (SCM_TYP7 (s) == scm_tc7_msymbol)
+ {
+ if (SCM_REGULAR_STRINGP (s))
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (answer) = SCM_BOOL_F;
+ else
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (answer) = SCM_BOOL_T;
+ }
+ return answer;
+}
+
+SCM_PROC(s_intern_symbol, "intern-symbol", 2, 0, 0, scm_intern_symbol);
+#ifdef __STDC__
+SCM
+scm_intern_symbol(SCM o, SCM s)
+#else
+SCM
+scm_intern_symbol(o, s)
+ SCM o;
+ SCM s;
+#endif
+{
+ scm_sizet hval;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_intern_symbol);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_intern_symbol);
+ hval = scm_strhash (SCM_UCHARS (s), SCM_LENGTH (s), SCM_LENGTH(o));
+ /* If the symbol is already interned, simply return. */
+ SCM_REDEFER_INTS;
+ {
+ SCM lsym;
+ SCM sym;
+ for (lsym = SCM_VELTS (o)[hval];
+ SCM_NIMP (lsym);
+ lsym = SCM_CDR (lsym))
+ {
+ sym = SCM_CAR (lsym);
+ if (SCM_CAR (sym) == s)
+ {
+ SCM_REALLOW_INTS;
+ return SCM_UNSPECIFIED;
+ }
+ }
+ SCM_VELTS (o)[hval] =
+ scm_acons (s, SCM_UNDEFINED, SCM_VELTS (o)[hval]);
+ }
+ SCM_REALLOW_INTS;
+ return SCM_UNSPECIFIED;
+}
+
+SCM_PROC(s_unintern_symbol, "unintern-symbol", 2, 0, 0, scm_unintern_symbol);
+#ifdef __STDC__
+SCM
+scm_unintern_symbol(SCM o, SCM s)
+#else
+SCM
+scm_unintern_symbol(o, s)
+ SCM o;
+ SCM s;
+#endif
+{
+ scm_sizet hval;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_unintern_symbol);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_unintern_symbol);
+ hval = scm_strhash (SCM_UCHARS (s), SCM_LENGTH (s), SCM_LENGTH(o));
+ SCM_DEFER_INTS;
+ {
+ SCM lsym_follow;
+ SCM lsym;
+ SCM sym;
+ for (lsym = SCM_VELTS (o)[hval], lsym_follow = SCM_BOOL_F;
+ SCM_NIMP (lsym);
+ lsym_follow = lsym, lsym = SCM_CDR (lsym))
+ {
+ sym = SCM_CAR (lsym);
+ if (SCM_CAR (sym) == s)
+ {
+ /* Found the symbol to unintern. */
+ if (lsym_follow == SCM_BOOL_F)
+ SCM_VELTS(o)[hval] = lsym;
+ else
+ SCM_CDR(lsym_follow) = SCM_CDR(lsym);
+ SCM_ALLOW_INTS;
+ return SCM_BOOL_T;
+ }
+ }
+ }
+ SCM_ALLOW_INTS;
+ return SCM_BOOL_F;
+}
+
+SCM_PROC(s_symbol_binding, "symbol-binding", 2, 0, 0, scm_symbol_binding);
+#ifdef __STDC__
+SCM
+scm_symbol_binding (SCM o, SCM s)
+#else
+SCM
+scm_symbol_binding (o, s)
+ SCM o;
+ SCM s;
+#endif
+{
+ SCM vcell;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_symbol_binding);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_symbol_binding);
+ vcell = scm_sym2ovcell (s, o);
+ return SCM_CDR(vcell);
+}
+
+
+SCM_PROC(s_symbol_interned_p, "symbol-interned?", 2, 0, 0, scm_symbol_interned_p);
+#ifdef __STDC__
+SCM
+scm_symbol_interned_p (SCM o, SCM s)
+#else
+SCM
+scm_symbol_interned_p (o, s)
+ SCM o;
+ SCM s;
+#endif
+{
+ SCM vcell;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_symbol_interned_p);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_symbol_interned_p);
+ vcell = scm_sym2ovcell_soft (s, o);
+ if (SCM_IMP(vcell) && (o == scm_symhash))
+ vcell = scm_sym2ovcell_soft (s, scm_weak_symhash);
+ return (SCM_NIMP(vcell)
+ ? SCM_BOOL_T
+ : SCM_BOOL_F);
+}
+
+
+SCM_PROC(s_symbol_bound_p, "symbol-bound?", 2, 0, 0, scm_symbol_bound_p);
+#ifdef __STDC__
+SCM
+scm_symbol_bound_p (SCM o, SCM s)
+#else
+SCM
+scm_symbol_bound_p (o, s)
+ SCM o;
+ SCM s;
+#endif
+{
+ SCM vcell;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_symbol_bound_p);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_symbol_bound_p);
+ vcell = scm_sym2ovcell_soft (s, o);
+ return (( SCM_NIMP(vcell)
+ && (SCM_CDR(vcell) != SCM_UNDEFINED))
+ ? SCM_BOOL_T
+ : SCM_BOOL_F);
+}
+
+
+SCM_PROC(s_symbol_set_x, "symbol-set!", 3, 0, 0, scm_symbol_set_x);
+#ifdef __STDC__
+SCM
+scm_symbol_set_x (SCM o, SCM s, SCM v)
+#else
+SCM
+scm_symbol_set_x (o, s, v)
+ SCM o;
+ SCM s;
+ SCM v;
+#endif
+{
+ SCM vcell;
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG2, s_symbol_set_x);
+ if (o == SCM_BOOL_F)
+ o = scm_symhash;
+ SCM_ASSERT(SCM_NIMP(o) && SCM_VECTORP(o), o, SCM_ARG1, s_symbol_set_x);
+ vcell = scm_sym2ovcell (s, o);
+ SCM_CDR(vcell) = v;
+ return SCM_UNSPECIFIED;
+}
+
+static void
+msymbolize (s)
+ SCM s;
+{
+ SCM string;
+ string = scm_makfromstr (SCM_CHARS (s), SCM_LENGTH (s), SCM_SYMBOL_SLOTS);
+ SCM_SETCHARS (s, SCM_CHARS (string));
+ SCM_SETLENGTH (s, SCM_LENGTH (s), scm_tc7_msymbol);
+ SCM_SYMBOL_MULTI_BYTE_SCM_STRINGP (s) = SCM_BOOL_F;
+ SCM_CDR (string) = SCM_EOL;
+ SCM_CAR (string) = SCM_EOL;
+}
+
+
+SCM_PROC(s_symbol_fref, "symbol-fref", 1, 0, 0, scm_symbol_fref);
+#ifdef __STDC__
+SCM
+scm_symbol_fref (SCM s)
+#else
+SCM
+scm_symbol_fref (s)
+ SCM s;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_fref);
+ SCM_DEFER_INTS;
+ if (SCM_TYP7(s) == scm_tc7_ssymbol)
+ msymbolize (s);
+ SCM_ALLOW_INTS;
+ return SCM_SYMBOL_FUNC (s);
+}
+
+
+SCM_PROC(s_symbol_pref, "symbol-pref", 1, 0, 0, scm_symbol_pref);
+#ifdef __STDC__
+SCM
+scm_symbol_pref (SCM s)
+#else
+SCM
+scm_symbol_pref (s)
+ SCM s;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_pref);
+ SCM_DEFER_INTS;
+ if (SCM_TYP7(s) == scm_tc7_ssymbol)
+ msymbolize (s);
+ SCM_ALLOW_INTS;
+ return SCM_SYMBOL_PROPS (s);
+}
+
+
+SCM_PROC(s_symbol_fset_x, "symbol-fset!", 2, 0, 0, scm_symbol_fset_x);
+#ifdef __STDC__
+SCM
+scm_symbol_fset_x (SCM s, SCM val)
+#else
+SCM
+scm_symbol_fset_x (s, val)
+ SCM s;
+ SCM val;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_fset_x);
+ SCM_DEFER_INTS;
+ if (SCM_TYP7(s) == scm_tc7_ssymbol)
+ msymbolize (s);
+ SCM_ALLOW_INTS;
+ SCM_SYMBOL_FUNC (s) = val;
+ return SCM_UNSPECIFIED;
+}
+
+
+SCM_PROC(s_symbol_pset_x, "symbol-pset!", 2, 0, 0, scm_symbol_pset_x);
+#ifdef __STDC__
+SCM
+scm_symbol_pset_x (SCM s, SCM val)
+#else
+SCM
+scm_symbol_pset_x (s, val)
+ SCM s;
+ SCM val;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_pset_x);
+ SCM_DEFER_INTS;
+ if (SCM_TYP7(s) == scm_tc7_ssymbol)
+ msymbolize (s);
+ SCM_SYMBOL_PROPS (s) = val;
+ SCM_ALLOW_INTS;
+ return SCM_UNSPECIFIED;
+}
+
+
+SCM_PROC(s_symbol_hash, "symbol-hash", 1, 0, 0, scm_symbol_hash);
+#ifdef __STDC__
+SCM
+scm_symbol_hash (SCM s)
+#else
+SCM
+scm_symbol_hash (s)
+ SCM s;
+#endif
+{
+ SCM_ASSERT(SCM_NIMP(s) && SCM_SYMBOLP(s), s, SCM_ARG1, s_symbol_hash);
+ return SCM_MAKINUM ((unsigned long)s ^ SCM_SYMBOL_HASH (s));
+}
+
+
+#ifdef __STDC__
+void
+scm_init_symbols (void)
+#else
+void
+scm_init_symbols ()
+#endif
+{
+#include "symbols.x"
+}
+