procyberian/emacs
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Move DEFSYM to lisp.h and use everywhere.

Browse source
This commit is contained in:
Juanma Barranquero 2011-06-24 23:25:22 +02:00
parent 7d0da90e7b
commit cd3520a41d
50 changed files with 643 additions and 1287 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

59
src/ChangeLog
View file

@ -1,7 +1,62 @@
2011-06-24 Juanma Barranquero <lekktu@gmail.com>
Move DEFSYM to lisp.h and use everywhere.
* character.h (DEFSYM): Move declaration...
* lisp.h (DEFSYM): ...here.
* gnutls.c:
* minibuf.c:
* w32menu.c:
* w32proc.c:
* w32select.c: Don't include character.h.
* alloc.c (syms_of_alloc):
* buffer.c (syms_of_buffer):
* bytecode.c (syms_of_bytecode):
* callint.c (syms_of_callint):
* casefiddle.c (syms_of_casefiddle):
* casetab.c (init_casetab_once):
* category.c (init_category_once, syms_of_category):
* ccl.c (syms_of_ccl):
* cmds.c (syms_of_cmds):
* composite.c (syms_of_composite):
* dbusbind.c (syms_of_dbusbind):
* dired.c (syms_of_dired):
* dispnew.c (syms_of_display):
* doc.c (syms_of_doc):
* editfns.c (syms_of_editfns):
* emacs.c (syms_of_emacs):
* eval.c (syms_of_eval):
* fileio.c (syms_of_fileio):
* fns.c (syms_of_fns):
* frame.c (syms_of_frame):
* fringe.c (syms_of_fringe):
* insdel.c (syms_of_insdel):
* keymap.c (syms_of_keymap):
* lread.c (init_obarray, syms_of_lread):
* macros.c (syms_of_macros):
* msdos.c (syms_of_msdos):
* print.c (syms_of_print):
* process.c (syms_of_process):
* search.c (syms_of_search):
* sound.c (syms_of_sound):
* syntax.c (init_syntax_once, syms_of_syntax):
* terminal.c (syms_of_terminal):
* textprop.c (syms_of_textprop):
* undo.c (syms_of_undo):
* w32.c (globals_of_w32):
* window.c (syms_of_window):
* xdisp.c (syms_of_xdisp):
* xfaces.c (syms_of_xfaces):
* xfns.c (syms_of_xfns):
* xmenu.c (syms_of_xmenu):
* xsettings.c (syms_of_xsettings):
* xterm.c (syms_of_xterm): Use DEFSYM.
2011-06-24 Teodor Zlatanov <tzz@lifelogs.com>
* gnutls.c (syms_of_gnutls): Use the DEFSYM macro from
character.h.
* gnutls.c (syms_of_gnutls): Use the DEFSYM macro from character.h.
2011-06-23 Paul Eggert <eggert@cs.ucla.edu>

10
src/alloc.c
View file

@ -6251,8 +6251,7 @@ do hash-consing of the objects allocated to pure space. */);
DEFVAR_LISP ("post-gc-hook", Vpost_gc_hook,
doc: /* Hook run after garbage collection has finished. */);
Vpost_gc_hook = Qnil;
Qpost_gc_hook = intern_c_string ("post-gc-hook");
staticpro (&Qpost_gc_hook);
DEFSYM (Qpost_gc_hook, "post-gc-hook");
DEFVAR_LISP ("memory-signal-data", Vmemory_signal_data,
doc: /* Precomputed `signal' argument for memory-full error. */);
@ -6266,11 +6265,8 @@ do hash-consing of the objects allocated to pure space. */);
doc: /* Non-nil means Emacs cannot get much more Lisp memory. */);
Vmemory_full = Qnil;
staticpro (&Qgc_cons_threshold);
Qgc_cons_threshold = intern_c_string ("gc-cons-threshold");
staticpro (&Qchar_table_extra_slots);
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
DEFSYM (Qgc_cons_threshold, "gc-cons-threshold");
DEFSYM (Qchar_table_extra_slots, "char-table-extra-slots");
DEFVAR_LISP ("gc-elapsed", Vgc_elapsed,
doc: /* Accumulated time elapsed in garbage collections.

51
src/buffer.c
View file

@ -5209,39 +5209,26 @@ syms_of_buffer (void)
staticpro (&Vbuffer_alist);
staticpro (&Qprotected_field);
staticpro (&Qpermanent_local);
Qpermanent_local_hook = intern_c_string ("permanent-local-hook");
staticpro (&Qpermanent_local_hook);
staticpro (&Qkill_buffer_hook);
Qoverlayp = intern_c_string ("overlayp");
staticpro (&Qoverlayp);
Qevaporate = intern_c_string ("evaporate");
staticpro (&Qevaporate);
Qmodification_hooks = intern_c_string ("modification-hooks");
staticpro (&Qmodification_hooks);
Qinsert_in_front_hooks = intern_c_string ("insert-in-front-hooks");
staticpro (&Qinsert_in_front_hooks);
Qinsert_behind_hooks = intern_c_string ("insert-behind-hooks");
staticpro (&Qinsert_behind_hooks);
Qget_file_buffer = intern_c_string ("get-file-buffer");
staticpro (&Qget_file_buffer);
Qpriority = intern_c_string ("priority");
staticpro (&Qpriority);
Qbefore_string = intern_c_string ("before-string");
staticpro (&Qbefore_string);
Qafter_string = intern_c_string ("after-string");
staticpro (&Qafter_string);
Qfirst_change_hook = intern_c_string ("first-change-hook");
staticpro (&Qfirst_change_hook);
Qbefore_change_functions = intern_c_string ("before-change-functions");
staticpro (&Qbefore_change_functions);
Qafter_change_functions = intern_c_string ("after-change-functions");
staticpro (&Qafter_change_functions);
DEFSYM (Qpermanent_local_hook, "permanent-local-hook");
DEFSYM (Qoverlayp, "overlayp");
DEFSYM (Qevaporate, "evaporate");
DEFSYM (Qmodification_hooks, "modification-hooks");
DEFSYM (Qinsert_in_front_hooks, "insert-in-front-hooks");
DEFSYM (Qinsert_behind_hooks, "insert-behind-hooks");
DEFSYM (Qget_file_buffer, "get-file-buffer");
DEFSYM (Qpriority, "priority");
DEFSYM (Qbefore_string, "before-string");
DEFSYM (Qafter_string, "after-string");
DEFSYM (Qfirst_change_hook, "first-change-hook");
DEFSYM (Qbefore_change_functions, "before-change-functions");
DEFSYM (Qafter_change_functions, "after-change-functions");
DEFSYM (Qkill_buffer_query_functions, "kill-buffer-query-functions");
/* The next one is initialized in init_buffer_once. */
staticpro (&Qucs_set_table_for_input);
Qkill_buffer_query_functions = intern_c_string ("kill-buffer-query-functions");
staticpro (&Qkill_buffer_query_functions);
Fput (Qprotected_field, Qerror_conditions,
pure_cons (Qprotected_field, pure_cons (Qerror, Qnil)));
Fput (Qprotected_field, Qerror_message,
@ -6035,8 +6022,7 @@ If any of them returns nil, the buffer is not killed. */);
doc: /* Normal hook run before changing the major mode of a buffer.
The function `kill-all-local-variables' runs this before doing anything else. */);
Vchange_major_mode_hook = Qnil;
Qchange_major_mode_hook = intern_c_string ("change-major-mode-hook");
staticpro (&Qchange_major_mode_hook);
DEFSYM (Qchange_major_mode_hook, "change-major-mode-hook");
DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook,
doc: /* Hook run when the buffer list changes.
@ -6044,8 +6030,7 @@ Functions running this hook are `get-buffer-create',
`make-indirect-buffer', `rename-buffer', `kill-buffer',
`record-buffer' and `unrecord-buffer'. */);
Vbuffer_list_update_hook = Qnil;
Qbuffer_list_update_hook = intern_c_string ("buffer-list-update-hook");
staticpro (&Qbuffer_list_update_hook);
DEFSYM (Qbuffer_list_update_hook, "buffer-list-update-hook");
defsubr (&Sbuffer_live_p);
defsubr (&Sbuffer_list);

6
src/bytecode.c
View file

