xemacs-beta: src/symbols.c comparison

comparison src/symbols.c @ 20:859a2309aef8 r19-15b93

Import from CVS: tag r19-15b93

author	cvs
date	Mon, 13 Aug 2007 08:50:05 +0200
parents	0293115a14e9
children	4103f0995bd7

comparison

equal deleted inserted replaced

-:ac1f612d5250
+:859a2309aef8
 		   ? make_pure_pname ((CONST Bufbyte *) str, len, 0)
 		   : make_string ((CONST Bufbyte *) str, len)),
 		  obarray);
 }
-DEFUN ("intern", Fintern, Sintern, 1, 2, 0 /*
+DEFUN ("intern", Fintern, 1, 2, 0, /*
 Return the canonical symbol whose name is STRING.
 If there is none, one is created by this function and returned.
 A second optional argument specifies the obarray to use;
 it defaults to the value of `obarray'.
-*/ )
+*/
-(str, obarray)
+(str, obarray))
-Lisp_Object str, obarray;
 {
 Lisp_Object sym, *ptr;
 Bytecount len;
 if (NILP (obarray)) obarray = Vobarray;
 symbol_next (XSYMBOL (sym)) = 0;
 *ptr = sym;
 return sym;
 }
-DEFUN ("intern-soft", Fintern_soft, Sintern_soft, 1, 2, 0 /*
+DEFUN ("intern-soft", Fintern_soft, 1, 2, 0, /*
 Return the canonical symbol whose name is STRING, or nil if none exists.
 A second optional argument specifies the obarray to use;
 it defaults to the value of `obarray'.
-*/ )
+*/
-(str, obarray)
+(str, obarray))
-Lisp_Object str, obarray;
 {
 Lisp_Object tem;
 if (NILP (obarray)) obarray = Vobarray;
 obarray = check_obarray (obarray);
 if (!INTP (tem))
 return tem;
 return Qnil;
 }
-DEFUN ("unintern", Funintern, Sunintern, 1, 2, 0 /*
+DEFUN ("unintern", Funintern, 1, 2, 0, /*
 Delete the symbol named NAME, if any, from OBARRAY.
 The value is t if a symbol was found and deleted, nil otherwise.
 NAME may be a string or a symbol.  If it is a symbol, that symbol
 is deleted, if it belongs to OBARRAY--no other symbol is deleted.
 OBARRAY defaults to the value of the variable `obarray'
-*/ )
+*/
-(name, obarray)
+(name, obarray))
-Lisp_Object name, obarray;
 {
 Lisp_Object string, tem;
 int hash;
 if (NILP (obarray)) obarray = Vobarray;
 mapatoms_1 (Lisp_Object sym, Lisp_Object function)
 {
 call1 (function, sym);
 }
-DEFUN ("mapatoms", Fmapatoms, Smapatoms, 1, 2, 0 /*
+DEFUN ("mapatoms", Fmapatoms, 1, 2, 0, /*
 Call FUNCTION on every symbol in OBARRAY.
 OBARRAY defaults to the value of `obarray'.
-*/ )
+*/
-(function, obarray)
+(function, obarray))
-Lisp_Object function, obarray;
 {
 if (NILP (obarray))
 obarray = Vobarray;
 obarray = check_obarray (obarray);
 tem = call1 (predicate, symbol);
 if (!NILP (tem))
 *accumulation = Fcons (symbol, *accumulation);
 }
-DEFUN ("apropos-internal", Fapropos_internal, Sapropos_internal, 1, 2, 0 /*
+DEFUN ("apropos-internal", Fapropos_internal, 1, 2, 0, /*
 Show all symbols whose names contain match for REGEXP.
 If optional 2nd arg PRED is non-nil, (funcall PRED SYM) is done
 for each symbol and a symbol is mentioned only if that returns non-nil.
 Return list of symbols found.
-*/ )
+*/
-(string, pred)
+(string, pred))
-Lisp_Object string, pred;
 {
 struct gcpro gcpro1;
 Lisp_Object accumulation;
 CHECK_STRING (string);
 				       struct symbol_value_buffer_local *bfwd,
 				       struct buffer *buf,
 				       Lisp_Object new_alist_el,
 				       int set_it_p);
