xemacs-beta: src/symbols.c comparison

comparison src/symbols.c @ 442:abe6d1db359e r21-2-36

Import from CVS: tag r21-2-36

author	cvs
date	Mon, 13 Aug 2007 11:35:02 +0200
parents	8de8e3f6228a
children	576fb035e263

comparison

equal deleted inserted replaced

-:72a7cfa4a488
+:abe6d1db359e
 /* "intern" and friends -- moved here from lread.c and data.c
 Copyright (C) 1985-1989, 1992-1994 Free Software Foundation, Inc.
-Copyright (C) 1995 Ben Wing.
+Copyright (C) 1995, 2000 Ben Wing.
 This file is part of XEmacs.
 XEmacs is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 { XD_LISP_OBJECT, offsetof (Lisp_Symbol, function) },
 { XD_LISP_OBJECT, offsetof (Lisp_Symbol, plist) },
 { XD_END }
 };
-DEFINE_BASIC_LRECORD_IMPLEMENTATION ("symbol", symbol,
+/* Symbol plists are directly accessible, so we need to protect against
-				     mark_symbol, print_symbol, 0, 0, 0,
+invalid property list structure */
-				     symbol_description, Lisp_Symbol);
+static Lisp_Object
+symbol_getprop (Lisp_Object symbol, Lisp_Object property)
+{
+return external_plist_get (&XSYMBOL (symbol)->plist, property, 0, ERROR_ME);
+}
+static int
+symbol_putprop (Lisp_Object symbol, Lisp_Object property, Lisp_Object value)
+{
+external_plist_put (&XSYMBOL (symbol)->plist, property, value, 0, ERROR_ME);
+return 1;
+}
+static int
+symbol_remprop (Lisp_Object symbol, Lisp_Object property)
+{
+return external_remprop (&XSYMBOL (symbol)->plist, property, 0, ERROR_ME);
+}
+DEFINE_BASIC_LRECORD_IMPLEMENTATION_WITH_PROPS ("symbol", symbol,
+						mark_symbol, print_symbol,
+						0, 0, 0, symbol_description,
+						symbol_getprop,
+						symbol_putprop,
+						symbol_remprop,
+						Fsymbol_plist,
+						Lisp_Symbol);
 /**********************************************************************/
 /*                              Intern				      */
 /**********************************************************************/
 }
 return obarray;
 }
 Lisp_Object