@ -1840,8 +1840,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
void
syms_of_bytecode (void)
{
Qbytecode = intern_c_string ("byte-code");
staticpro (&Qbytecode);
DEFSYM (Qbytecode, "byte-code");
defsubr (&Sbyte_code);
@ -1863,8 +1862,7 @@ integer, it is incremented each time that symbol's function is called. */);
byte_metering_on = 0;
Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
Qbyte_code_meter = intern_c_string ("byte-code-meter");
staticpro (&Qbyte_code_meter);
DEFSYM (Qbyte_code_meter, "byte-code-meter");
{
int i = 256;
while (i--)

49
src/callint.c
View file

@ -896,41 +896,20 @@ syms_of_callint (void)
pure_cons (intern_c_string ("point"),
pure_cons (intern_c_string ("mark"), Qnil))));
Qlist = intern_c_string ("list");
staticpro (&Qlist);
Qlet = intern_c_string ("let");
staticpro (&Qlet);
Qif = intern_c_string ("if");
staticpro (&Qif);
Qwhen = intern_c_string ("when");
staticpro (&Qwhen);
Qletx = intern_c_string ("let*");
staticpro (&Qletx);
Qsave_excursion = intern_c_string ("save-excursion");
staticpro (&Qsave_excursion);
Qprogn = intern_c_string ("progn");
staticpro (&Qprogn);
Qminus = intern_c_string ("-");
staticpro (&Qminus);
Qplus = intern_c_string ("+");
staticpro (&Qplus);
Qhandle_shift_selection = intern_c_string ("handle-shift-selection");
staticpro (&Qhandle_shift_selection);
Qcall_interactively = intern_c_string ("call-interactively");
staticpro (&Qcall_interactively);
Qcommand_debug_status = intern_c_string ("command-debug-status");
staticpro (&Qcommand_debug_status);
Qenable_recursive_minibuffers = intern_c_string ("enable-recursive-minibuffers");
staticpro (&Qenable_recursive_minibuffers);
Qmouse_leave_buffer_hook = intern_c_string ("mouse-leave-buffer-hook");
staticpro (&Qmouse_leave_buffer_hook);
DEFSYM (Qlist, "list");
DEFSYM (Qlet, "let");
DEFSYM (Qif, "if");
DEFSYM (Qwhen, "when");
DEFSYM (Qletx, "let*");
DEFSYM (Qsave_excursion, "save-excursion");
DEFSYM (Qprogn, "progn");
DEFSYM (Qminus, "-");
DEFSYM (Qplus, "+");
DEFSYM (Qhandle_shift_selection, "handle-shift-selection");
DEFSYM (Qcall_interactively, "call-interactively");
DEFSYM (Qcommand_debug_status, "command-debug-status");
DEFSYM (Qenable_recursive_minibuffers, "enable-recursive-minibuffers");
DEFSYM (Qmouse_leave_buffer_hook, "mouse-leave-buffer-hook");
DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
doc: /* The value of the prefix argument for the next editing command.

3
src/casefiddle.c
View file

@ -417,8 +417,7 @@ With negative argument, capitalize previous words but do not move. */)
void
syms_of_casefiddle (void)
{
Qidentity = intern_c_string ("identity");
staticpro (&Qidentity);
DEFSYM (Qidentity, "identity");
defsubr (&Supcase);
defsubr (&Sdowncase);
defsubr (&Scapitalize);

6
src/casetab.c
View file

@ -244,8 +244,7 @@ init_casetab_once (void)
{
register int i;
Lisp_Object down, up;
Qcase_table = intern_c_string ("case-table");
staticpro (&Qcase_table);
DEFSYM (Qcase_table, "case-table");
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
@ -288,8 +287,7 @@ init_casetab_once (void)
void
syms_of_casetab (void)
{
Qcase_table_p = intern_c_string ("case-table-p");
staticpro (&Qcase_table_p);
DEFSYM (Qcase_table_p, "case-table-p");
staticpro (&Vascii_canon_table);
staticpro (&Vascii_downcase_table);

12
src/category.c
View file

@ -453,8 +453,7 @@ void
init_category_once (void)
{
/* This has to be done here, before we call Fmake_char_table. */
Qcategory_table = intern_c_string ("category-table");
staticpro (&Qcategory_table);
DEFSYM (Qcategory_table, "category-table");
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
@ -475,12 +474,9 @@ init_category_once (void)
void
syms_of_category (void)
{
Qcategoryp = intern_c_string ("categoryp");
staticpro (&Qcategoryp);
Qcategorysetp = intern_c_string ("categorysetp");
staticpro (&Qcategorysetp);
Qcategory_table_p = intern_c_string ("category-table-p");
staticpro (&Qcategory_table_p);
DEFSYM (Qcategoryp, "categoryp");
DEFSYM (Qcategorysetp, "categorysetp");
DEFSYM (Qcategory_table_p, "category-table-p");
DEFVAR_LISP ("word-combining-categories", Vword_combining_categories,
doc: /* List of pair (cons) of categories to determine word boundary.

23
src/ccl.c
View file

@ -2305,23 +2305,12 @@ syms_of_ccl (void)
staticpro (&Vccl_program_table);
Vccl_program_table = Fmake_vector (make_number (32), Qnil);
Qccl = intern_c_string ("ccl");
staticpro (&Qccl);
Qcclp = intern_c_string ("cclp");
staticpro (&Qcclp);
Qccl_program = intern_c_string ("ccl-program");
staticpro (&Qccl_program);
Qccl_program_idx = intern_c_string ("ccl-program-idx");
staticpro (&Qccl_program_idx);
Qcode_conversion_map = intern_c_string ("code-conversion-map");
staticpro (&Qcode_conversion_map);
Qcode_conversion_map_id = intern_c_string ("code-conversion-map-id");
staticpro (&Qcode_conversion_map_id);
DEFSYM (Qccl, "ccl");
DEFSYM (Qcclp, "cclp");
DEFSYM (Qccl_program, "ccl-program");
DEFSYM (Qccl_program_idx, "ccl-program-idx");
DEFSYM (Qcode_conversion_map, "code-conversion-map");
DEFSYM (Qcode_conversion_map_id, "code-conversion-map-id");
DEFVAR_LISP ("code-conversion-map-vector", Vcode_conversion_map_vector,
doc: /* Vector of code conversion maps. */);

3
src/character.h
View file

@ -628,7 +628,4 @@ extern Lisp_Object string_escape_byte8 (Lisp_Object);
#define GET_TRANSLATION_TABLE(id) \
(XCDR(XVECTOR(Vtranslation_table_vector)->contents[(id)]))
#define DEFSYM(sym, name) \
do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
#endif /* EMACS_CHARACTER_H */

19
src/cmds.c
View file

@ -511,20 +511,11 @@ internal_self_insert (int c, EMACS_INT n)
void
syms_of_cmds (void)
{
Qkill_backward_chars = intern_c_string ("kill-backward-chars");
staticpro (&Qkill_backward_chars);
Qkill_forward_chars = intern_c_string ("kill-forward-chars");
staticpro (&Qkill_forward_chars);
Qoverwrite_mode_binary = intern_c_string ("overwrite-mode-binary");
staticpro (&Qoverwrite_mode_binary);
Qexpand_abbrev = intern_c_string ("expand-abbrev");
staticpro (&Qexpand_abbrev);
Qpost_self_insert_hook = intern_c_string ("post-self-insert-hook");
staticpro (&Qpost_self_insert_hook);
DEFSYM (Qkill_backward_chars, "kill-backward-chars");
DEFSYM (Qkill_forward_chars, "kill-forward-chars");
DEFSYM (Qoverwrite_mode_binary, "overwrite-mode-binary");
DEFSYM (Qexpand_abbrev, "expand-abbrev");
DEFSYM (Qpost_self_insert_hook, "post-self-insert-hook");
DEFVAR_LISP ("post-self-insert-hook", Vpost_self_insert_hook,
doc: /* Hook run at the end of `self-insert-command'.

10
src/composite.c
View file

@ -1937,8 +1937,7 @@ syms_of_composite (void)
{
int i;
Qcomposition = intern_c_string ("composition");
staticpro (&Qcomposition);
DEFSYM (Qcomposition, "composition");
/* Make a hash table for static composition. */
{
@ -1997,11 +1996,8 @@ valid.
The default value is the function `compose-chars-after'. */);
Vcompose_chars_after_function = intern_c_string ("compose-chars-after");
Qauto_composed = intern_c_string ("auto-composed");
staticpro (&Qauto_composed);
Qauto_composition_function = intern_c_string ("auto-composition-function");
staticpro (&Qauto_composition_function);
DEFSYM (Qauto_composed, "auto-composed");
DEFSYM (Qauto_composition_function, "auto-composition-function");
DEFVAR_LISP ("auto-composition-mode", Vauto_composition_mode,
doc: /* Non-nil if Auto-Composition mode is enabled.

144
src/dbusbind.c
View file

@ -2189,142 +2189,76 @@ void
syms_of_dbusbind (void)
{
Qdbus_init_bus = intern_c_string ("dbus-init-bus");
staticpro (&Qdbus_init_bus);
DEFSYM (Qdbus_init_bus, "dbus-init-bus");
defsubr (&Sdbus_init_bus);
Qdbus_close_bus = intern_c_string ("dbus-close-bus");
staticpro (&Qdbus_close_bus);
DEFSYM (Qdbus_close_bus, "dbus-close-bus");
defsubr (&Sdbus_close_bus);
Qdbus_get_unique_name = intern_c_string ("dbus-get-unique-name");
staticpro (&Qdbus_get_unique_name);
DEFSYM (Qdbus_get_unique_name, "dbus-get-unique-name");
defsubr (&Sdbus_get_unique_name);
Qdbus_call_method = intern_c_string ("dbus-call-method");
staticpro (&Qdbus_call_method);
DEFSYM (Qdbus_call_method, "dbus-call-method");
defsubr (&Sdbus_call_method);
Qdbus_call_method_asynchronously
= intern_c_string ("dbus-call-method-asynchronously");
staticpro (&Qdbus_call_method_asynchronously);
DEFSYM (Qdbus_call_method_asynchronously, "dbus-call-method-asynchronously");
defsubr (&Sdbus_call_method_asynchronously);
Qdbus_method_return_internal
= intern_c_string ("dbus-method-return-internal");
staticpro (&Qdbus_method_return_internal);
DEFSYM (Qdbus_method_return_internal, "dbus-method-return-internal");
defsubr (&Sdbus_method_return_internal);
Qdbus_method_error_internal = intern_c_string ("dbus-method-error-internal");
staticpro (&Qdbus_method_error_internal);
DEFSYM (Qdbus_method_error_internal, "dbus-method-error-internal");
defsubr (&Sdbus_method_error_internal);
Qdbus_send_signal = intern_c_string ("dbus-send-signal");
staticpro (&Qdbus_send_signal);
DEFSYM (Qdbus_send_signal, "dbus-send-signal");
defsubr (&Sdbus_send_signal);
Qdbus_register_service = intern_c_string ("dbus-register-service");
staticpro (&Qdbus_register_service);
DEFSYM (Qdbus_register_service, "dbus-register-service");
defsubr (&Sdbus_register_service);
Qdbus_register_signal = intern_c_string ("dbus-register-signal");
staticpro (&Qdbus_register_signal);
DEFSYM (Qdbus_register_signal, "dbus-register-signal");
defsubr (&Sdbus_register_signal);
Qdbus_register_method = intern_c_string ("dbus-register-method");
staticpro (&Qdbus_register_method);
DEFSYM (Qdbus_register_method, "dbus-register-method");
defsubr (&Sdbus_register_method);
Qdbus_error = intern_c_string ("dbus-error");
staticpro (&Qdbus_error);
DEFSYM (Qdbus_error, "dbus-error");
Fput (Qdbus_error, Qerror_conditions,
list2 (Qdbus_error, Qerror));
Fput (Qdbus_error, Qerror_message,
make_pure_c_string ("D-Bus error"));
QCdbus_system_bus = intern_c_string (":system");
staticpro (&QCdbus_system_bus);
QCdbus_session_bus = intern_c_string (":session");
staticpro (&QCdbus_session_bus);
QCdbus_request_name_allow_replacement
= intern_c_string (":allow-replacement");
staticpro (&QCdbus_request_name_allow_replacement);
QCdbus_request_name_replace_existing = intern_c_string (":replace-existing");
staticpro (&QCdbus_request_name_replace_existing);
QCdbus_request_name_do_not_queue = intern_c_string (":do-not-queue");
staticpro (&QCdbus_request_name_do_not_queue);
QCdbus_request_name_reply_primary_owner = intern_c_string (":primary-owner");
staticpro (&QCdbus_request_name_reply_primary_owner);
QCdbus_request_name_reply_exists = intern_c_string (":exists");
staticpro (&QCdbus_request_name_reply_exists);
QCdbus_request_name_reply_in_queue = intern_c_string (":in-queue");
staticpro (&QCdbus_request_name_reply_in_queue);
QCdbus_request_name_reply_already_owner = intern_c_string (":already-owner");
staticpro (&QCdbus_request_name_reply_already_owner);
QCdbus_timeout = intern_c_string (":timeout");
staticpro (&QCdbus_timeout);
QCdbus_type_byte = intern_c_string (":byte");
staticpro (&QCdbus_type_byte);
QCdbus_type_boolean = intern_c_string (":boolean");
staticpro (&QCdbus_type_boolean);
QCdbus_type_int16 = intern_c_string (":int16");
staticpro (&QCdbus_type_int16);
QCdbus_type_uint16 = intern_c_string (":uint16");
staticpro (&QCdbus_type_uint16);
QCdbus_type_int32 = intern_c_string (":int32");
staticpro (&QCdbus_type_int32);
QCdbus_type_uint32 = intern_c_string (":uint32");
staticpro (&QCdbus_type_uint32);
QCdbus_type_int64 = intern_c_string (":int64");
staticpro (&QCdbus_type_int64);
QCdbus_type_uint64 = intern_c_string (":uint64");
staticpro (&QCdbus_type_uint64);
QCdbus_type_double = intern_c_string (":double");
staticpro (&QCdbus_type_double);
QCdbus_type_string = intern_c_string (":string");
staticpro (&QCdbus_type_string);
QCdbus_type_object_path = intern_c_string (":object-path");
staticpro (&QCdbus_type_object_path);
QCdbus_type_signature = intern_c_string (":signature");
staticpro (&QCdbus_type_signature);
DEFSYM (QCdbus_system_bus, ":system");
DEFSYM (QCdbus_session_bus, ":session");
DEFSYM (QCdbus_request_name_allow_replacement, ":allow-replacement");
DEFSYM (QCdbus_request_name_replace_existing, ":replace-existing");
DEFSYM (QCdbus_request_name_do_not_queue, ":do-not-queue");
DEFSYM (QCdbus_request_name_reply_primary_owner, ":primary-owner");
DEFSYM (QCdbus_request_name_reply_exists, ":exists");
DEFSYM (QCdbus_request_name_reply_in_queue, ":in-queue");
DEFSYM (QCdbus_request_name_reply_already_owner, ":already-owner");
DEFSYM (QCdbus_timeout, ":timeout");
DEFSYM (QCdbus_type_byte, ":byte");
DEFSYM (QCdbus_type_boolean, ":boolean");
DEFSYM (QCdbus_type_int16, ":int16");
DEFSYM (QCdbus_type_uint16, ":uint16");
DEFSYM (QCdbus_type_int32, ":int32");
DEFSYM (QCdbus_type_uint32, ":uint32");
DEFSYM (QCdbus_type_int64, ":int64");
DEFSYM (QCdbus_type_uint64, ":uint64");
DEFSYM (QCdbus_type_double, ":double");
DEFSYM (QCdbus_type_string, ":string");
DEFSYM (QCdbus_type_object_path, ":object-path");
DEFSYM (QCdbus_type_signature, ":signature");
#ifdef DBUS_TYPE_UNIX_FD
QCdbus_type_unix_fd = intern_c_string (":unix-fd");
staticpro (&QCdbus_type_unix_fd);
DEFSYM (QCdbus_type_unix_fd, ":unix-fd");
#endif
QCdbus_type_array = intern_c_string (":array");
staticpro (&QCdbus_type_array);
QCdbus_type_variant = intern_c_string (":variant");
staticpro (&QCdbus_type_variant);
QCdbus_type_struct = intern_c_string (":struct");
staticpro (&QCdbus_type_struct);
QCdbus_type_dict_entry = intern_c_string (":dict-entry");
staticpro (&QCdbus_type_dict_entry);
DEFSYM (QCdbus_type_array, ":array");
DEFSYM (QCdbus_type_variant, ":variant");
DEFSYM (QCdbus_type_struct, ":struct");
DEFSYM (QCdbus_type_dict_entry, ":dict-entry");
DEFVAR_LISP ("dbus-registered-buses",
Vdbus_registered_buses,

22
src/dired.c
View file

@ -1017,21 +1017,13 @@ Comparison is in lexicographic order and case is significant. */)
void
syms_of_dired (void)
{
Qdirectory_files = intern_c_string ("directory-files");
Qdirectory_files_and_attributes = intern_c_string ("directory-files-and-attributes");
Qfile_name_completion = intern_c_string ("file-name-completion");
Qfile_name_all_completions = intern_c_string ("file-name-all-completions");
Qfile_attributes = intern_c_string ("file-attributes");
Qfile_attributes_lessp = intern_c_string ("file-attributes-lessp");
Qdefault_directory = intern_c_string ("default-directory");
staticpro (&Qdirectory_files);
staticpro (&Qdirectory_files_and_attributes);
staticpro (&Qfile_name_completion);
staticpro (&Qfile_name_all_completions);
staticpro (&Qfile_attributes);
staticpro (&Qfile_attributes_lessp);
staticpro (&Qdefault_directory);
DEFSYM (Qdirectory_files, "directory-files");
DEFSYM (Qdirectory_files_and_attributes, "directory-files-and-attributes");
DEFSYM (Qfile_name_completion, "file-name-completion");
DEFSYM (Qfile_name_all_completions, "file-name-all-completions");
DEFSYM (Qfile_attributes, "file-attributes");
DEFSYM (Qfile_attributes_lessp, "file-attributes-lessp");
DEFSYM (Qdefault_directory, "default-directory");
defsubr (&Sdirectory_files);
defsubr (&Sdirectory_files_and_attributes);

6
src/dispnew.c
View file

@ -6438,10 +6438,8 @@ syms_of_display (void)
frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
staticpro (&frame_and_buffer_state);
Qdisplay_table = intern_c_string ("display-table");
staticpro (&Qdisplay_table);
Qredisplay_dont_pause = intern_c_string ("redisplay-dont-pause");
staticpro (&Qredisplay_dont_pause);
DEFSYM (Qdisplay_table, "display-table");
DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
DEFVAR_INT ("baud-rate", baud_rate,
doc: /* *The output baud rate of the terminal.

3
src/doc.c
View file

@ -945,8 +945,7 @@ a new string, without any text properties, is returned. */)
void
syms_of_doc (void)
{
Qfunction_documentation = intern_c_string ("function-documentation");
staticpro (&Qfunction_documentation);
DEFSYM (Qfunction_documentation, "function-documentation");
DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name,
doc: /* Name of file containing documentation strings of built-in symbols. */);

10
src/editfns.c
View file

@ -4738,9 +4738,7 @@ syms_of_editfns (void)
environbuf = 0;
initial_tz = 0;
Qbuffer_access_fontify_functions
= intern_c_string ("buffer-access-fontify-functions");
staticpro (&Qbuffer_access_fontify_functions);
DEFSYM (Qbuffer_access_fontify_functions, "buffer-access-fontify-functions");
DEFVAR_LISP ("inhibit-field-text-motion", Vinhibit_field_text_motion,
doc: /* Non-nil means text motion commands don't notice fields. */);
@ -4802,10 +4800,8 @@ functions if all the text being accessed has this property. */);
defsubr (&Sregion_beginning);
defsubr (&Sregion_end);
staticpro (&Qfield);
Qfield = intern_c_string ("field");
staticpro (&Qboundary);
Qboundary = intern_c_string ("boundary");
DEFSYM (Qfield, "field");
DEFSYM (Qboundary, "boundary");
defsubr (&Sfield_beginning);
defsubr (&Sfield_end);
defsubr (&Sfield_string);

6
src/emacs.c
View file

@ -2375,10 +2375,8 @@ from the parent process and its tty file descriptors. */)
void
syms_of_emacs (void)
{
Qfile_name_handler_alist = intern_c_string ("file-name-handler-alist");
staticpro (&Qfile_name_handler_alist);
Qrisky_local_variable = intern_c_string ("risky-local-variable");
staticpro (&Qrisky_local_variable);
DEFSYM (Qfile_name_handler_alist, "file-name-handler-alist");
DEFSYM (Qrisky_local_variable, "risky-local-variable");
#ifndef CANNOT_DUMP
defsubr (&Sdump_emacs);

56
src/eval.c
View file

@ -3694,46 +3694,23 @@ To prevent this happening, set `quit-flag' to nil
before making `inhibit-quit' nil. */);
Vinhibit_quit = Qnil;
Qinhibit_quit = intern_c_string ("inhibit-quit");
staticpro (&Qinhibit_quit);
Qautoload = intern_c_string ("autoload");
staticpro (&Qautoload);
Qdebug_on_error = intern_c_string ("debug-on-error");
staticpro (&Qdebug_on_error);
Qmacro = intern_c_string ("macro");
staticpro (&Qmacro);
Qdeclare = intern_c_string ("declare");
staticpro (&Qdeclare);
DEFSYM (Qinhibit_quit, "inhibit-quit");
DEFSYM (Qautoload, "autoload");
DEFSYM (Qdebug_on_error, "debug-on-error");
DEFSYM (Qmacro, "macro");
DEFSYM (Qdeclare, "declare");
/* Note that the process handling also uses Qexit, but we don't want
to staticpro it twice, so we just do it here. */
Qexit = intern_c_string ("exit");
staticpro (&Qexit);
DEFSYM (Qexit, "exit");
Qinteractive = intern_c_string ("interactive");
staticpro (&Qinteractive);
Qcommandp = intern_c_string ("commandp");
staticpro (&Qcommandp);
Qdefun = intern_c_string ("defun");
staticpro (&Qdefun);
Qand_rest = intern_c_string ("&rest");
staticpro (&Qand_rest);
Qand_optional = intern_c_string ("&optional");
staticpro (&Qand_optional);
Qclosure = intern_c_string ("closure");
staticpro (&Qclosure);
Qdebug = intern_c_string ("debug");
staticpro (&Qdebug);
DEFSYM (Qinteractive, "interactive");
DEFSYM (Qcommandp, "commandp");
DEFSYM (Qdefun, "defun");
DEFSYM (Qand_rest, "&rest");
DEFSYM (Qand_optional, "&optional");
DEFSYM (Qclosure, "closure");
DEFSYM (Qdebug, "debug");
DEFVAR_LISP ("debug-on-error", Vdebug_on_error,
doc: /* *Non-nil means enter debugger if an error is signaled.
@ -3807,9 +3784,7 @@ The value the function returns is not used. */);
Every element of this list can be either a cons (VAR . VAL)
specifying a lexical binding, or a single symbol VAR indicating
that this variable should use dynamic scoping. */
Qinternal_interpreter_environment
= intern_c_string ("internal-interpreter-environment");
staticpro (&Qinternal_interpreter_environment);
DEFSYM (Qinternal_interpreter_environment, "internal-interpreter-environment");
DEFVAR_LISP ("internal-interpreter-environment",
Vinternal_interpreter_environment,
doc: /* If non-nil, the current lexical environment of the lisp interpreter.
@ -3821,8 +3796,7 @@ alist of active lexical bindings. */);
(Just imagine if someone makes it buffer-local). */
Funintern (Qinternal_interpreter_environment, Qnil);
Vrun_hooks = intern_c_string ("run-hooks");
staticpro (&Vrun_hooks);
DEFSYM (Vrun_hooks, "run-hooks");
staticpro (&Vautoload_queue);
Vautoload_queue = Qnil;

151
src/fileio.c
View file

@ -5425,92 +5425,50 @@ Fread_file_name (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filena
void
syms_of_fileio (void)
{
Qoperations = intern_c_string ("operations");
Qexpand_file_name = intern_c_string ("expand-file-name");
Qsubstitute_in_file_name = intern_c_string ("substitute-in-file-name");
Qdirectory_file_name = intern_c_string ("directory-file-name");
Qfile_name_directory = intern_c_string ("file-name-directory");
Qfile_name_nondirectory = intern_c_string ("file-name-nondirectory");
Qunhandled_file_name_directory = intern_c_string ("unhandled-file-name-directory");
Qfile_name_as_directory = intern_c_string ("file-name-as-directory");
Qcopy_file = intern_c_string ("copy-file");
Qmake_directory_internal = intern_c_string ("make-directory-internal");
Qmake_directory = intern_c_string ("make-directory");
Qdelete_directory_internal = intern_c_string ("delete-directory-internal");
Qdelete_file = intern_c_string ("delete-file");
Qrename_file = intern_c_string ("rename-file");
Qadd_name_to_file = intern_c_string ("add-name-to-file");
Qmake_symbolic_link = intern_c_string ("make-symbolic-link");
Qfile_exists_p = intern_c_string ("file-exists-p");
Qfile_executable_p = intern_c_string ("file-executable-p");
Qfile_readable_p = intern_c_string ("file-readable-p");
Qfile_writable_p = intern_c_string ("file-writable-p");
Qfile_symlink_p = intern_c_string ("file-symlink-p");
Qaccess_file = intern_c_string ("access-file");
Qfile_directory_p = intern_c_string ("file-directory-p");
Qfile_regular_p = intern_c_string ("file-regular-p");
Qfile_accessible_directory_p = intern_c_string ("file-accessible-directory-p");
Qfile_modes = intern_c_string ("file-modes");
Qset_file_modes = intern_c_string ("set-file-modes");
Qset_file_times = intern_c_string ("set-file-times");
Qfile_selinux_context = intern_c_string("file-selinux-context");
Qset_file_selinux_context = intern_c_string("set-file-selinux-context");
Qfile_newer_than_file_p = intern_c_string ("file-newer-than-file-p");
Qinsert_file_contents = intern_c_string ("insert-file-contents");
Qwrite_region = intern_c_string ("write-region");
Qverify_visited_file_modtime = intern_c_string ("verify-visited-file-modtime");
Qset_visited_file_modtime = intern_c_string ("set-visited-file-modtime");
Qauto_save_coding = intern_c_string ("auto-save-coding");
DEFSYM (Qoperations, "operations");
DEFSYM (Qexpand_file_name, "expand-file-name");
DEFSYM (Qsubstitute_in_file_name, "substitute-in-file-name");
DEFSYM (Qdirectory_file_name, "directory-file-name");
DEFSYM (Qfile_name_directory, "file-name-directory");
DEFSYM (Qfile_name_nondirectory, "file-name-nondirectory");
DEFSYM (Qunhandled_file_name_directory, "unhandled-file-name-directory");
DEFSYM (Qfile_name_as_directory, "file-name-as-directory");
DEFSYM (Qcopy_file, "copy-file");
DEFSYM (Qmake_directory_internal, "make-directory-internal");
DEFSYM (Qmake_directory, "make-directory");
DEFSYM (Qdelete_directory_internal, "delete-directory-internal");
DEFSYM (Qdelete_file, "delete-file");
DEFSYM (Qrename_file, "rename-file");
DEFSYM (Qadd_name_to_file, "add-name-to-file");
DEFSYM (Qmake_symbolic_link, "make-symbolic-link");
DEFSYM (Qfile_exists_p, "file-exists-p");
DEFSYM (Qfile_executable_p, "file-executable-p");
DEFSYM (Qfile_readable_p, "file-readable-p");
DEFSYM (Qfile_writable_p, "file-writable-p");
DEFSYM (Qfile_symlink_p, "file-symlink-p");
DEFSYM (Qaccess_file, "access-file");
DEFSYM (Qfile_directory_p, "file-directory-p");
DEFSYM (Qfile_regular_p, "file-regular-p");
DEFSYM (Qfile_accessible_directory_p, "file-accessible-directory-p");
DEFSYM (Qfile_modes, "file-modes");
DEFSYM (Qset_file_modes, "set-file-modes");
DEFSYM (Qset_file_times, "set-file-times");
DEFSYM (Qfile_selinux_context, "file-selinux-context");
DEFSYM (Qset_file_selinux_context, "set-file-selinux-context");
DEFSYM (Qfile_newer_than_file_p, "file-newer-than-file-p");
DEFSYM (Qinsert_file_contents, "insert-file-contents");
DEFSYM (Qwrite_region, "write-region");
DEFSYM (Qverify_visited_file_modtime, "verify-visited-file-modtime");
DEFSYM (Qset_visited_file_modtime, "set-visited-file-modtime");
DEFSYM (Qauto_save_coding, "auto-save-coding");
staticpro (&Qoperations);
staticpro (&Qexpand_file_name);
staticpro (&Qsubstitute_in_file_name);
staticpro (&Qdirectory_file_name);
staticpro (&Qfile_name_directory);
staticpro (&Qfile_name_nondirectory);
staticpro (&Qunhandled_file_name_directory);
staticpro (&Qfile_name_as_directory);
staticpro (&Qcopy_file);
staticpro (&Qmake_directory_internal);
staticpro (&Qmake_directory);
staticpro (&Qdelete_directory_internal);
staticpro (&Qdelete_file);
staticpro (&Qrename_file);
staticpro (&Qadd_name_to_file);
staticpro (&Qmake_symbolic_link);
staticpro (&Qfile_exists_p);
staticpro (&Qfile_executable_p);
staticpro (&Qfile_readable_p);
staticpro (&Qfile_writable_p);
staticpro (&Qaccess_file);
staticpro (&Qfile_symlink_p);
staticpro (&Qfile_directory_p);
staticpro (&Qfile_regular_p);
staticpro (&Qfile_accessible_directory_p);
staticpro (&Qfile_modes);
staticpro (&Qset_file_modes);
staticpro (&Qset_file_times);
staticpro (&Qfile_selinux_context);
staticpro (&Qset_file_selinux_context);
staticpro (&Qfile_newer_than_file_p);
staticpro (&Qinsert_file_contents);
staticpro (&Qwrite_region);
staticpro (&Qverify_visited_file_modtime);
staticpro (&Qset_visited_file_modtime);
staticpro (&Qauto_save_coding);
Qfile_name_history = intern_c_string ("file-name-history");
DEFSYM (Qfile_name_history, "file-name-history");
Fset (Qfile_name_history, Qnil);
staticpro (&Qfile_name_history);
Qfile_error = intern_c_string ("file-error");
staticpro (&Qfile_error);
Qfile_already_exists = intern_c_string ("file-already-exists");
staticpro (&Qfile_already_exists);
Qfile_date_error = intern_c_string ("file-date-error");
staticpro (&Qfile_date_error);
Qexcl = intern_c_string ("excl");
staticpro (&Qexcl);
DEFSYM (Qfile_error, "file-error");
DEFSYM (Qfile_already_exists, "file-already-exists");
DEFSYM (Qfile_date_error, "file-date-error");
DEFSYM (Qexcl, "excl");
DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system,
doc: /* *Coding system for encoding file names.
@ -5528,15 +5486,10 @@ instead use `file-name-coding-system' to get a constant encoding
of file names regardless of the current language environment. */);
Vdefault_file_name_coding_system = Qnil;
Qformat_decode = intern_c_string ("format-decode");
staticpro (&Qformat_decode);
Qformat_annotate_function = intern_c_string ("format-annotate-function");
staticpro (&Qformat_annotate_function);
Qafter_insert_file_set_coding = intern_c_string ("after-insert-file-set-coding");
staticpro (&Qafter_insert_file_set_coding);
Qcar_less_than_car = intern_c_string ("car-less-than-car");
staticpro (&Qcar_less_than_car);
DEFSYM (Qformat_decode, "format-decode");
DEFSYM (Qformat_annotate_function, "format-annotate-function");
DEFSYM (Qafter_insert_file_set_coding, "after-insert-file-set-coding");
DEFSYM (Qcar_less_than_car, "car-less-than-car");
Fput (Qfile_error, Qerror_conditions,
Fpurecopy (list2 (Qfile_error, Qerror)));
@ -5615,9 +5568,7 @@ After `write-region' completes, Emacs calls the function stored in
current when building the annotations (i.e., at least once), with that
buffer current. */);
Vwrite_region_annotate_functions = Qnil;
staticpro (&Qwrite_region_annotate_functions);
Qwrite_region_annotate_functions
= intern_c_string ("write-region-annotate-functions");
DEFSYM (Qwrite_region_annotate_functions, "write-region-annotate-functions");
DEFVAR_LISP ("write-region-post-annotation-function",
Vwrite_region_post_annotation_function,
@ -5681,12 +5632,10 @@ This includes interactive calls to `delete-file' and
`delete-directory' and the Dired deletion commands. */);
delete_by_moving_to_trash = 0;
Qdelete_by_moving_to_trash = intern_c_string ("delete-by-moving-to-trash");
Qmove_file_to_trash = intern_c_string ("move-file-to-trash");
staticpro (&Qmove_file_to_trash);
Qcopy_directory = intern_c_string ("copy-directory");
staticpro (&Qcopy_directory);
Qdelete_directory = intern_c_string ("delete-directory");
staticpro (&Qdelete_directory);
DEFSYM (Qmove_file_to_trash, "move-file-to-trash");
DEFSYM (Qcopy_directory, "copy-directory");
DEFSYM (Qdelete_directory, "delete-directory");
defsubr (&Sfind_file_name_handler);
defsubr (&Sfile_name_directory);

75
src/fns.c
View file

@ -4854,34 +4854,20 @@ syms_of_fns (void)
DEFSYM (Qsha512, "sha512");
/* Hash table stuff. */
Qhash_table_p = intern_c_string ("hash-table-p");
staticpro (&Qhash_table_p);
Qeq = intern_c_string ("eq");
staticpro (&Qeq);
Qeql = intern_c_string ("eql");
staticpro (&Qeql);
Qequal = intern_c_string ("equal");
staticpro (&Qequal);
QCtest = intern_c_string (":test");
staticpro (&QCtest);
QCsize = intern_c_string (":size");
staticpro (&QCsize);
QCrehash_size = intern_c_string (":rehash-size");
staticpro (&QCrehash_size);
QCrehash_threshold = intern_c_string (":rehash-threshold");
staticpro (&QCrehash_threshold);
QCweakness = intern_c_string (":weakness");
staticpro (&QCweakness);
Qkey = intern_c_string ("key");
staticpro (&Qkey);
Qvalue = intern_c_string ("value");
staticpro (&Qvalue);
Qhash_table_test = intern_c_string ("hash-table-test");
staticpro (&Qhash_table_test);
Qkey_or_value = intern_c_string ("key-or-value");
staticpro (&Qkey_or_value);
Qkey_and_value = intern_c_string ("key-and-value");
staticpro (&Qkey_and_value);
DEFSYM (Qhash_table_p, "hash-table-p");
DEFSYM (Qeq, "eq");
DEFSYM (Qeql, "eql");
DEFSYM (Qequal, "equal");
DEFSYM (QCtest, ":test");
DEFSYM (QCsize, ":size");
DEFSYM (QCrehash_size, ":rehash-size");
DEFSYM (QCrehash_threshold, ":rehash-threshold");
DEFSYM (QCweakness, ":weakness");
DEFSYM (Qkey, "key");
DEFSYM (Qvalue, "value");
DEFSYM (Qhash_table_test, "hash-table-test");
DEFSYM (Qkey_or_value, "key-or-value");
DEFSYM (Qkey_and_value, "key-and-value");
defsubr (&Ssxhash);
defsubr (&Smake_hash_table);
@ -4900,18 +4886,12 @@ syms_of_fns (void)
defsubr (&Smaphash);
defsubr (&Sdefine_hash_table_test);
Qstring_lessp = intern_c_string ("string-lessp");
staticpro (&Qstring_lessp);
Qprovide = intern_c_string ("provide");
staticpro (&Qprovide);
Qrequire = intern_c_string ("require");
staticpro (&Qrequire);
Qyes_or_no_p_history = intern_c_string ("yes-or-no-p-history");
staticpro (&Qyes_or_no_p_history);
Qcursor_in_echo_area = intern_c_string ("cursor-in-echo-area");
staticpro (&Qcursor_in_echo_area);
Qwidget_type = intern_c_string ("widget-type");
staticpro (&Qwidget_type);
DEFSYM (Qstring_lessp, "string-lessp");
DEFSYM (Qprovide, "provide");
DEFSYM (Qrequire, "require");
DEFSYM (Qyes_or_no_p_history, "yes-or-no-p-history");
DEFSYM (Qcursor_in_echo_area, "cursor-in-echo-area");
DEFSYM (Qwidget_type, "widget-type");
staticpro (&string_char_byte_cache_string);
string_char_byte_cache_string = Qnil;
@ -4925,18 +4905,13 @@ syms_of_fns (void)
doc: /* A list of symbols which are the features of the executing Emacs.
Used by `featurep' and `require', and altered by `provide'. */);
Vfeatures = Fcons (intern_c_string ("emacs"), Qnil);
Qsubfeatures = intern_c_string ("subfeatures");
staticpro (&Qsubfeatures);
DEFSYM (Qsubfeatures, "subfeatures");
#ifdef HAVE_LANGINFO_CODESET
Qcodeset = intern_c_string ("codeset");
staticpro (&Qcodeset);
Qdays = intern_c_string ("days");
staticpro (&Qdays);
Qmonths = intern_c_string ("months");
staticpro (&Qmonths);
Qpaper = intern_c_string ("paper");
staticpro (&Qpaper);
DEFSYM (Qcodeset, "codeset");
DEFSYM (Qdays, "days");
DEFSYM (Qmonths, "months");
DEFSYM (Qpaper, "paper");
#endif /* HAVE_LANGINFO_CODESET */
DEFVAR_BOOL ("use-dialog-box", use_dialog_box,

139
src/frame.c
View file

@ -4240,104 +4240,58 @@ selected frame. This is useful when `make-pointer-invisible' is set. */)
void
syms_of_frame (void)
{
Qframep = intern_c_string ("framep");
staticpro (&Qframep);
Qframe_live_p = intern_c_string ("frame-live-p");
staticpro (&Qframe_live_p);
Qexplicit_name = intern_c_string ("explicit-name");
staticpro (&Qexplicit_name);
Qheight = intern_c_string ("height");
staticpro (&Qheight);
Qicon = intern_c_string ("icon");
staticpro (&Qicon);
Qminibuffer = intern_c_string ("minibuffer");
staticpro (&Qminibuffer);
Qmodeline = intern_c_string ("modeline");
staticpro (&Qmodeline);
Qonly = intern_c_string ("only");
staticpro (&Qonly);
Qwidth = intern_c_string ("width");
staticpro (&Qwidth);
Qgeometry = intern_c_string ("geometry");
staticpro (&Qgeometry);
Qicon_left = intern_c_string ("icon-left");
staticpro (&Qicon_left);
Qicon_top = intern_c_string ("icon-top");
staticpro (&Qicon_top);
Qtooltip = intern_c_string ("tooltip");
staticpro (&Qtooltip);
Qleft = intern_c_string ("left");
staticpro (&Qleft);
Qright = intern_c_string ("right");
staticpro (&Qright);
Quser_position = intern_c_string ("user-position");
staticpro (&Quser_position);
Quser_size = intern_c_string ("user-size");
staticpro (&Quser_size);
Qwindow_id = intern_c_string ("window-id");
staticpro (&Qwindow_id);
DEFSYM (Qframep, "framep");
DEFSYM (Qframe_live_p, "frame-live-p");
DEFSYM (Qexplicit_name, "explicit-name");
DEFSYM (Qheight, "height");
DEFSYM (Qicon, "icon");
DEFSYM (Qminibuffer, "minibuffer");
DEFSYM (Qmodeline, "modeline");
DEFSYM (Qonly, "only");
DEFSYM (Qwidth, "width");
DEFSYM (Qgeometry, "geometry");
DEFSYM (Qicon_left, "icon-left");
DEFSYM (Qicon_top, "icon-top");
DEFSYM (Qtooltip, "tooltip");
DEFSYM (Qleft, "left");
DEFSYM (Qright, "right");
DEFSYM (Quser_position, "user-position");
DEFSYM (Quser_size, "user-size");
DEFSYM (Qwindow_id, "window-id");
#ifdef HAVE_X_WINDOWS
Qouter_window_id = intern_c_string ("outer-window-id");
staticpro (&Qouter_window_id);
DEFSYM (Qouter_window_id, "outer-window-id");
#endif
Qparent_id = intern_c_string ("parent-id");
staticpro (&Qparent_id);
Qx = intern_c_string ("x");
staticpro (&Qx);
Qw32 = intern_c_string ("w32");
staticpro (&Qw32);
Qpc = intern_c_string ("pc");
staticpro (&Qpc);
Qmac = intern_c_string ("mac");
staticpro (&Qmac);
Qns = intern_c_string ("ns");
staticpro (&Qns);
Qvisible = intern_c_string ("visible");
staticpro (&Qvisible);
Qbuffer_predicate = intern_c_string ("buffer-predicate");
staticpro (&Qbuffer_predicate);
Qbuffer_list = intern_c_string ("buffer-list");
staticpro (&Qbuffer_list);
Qburied_buffer_list = intern_c_string ("buried-buffer-list");
staticpro (&Qburied_buffer_list);
Qdisplay_type = intern_c_string ("display-type");
staticpro (&Qdisplay_type);
Qbackground_mode = intern_c_string ("background-mode");
staticpro (&Qbackground_mode);
Qnoelisp = intern_c_string ("noelisp");
staticpro (&Qnoelisp);
Qtty_color_mode = intern_c_string ("tty-color-mode");
staticpro (&Qtty_color_mode);
Qtty = intern_c_string ("tty");
staticpro (&Qtty);
Qtty_type = intern_c_string ("tty-type");
staticpro (&Qtty_type);
DEFSYM (Qparent_id, "parent-id");
DEFSYM (Qx, "x");
DEFSYM (Qw32, "w32");
DEFSYM (Qpc, "pc");
DEFSYM (Qmac, "mac");
DEFSYM (Qns, "ns");
DEFSYM (Qvisible, "visible");
DEFSYM (Qbuffer_predicate, "buffer-predicate");
DEFSYM (Qbuffer_list, "buffer-list");
DEFSYM (Qburied_buffer_list, "buried-buffer-list");
DEFSYM (Qdisplay_type, "display-type");
DEFSYM (Qbackground_mode, "background-mode");
DEFSYM (Qnoelisp, "noelisp");
DEFSYM (Qtty_color_mode, "tty-color-mode");
DEFSYM (Qtty, "tty");
DEFSYM (Qtty_type, "tty-type");
Qface_set_after_frame_default = intern_c_string ("face-set-after-frame-default");
staticpro (&Qface_set_after_frame_default);
DEFSYM (Qface_set_after_frame_default, "face-set-after-frame-default");
Qfullwidth = intern_c_string ("fullwidth");
staticpro (&Qfullwidth);
Qfullheight = intern_c_string ("fullheight");
staticpro (&Qfullheight);
Qfullboth = intern_c_string ("fullboth");
staticpro (&Qfullboth);
Qmaximized = intern_c_string ("maximized");
staticpro (&Qmaximized);
Qx_resource_name = intern_c_string ("x-resource-name");
staticpro (&Qx_resource_name);
DEFSYM (Qfullwidth, "fullwidth");
DEFSYM (Qfullheight, "fullheight");
DEFSYM (Qfullboth, "fullboth");
DEFSYM (Qmaximized, "maximized");
DEFSYM (Qx_resource_name, "x-resource-name");
DEFSYM (Qx_frame_parameter, "x-frame-parameter");
Qx_frame_parameter = intern_c_string ("x-frame-parameter");
staticpro (&Qx_frame_parameter);
Qterminal = intern_c_string ("terminal");
staticpro (&Qterminal);
Qterminal_live_p = intern_c_string ("terminal-live-p");
staticpro (&Qterminal_live_p);
DEFSYM (Qterminal, "terminal");
DEFSYM (Qterminal_live_p, "terminal-live-p");
#ifdef HAVE_NS
Qns_parse_geometry = intern_c_string ("ns-parse-geometry");
staticpro (&Qns_parse_geometry);
DEFSYM (Qns_parse_geometry, "ns-parse-geometry");
#endif
{
@ -4451,8 +4405,7 @@ actually deleted, or some time later (or even both when an earlier function
in `delete-frame-functions' (indirectly) calls `delete-frame'
recursively). */);
Vdelete_frame_functions = Qnil;
Qdelete_frame_functions = intern_c_string ("delete-frame-functions");
staticpro (&Qdelete_frame_functions);
DEFSYM (Qdelete_frame_functions, "delete-frame-functions");
DEFVAR_LISP ("menu-bar-mode", Vmenu_bar_mode,
doc: /* Non-nil if Menu-Bar mode is enabled.

18
src/fringe.c
View file

@ -1738,18 +1738,12 @@ Return nil if POS is not visible in WINDOW. */)
void
syms_of_fringe (void)
{
Qtruncation = intern_c_string ("truncation");
staticpro (&Qtruncation);
Qcontinuation = intern_c_string ("continuation");
staticpro (&Qcontinuation);
Qoverlay_arrow = intern_c_string ("overlay-arrow");
staticpro (&Qoverlay_arrow);
Qempty_line = intern_c_string ("empty-line");
staticpro (&Qempty_line);
Qtop_bottom = intern_c_string ("top-bottom");
staticpro (&Qtop_bottom);
Qhollow_small = intern_c_string ("hollow-small");
staticpro (&Qhollow_small);
DEFSYM (Qtruncation, "truncation");
DEFSYM (Qcontinuation, "continuation");
DEFSYM (Qoverlay_arrow, "overlay-arrow");
DEFSYM (Qempty_line, "empty-line");
DEFSYM (Qtop_bottom, "top-bottom");
DEFSYM (Qhollow_small, "hollow-small");
defsubr (&Sdestroy_fringe_bitmap);
defsubr (&Sdefine_fringe_bitmap);

1
src/gnutls.c
View file

@ -22,7 +22,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "lisp.h"
#include "process.h"
#include "character.h"
#ifdef HAVE_GNUTLS
#include <gnutls/gnutls.h>

3
src/insdel.c
View file

@ -2219,8 +2219,7 @@ syms_of_insdel (void)
This affects `before-change-functions' and `after-change-functions',
as well as hooks attached to text properties and overlays. */);
inhibit_modification_hooks = 0;
Qinhibit_modification_hooks = intern_c_string ("inhibit-modification-hooks");
staticpro (&Qinhibit_modification_hooks);
DEFSYM (Qinhibit_modification_hooks, "inhibit-modification-hooks");
defsubr (&Scombine_after_change_execute);
}

34
src/keymap.c
View file

@ -3774,15 +3774,13 @@ Return list of symbols found. */)
void
syms_of_keymap (void)
{
Qkeymap = intern_c_string ("keymap");
staticpro (&Qkeymap);
DEFSYM (Qkeymap, "keymap");
staticpro (&apropos_predicate);
staticpro (&apropos_accumulate);
apropos_predicate = Qnil;
apropos_accumulate = Qnil;
Qkeymap_canonicalize = intern_c_string ("keymap-canonicalize");
staticpro (&Qkeymap_canonicalize);
DEFSYM (Qkeymap_canonicalize, "keymap-canonicalize");
/* Now we are ready to set up this property, so we can
create char tables. */
@ -3902,27 +3900,13 @@ preferred. */);
pure_cons (intern_c_string ("mouse-5"),
Qnil)))))))));
Qsingle_key_description = intern_c_string ("single-key-description");
staticpro (&Qsingle_key_description);
Qkey_description = intern_c_string ("key-description");
staticpro (&Qkey_description);
Qkeymapp = intern_c_string ("keymapp");
staticpro (&Qkeymapp);
Qnon_ascii = intern_c_string ("non-ascii");
staticpro (&Qnon_ascii);
Qmenu_item = intern_c_string ("menu-item");
staticpro (&Qmenu_item);
Qremap = intern_c_string ("remap");
staticpro (&Qremap);
QCadvertised_binding = intern_c_string (":advertised-binding");
staticpro (&QCadvertised_binding);
DEFSYM (Qsingle_key_description, "single-key-description");
DEFSYM (Qkey_description, "key-description");
DEFSYM (Qkeymapp, "keymapp");
DEFSYM (Qnon_ascii, "non-ascii");
DEFSYM (Qmenu_item, "menu-item");
DEFSYM (Qremap, "remap");
DEFSYM (QCadvertised_binding, ":advertised-binding");
command_remapping_vector = Fmake_vector (make_number (2), Qremap);
staticpro (&command_remapping_vector);