-DEFUN ("boundp", Fboundp, Sboundp, 1, 1, 0 /*
+DEFUN ("boundp", Fboundp, 1, 1, 0, /*
 T if SYMBOL's value is not void.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 CHECK_SYMBOL (sym);
 return (UNBOUNDP (find_symbol_value (sym)) ? Qnil : Qt);
 }
-DEFUN ("globally-boundp", Fglobally_boundp, Sglobally_boundp, 1, 1, 0 /*
+DEFUN ("globally-boundp", Fglobally_boundp, 1, 1, 0, /*
 T if SYMBOL has a global (non-bound) value.
 This is for the byte-compiler; you really shouldn't be using this.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 CHECK_SYMBOL (sym);
 return (UNBOUNDP (top_level_value (sym)) ? Qnil : Qt);
 }
-DEFUN ("fboundp", Ffboundp, Sfboundp, 1, 1, 0 /*
+DEFUN ("fboundp", Ffboundp, 1, 1, 0, /*
 T if SYMBOL's function definition is not void.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 CHECK_SYMBOL (sym);
 return ((UNBOUNDP (XSYMBOL (sym)->function)) ? Qnil : Qt);
 }
 signal_error (Qerror,
 		  list2 (build_string ("Symbol may not be buffer-local"),
 			 sym));
 }
-DEFUN ("makunbound", Fmakunbound, Smakunbound, 1, 1, 0 /*
+DEFUN ("makunbound", Fmakunbound, 1, 1, 0, /*
 Make SYMBOL's value be void.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 Fset (sym, Qunbound);
 return sym;
 }
-DEFUN ("fmakunbound", Ffmakunbound, Sfmakunbound, 1, 1, 0 /*
+DEFUN ("fmakunbound", Ffmakunbound, 1, 1, 0, /*
 Make SYMBOL's function definition be void.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 CHECK_SYMBOL (sym);
 reject_constant_symbols (sym, Qunbound, 1, Qt);
 XSYMBOL (sym)->function = Qunbound;
 return sym;
 }
-DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0 /*
+DEFUN ("symbol-function", Fsymbol_function, 1, 1, 0, /*
 Return SYMBOL's function definition.	 Error if that is void.
-*/ )
+*/
-(symbol)
+(symbol))
-Lisp_Object symbol;
 {
 CHECK_SYMBOL (symbol);
 if (UNBOUNDP (XSYMBOL (symbol)->function))
 return Fsignal (Qvoid_function, list1 (symbol));
 return XSYMBOL (symbol)->function;
 }
-DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0 /*
+DEFUN ("symbol-plist", Fsymbol_plist, 1, 1, 0, /*
 Return SYMBOL's property list.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 CHECK_SYMBOL (sym);
 return XSYMBOL (sym)->plist;
 }
-DEFUN ("symbol-name", Fsymbol_name, Ssymbol_name, 1, 1, 0 /*
+DEFUN ("symbol-name", Fsymbol_name, 1, 1, 0, /*
 Return SYMBOL's name, a string.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 Lisp_Object name;
 CHECK_SYMBOL (sym);
 XSETSTRING (name, XSYMBOL (sym)->name);
 return name;
 }
-DEFUN ("fset", Ffset, Sfset, 2, 2, 0 /*
+DEFUN ("fset", Ffset, 2, 2, 0, /*
 Set SYMBOL's function definition to NEWVAL, and return NEWVAL.
-*/ )
+*/
-(sym, newdef)
+(sym, newdef))
-Lisp_Object sym, newdef;
 {
 /* This function can GC */
 CHECK_SYMBOL (sym);
 reject_constant_symbols (sym, newdef, 1, Qt);
 if (!NILP (Vautoload_queue) && !UNBOUNDP (XSYMBOL (sym)->function))
 }
 return newdef;
 }
 /* FSFmacs */
-DEFUN ("define-function", Fdefine_function, Sdefine_function, 2, 2, 0 /*
+DEFUN ("define-function", Fdefine_function, 2, 2, 0, /*
 Set SYMBOL's function definition to NEWVAL, and return NEWVAL.
 Associates the function with the current load file, if any.
-*/ )
+*/
-(sym, newdef)
+(sym, newdef))
-Lisp_Object sym, newdef;
 {
 /* This function can GC */
 CHECK_SYMBOL (sym);
 Ffset (sym, newdef);
 LOADHIST_ATTACH (sym);
 return newdef;
 }