-intern (CONST char *str)
+intern (const char *str)
 {
 Bytecount len = strlen (str);
-CONST Bufbyte *buf = (CONST Bufbyte *) str;
+const Bufbyte *buf = (const Bufbyte *) str;
 Lisp_Object obarray = Vobarray;
 if (!VECTORP (obarray) || XVECTOR_LENGTH (obarray) == 0)
 obarray = check_obarray (obarray);
 return the index into OBARRAY that the string hashes to.
 Also store the bucket number in oblookup_last_bucket_number.  */
 Lisp_Object
-oblookup (Lisp_Object obarray, CONST Bufbyte *ptr, Bytecount size)
+oblookup (Lisp_Object obarray, const Bufbyte *ptr, Bytecount size)
 {
 int hash, obsize;
 Lisp_Symbol *tail;
 Lisp_Object bucket;
 return make_int (hash);
 }
 #if 0 /* Emacs 19.34 */
 int
-hash_string (CONST Bufbyte *ptr, Bytecount len)
+hash_string (const Bufbyte *ptr, Bytecount len)
 {
-CONST Bufbyte *p = ptr;
+const Bufbyte *p = ptr;
-CONST Bufbyte *end = p + len;
+const Bufbyte *end = p + len;
 Bufbyte c;
 int hash = 0;
 while (p != end)
 {
 }
 #endif
 /* derived from hashpjw, Dragon Book P436. */
 int
-hash_string (CONST Bufbyte *ptr, Bytecount len)
+hash_string (const Bufbyte *ptr, Bytecount len)
 {
 int hash = 0;
 while (len-- > 0)
 {
 Call FUNCTION on every symbol in OBARRAY.
 OBARRAY defaults to the value of `obarray'.
 */
 (function, obarray))
 {
+struct gcpro gcpro1;
 if (NILP (obarray))
 obarray = Vobarray;
 obarray = check_obarray (obarray);
+GCPRO1 (obarray);
 map_obarray (obarray, mapatoms_1, &function);
+UNGCPRO;
 return Qnil;
 }
 /**********************************************************************/
 Return list of symbols found.
 */
 (regexp, predicate))
 {
 struct appropos_mapper_closure closure;
+struct gcpro gcpro1;
 CHECK_STRING (regexp);
 closure.regexp = regexp;
 closure.predicate = predicate;
 closure.accumulation = Qnil;
+GCPRO1 (closure.accumulation);
 map_obarray (Vobarray, apropos_mapper, &closure);
 closure.accumulation = Fsort (closure.accumulation, Qstring_lessp);
+UNGCPRO;
 return closure.accumulation;
 }
 /* Extract and set components of symbols */
 { XD_END }
 };
 DEFINE_LRECORD_IMPLEMENTATION ("symbol-value-forward",
 			       symbol_value_forward,
-			       this_one_is_unmarkable,
+			       0,
 			       print_symbol_value_magic, 0, 0, 0,
 			       symbol_value_forward_description,
 			       struct symbol_value_forward);
 DEFINE_LRECORD_IMPLEMENTATION ("symbol-value-buffer-local",
 static Lisp_Object
 do_symval_forwarding (Lisp_Object valcontents, struct buffer *buffer,
 		      struct console *console)
 {
-CONST struct symbol_value_forward *fwd;
+const struct symbol_value_forward *fwd;
 if (!SYMBOL_VALUE_MAGIC_P (valcontents))
 return valcontents;
 fwd = XSYMBOL_VALUE_FORWARD (valcontents);
 */
 /* At this point, the value cell may not contain a symbol-value-varalias
 or symbol-value-buffer-local, and if there's a handler, we should
 have already called it. */
 Lisp_Object valcontents = fetch_value_maybe_past_magic (sym, Qt);
-CONST struct symbol_value_forward *fwd
+const struct symbol_value_forward *fwd
 = XSYMBOL_VALUE_FORWARD (valcontents);
 int offset = ((char *) symbol_value_forward_forward (fwd)
 		- (char *) &buffer_local_flags);
 int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object,
 *((Lisp_Object *) (offset + (char *) XBUFFER (Vbuffer_defaults)))
 = value;
 if (mask > 0)		/* Not always per-buffer */
 {
-Lisp_Object elt;
 /* Set value in each buffer which hasn't shadowed the default */
 LIST_LOOP_2 (elt, Vbuffer_alist)
 	{
 	  struct buffer *b = XBUFFER (XCDR (elt));
 	  if (!(b->local_var_flags & mask))
 */
 /* At this point, the value cell may not contain a symbol-value-varalias
 or symbol-value-buffer-local, and if there's a handler, we should
 have already called it. */
 Lisp_Object valcontents = fetch_value_maybe_past_magic (sym, Qt);
-CONST struct symbol_value_forward *fwd
+const struct symbol_value_forward *fwd
 = XSYMBOL_VALUE_FORWARD (valcontents);
 int offset = ((char *) symbol_value_forward_forward (fwd)
 		- (char *) &console_local_flags);
 int mask = XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 int (*magicfun) (Lisp_Object simm, Lisp_Object *val, Lisp_Object in_object,
 *((Lisp_Object *) (offset + (char *) XCONSOLE (Vconsole_defaults)))
 = value;
 if (mask > 0)		/* Not always per-console */
 {
-Lisp_Object console;
 /* Set value in each console which hasn't shadowed the default */
 LIST_LOOP_2 (console, Vconsole_list)
 	{
 	  struct console *d = XCONSOLE (console);
 	  if (!(d->local_var_flags & mask))
 	      || !SYMBOL_VALUE_MAGIC_P (*store_pointer));
 *store_pointer = newval;
 }
 else
 {
-CONST struct symbol_value_forward *fwd = XSYMBOL_VALUE_FORWARD (ovalue);
+const struct symbol_value_forward *fwd = XSYMBOL_VALUE_FORWARD (ovalue);
 int (*magicfun) (Lisp_Object simm, Lisp_Object *val,
 		       Lisp_Object in_object, int flags)
 	= symbol_value_forward_magicfun (fwd);
 switch (XSYMBOL_VALUE_MAGIC_TYPE (ovalue))
 /* case SYMVAL_UNBOUND_MARKER: break; */
 case SYMVAL_CURRENT_BUFFER_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int mask = XINT (*((Lisp_Object *)
 			   symbol_value_forward_forward (fwd)));
 	if (mask > 0)
 	  /* Setting this variable makes it buffer-local */
 	break;
 }
 case SYMVAL_SELECTED_CONSOLE_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int mask = XINT (*((Lisp_Object *)
 			   symbol_value_forward_forward (fwd)));
 	if (mask > 0)
 	  /* Setting this variable makes it console-local */
 case SYMVAL_UNBOUND_MARKER:
 return valcontents;
 case SYMVAL_CURRENT_BUFFER_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	return (*((Lisp_Object *)((char *) XBUFFER (Vbuffer_defaults)
 				  + ((char *)symbol_value_forward_forward (fwd)
 				     - (char *)&buffer_local_flags))));
 }
 case SYMVAL_SELECTED_CONSOLE_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	return (*((Lisp_Object *)((char *) XCONSOLE (Vconsole_defaults)
 				  + ((char *)symbol_value_forward_forward (fwd)
 				     - (char *)&console_local_flags))));
 }
 /* presto change-o! */
 goto retry;
 case SYMVAL_CURRENT_BUFFER_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int offset = ((char *) symbol_value_forward_forward (fwd)
 			       - (char *) &buffer_local_flags);
 	int mask =
 	  XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 /* presto change-o! */
 goto retry;
 case SYMVAL_SELECTED_CONSOLE_FORWARD:
 {
-	CONST struct symbol_value_forward *fwd
+	const struct symbol_value_forward *fwd
 	  = XSYMBOL_VALUE_FORWARD (valcontents);
 	int offset = ((char *) symbol_value_forward_forward (fwd)
 			       - (char *) &console_local_flags);
 	int mask =
 	  XINT (*((Lisp_Object *) symbol_value_forward_forward (fwd)));
 	  /* presto change-o! */
 	  goto retry;
 	case SYMVAL_CURRENT_BUFFER_FORWARD:
 	  {
-	    CONST struct symbol_value_forward *fwd
+	    const struct symbol_value_forward *fwd
 	      = XSYMBOL_VALUE_FORWARD (valcontents);
 	    int mask = XINT (*((Lisp_Object *)
 			       symbol_value_forward_forward (fwd)));
 	    if ((mask <= 0) || (buffer && (buffer->local_var_flags & mask)))
 	      /* Already buffer-local */
 #ifndef Qnull_pointer
 Lisp_Object Qnull_pointer;
 #endif
 /* some losing systems can't have static vars at function scope... */
-static struct symbol_value_magic guts_of_unbound_marker =
+static const struct symbol_value_magic guts_of_unbound_marker =
-{ { symbol_value_forward_lheader_initializer, 0, 69},
+{ /* struct symbol_value_magic */
-SYMVAL_UNBOUND_MARKER };
+{ /* struct lcrecord_header */
+{ /* struct lrecord_header */
+lrecord_type_symbol_value_forward, /* lrecord_type_index */
+1, /* mark bit */
+1, /* c_readonly bit */
+1, /* lisp_readonly bit */
+},
+0, /* next */
+0, /* uid  */
+0, /* free */
+},
+0, /* value */
+SYMVAL_UNBOUND_MARKER
+};
 void
 init_symbols_once_early (void)
 {
+INIT_LRECORD_IMPLEMENTATION (symbol);
+INIT_LRECORD_IMPLEMENTATION (symbol_value_forward);
+INIT_LRECORD_IMPLEMENTATION (symbol_value_buffer_local);
+INIT_LRECORD_IMPLEMENTATION (symbol_value_lisp_magic);
+INIT_LRECORD_IMPLEMENTATION (symbol_value_varalias);
 reinit_symbols_once_early ();
 /* Bootstrapping problem: Qnil isn't set when make_string_nocopy is
 called the first time. */
-Qnil = Fmake_symbol (make_string_nocopy ((CONST Bufbyte *) "nil", 3));
+Qnil = Fmake_symbol (make_string_nocopy ((const Bufbyte *) "nil", 3));
 XSYMBOL (Qnil)->name->plist = Qnil;
 XSYMBOL (Qnil)->value = Qnil; /* Nihil ex nihil */
 XSYMBOL (Qnil)->plist = Qnil;
 Vobarray = make_vector (OBARRAY_SIZE, Qzero);
 }
 {
 /* Required to get around a GCC syntax error on certain
 architectures */
-struct symbol_value_magic *tem = &guts_of_unbound_marker;
+const struct symbol_value_magic *tem = &guts_of_unbound_marker;
 XSETSYMBOL_VALUE_MAGIC (Qunbound, tem);
 }
-if ((CONST void *) XPNTR (Qunbound) !=
-(CONST void *)&guts_of_unbound_marker)
-{
-/* This might happen on DATA_SEG_BITS machines. */
-/* abort (); */
-/* Can't represent a pointer to constant C data using a Lisp_Object.
-	 So heap-allocate it. */
-struct symbol_value_magic *urk = xnew (struct symbol_value_magic);
-memcpy (urk, &guts_of_unbound_marker, sizeof (*urk));
-XSETSYMBOL_VALUE_MAGIC (Qunbound, urk);
-}
 XSYMBOL (Qnil)->function = Qunbound;
 defsymbol (&Qt, "t");
 XSYMBOL (Qt)->value = Qt;	/* Veritas aetera */
 #endif
 #ifndef Qnull_pointer
 /* C guarantees that Qnull_pointer will be initialized to all 0 bits,
 so the following is actually a no-op.  */
-XSETOBJ (Qnull_pointer, (enum Lisp_Type) 0, 0);
+XSETOBJ (Qnull_pointer, 0);
 #endif
 }
+static void
+defsymbol_massage_name_1 (Lisp_Object *location, const char *name, int dump_p,
+			  int multiword_predicate_p)
+{
+char temp[500];
+int len = strlen (name) - 1;
+int i;
+if (multiword_predicate_p)
+assert (len + 1 < sizeof (temp));
+else
+assert (len < sizeof (temp));
+strcpy (temp, name + 1); /* Remove initial Q */
+if (multiword_predicate_p)
+{
+strcpy (temp + len - 1, "_p");
+len++;
+}
+for (i = 0; i < len; i++)
+if (temp[i] == '_')
+temp[i] = '-';
+*location = Fintern (make_string ((const Bufbyte *) temp, len), Qnil);
+if (dump_p)
+staticpro (location);
+else
+staticpro_nodump (location);
+}
 void
-defsymbol_nodump (Lisp_Object *location, CONST char *name)
+defsymbol_massage_name_nodump (Lisp_Object *location, const char *name)
 {
-*location = Fintern (make_string_nocopy ((CONST Bufbyte *) name,
+defsymbol_massage_name_1 (location, name, 0, 0);
+}
+void
+defsymbol_massage_name (Lisp_Object *location, const char *name)
+{
+defsymbol_massage_name_1 (location, name, 1, 0);
+}
+void
+defsymbol_massage_multiword_predicate_nodump (Lisp_Object *location,
+					      const char *name)
+{
+defsymbol_massage_name_1 (location, name, 0, 1);
+}
+void
+defsymbol_massage_multiword_predicate (Lisp_Object *location, const char *name)
+{
+defsymbol_massage_name_1 (location, name, 1, 1);
+}
+void
+defsymbol_nodump (Lisp_Object *location, const char *name)
+{
+*location = Fintern (make_string_nocopy ((const Bufbyte *) name,
 					   strlen (name)),
 		       Qnil);
 staticpro_nodump (location);
 }
 void
-defsymbol (Lisp_Object *location, CONST char *name)
+defsymbol (Lisp_Object *location, const char *name)
 {
-*location = Fintern (make_string_nocopy ((CONST Bufbyte *) name,
+*location = Fintern (make_string_nocopy ((const Bufbyte *) name,
 					   strlen (name)),
 		       Qnil);
 staticpro (location);
 }
 void
-defkeyword (Lisp_Object *location, CONST char *name)
+defkeyword (Lisp_Object *location, const char *name)
 {
 defsymbol (location, name);
+Fset (*location, *location);
+}
+void
+defkeyword_massage_name (Lisp_Object *location, const char *name)
+{
+char temp[500];
+int len = strlen (name);
+assert (len < sizeof (temp));
+strcpy (temp, name);
+temp[1] = ':'; /* it's an underscore in the C variable */
+defsymbol_massage_name (location, temp);
 Fset (*location, *location);
 }
 #ifdef DEBUG_XEMACS
 /* Check that nobody spazzed writing a DEFUN. */
 * a copy here to ensure that a real address is used.
 *
 * Once we have copied everything across, we re-use the original static
 * structure to store a pointer to the newly allocated one. This will be
 * used in emodules.c by emodules_doc_subr() to find a pointer to the
-* allocated object so that we can set its doc string propperly.
+* allocated object so that we can set its doc string properly.
 *
-* NOTE: We dont actually use the DOC pointer here any more, but we did
+* NOTE: We don't actually use the DOC pointer here any more, but we did
 * in an earlier implementation of module support. There is no harm in
 * setting it here in case we ever need it in future implementations.
 * subr->doc will point to the new subr structure that was allocated.
-* Code can then get this value from the statis subr structure and use
+* Code can then get this value from the static subr structure and use
 * it if required.
 *
-* FIXME: Should newsubr be staticpro()'ed? I dont think so but I need
+* FIXME: Should newsubr be staticpro()'ed? I don't think so but I need
 * a guru to check.
 */
 #define check_module_subr()						\
 do {									\
 if (initialized) {							\
 Lisp_Subr *newsubr = (Lisp_Subr *) xmalloc (sizeof (Lisp_Subr));	\
 memcpy (newsubr, subr, sizeof (Lisp_Subr));				\
-subr->doc = (CONST char *)newsubr;					\
+subr->doc = (const char *)newsubr;					\
 subr = newsubr;							\
 }									\
 } while (0)
 #else /* ! HAVE_SHLIB */
 #define check_module_subr()
 XSETSUBR (fun, subr);
 XSYMBOL (sym)->function = Fcons (Qmacro, fun);
 }
-void
+static void
-deferror (Lisp_Object *symbol, CONST char *name, CONST char *messuhhj,
+deferror_1 (Lisp_Object *symbol, const char *name, const char *messuhhj,
-	  Lisp_Object inherits_from)
+	    Lisp_Object inherits_from, int massage_p)
 {
 Lisp_Object conds;
-defsymbol (symbol, name);
+if (massage_p)
+defsymbol_massage_name (symbol, name);
+else
+defsymbol (symbol, name);
 assert (SYMBOLP (inherits_from));
 conds = Fget (inherits_from, Qerror_conditions, Qnil);
 Fput (*symbol, Qerror_conditions, Fcons (*symbol, conds));
 /* NOT build_translated_string ().  This function is called at load time
 in the function (display-error) in cmdloop.el.) */
 Fput (*symbol, Qerror_message, build_string (messuhhj));
 }
 void
+deferror (Lisp_Object *symbol, const char *name, const char *messuhhj,
+	  Lisp_Object inherits_from)
+{
+deferror_1 (symbol, name, messuhhj, inherits_from, 0);
+}
+void
+deferror_massage_name (Lisp_Object *symbol, const char *name,
+		       const char *messuhhj, Lisp_Object inherits_from)
+{
+deferror_1 (symbol, name, messuhhj, inherits_from, 1);
+}
+void
+deferror_massage_name_and_message (Lisp_Object *symbol, const char *name,
+				   Lisp_Object inherits_from)
+{
+char temp[500];
+int i;
+int len = strlen (name) - 1;
+assert (len < sizeof (temp));
+strcpy (temp, name + 1); /* Remove initial Q */
+temp[0] = toupper (temp[0]);
+for (i = 0; i < len; i++)
+if (temp[i] == '_')
+temp[i] = ' ';
+deferror_1 (symbol, name, temp, inherits_from, 1);
+}
+void
 syms_of_symbols (void)
 {
-defsymbol (&Qvariable_documentation, "variable-documentation");
+DEFSYMBOL (Qvariable_documentation);
-defsymbol (&Qvariable_domain, "variable-domain");	/* I18N3 */
+DEFSYMBOL (Qvariable_domain);	/* I18N3 */
-defsymbol (&Qad_advice_info, "ad-advice-info");
+DEFSYMBOL (Qad_advice_info);
-defsymbol (&Qad_activate, "ad-activate");
+DEFSYMBOL (Qad_activate);
-defsymbol (&Qget_value, "get-value");
+DEFSYMBOL (Qget_value);
-defsymbol (&Qset_value, "set-value");
+DEFSYMBOL (Qset_value);
-defsymbol (&Qbound_predicate, "bound-predicate");
+DEFSYMBOL (Qbound_predicate);
-defsymbol (&Qmake_unbound, "make-unbound");
+DEFSYMBOL (Qmake_unbound);
-defsymbol (&Qlocal_predicate, "local-predicate");
+DEFSYMBOL (Qlocal_predicate);
-defsymbol (&Qmake_local, "make-local");
+DEFSYMBOL (Qmake_local);
-defsymbol (&Qboundp, "boundp");
+DEFSYMBOL (Qboundp);
-defsymbol (&Qglobally_boundp, "globally-boundp");
+DEFSYMBOL (Qglobally_boundp);
-defsymbol (&Qmakunbound, "makunbound");
+DEFSYMBOL (Qmakunbound);
-defsymbol (&Qsymbol_value, "symbol-value");
+DEFSYMBOL (Qsymbol_value);
-defsymbol (&Qset, "set");
+DEFSYMBOL (Qset);
-defsymbol (&Qsetq_default, "setq-default");
+DEFSYMBOL (Qsetq_default);
-defsymbol (&Qdefault_boundp, "default-boundp");
+DEFSYMBOL (Qdefault_boundp);
-defsymbol (&Qdefault_value, "default-value");
+DEFSYMBOL (Qdefault_value);
-defsymbol (&Qset_default, "set-default");
+DEFSYMBOL (Qset_default);
-defsymbol (&Qmake_variable_buffer_local, "make-variable-buffer-local");
+DEFSYMBOL (Qmake_variable_buffer_local);
-defsymbol (&Qmake_local_variable, "make-local-variable");
+DEFSYMBOL (Qmake_local_variable);
-defsymbol (&Qkill_local_variable, "kill-local-variable");
+DEFSYMBOL (Qkill_local_variable);
-defsymbol (&Qkill_console_local_variable, "kill-console-local-variable");
+DEFSYMBOL (Qkill_console_local_variable);
-defsymbol (&Qsymbol_value_in_buffer, "symbol-value-in-buffer");
+DEFSYMBOL (Qsymbol_value_in_buffer);
-defsymbol (&Qsymbol_value_in_console, "symbol-value-in-console");
+DEFSYMBOL (Qsymbol_value_in_console);
-defsymbol (&Qlocal_variable_p, "local-variable-p");
+DEFSYMBOL (Qlocal_variable_p);
-defsymbol (&Qconst_integer, "const-integer");
+DEFSYMBOL (Qconst_integer);
-defsymbol (&Qconst_boolean, "const-boolean");
+DEFSYMBOL (Qconst_boolean);
-defsymbol (&Qconst_object, "const-object");
+DEFSYMBOL (Qconst_object);
-defsymbol (&Qconst_specifier, "const-specifier");
+DEFSYMBOL (Qconst_specifier);
-defsymbol (&Qdefault_buffer, "default-buffer");
+DEFSYMBOL (Qdefault_buffer);
-defsymbol (&Qcurrent_buffer, "current-buffer");
+DEFSYMBOL (Qcurrent_buffer);
-defsymbol (&Qconst_current_buffer, "const-current-buffer");
+DEFSYMBOL (Qconst_current_buffer);
-defsymbol (&Qdefault_console, "default-console");
+DEFSYMBOL (Qdefault_console);
-defsymbol (&Qselected_console, "selected-console");
+DEFSYMBOL (Qselected_console);
-defsymbol (&Qconst_selected_console, "const-selected-console");
+DEFSYMBOL (Qconst_selected_console);
 DEFSUBR (Fintern);
 DEFSUBR (Fintern_soft);
 DEFSUBR (Funintern);
 DEFSUBR (Fmapatoms);
 DEFSUBR (Fdontusethis_set_symbol_value_handler);
 }
 /* Create and initialize a Lisp variable whose value is forwarded to C data */
 void
-defvar_magic (CONST char *symbol_name, CONST struct symbol_value_forward *magic)
+defvar_magic (const char *symbol_name, const struct symbol_value_forward *magic)
 {
-Lisp_Object sym, kludge;
+Lisp_Object sym;
-/* Check that `magic' points somewhere we can represent as a Lisp pointer */
-XSETOBJ (kludge, Lisp_Type_Record, magic);
-if ((void *)magic != (void*) XPNTR (kludge))
-{
-/* This might happen on DATA_SEG_BITS machines. */
-/* abort (); */
-/* Copy it to somewhere which is representable. */
-struct symbol_value_forward *p = xnew (struct symbol_value_forward);
-memcpy (p, magic, sizeof *magic);
-magic = p;
-}
 #if defined(HAVE_SHLIB)
 /*
 * As with defsubr(), this will only be called in a dumped Emacs when
 * we are adding variables from a dynamically loaded module. That means
 */
 if (initialized)
 sym = Fintern (build_string (symbol_name), Qnil);
 else
 #endif
-sym = Fintern (make_string_nocopy ((CONST Bufbyte *) symbol_name,
+sym = Fintern (make_string_nocopy ((const Bufbyte *) symbol_name,
 				       strlen (symbol_name)), Qnil);
-XSETOBJ (XSYMBOL (sym)->value, Lisp_Type_Record, magic);
+XSETOBJ (XSYMBOL (sym)->value, magic);
 }
 void
 vars_of_symbols (void)
 {

Mercurial > hg > xemacs-beta

comparison src/symbols.c @ 442:abe6d1db359e r21-2-36