3
src/lisp.h
View file

@ -1162,6 +1162,9 @@ struct Lisp_Symbol
#define SYMBOL_CONSTANT_P(sym) XSYMBOL (sym)->constant
#define DEFSYM(sym, name) \
do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
/***********************************************************************
Hash Tables

100
src/lread.c
View file

@ -3983,8 +3983,7 @@ init_obarray (void)
/* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
Vpurify_flag = Qt;
Qvariable_documentation = intern_c_string ("variable-documentation");
staticpro (&Qvariable_documentation);
DEFSYM (Qvariable_documentation, "variable-documentation");
read_buffer_size = 100 + MAX_MULTIBYTE_LENGTH;
read_buffer = (char *) xmalloc (read_buffer_size);
@ -4392,8 +4391,7 @@ customize `jka-compr-load-suffixes' rather than the present variable. */);
DEFVAR_BOOL ("load-in-progress", load_in_progress,
doc: /* Non-nil if inside of `load'. */);
Qload_in_progress = intern_c_string ("load-in-progress");
staticpro (&Qload_in_progress);
DEFSYM (Qload_in_progress, "load-in-progress");
DEFVAR_LISP ("after-load-alist", Vafter_load_alist,
doc: /* An alist of expressions to be evalled when particular files are loaded.
@ -4524,67 +4522,34 @@ This variable is automatically set from the file variables of an interpreted
DEFVAR_LISP ("old-style-backquotes", Vold_style_backquotes,
doc: /* Set to non-nil when `read' encounters an old-style backquote. */);
Vold_style_backquotes = Qnil;
Qold_style_backquotes = intern_c_string ("old-style-backquotes");
staticpro (&Qold_style_backquotes);
DEFSYM (Qold_style_backquotes, "old-style-backquotes");
/* Vsource_directory was initialized in init_lread. */
load_descriptor_list = Qnil;
staticpro (&load_descriptor_list);
Qcurrent_load_list = intern_c_string ("current-load-list");
staticpro (&Qcurrent_load_list);
DEFSYM (Qcurrent_load_list, "current-load-list");
DEFSYM (Qstandard_input, "standard-input");
DEFSYM (Qread_char, "read-char");
DEFSYM (Qget_file_char, "get-file-char");
DEFSYM (Qget_emacs_mule_file_char, "get-emacs-mule-file-char");
DEFSYM (Qload_force_doc_strings, "load-force-doc-strings");
Qstandard_input = intern_c_string ("standard-input");
staticpro (&Qstandard_input);
DEFSYM (Qbackquote, "`");
DEFSYM (Qcomma, ",");
DEFSYM (Qcomma_at, ",@");
DEFSYM (Qcomma_dot, ",.");
Qread_char = intern_c_string ("read-char");
staticpro (&Qread_char);
Qget_file_char = intern_c_string ("get-file-char");
staticpro (&Qget_file_char);
Qget_emacs_mule_file_char = intern_c_string ("get-emacs-mule-file-char");
staticpro (&Qget_emacs_mule_file_char);
Qload_force_doc_strings = intern_c_string ("load-force-doc-strings");
staticpro (&Qload_force_doc_strings);
Qbackquote = intern_c_string ("`");
staticpro (&Qbackquote);
Qcomma = intern_c_string (",");
staticpro (&Qcomma);
Qcomma_at = intern_c_string (",@");
staticpro (&Qcomma_at);
Qcomma_dot = intern_c_string (",.");
staticpro (&Qcomma_dot);
Qinhibit_file_name_operation = intern_c_string ("inhibit-file-name-operation");
staticpro (&Qinhibit_file_name_operation);
Qascii_character = intern_c_string ("ascii-character");
staticpro (&Qascii_character);
Qfunction = intern_c_string ("function");
staticpro (&Qfunction);
Qload = intern_c_string ("load");
staticpro (&Qload);
Qload_file_name = intern_c_string ("load-file-name");
staticpro (&Qload_file_name);
Qeval_buffer_list = intern_c_string ("eval-buffer-list");
staticpro (&Qeval_buffer_list);
Qfile_truename = intern_c_string ("file-truename");
staticpro (&Qfile_truename) ;
Qdir_ok = intern_c_string ("dir-ok");
staticpro (&Qdir_ok);
Qdo_after_load_evaluation = intern_c_string ("do-after-load-evaluation");
staticpro (&Qdo_after_load_evaluation) ;
DEFSYM (Qinhibit_file_name_operation, "inhibit-file-name-operation");
DEFSYM (Qascii_character, "ascii-character");
DEFSYM (Qfunction, "function");
DEFSYM (Qload, "load");
DEFSYM (Qload_file_name, "load-file-name");
DEFSYM (Qeval_buffer_list, "eval-buffer-list");
DEFSYM (Qfile_truename, "file-truename");
DEFSYM (Qdir_ok, "dir-ok");
DEFSYM (Qdo_after_load_evaluation, "do-after-load-evaluation");
staticpro (&dump_path);
@ -4596,18 +4561,11 @@ This variable is automatically set from the file variables of an interpreted
Vloads_in_progress = Qnil;
staticpro (&Vloads_in_progress);
Qhash_table = intern_c_string ("hash-table");
staticpro (&Qhash_table);
Qdata = intern_c_string ("data");
staticpro (&Qdata);
Qtest = intern_c_string ("test");
staticpro (&Qtest);
Qsize = intern_c_string ("size");
staticpro (&Qsize);
Qweakness = intern_c_string ("weakness");
staticpro (&Qweakness);
Qrehash_size = intern_c_string ("rehash-size");
staticpro (&Qrehash_size);
Qrehash_threshold = intern_c_string ("rehash-threshold");
staticpro (&Qrehash_threshold);
DEFSYM (Qhash_table, "hash-table");
DEFSYM (Qdata, "data");
DEFSYM (Qtest, "test");
DEFSYM (Qsize, "size");
DEFSYM (Qweakness, "weakness");
DEFSYM (Qrehash_size, "rehash-size");
DEFSYM (Qrehash_threshold, "rehash-threshold");
}