-DEFUN ("setplist", Fsetplist, Ssetplist, 2, 2, 0 /*
+DEFUN ("setplist", Fsetplist, 2, 2, 0, /*
 Set SYMBOL's property list to NEWVAL, and return NEWVAL.
-*/ )
+*/
-(sym, newplist)
+(sym, newplist))
-Lisp_Object sym, newplist;
 {
 CHECK_SYMBOL (sym);
 XSYMBOL (sym)->plist = newplist;
 return newplist;
 }
 return find_symbol_value_1 (sym, current_buffer, dev, 1,
 			      find_it_p ? symbol_cons : Qnil,
 			      find_it_p);
 }
-DEFUN ("symbol-value", Fsymbol_value, Ssymbol_value, 1, 1, 0 /*
+DEFUN ("symbol-value", Fsymbol_value, 1, 1, 0, /*
 Return SYMBOL's value.  Error if that is void.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 Lisp_Object val = find_symbol_value (sym);
 if (UNBOUNDP (val))
 return Fsignal (Qvoid_variable, list1 (sym));
 else
 return val;
 }
-DEFUN ("set", Fset, Sset, 2, 2, 0 /*
+DEFUN ("set", Fset, 2, 2, 0, /*
 Set SYMBOL's value to NEWVAL, and return NEWVAL.
-*/ )
+*/
-(sym, newval)
+(sym, newval))
-Lisp_Object sym, newval;
 {
 REGISTER Lisp_Object valcontents;
 /* remember, we're called by Fmakunbound() as well */
 CHECK_SYMBOL (sym);
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
-DEFUN ("default-boundp", Fdefault_boundp, Sdefault_boundp, 1, 1, 0 /*
+DEFUN ("default-boundp", Fdefault_boundp, 1, 1, 0, /*
 Return T if SYMBOL has a non-void default value.
 This is the value that is seen in buffers that do not have their own values
 for this variable.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 Lisp_Object value;
 value = default_value (sym);
 return (UNBOUNDP (value) ? Qnil : Qt);
 }
-DEFUN ("default-value", Fdefault_value, Sdefault_value, 1, 1, 0 /*
+DEFUN ("default-value", Fdefault_value, 1, 1, 0, /*
 Return SYMBOL's default value.
 This is the value that is seen in buffers that do not have their own values
 for this variable.  The default value is meaningful for variables with
 local bindings in certain buffers.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 Lisp_Object value;
 value = default_value (sym);
 if (UNBOUNDP (value))
 return Fsignal (Qvoid_variable, list1 (sym));
 return value;
 }
-DEFUN ("set-default", Fset_default, Sset_default, 2, 2, 0 /*
+DEFUN ("set-default", Fset_default, 2, 2, 0, /*
 Set SYMBOL's default value to VAL.  SYMBOL and VAL are evaluated.
 The default value is seen in buffers that do not have their own values
 for this variable.
-*/ )
+*/
-(sym, value)
+(sym, value))
-Lisp_Object sym, value;
 {
 Lisp_Object valcontents;
 CHECK_SYMBOL (sym);
 return Fset (sym, value);
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
-DEFUN ("setq-default", Fsetq_default, Ssetq_default, 2, UNEVALLED, 0 /*
+DEFUN ("setq-default", Fsetq_default, 2, UNEVALLED, 0, /*
 Set the default value of variable VAR to VALUE.
 VAR, the variable name, is literal (not evaluated);
 VALUE is an expression and it is evaluated.
 The default value of a variable is seen in buffers
 that do not have their own values for the variable.
 More generally, you can use multiple variables and values, as in
 (setq-default SYM VALUE SYM VALUE...)
 This sets each SYM's default value to the corresponding VALUE.
 The VALUE for the Nth SYM can refer to the new default values
 of previous SYMs.
-*/ )
+*/
-(args)
+(args))
-Lisp_Object args;
 {
 /* This function can GC */
 Lisp_Object args_left;
 Lisp_Object val, sym;
 struct gcpro gcpro1;
 return val;
 }
 /* Lisp functions for creating and removing buffer-local variables.  */
-DEFUN ("make-variable-buffer-local", Fmake_variable_buffer_local,
+DEFUN ("make-variable-buffer-local", Fmake_variable_buffer_local, 1, 1,
-Smake_variable_buffer_local,
+"vMake Variable Buffer Local: ", /*
-1, 1, "vMake Variable Buffer Local: " /*
 Make VARIABLE have a separate value for each buffer.
 At any time, the value for the current buffer is in effect.
 There is also a default value which is seen in any buffer which has not yet
 set its own value.
 Using `set' or `setq' to set the variable causes it to have a separate value
 for the current buffer if it was previously using the default value.
 The function `default-value' gets the default value and `set-default'
 sets it.
-*/ )
+*/
-(variable)
+(variable))
-Lisp_Object variable;
 {
 Lisp_Object valcontents;
 CHECK_SYMBOL (variable);
 #endif
 return (variable);
 }
 }
-DEFUN ("make-local-variable", Fmake_local_variable, Smake_local_variable,
+DEFUN ("make-local-variable", Fmake_local_variable, 1, 1, "vMake Local Variable: ", /*
-1, 1, "vMake Local Variable: " /*
 Make VARIABLE have a separate value in the current buffer.
 Other buffers will continue to share a common default value.
 \(The buffer-local value of VARIABLE starts out as the same value
 VARIABLE previously had.  If VARIABLE was void, it remains void.)
 See also `make-variable-buffer-local'.
 this function causes a local value to exist for this buffer,
 just as setting the variable would do.
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Use `make-local-hook' instead.
-*/ )
+*/
-(variable)
+(variable))
-Lisp_Object variable;
 {
 Lisp_Object valcontents;
 struct symbol_value_buffer_local *bfwd;
 CHECK_SYMBOL (variable);
 }
 return (variable);
 }
-DEFUN ("kill-local-variable", Fkill_local_variable, Skill_local_variable,
+DEFUN ("kill-local-variable", Fkill_local_variable, 1, 1, "vKill Local Variable: ", /*
-1, 1, "vKill Local Variable: " /*
 Make VARIABLE no longer have a separate value in the current buffer.
 From now on the default value will apply in this buffer.
-*/ )
+*/
-(variable)
+(variable))
-Lisp_Object variable;
 {
 Lisp_Object valcontents;
 CHECK_SYMBOL (variable);
 }
 RETURN_NOT_REACHED(Qnil)	/* suppress compiler warning */
 }
-DEFUN ("kill-console-local-variable", Fkill_console_local_variable,
+DEFUN ("kill-console-local-variable", Fkill_console_local_variable, 1, 1, "vKill Console Local Variable: ", /*
-Skill_console_local_variable,
-1, 1, "vKill Console Local Variable: " /*
 Make VARIABLE no longer have a separate value in the selected console.
 From now on the default value will apply in this console.
-*/ )
+*/
-(variable)
+(variable))
-Lisp_Object variable;
 {
 Lisp_Object valcontents;
 CHECK_SYMBOL (variable);
 }
 return (0);
 }
-DEFUN ("symbol-value-in-buffer", Fsymbol_value_in_buffer,
+DEFUN ("symbol-value-in-buffer", Fsymbol_value_in_buffer, 2, 3, 0, /*
-Ssymbol_value_in_buffer, 2, 3, 0 /*
 Return the value of SYMBOL in BUFFER, or UNBOUND-VALUE if it is unbound.
-*/ )
+*/
-(symbol, buffer, unbound_value)
+(symbol, buffer, unbound_value))
-Lisp_Object symbol, buffer, unbound_value;
 {
 Lisp_Object value;
 CHECK_SYMBOL (symbol);
 CHECK_BUFFER (buffer);
 value = symbol_value_in_buffer (symbol, buffer);
 return (unbound_value);
 else
 return (value);
 }
-DEFUN ("symbol-value-in-console", Fsymbol_value_in_console,
+DEFUN ("symbol-value-in-console", Fsymbol_value_in_console, 2, 3, 0, /*
-Ssymbol_value_in_console, 2, 3, 0 /*
 Return the value of SYMBOL in CONSOLE, or UNBOUND-VALUE if it is unbound.
-*/ )
+*/
-(symbol, console, unbound_value)
+(symbol, console, unbound_value))
-Lisp_Object symbol, console, unbound_value;
 {
 Lisp_Object value;
 CHECK_SYMBOL (symbol);
 CHECK_CONSOLE (console);
 value = symbol_value_in_console (symbol, console);
 return (unbound_value);
 else
 return (value);
 }
-DEFUN ("built-in-variable-type", Fbuilt_in_variable_type,
+DEFUN ("built-in-variable-type", Fbuilt_in_variable_type, 1, 1, 0, /*
-Sbuilt_in_variable_type, 1, 1, 0 /*
 If SYM is a built-in variable, return info about this; else return nil.
 The returned info will be a symbol, one of
 `object'		A simple built-in variable.
 `const-object'		Same, but cannot be set.
 			buffer-local variable.
 `selected-console'	A built-in console-local variable.
 `const-selected-console' Same, but cannot be set.
 `default-console'	Forwards to the default value of a built-in
 			console-local variable.
-*/ )
+*/
-(sym)
+(sym))
-Lisp_Object sym;
 {
 REGISTER Lisp_Object valcontents;
 CHECK_SYMBOL (sym);
 return Qnil;
 }