6
src/macros.c
View file

@ -367,15 +367,13 @@ init_macros (void)
void
syms_of_macros (void)
{
Qexecute_kbd_macro = intern_c_string ("execute-kbd-macro");
staticpro (&Qexecute_kbd_macro);
DEFSYM (Qexecute_kbd_macro, "execute-kbd-macro");
DEFVAR_LISP ("kbd-macro-termination-hook", Vkbd_macro_termination_hook,
doc: /* Normal hook run whenever a keyboard macro terminates.
This is run whether the macro ends normally or prematurely due to an error. */);
Vkbd_macro_termination_hook = Qnil;
Qkbd_macro_termination_hook = intern_c_string ("kbd-macro-termination-hook");
staticpro (&Qkbd_macro_termination_hook);
DEFSYM (Qkbd_macro_termination_hook, "kbd-macro-termination-hook");
defsubr (&Sstart_kbd_macro);
defsubr (&Send_kbd_macro);

1
src/minibuf.c
View file

@ -25,7 +25,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "lisp.h"
#include "commands.h"
#include "buffer.h"
#include "character.h"
#include "dispextern.h"
#include "keyboard.h"
#include "frame.h"

3
src/msdos.c
View file

@ -4267,8 +4267,7 @@ syms_of_msdos (void)
#ifndef HAVE_X_WINDOWS
/* The following two are from xfns.c: */
Qreverse = intern_c_string ("reverse");
staticpro (&Qreverse);
DEFSYM (Qreverse, "reverse");
DEFVAR_LISP ("dos-unsupported-char-glyph", Vdos_unsupported_char_glyph,
doc: /* *Glyph to display instead of chars not supported by current codepage.

24
src/print.c
View file

@ -2069,8 +2069,7 @@ print_interval (INTERVAL interval, Lisp_Object printcharfun)
void
syms_of_print (void)
{
Qtemp_buffer_setup_hook = intern_c_string ("temp-buffer-setup-hook");
staticpro (&Qtemp_buffer_setup_hook);
DEFSYM (Qtemp_buffer_setup_hook, "temp-buffer-setup-hook");
DEFVAR_LISP ("standard-output", Vstandard_output,
doc: /* Output stream `print' uses by default for outputting a character.
@ -2079,8 +2078,7 @@ It may also be a buffer (output is inserted before point)
or a marker (output is inserted and the marker is advanced)
or the symbol t (output appears in the echo area). */);
Vstandard_output = Qt;
Qstandard_output = intern_c_string ("standard-output");
staticpro (&Qstandard_output);
DEFSYM (Qstandard_output, "standard-output");
DEFVAR_LISP ("float-output-format", Vfloat_output_format,
doc: /* The format descriptor string used to print floats.
@ -2099,8 +2097,7 @@ decimal point. 0 is not allowed with `e' or `g'.
A value of nil means to use the shortest notation
that represents the number without losing information. */);
Vfloat_output_format = Qnil;
Qfloat_output_format = intern_c_string ("float-output-format");
staticpro (&Qfloat_output_format);
DEFSYM (Qfloat_output_format, "float-output-format");
DEFVAR_LISP ("print-length", Vprint_length,
doc: /* Maximum length of list to print before abbreviating.
@ -2205,17 +2202,10 @@ priorities. */);
defsubr (&Sredirect_debugging_output);
#endif
Qexternal_debugging_output = intern_c_string ("external-debugging-output");
staticpro (&Qexternal_debugging_output);
Qprint_escape_newlines = intern_c_string ("print-escape-newlines");
staticpro (&Qprint_escape_newlines);
Qprint_escape_multibyte = intern_c_string ("print-escape-multibyte");
staticpro (&Qprint_escape_multibyte);
Qprint_escape_nonascii = intern_c_string ("print-escape-nonascii");
staticpro (&Qprint_escape_nonascii);
DEFSYM (Qexternal_debugging_output, "external-debugging-output");
DEFSYM (Qprint_escape_newlines, "print-escape-newlines");
DEFSYM (Qprint_escape_multibyte, "print-escape-multibyte");
DEFSYM (Qprint_escape_nonascii, "print-escape-nonascii");
print_prune_charset_plist = Qnil;
staticpro (&print_prune_charset_plist);

231
src/process.c
View file

@ -7236,14 +7236,10 @@ syms_of_process (void)
{
#ifdef subprocesses
Qprocessp = intern_c_string ("processp");
staticpro (&Qprocessp);
Qrun = intern_c_string ("run");
staticpro (&Qrun);
Qstop = intern_c_string ("stop");
staticpro (&Qstop);
Qsignal = intern_c_string ("signal");
staticpro (&Qsignal);
DEFSYM (Qprocessp, "processp");
DEFSYM (Qrun, "run");
DEFSYM (Qstop, "stop");
DEFSYM (Qsignal, "signal");
/* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
here again.
@ -7251,92 +7247,52 @@ syms_of_process (void)
Qexit = intern_c_string ("exit");
staticpro (&Qexit); */
Qopen = intern_c_string ("open");
staticpro (&Qopen);
Qclosed = intern_c_string ("closed");
staticpro (&Qclosed);
Qconnect = intern_c_string ("connect");
staticpro (&Qconnect);
Qfailed = intern_c_string ("failed");
staticpro (&Qfailed);
Qlisten = intern_c_string ("listen");
staticpro (&Qlisten);
Qlocal = intern_c_string ("local");
staticpro (&Qlocal);
Qipv4 = intern_c_string ("ipv4");
staticpro (&Qipv4);
DEFSYM (Qopen, "open");
DEFSYM (Qclosed, "closed");
DEFSYM (Qconnect, "connect");
DEFSYM (Qfailed, "failed");
DEFSYM (Qlisten, "listen");
DEFSYM (Qlocal, "local");
DEFSYM (Qipv4, "ipv4");
#ifdef AF_INET6
Qipv6 = intern_c_string ("ipv6");
staticpro (&Qipv6);
DEFSYM (Qipv6, "ipv6");
#endif
Qdatagram = intern_c_string ("datagram");
staticpro (&Qdatagram);
Qseqpacket = intern_c_string ("seqpacket");
staticpro (&Qseqpacket);
DEFSYM (Qdatagram, "datagram");
DEFSYM (Qseqpacket, "seqpacket");
QCport = intern_c_string (":port");
staticpro (&QCport);
QCspeed = intern_c_string (":speed");
staticpro (&QCspeed);
QCprocess = intern_c_string (":process");
staticpro (&QCprocess);
DEFSYM (QCport, ":port");
DEFSYM (QCspeed, ":speed");
DEFSYM (QCprocess, ":process");
QCbytesize = intern_c_string (":bytesize");
staticpro (&QCbytesize);
QCstopbits = intern_c_string (":stopbits");
staticpro (&QCstopbits);
QCparity = intern_c_string (":parity");
staticpro (&QCparity);
Qodd = intern_c_string ("odd");
staticpro (&Qodd);
Qeven = intern_c_string ("even");
staticpro (&Qeven);
QCflowcontrol = intern_c_string (":flowcontrol");
staticpro (&QCflowcontrol);
Qhw = intern_c_string ("hw");
staticpro (&Qhw);
Qsw = intern_c_string ("sw");
staticpro (&Qsw);
QCsummary = intern_c_string (":summary");
staticpro (&QCsummary);
DEFSYM (QCbytesize, ":bytesize");
DEFSYM (QCstopbits, ":stopbits");
DEFSYM (QCparity, ":parity");
DEFSYM (Qodd, "odd");
DEFSYM (Qeven, "even");
DEFSYM (QCflowcontrol, ":flowcontrol");
DEFSYM (Qhw, "hw");
DEFSYM (Qsw, "sw");
DEFSYM (QCsummary, ":summary");
Qreal = intern_c_string ("real");
staticpro (&Qreal);
Qnetwork = intern_c_string ("network");
staticpro (&Qnetwork);
Qserial = intern_c_string ("serial");
staticpro (&Qserial);
QCbuffer = intern_c_string (":buffer");
staticpro (&QCbuffer);
QChost = intern_c_string (":host");
staticpro (&QChost);
QCservice = intern_c_string (":service");
staticpro (&QCservice);
QClocal = intern_c_string (":local");
staticpro (&QClocal);
QCremote = intern_c_string (":remote");
staticpro (&QCremote);
QCcoding = intern_c_string (":coding");
staticpro (&QCcoding);
QCserver = intern_c_string (":server");
staticpro (&QCserver);
QCnowait = intern_c_string (":nowait");
staticpro (&QCnowait);
QCsentinel = intern_c_string (":sentinel");
staticpro (&QCsentinel);
QClog = intern_c_string (":log");
staticpro (&QClog);
QCnoquery = intern_c_string (":noquery");
staticpro (&QCnoquery);
QCstop = intern_c_string (":stop");
staticpro (&QCstop);
QCoptions = intern_c_string (":options");
staticpro (&QCoptions);
QCplist = intern_c_string (":plist");
staticpro (&QCplist);
DEFSYM (Qreal, "real");
DEFSYM (Qnetwork, "network");
DEFSYM (Qserial, "serial");
DEFSYM (QCbuffer, ":buffer");
DEFSYM (QChost, ":host");
DEFSYM (QCservice, ":service");
DEFSYM (QClocal, ":local");
DEFSYM (QCremote, ":remote");
DEFSYM (QCcoding, ":coding");
DEFSYM (QCserver, ":server");
DEFSYM (QCnowait, ":nowait");
DEFSYM (QCsentinel, ":sentinel");
DEFSYM (QClog, ":log");
DEFSYM (QCnoquery, ":noquery");
DEFSYM (QCstop, ":stop");
DEFSYM (QCoptions, ":options");
DEFSYM (QCplist, ":plist");
Qlast_nonmenu_event = intern_c_string ("last-nonmenu-event");
staticpro (&Qlast_nonmenu_event);
DEFSYM (Qlast_nonmenu_event, "last-nonmenu-event");
staticpro (&Vprocess_alist);
#ifdef SIGCHLD
@ -7345,73 +7301,40 @@ syms_of_process (void)
#endif /* subprocesses */
QCname = intern_c_string (":name");
staticpro (&QCname);
QCtype = intern_c_string (":type");
staticpro (&QCtype);
DEFSYM (QCname, ":name");
DEFSYM (QCtype, ":type");
Qeuid = intern_c_string ("euid");
staticpro (&Qeuid);
Qegid = intern_c_string ("egid");
staticpro (&Qegid);
Quser = intern_c_string ("user");
staticpro (&Quser);
Qgroup = intern_c_string ("group");
staticpro (&Qgroup);
Qcomm = intern_c_string ("comm");
staticpro (&Qcomm);
Qstate = intern_c_string ("state");
staticpro (&Qstate);
Qppid = intern_c_string ("ppid");
staticpro (&Qppid);
Qpgrp = intern_c_string ("pgrp");
staticpro (&Qpgrp);
Qsess = intern_c_string ("sess");
staticpro (&Qsess);
Qttname = intern_c_string ("ttname");
staticpro (&Qttname);
Qtpgid = intern_c_string ("tpgid");
staticpro (&Qtpgid);
Qminflt = intern_c_string ("minflt");
staticpro (&Qminflt);
Qmajflt = intern_c_string ("majflt");
staticpro (&Qmajflt);
Qcminflt = intern_c_string ("cminflt");
staticpro (&Qcminflt);
Qcmajflt = intern_c_string ("cmajflt");
staticpro (&Qcmajflt);
Qutime = intern_c_string ("utime");
staticpro (&Qutime);
Qstime = intern_c_string ("stime");
staticpro (&Qstime);
Qtime = intern_c_string ("time");
staticpro (&Qtime);
Qcutime = intern_c_string ("cutime");
staticpro (&Qcutime);
Qcstime = intern_c_string ("cstime");
staticpro (&Qcstime);
Qctime = intern_c_string ("ctime");
staticpro (&Qctime);
Qpri = intern_c_string ("pri");
staticpro (&Qpri);
Qnice = intern_c_string ("nice");
staticpro (&Qnice);
Qthcount = intern_c_string ("thcount");
staticpro (&Qthcount);
Qstart = intern_c_string ("start");
staticpro (&Qstart);
Qvsize = intern_c_string ("vsize");
staticpro (&Qvsize);
Qrss = intern_c_string ("rss");
staticpro (&Qrss);
Qetime = intern_c_string ("etime");
staticpro (&Qetime);
Qpcpu = intern_c_string ("pcpu");
staticpro (&Qpcpu);
Qpmem = intern_c_string ("pmem");
staticpro (&Qpmem);
Qargs = intern_c_string ("args");
staticpro (&Qargs);
DEFSYM (Qeuid, "euid");
DEFSYM (Qegid, "egid");
DEFSYM (Quser, "user");
DEFSYM (Qgroup, "group");
DEFSYM (Qcomm, "comm");
DEFSYM (Qstate, "state");
DEFSYM (Qppid, "ppid");
DEFSYM (Qpgrp, "pgrp");
DEFSYM (Qsess, "sess");
DEFSYM (Qttname, "ttname");
DEFSYM (Qtpgid, "tpgid");
DEFSYM (Qminflt, "minflt");
DEFSYM (Qmajflt, "majflt");
DEFSYM (Qcminflt, "cminflt");
DEFSYM (Qcmajflt, "cmajflt");
DEFSYM (Qutime, "utime");
DEFSYM (Qstime, "stime");
DEFSYM (Qtime, "time");
DEFSYM (Qcutime, "cutime");
DEFSYM (Qcstime, "cstime");
DEFSYM (Qctime, "ctime");
DEFSYM (Qpri, "pri");
DEFSYM (Qnice, "nice");
DEFSYM (Qthcount, "thcount");
DEFSYM (Qstart, "start");
DEFSYM (Qvsize, "vsize");
DEFSYM (Qrss, "rss");
DEFSYM (Qetime, "etime");
DEFSYM (Qpcpu, "pcpu");
DEFSYM (Qpmem, "pmem");
DEFSYM (Qargs, "args");
DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes,
doc: /* *Non-nil means delete processes immediately when they exit.

6
src/search.c
View file

@ -3181,10 +3181,8 @@ syms_of_search (void)
}
searchbuf_head = &searchbufs[0];
Qsearch_failed = intern_c_string ("search-failed");
staticpro (&Qsearch_failed);
Qinvalid_regexp = intern_c_string ("invalid-regexp");
staticpro (&Qinvalid_regexp);
DEFSYM (Qsearch_failed, "search-failed");
DEFSYM (Qinvalid_regexp, "invalid-regexp");
Fput (Qsearch_failed, Qerror_conditions,
pure_cons (Qsearch_failed, pure_cons (Qerror, Qnil)));

12
src/sound.c
View file

@ -1477,14 +1477,10 @@ Internal use only, use `play-sound' instead. */)
void
syms_of_sound (void)
{
QCdevice = intern_c_string(":device");
staticpro (&QCdevice);
QCvolume = intern_c_string (":volume");
staticpro (&QCvolume);
Qsound = intern_c_string ("sound");
staticpro (&Qsound);
Qplay_sound_functions = intern_c_string ("play-sound-functions");
staticpro (&Qplay_sound_functions);
DEFSYM (QCdevice, ":device");
DEFSYM (QCvolume, ":volume");
DEFSYM (Qsound, "sound");
DEFSYM (Qplay_sound_functions, "play-sound-functions");
defsubr (&Splay_sound_internal);
}

9
src/syntax.c
View file

@ -3362,8 +3362,7 @@ init_syntax_once (void)
Lisp_Object temp;
/* This has to be done here, before we call Fmake_char_table. */
Qsyntax_table = intern_c_string ("syntax-table");
staticpro (&Qsyntax_table);
DEFSYM (Qsyntax_table, "syntax-table");
/* Intern_C_String this now in case it isn't already done.
Setting this variable twice is harmless.
@ -3448,8 +3447,7 @@ init_syntax_once (void)
void
syms_of_syntax (void)
{
Qsyntax_table_p = intern_c_string ("syntax-table-p");
staticpro (&Qsyntax_table_p);
DEFSYM (Qsyntax_table_p, "syntax-table-p");
staticpro (&Vsyntax_code_object);
@ -3461,8 +3459,7 @@ syms_of_syntax (void)
/* Defined in regex.c */
staticpro (&re_match_object);
Qscan_error = intern_c_string ("scan-error");
staticpro (&Qscan_error);
DEFSYM (Qscan_error, "scan-error");
Fput (Qscan_error, Qerror_conditions,
pure_cons (Qscan_error, pure_cons (Qerror, Qnil)));
Fput (Qscan_error, Qerror_message,

6
src/terminal.c
View file

@ -555,10 +555,8 @@ Each function is called with argument, the terminal.
This may be called just before actually deleting the terminal,
or some time later. */);
Vdelete_terminal_functions = Qnil;
Qdelete_terminal_functions = intern_c_string ("delete-terminal-functions");
staticpro (&Qdelete_terminal_functions);
Qrun_hook_with_args = intern_c_string ("run-hook-with-args");
staticpro (&Qrun_hook_with_args);
DEFSYM (Qdelete_terminal_functions, "delete-terminal-functions");
DEFSYM (Qrun_hook_with_args, "run-hook-with-args");
defsubr (&Sdelete_terminal);
defsubr (&Sframe_terminal);

54
src/textprop.c
View file

@ -2242,45 +2242,27 @@ inherits it if NONSTICKINESS is nil. The `front-sticky' and
/* Common attributes one might give text */
staticpro (&Qforeground);
Qforeground = intern_c_string ("foreground");
staticpro (&Qbackground);
Qbackground = intern_c_string ("background");
staticpro (&Qfont);
Qfont = intern_c_string ("font");
staticpro (&Qstipple);
Qstipple = intern_c_string ("stipple");
staticpro (&Qunderline);
Qunderline = intern_c_string ("underline");
staticpro (&Qread_only);
Qread_only = intern_c_string ("read-only");
staticpro (&Qinvisible);
Qinvisible = intern_c_string ("invisible");
staticpro (&Qintangible);
Qintangible = intern_c_string ("intangible");
staticpro (&Qcategory);
Qcategory = intern_c_string ("category");
staticpro (&Qlocal_map);
Qlocal_map = intern_c_string ("local-map");
staticpro (&Qfront_sticky);
Qfront_sticky = intern_c_string ("front-sticky");
staticpro (&Qrear_nonsticky);
Qrear_nonsticky = intern_c_string ("rear-nonsticky");
staticpro (&Qmouse_face);
Qmouse_face = intern_c_string ("mouse-face");
staticpro (&Qminibuffer_prompt);
Qminibuffer_prompt = intern_c_string ("minibuffer-prompt");
DEFSYM (Qforeground, "foreground");
DEFSYM (Qbackground, "background");
DEFSYM (Qfont, "font");
DEFSYM (Qstipple, "stipple");
DEFSYM (Qunderline, "underline");
DEFSYM (Qread_only, "read-only");
DEFSYM (Qinvisible, "invisible");
DEFSYM (Qintangible, "intangible");
DEFSYM (Qcategory, "category");
DEFSYM (Qlocal_map, "local-map");
DEFSYM (Qfront_sticky, "front-sticky");
DEFSYM (Qrear_nonsticky, "rear-nonsticky");
DEFSYM (Qmouse_face, "mouse-face");
DEFSYM (Qminibuffer_prompt, "minibuffer-prompt");
/* Properties that text might use to specify certain actions */
staticpro (&Qmouse_left);
Qmouse_left = intern_c_string ("mouse-left");
staticpro (&Qmouse_entered);
Qmouse_entered = intern_c_string ("mouse-entered");
staticpro (&Qpoint_left);
Qpoint_left = intern_c_string ("point-left");
staticpro (&Qpoint_entered);
Qpoint_entered = intern_c_string ("point-entered");
DEFSYM (Qmouse_left, "mouse-left");
DEFSYM (Qmouse_entered, "mouse-entered");
DEFSYM (Qpoint_left, "point-left");
DEFSYM (Qpoint_entered, "point-entered");
defsubr (&Stext_properties_at);
defsubr (&Sget_text_property);

7
src/undo.c
View file

@ -637,11 +637,8 @@ Return what remains of the list. */)
void
syms_of_undo (void)
{
Qinhibit_read_only = intern_c_string ("inhibit-read-only");
staticpro (&Qinhibit_read_only);
Qapply = intern_c_string ("apply");
staticpro (&Qapply);
DEFSYM (Qinhibit_read_only, "inhibit-read-only");
DEFSYM (Qapply, "apply");
pending_boundary = Qnil;
staticpro (&pending_boundary);

3
src/w32.c
View file

@ -5960,8 +5960,7 @@ globals_of_w32 (void)
get_process_times_fn = (GetProcessTimes_Proc)
GetProcAddress (kernel32, "GetProcessTimes");
QCloaded_from = intern_c_string (":loaded-from");
staticpro (&QCloaded_from);
DEFSYM (QCloaded_from, ":loaded-from");
Vlibrary_cache = Qnil;
staticpro (&Vlibrary_cache);

1
src/w32menu.c
View file

@ -33,7 +33,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "blockinput.h"
#include "buffer.h"
#include "charset.h"
#include "character.h"
#include "coding.h"
#include "menu.h"

1
src/w32proc.c
View file

@ -51,7 +51,6 @@ extern BOOL WINAPI IsValidLocale (LCID, DWORD);
#endif
#include "lisp.h"
#include "character.h"
#include "w32.h"
#include "w32heap.h"
#include "systime.h"

1
src/w32select.c
View file

@ -80,7 +80,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#include "blockinput.h"
#include "charset.h"
#include "coding.h"
#include "character.h"
#include "composite.h"

79
src/window.c
View file

@ -6441,69 +6441,30 @@ init_window (void)
void
syms_of_window (void)
{
Qscroll_up = intern_c_string ("scroll-up");
staticpro (&Qscroll_up);
Qscroll_down = intern_c_string ("scroll-down");
staticpro (&Qscroll_down);
Qscroll_command = intern_c_string ("scroll-command");
staticpro (&Qscroll_command);
DEFSYM (Qscroll_up, "scroll-up");
DEFSYM (Qscroll_down, "scroll-down");
DEFSYM (Qscroll_command, "scroll-command");
Fput (Qscroll_up, Qscroll_command, Qt);
Fput (Qscroll_down, Qscroll_command, Qt);
staticpro (&Qwindow_configuration_change_hook);
Qwindow_configuration_change_hook
= intern_c_string ("window-configuration-change-hook");
Qwindowp = intern_c_string ("windowp");
staticpro (&Qwindowp);
Qwindow_configuration_p = intern_c_string ("window-configuration-p");
staticpro (&Qwindow_configuration_p);
Qwindow_live_p = intern_c_string ("window-live-p");
staticpro (&Qwindow_live_p);
Qwindow_deletable_p = intern_c_string ("window-deletable-p");
staticpro (&Qwindow_deletable_p);
Qdelete_window = intern_c_string ("delete-window");
staticpro (&Qdelete_window);
Qresize_root_window = intern_c_string ("resize-root-window");
staticpro (&Qresize_root_window);
Qresize_root_window_vertically = intern_c_string ("resize-root-window-vertically");
staticpro (&Qresize_root_window_vertically);
Qsafe = intern_c_string ("safe");
staticpro (&Qsafe);
Qdisplay_buffer = intern_c_string ("display-buffer");
staticpro (&Qdisplay_buffer);
Qreplace_buffer_in_windows = intern_c_string ("replace-buffer-in-windows");
staticpro (&Qreplace_buffer_in_windows);
Qrecord_window_buffer = intern_c_string ("record-window-buffer");
staticpro (&Qrecord_window_buffer);
Qget_mru_window = intern_c_string ("get-mru-window");
staticpro (&Qget_mru_window);
Qtemp_buffer_show_hook = intern_c_string ("temp-buffer-show-hook");
staticpro (&Qtemp_buffer_show_hook);
Qabove = intern_c_string ("above");
staticpro (&Qabove);
Qbelow = intern_c_string ("below");
staticpro (&Qbelow);
Qauto_buffer_name = intern_c_string ("auto-buffer-name");
staticpro (&Qauto_buffer_name);
DEFSYM (Qwindow_configuration_change_hook, "window-configuration-change-hook");
DEFSYM (Qwindowp, "windowp");
DEFSYM (Qwindow_configuration_p, "window-configuration-p");
DEFSYM (Qwindow_live_p, "window-live-p");
DEFSYM (Qwindow_deletable_p, "window-deletable-p");
DEFSYM (Qdelete_window, "delete-window");
DEFSYM (Qresize_root_window, "resize-root-window");
DEFSYM (Qresize_root_window_vertically, "resize-root-window-vertically");
DEFSYM (Qsafe, "safe");
DEFSYM (Qdisplay_buffer, "display-buffer");
DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
DEFSYM (Qrecord_window_buffer, "record-window-buffer");
DEFSYM (Qget_mru_window, "get-mru-window");
DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
DEFSYM (Qabove, "above");
DEFSYM (Qbelow, "below");
DEFSYM (Qauto_buffer_name, "auto-buffer-name");
staticpro (&Vwindow_list);

207
src/xdisp.c
View file

@ -26428,8 +26428,7 @@ syms_of_xdisp (void)
Vmessage_stack = Qnil;
staticpro (&Vmessage_stack);
Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
staticpro (&Qinhibit_redisplay);
DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
message_dolog_marker1 = Fmake_marker ();
staticpro (&message_dolog_marker1);
@ -26454,141 +26453,72 @@ syms_of_xdisp (void)
defsubr (&Sinvisible_p);
defsubr (&Scurrent_bidi_paragraph_direction);
staticpro (&Qmenu_bar_update_hook);
Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
staticpro (&Qoverriding_terminal_local_map);
Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
staticpro (&Qoverriding_local_map);
Qoverriding_local_map = intern_c_string ("overriding-local-map");
staticpro (&Qwindow_scroll_functions);
Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
staticpro (&Qwindow_text_change_functions);
Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
staticpro (&Qredisplay_end_trigger_functions);
Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
staticpro (&Qinhibit_point_motion_hooks);
Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
Qeval = intern_c_string ("eval");
staticpro (&Qeval);
QCdata = intern_c_string (":data");
staticpro (&QCdata);
Qdisplay = intern_c_string ("display");
staticpro (&Qdisplay);
Qspace_width = intern_c_string ("space-width");
staticpro (&Qspace_width);
Qraise = intern_c_string ("raise");
staticpro (&Qraise);
Qslice = intern_c_string ("slice");
staticpro (&Qslice);
Qspace = intern_c_string ("space");
staticpro (&Qspace);
Qmargin = intern_c_string ("margin");
staticpro (&Qmargin);
Qpointer = intern_c_string ("pointer");
staticpro (&Qpointer);
Qleft_margin = intern_c_string ("left-margin");
staticpro (&Qleft_margin);
Qright_margin = intern_c_string ("right-margin");
staticpro (&Qright_margin);
Qcenter = intern_c_string ("center");
staticpro (&Qcenter);
Qline_height = intern_c_string ("line-height");
staticpro (&Qline_height);
QCalign_to = intern_c_string (":align-to");
staticpro (&QCalign_to);
QCrelative_width = intern_c_string (":relative-width");
staticpro (&QCrelative_width);
QCrelative_height = intern_c_string (":relative-height");
staticpro (&QCrelative_height);
QCeval = intern_c_string (":eval");
staticpro (&QCeval);
QCpropertize = intern_c_string (":propertize");
staticpro (&QCpropertize);
QCfile = intern_c_string (":file");
staticpro (&QCfile);
Qfontified = intern_c_string ("fontified");
staticpro (&Qfontified);
Qfontification_functions = intern_c_string ("fontification-functions");
staticpro (&Qfontification_functions);
Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
staticpro (&Qtrailing_whitespace);
Qescape_glyph = intern_c_string ("escape-glyph");
staticpro (&Qescape_glyph);
Qnobreak_space = intern_c_string ("nobreak-space");
staticpro (&Qnobreak_space);
Qimage = intern_c_string ("image");
staticpro (&Qimage);
Qtext = intern_c_string ("text");
staticpro (&Qtext);
Qboth = intern_c_string ("both");
staticpro (&Qboth);
Qboth_horiz = intern_c_string ("both-horiz");
staticpro (&Qboth_horiz);
Qtext_image_horiz = intern_c_string ("text-image-horiz");
staticpro (&Qtext_image_horiz);
QCmap = intern_c_string (":map");
staticpro (&QCmap);
QCpointer = intern_c_string (":pointer");
staticpro (&QCpointer);
Qrect = intern_c_string ("rect");
staticpro (&Qrect);
Qcircle = intern_c_string ("circle");
staticpro (&Qcircle);
Qpoly = intern_c_string ("poly");
staticpro (&Qpoly);
Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
staticpro (&Qmessage_truncate_lines);
Qgrow_only = intern_c_string ("grow-only");
staticpro (&Qgrow_only);
Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
staticpro (&Qinhibit_menubar_update);
Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
staticpro (&Qinhibit_eval_during_redisplay);
Qposition = intern_c_string ("position");
staticpro (&Qposition);
Qbuffer_position = intern_c_string ("buffer-position");
staticpro (&Qbuffer_position);
Qobject = intern_c_string ("object");
staticpro (&Qobject);
Qbar = intern_c_string ("bar");
staticpro (&Qbar);
Qhbar = intern_c_string ("hbar");
staticpro (&Qhbar);
Qbox = intern_c_string ("box");
staticpro (&Qbox);
Qhollow = intern_c_string ("hollow");
staticpro (&Qhollow);
Qhand = intern_c_string ("hand");
staticpro (&Qhand);
Qarrow = intern_c_string ("arrow");
staticpro (&Qarrow);
Qtext = intern_c_string ("text");
staticpro (&Qtext);
Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
staticpro (&Qinhibit_free_realized_faces);
DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
DEFSYM (Qoverriding_local_map, "overriding-local-map");
DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
DEFSYM (Qwindow_text_change_functions, "window-text-change-functions");
DEFSYM (Qredisplay_end_trigger_functions, "redisplay-end-trigger-functions");
DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
DEFSYM (Qeval, "eval");
DEFSYM (QCdata, ":data");
DEFSYM (Qdisplay, "display");
DEFSYM (Qspace_width, "space-width");
DEFSYM (Qraise, "raise");
DEFSYM (Qslice, "slice");
DEFSYM (Qspace, "space");
DEFSYM (Qmargin, "margin");
DEFSYM (Qpointer, "pointer");
DEFSYM (Qleft_margin, "left-margin");
DEFSYM (Qright_margin, "right-margin");
DEFSYM (Qcenter, "center");
DEFSYM (Qline_height, "line-height");
DEFSYM (QCalign_to, ":align-to");
DEFSYM (QCrelative_width, ":relative-width");
DEFSYM (QCrelative_height, ":relative-height");
DEFSYM (QCeval, ":eval");
DEFSYM (QCpropertize, ":propertize");
DEFSYM (QCfile, ":file");
DEFSYM (Qfontified, "fontified");
DEFSYM (Qfontification_functions, "fontification-functions");
DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
DEFSYM (Qescape_glyph, "escape-glyph");
DEFSYM (Qnobreak_space, "nobreak-space");
DEFSYM (Qimage, "image");
DEFSYM (Qtext, "text");
DEFSYM (Qboth, "both");
DEFSYM (Qboth_horiz, "both-horiz");
DEFSYM (Qtext_image_horiz, "text-image-horiz");
DEFSYM (QCmap, ":map");
DEFSYM (QCpointer, ":pointer");
DEFSYM (Qrect, "rect");
DEFSYM (Qcircle, "circle");
DEFSYM (Qpoly, "poly");
DEFSYM (Qmessage_truncate_lines, "message-truncate-lines");
DEFSYM (Qgrow_only, "grow-only");
DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
DEFSYM (Qposition, "position");
DEFSYM (Qbuffer_position, "buffer-position");
DEFSYM (Qobject, "object");
DEFSYM (Qbar, "bar");
DEFSYM (Qhbar, "hbar");
DEFSYM (Qbox, "box");
DEFSYM (Qhollow, "hollow");
DEFSYM (Qhand, "hand");
DEFSYM (Qarrow, "arrow");
DEFSYM (Qtext, "text");
DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
list_of_error = Fcons (Fcons (intern_c_string ("error"),
Fcons (intern_c_string ("void-variable"), Qnil)),
Qnil);
staticpro (&list_of_error);
Qlast_arrow_position = intern_c_string ("last-arrow-position");
staticpro (&Qlast_arrow_position);
Qlast_arrow_string = intern_c_string ("last-arrow-string");
staticpro (&Qlast_arrow_string);
Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
staticpro (&Qoverlay_arrow_string);
Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
staticpro (&Qoverlay_arrow_bitmap);
DEFSYM (Qlast_arrow_position, "last-arrow-position");
DEFSYM (Qlast_arrow_string, "last-arrow-string");
DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
echo_buffer[0] = echo_buffer[1] = Qnil;
staticpro (&echo_buffer[0]);
@ -26622,10 +26552,8 @@ syms_of_xdisp (void)
staticpro (&previous_help_echo_string);
help_echo_pos = -1;
Qright_to_left = intern_c_string ("right-to-left");
staticpro (&Qright_to_left);
Qleft_to_right = intern_c_string ("left-to-right");
staticpro (&Qleft_to_right);
DEFSYM (Qright_to_left, "right-to-left");
DEFSYM (Qleft_to_right, "left-to-right");
#ifdef HAVE_WINDOW_SYSTEM
DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
@ -26945,8 +26873,7 @@ the frame's other specifications determine how to blink the cursor off. */);
If non-nil, windows are automatically scrolled horizontally to make
point visible. */);
automatic_hscrolling_p = 1;
Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
staticpro (&Qauto_hscroll_mode);
DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
DEFVAR_INT ("hscroll-margin", hscroll_margin,
doc: /* *How many columns away from the window edge point is allowed to get
@ -27002,8 +26929,7 @@ property.
To add a prefix to non-continuation lines, use `line-prefix'. */);
Vwrap_prefix = Qnil;
staticpro (&Qwrap_prefix);
Qwrap_prefix = intern_c_string ("wrap-prefix");
DEFSYM (Qwrap_prefix, "wrap-prefix");
Fmake_variable_buffer_local (Qwrap_prefix);
DEFVAR_LISP ("line-prefix", Vline_prefix,
@ -27016,8 +26942,7 @@ property.
To add a prefix to continuation lines, use `wrap-prefix'. */);
Vline_prefix = Qnil;
staticpro (&Qline_prefix);
Qline_prefix = intern_c_string ("line-prefix");
DEFSYM (Qline_prefix, "line-prefix");
Fmake_variable_buffer_local (Qline_prefix);
DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,

213
src/xfaces.c
View file

@ -6393,153 +6393,82 @@ DEFUN ("show-face-resources", Fshow_face_resources, Sshow_face_resources,
void
syms_of_xfaces (void)
{
Qface = intern_c_string ("face");
staticpro (&Qface);
Qface_no_inherit = intern_c_string ("face-no-inherit");
staticpro (&Qface_no_inherit);
Qbitmap_spec_p = intern_c_string ("bitmap-spec-p");
staticpro (&Qbitmap_spec_p);
Qframe_set_background_mode = intern_c_string ("frame-set-background-mode");
staticpro (&Qframe_set_background_mode);
DEFSYM (Qface, "face");
DEFSYM (Qface_no_inherit, "face-no-inherit");
DEFSYM (Qbitmap_spec_p, "bitmap-spec-p");
DEFSYM (Qframe_set_background_mode, "frame-set-background-mode");
/* Lisp face attribute keywords. */
QCfamily = intern_c_string (":family");
staticpro (&QCfamily);
QCheight = intern_c_string (":height");
staticpro (&QCheight);
QCweight = intern_c_string (":weight");
staticpro (&QCweight);
QCslant = intern_c_string (":slant");
staticpro (&QCslant);
QCunderline = intern_c_string (":underline");
staticpro (&QCunderline);
QCinverse_video = intern_c_string (":inverse-video");
staticpro (&QCinverse_video);
QCreverse_video = intern_c_string (":reverse-video");
staticpro (&QCreverse_video);
QCforeground = intern_c_string (":foreground");
staticpro (&QCforeground);
QCbackground = intern_c_string (":background");
staticpro (&QCbackground);
QCstipple = intern_c_string (":stipple");
staticpro (&QCstipple);
QCwidth = intern_c_string (":width");
staticpro (&QCwidth);
QCfont = intern_c_string (":font");
staticpro (&QCfont);
QCfontset = intern_c_string (":fontset");
staticpro (&QCfontset);
QCbold = intern_c_string (":bold");
staticpro (&QCbold);
QCitalic = intern_c_string (":italic");
staticpro (&QCitalic);
QCoverline = intern_c_string (":overline");
staticpro (&QCoverline);
QCstrike_through = intern_c_string (":strike-through");
staticpro (&QCstrike_through);
QCbox = intern_c_string (":box");
staticpro (&QCbox);
QCinherit = intern_c_string (":inherit");
staticpro (&QCinherit);
DEFSYM (QCfamily, ":family");
DEFSYM (QCheight, ":height");
DEFSYM (QCweight, ":weight");
DEFSYM (QCslant, ":slant");
DEFSYM (QCunderline, ":underline");
DEFSYM (QCinverse_video, ":inverse-video");
DEFSYM (QCreverse_video, ":reverse-video");
DEFSYM (QCforeground, ":foreground");
DEFSYM (QCbackground, ":background");
DEFSYM (QCstipple, ":stipple");
DEFSYM (QCwidth, ":width");
DEFSYM (QCfont, ":font");
DEFSYM (QCfontset, ":fontset");
DEFSYM (QCbold, ":bold");
DEFSYM (QCitalic, ":italic");
DEFSYM (QCoverline, ":overline");
DEFSYM (QCstrike_through, ":strike-through");
DEFSYM (QCbox, ":box");
DEFSYM (QCinherit, ":inherit");
/* Symbols used for Lisp face attribute values. */
QCcolor = intern_c_string (":color");
staticpro (&QCcolor);
QCline_width = intern_c_string (":line-width");
staticpro (&QCline_width);
QCstyle = intern_c_string (":style");
staticpro (&QCstyle);
Qreleased_button = intern_c_string ("released-button");
staticpro (&Qreleased_button);
Qpressed_button = intern_c_string ("pressed-button");
staticpro (&Qpressed_button);
Qnormal = intern_c_string ("normal");
staticpro (&Qnormal);
Qultra_light = intern_c_string ("ultra-light");
staticpro (&Qultra_light);
Qextra_light = intern_c_string ("extra-light");
staticpro (&Qextra_light);
Qlight = intern_c_string ("light");
staticpro (&Qlight);
Qsemi_light = intern_c_string ("semi-light");
staticpro (&Qsemi_light);
Qsemi_bold = intern_c_string ("semi-bold");
staticpro (&Qsemi_bold);
Qbold = intern_c_string ("bold");
staticpro (&Qbold);
Qextra_bold = intern_c_string ("extra-bold");
staticpro (&Qextra_bold);
Qultra_bold = intern_c_string ("ultra-bold");
staticpro (&Qultra_bold);
Qoblique = intern_c_string ("oblique");
staticpro (&Qoblique);
Qitalic = intern_c_string ("italic");
staticpro (&Qitalic);
Qreverse_oblique = intern_c_string ("reverse-oblique");
staticpro (&Qreverse_oblique);
Qreverse_italic = intern_c_string ("reverse-italic");
staticpro (&Qreverse_italic);
Qultra_condensed = intern_c_string ("ultra-condensed");
staticpro (&Qultra_condensed);
Qextra_condensed = intern_c_string ("extra-condensed");
staticpro (&Qextra_condensed);
Qcondensed = intern_c_string ("condensed");
staticpro (&Qcondensed);
Qsemi_condensed = intern_c_string ("semi-condensed");
staticpro (&Qsemi_condensed);
Qsemi_expanded = intern_c_string ("semi-expanded");
staticpro (&Qsemi_expanded);
Qexpanded = intern_c_string ("expanded");
staticpro (&Qexpanded);
Qextra_expanded = intern_c_string ("extra-expanded");
staticpro (&Qextra_expanded);
Qultra_expanded = intern_c_string ("ultra-expanded");
staticpro (&Qultra_expanded);
Qbackground_color = intern_c_string ("background-color");
staticpro (&Qbackground_color);
Qforeground_color = intern_c_string ("foreground-color");
staticpro (&Qforeground_color);
Qunspecified = intern_c_string ("unspecified");
staticpro (&Qunspecified);
Qignore_defface = intern_c_string (":ignore-defface");
staticpro (&Qignore_defface);
DEFSYM (QCcolor, ":color");
DEFSYM (QCline_width, ":line-width");
DEFSYM (QCstyle, ":style");
DEFSYM (Qreleased_button, "released-button");
DEFSYM (Qpressed_button, "pressed-button");
DEFSYM (Qnormal, "normal");
DEFSYM (Qultra_light, "ultra-light");
DEFSYM (Qextra_light, "extra-light");
DEFSYM (Qlight, "light");
DEFSYM (Qsemi_light, "semi-light");
DEFSYM (Qsemi_bold, "semi-bold");
DEFSYM (Qbold, "bold");
DEFSYM (Qextra_bold, "extra-bold");
DEFSYM (Qultra_bold, "ultra-bold");
DEFSYM (Qoblique, "oblique");
DEFSYM (Qitalic, "italic");
DEFSYM (Qreverse_oblique, "reverse-oblique");
DEFSYM (Qreverse_italic, "reverse-italic");
DEFSYM (Qultra_condensed, "ultra-condensed");
DEFSYM (Qextra_condensed, "extra-condensed");
DEFSYM (Qcondensed, "condensed");
DEFSYM (Qsemi_condensed, "semi-condensed");
DEFSYM (Qsemi_expanded, "semi-expanded");
DEFSYM (Qexpanded, "expanded");
DEFSYM (Qextra_expanded, "extra-expanded");
DEFSYM (Qultra_expanded, "ultra-expanded");
DEFSYM (Qbackground_color, "background-color");
DEFSYM (Qforeground_color, "foreground-color");
DEFSYM (Qunspecified, "unspecified");
DEFSYM (Qignore_defface, ":ignore-defface");
Qface_alias = intern_c_string ("face-alias");
staticpro (&Qface_alias);
Qdefault = intern_c_string ("default");
staticpro (&Qdefault);
Qtool_bar = intern_c_string ("tool-bar");
staticpro (&Qtool_bar);
Qregion = intern_c_string ("region");
staticpro (&Qregion);
Qfringe = intern_c_string ("fringe");
staticpro (&Qfringe);
Qheader_line = intern_c_string ("header-line");
staticpro (&Qheader_line);
Qscroll_bar = intern_c_string ("scroll-bar");
staticpro (&Qscroll_bar);
Qmenu = intern_c_string ("menu");
staticpro (&Qmenu);
Qcursor = intern_c_string ("cursor");
staticpro (&Qcursor);
Qborder = intern_c_string ("border");
staticpro (&Qborder);
Qmouse = intern_c_string ("mouse");
staticpro (&Qmouse);
Qmode_line_inactive = intern_c_string ("mode-line-inactive");
staticpro (&Qmode_line_inactive);
Qvertical_border = intern_c_string ("vertical-border");
staticpro (&Qvertical_border);
Qtty_color_desc = intern_c_string ("tty-color-desc");
staticpro (&Qtty_color_desc);
Qtty_color_standard_values = intern_c_string ("tty-color-standard-values");
staticpro (&Qtty_color_standard_values);
Qtty_color_by_index = intern_c_string ("tty-color-by-index");
staticpro (&Qtty_color_by_index);
Qtty_color_alist = intern_c_string ("tty-color-alist");
staticpro (&Qtty_color_alist);
Qscalable_fonts_allowed = intern_c_string ("scalable-fonts-allowed");
staticpro (&Qscalable_fonts_allowed);
DEFSYM (Qface_alias, "face-alias");
DEFSYM (Qdefault, "default");
DEFSYM (Qtool_bar, "tool-bar");
DEFSYM (Qregion, "region");
DEFSYM (Qfringe, "fringe");
DEFSYM (Qheader_line, "header-line");
DEFSYM (Qscroll_bar, "scroll-bar");
DEFSYM (Qmenu, "menu");
DEFSYM (Qcursor, "cursor");
DEFSYM (Qborder, "border");
DEFSYM (Qmouse, "mouse");
DEFSYM (Qmode_line_inactive, "mode-line-inactive");
DEFSYM (Qvertical_border, "vertical-border");
DEFSYM (Qtty_color_desc, "tty-color-desc");
DEFSYM (Qtty_color_standard_values, "tty-color-standard-values");
DEFSYM (Qtty_color_by_index, "tty-color-by-index");
DEFSYM (Qtty_color_alist, "tty-color-alist");
DEFSYM (Qscalable_fonts_allowed, "scalable-fonts-allowed");
Vparam_value_alist = Fcons (Fcons (Qnil, Qnil), Qnil);
staticpro (&Vparam_value_alist);

19
src/xfns.c
View file

@ -5797,25 +5797,18 @@ syms_of_xfns (void)
/* The section below is built by the lisp expression at the top of the file,
just above where these variables are declared. */
/*&&& init symbols here &&&*/
Qnone = intern_c_string ("none");
staticpro (&Qnone);
Qsuppress_icon = intern_c_string ("suppress-icon");
staticpro (&Qsuppress_icon);
Qundefined_color = intern_c_string ("undefined-color");
staticpro (&Qundefined_color);
Qcompound_text = intern_c_string ("compound-text");
staticpro (&Qcompound_text);
Qcancel_timer = intern_c_string ("cancel-timer");
staticpro (&Qcancel_timer);
Qfont_param = intern_c_string ("font-parameter");
staticpro (&Qfont_param);
DEFSYM (Qnone, "none");
DEFSYM (Qsuppress_icon, "suppress-icon");
DEFSYM (Qundefined_color, "undefined-color");
DEFSYM (Qcompound_text, "compound-text");
DEFSYM (Qcancel_timer, "cancel-timer");
DEFSYM (Qfont_param, "font-parameter");
/* This is the end of symbol initialization. */
/* Text property `display' should be nonsticky by default. */
Vtext_property_default_nonsticky
= Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
Fput (Qundefined_color, Qerror_conditions,
pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
Fput (Qundefined_color, Qerror_message,

3
src/xmenu.c
View file

@ -2559,8 +2559,7 @@ DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_
void
syms_of_xmenu (void)
{
Qdebug_on_next_call = intern_c_string ("debug-on-next-call");
staticpro (&Qdebug_on_next_call);
DEFSYM (Qdebug_on_next_call, "debug-on-next-call");
#ifdef USE_X_TOOLKIT
widget_id_tick = (1<<16);

12
src/xsettings.c
View file

@ -750,12 +750,9 @@ syms_of_xsettings (void)
gconf_client = NULL;
#endif
Qmonospace_font_name = intern_c_string ("monospace-font-name");
staticpro (&Qmonospace_font_name);
Qfont_name = intern_c_string ("font-name");
staticpro (&Qfont_name);
Qfont_render = intern_c_string ("font-render");
staticpro (&Qfont_render);
DEFSYM (Qmonospace_font_name, "monospace-font-name");
DEFSYM (Qfont_name, "font-name");
DEFSYM (Qfont_render, "font-render");
defsubr (&Sfont_get_system_font);
defsubr (&Sfont_get_system_normal_font);
@ -778,8 +775,7 @@ If this variable is nil, Emacs ignores system font changes. */);
#endif
current_tool_bar_style = Qnil;
Qtool_bar_style = intern_c_string ("tool-bar-style");
staticpro (&Qtool_bar_style);
DEFSYM (Qtool_bar_style, "tool-bar-style");
defsubr (&Stool_bar_get_system_style);
Fprovide (intern_c_string ("dynamic-setting"), Qnil);

10
src/xterm.c
View file

@ -10698,11 +10698,8 @@ syms_of_xterm (void)
staticpro (&last_mouse_scroll_bar);
last_mouse_scroll_bar = Qnil;
staticpro (&Qvendor_specific_keysyms);
Qvendor_specific_keysyms = intern_c_string ("vendor-specific-keysyms");
staticpro (&Qlatin_1);
Qlatin_1 = intern_c_string ("latin-1");
DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
DEFSYM (Qlatin_1, "latin-1");
staticpro (&last_mouse_press_frame);
last_mouse_press_frame = Qnil;
@ -10711,8 +10708,7 @@ syms_of_xterm (void)
xg_default_icon_file = make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
staticpro (&xg_default_icon_file);
Qx_gtk_map_stock = intern_c_string ("x-gtk-map-stock");
staticpro (&Qx_gtk_map_stock);
DEFSYM (Qx_gtk_map_stock, "x-gtk-map-stock");
#endif
DEFVAR_BOOL ("x-use-underline-position-properties",