-DEFUN ("local-variable-p", Flocal_variable_p, Slocal_variable_p, 2, 3, 0 /*
+DEFUN ("local-variable-p", Flocal_variable_p, 2, 3, 0, /*
 Return t if SYMBOL's value is local to BUFFER.
 If optional third arg AFTER-SET is true, return t if SYMBOL would be
 buffer-local after it is set, regardless of whether it is so presently.
 A nil value for BUFFER is *not* the same as (current-buffer), but means
 "no buffer".  Specifically:
 buffer-local. (This includes `buffer-file-name', `buffer-read-only',
 `buffer-undo-list', and others.)
 -- If BUFFER is nil and AFTER-SET is t, a return value of t indicates that
 the variable has had `make-variable-buffer-local' applied to it.
-*/ )
+*/
-(symbol, buffer, after_set)
+(symbol, buffer, after_set))
-Lisp_Object symbol, buffer, after_set;
 {
 int local_info;
 CHECK_SYMBOL (symbol);
 if (!NILP (buffer))
 return call5 (bfwd->handler[htype], sym, Flist (nargs, args), funsym,
 		bfwd->harg[htype], Qnil);
 }
 DEFUN ("dontusethis-set-symbol-value-handler",
-Fdontusethis_set_symbol_value_handler,
+Fdontusethis_set_symbol_value_handler, 3, 5, 0, /*
-Sdontusethis_set_symbol_value_handler, 3, 5, 0 /*
 Don't you dare use this.
 If you do, suffer the wrath of Ben, who is likely to rename
 this function (or change the semantics of its arguments) without
 pity, thereby invalidating your code.
-*/ )
+*/
-(variable, handler_type, handler, harg, keep_existing)
+(variable, handler_type, handler, harg, keep_existing))
-Lisp_Object variable, handler_type, handler, harg, keep_existing;
 {
 Lisp_Object valcontents;
 struct symbol_value_lisp_magic *bfwd;
 enum lisp_magic_handler htype;
 int i;
 }
 return hare;
 }
-DEFUN ("defvaralias", Fdefvaralias, Sdefvaralias, 2, 2, 0 /*
+DEFUN ("defvaralias", Fdefvaralias, 2, 2, 0, /*
 Define a variable as an alias for another variable.
 Thenceforth, any operations performed on VARIABLE will actually be
 performed on ALIAS.  Both VARIABLE and ALIAS should be symbols.
 If ALIAS is nil, remove any aliases for VARIABLE.
 ALIAS can itself be aliased, and the chain of variable aliases
 If VARIABLE already has a value, this value will be shadowed
 until the alias is removed, at which point it will be restored.
 Currently VARIABLE cannot be a built-in variable, a variable that
 has a buffer-local value in any buffer, or the symbols nil or t.
 (ALIAS, however, can be any type of variable.)
-*/ )
+*/
-(variable, alias)
+(variable, alias))
-Lisp_Object variable, alias;
 {
 struct symbol_value_varalias *bfwd;
 Lisp_Object valcontents;
 CHECK_SYMBOL (variable);
 XSETSYMBOL_VALUE_MAGIC (valcontents, bfwd);
 XSYMBOL (variable)->value = valcontents;
 return Qnil;
 }
-DEFUN ("variable-alias", Fvariable_alias, Svariable_alias, 1, 2, 0 /*
+DEFUN ("variable-alias", Fvariable_alias, 1, 2, 0, /*
 If VARIABLE is aliased to another variable, return that variable.
 VARIABLE should be a symbol.  If VARIABLE is not aliased, return nil.
 Variable aliases are created with `defvaralias'.  See also
 `indirect-variable'.
-*/ )
+*/
-(variable, follow_past_lisp_magic)
+(variable, follow_past_lisp_magic))
-Lisp_Object variable, follow_past_lisp_magic;
 {
 Lisp_Object valcontents;
 CHECK_SYMBOL (variable);
 if (!NILP (follow_past_lisp_magic) && !EQ (follow_past_lisp_magic, Qt))
 (XSYMBOL_VALUE_VARALIAS (valcontents));
 else
 return Qnil;
 }
-DEFUN ("indirect-variable", Findirect_variable, Sindirect_variable, 1, 2, 0 /*
+DEFUN ("indirect-variable", Findirect_variable, 1, 2, 0, /*
 Return the variable at the end of OBJECT's variable-alias chain.
 If OBJECT is a symbol, follow all variable aliases and return
 the final (non-aliased) symbol.  Variable aliases are created with
 the function `defvaralias'.
 If OBJECT is not a symbol, just return it.
 Signal a cyclic-variable-indirection error if there is a loop in the
 variable chain of symbols.
-*/ )
+*/
-(object, follow_past_lisp_magic)
+(object, follow_past_lisp_magic))
-Lisp_Object object, follow_past_lisp_magic;
 {
 if (!SYMBOLP (object))
 return object;
 if (!NILP (follow_past_lisp_magic) && !EQ (follow_past_lisp_magic, Qt))
 {
 defsymbol (&Qconst_current_buffer, "const-current-buffer");
 defsymbol (&Qdefault_console, "default-console");
 defsymbol (&Qselected_console, "selected-console");
 defsymbol (&Qconst_selected_console, "const-selected-console");
-defsubr (&Sintern);
+DEFSUBR (Fintern);
-defsubr (&Sintern_soft);
+DEFSUBR (Fintern_soft);
-defsubr (&Sunintern);
+DEFSUBR (Funintern);
-defsubr (&Smapatoms);
+DEFSUBR (Fmapatoms);
-defsubr (&Sapropos_internal);
+DEFSUBR (Fapropos_internal);
-defsubr (&Ssymbol_function);
+DEFSUBR (Fsymbol_function);
-defsubr (&Ssymbol_plist);
+DEFSUBR (Fsymbol_plist);
-defsubr (&Ssymbol_name);
+DEFSUBR (Fsymbol_name);
-defsubr (&Smakunbound);
+DEFSUBR (Fmakunbound);
-defsubr (&Sfmakunbound);
+DEFSUBR (Ffmakunbound);
-defsubr (&Sboundp);
+DEFSUBR (Fboundp);
-defsubr (&Sglobally_boundp);
+DEFSUBR (Fglobally_boundp);
-defsubr (&Sfboundp);
+DEFSUBR (Ffboundp);
-defsubr (&Sfset);
+DEFSUBR (Ffset);
-defsubr (&Sdefine_function);
+DEFSUBR (Fdefine_function);
-defsubr (&Ssetplist);
+DEFSUBR (Fsetplist);
-defsubr (&Ssymbol_value_in_buffer);
+DEFSUBR (Fsymbol_value_in_buffer);
-defsubr (&Ssymbol_value_in_console);
+DEFSUBR (Fsymbol_value_in_console);
-defsubr (&Sbuilt_in_variable_type);
+DEFSUBR (Fbuilt_in_variable_type);
-defsubr (&Ssymbol_value);
+DEFSUBR (Fsymbol_value);
-defsubr (&Sset);
+DEFSUBR (Fset);
-defsubr (&Sdefault_boundp);
+DEFSUBR (Fdefault_boundp);
-defsubr (&Sdefault_value);
+DEFSUBR (Fdefault_value);
-defsubr (&Sset_default);
+DEFSUBR (Fset_default);
-defsubr (&Ssetq_default);
+DEFSUBR (Fsetq_default);
-defsubr (&Smake_variable_buffer_local);
+DEFSUBR (Fmake_variable_buffer_local);
-defsubr (&Smake_local_variable);
+DEFSUBR (Fmake_local_variable);
-defsubr (&Skill_local_variable);
+DEFSUBR (Fkill_local_variable);
-defsubr (&Skill_console_local_variable);
+DEFSUBR (Fkill_console_local_variable);
-defsubr (&Slocal_variable_p);
+DEFSUBR (Flocal_variable_p);
-defsubr (&Sdefvaralias);
+DEFSUBR (Fdefvaralias);
-defsubr (&Svariable_alias);
+DEFSUBR (Fvariable_alias);
-defsubr (&Sindirect_variable);
+DEFSUBR (Findirect_variable);
-defsubr (&Sdontusethis_set_symbol_value_handler);
+DEFSUBR (Fdontusethis_set_symbol_value_handler);
 }
 /* Create and initialize a variable whose value is forwarded to C data */
 void
 defvar_mumble (CONST char *namestring,

Mercurial > hg > xemacs-beta

comparison src/symbols.c @ 20:859a2309aef8 r19-15b93