mirrors/emacs
1
Fork 0
mirror of git://git.sv.gnu.org/emacs.git synced 2025-12-24 06:20:43 -08:00
Code Issues Projects Releases Wiki Activity

* xterm.c (syms_of_xterm):

Browse source 
* xselect.c (syms_of_xselect):
* xmenu.c (syms_of_xmenu):
* xfns.c (syms_of_xfns):
* xfaces.c (syms_of_xfaces):
* xdisp.c (syms_of_xdisp):
* window.c (syms_of_window):
* w32fns.c (syms_of_w32fns):
* undo.c (syms_of_undo):
* textprop.c (syms_of_textprop):
* terminal.c (syms_of_terminal):
* syntax.c (syms_of_syntax):
* sound.c (syms_of_sound):
* search.c (syms_of_search):
* print.c (syms_of_print):
* minibuf.c (syms_of_minibuf):
* macros.c (syms_of_macros):
* keymap.c (syms_of_keymap, initial_define_key)
(initial_define_lispy_key):
* keyboard.c (syms_of_keyboard):
* insdel.c (syms_of_insdel):
* image.c (syms_of_image):
* fringe.c (syms_of_fringe):
* frame.c (syms_of_frame):
* fontset.c (syms_of_fontset):
* fns.c (syms_of_fns):
* fns.c (syms_of_fns):
* fileio.c (syms_of_fileio):
* fileio.c (syms_of_fileio):
* eval.c (syms_of_eval):
* doc.c (syms_of_doc):
* dispnew.c (syms_of_display):
* dired.c (syms_of_dired):
* dbusbind.c (syms_of_dbusbind):
* data.c (syms_of_data):
* composite.c (syms_of_composite):
* coding.c (syms_of_coding):
* cmds.c (syms_of_cmds):
* charset.c (define_charset_internal, syms_of_character):
* ccl.c (syms_of_ccl):
* category.c (syms_of_category, init_category_once):
* casetab.c (syms_of_casetab):
* casefiddle.c (syms_of_casefiddle):
* callint.c (syms_of_callint):
* bytecode.c (syms_of_bytecode):
* buffer.c (keys_of_buffer, syms_of_buffer):
* alloc.c (syms_of_alloc):
* process.c (syms_of_process, init_process):
* lread.c (syms_of_lread, init_obarray):
* font.c (build_style_table):
* emacs.c (syms_of_emacs, main): Replace calls to intern with
intern_c_string, calls to make_pure_string with
make_pure_c_string.  Use pure_cons instead of Fcons.

* process.c (socket_options): Make it const.
(set_socket_option, init_process): Use a const pointer.

* lread.c (intern_c_string): New function.
(defvar_kboard, defvar_lisp, defvar_lisp_nopro, defvar_bool)
(defvar_int): Uset it.  Make the name const char*.

* font.c (struct table_entry): Remove unused member.  Make NAMES
constant.
(weight_table, slant_table, width_table): Make constant.

* emacs.c (struct standard_args): Make name and longname constant.
This commit is contained in:
Dan Nicolaescu 2009-11-06 06:50:52 +00:00
parent 495bd5ca19
commit d67b4f80db
51 changed files with 1045 additions and 994 deletions
Download patch file Download diff file Expand all files Collapse all files

54
src/ChangeLog
View file

@ -1,5 +1,59 @@
2009-11-06 Dan Nicolaescu <dann@ics.uci.edu>
* xterm.c (syms_of_xterm):
* xselect.c (syms_of_xselect):
* xmenu.c (syms_of_xmenu):
* xfns.c (syms_of_xfns):
* xfaces.c (syms_of_xfaces):
* xdisp.c (syms_of_xdisp):
* window.c (syms_of_window):
* w32fns.c (syms_of_w32fns):
* undo.c (syms_of_undo):
* textprop.c (syms_of_textprop):
* terminal.c (syms_of_terminal):
* syntax.c (syms_of_syntax):
* sound.c (syms_of_sound):
* search.c (syms_of_search):
* print.c (syms_of_print):
* minibuf.c (syms_of_minibuf):
* macros.c (syms_of_macros):
* keymap.c (syms_of_keymap, initial_define_key)
(initial_define_lispy_key):
* keyboard.c (syms_of_keyboard):
* insdel.c (syms_of_insdel):
* image.c (syms_of_image):
* fringe.c (syms_of_fringe):
* frame.c (syms_of_frame):
* fontset.c (syms_of_fontset):
* fns.c (syms_of_fns):
* fns.c (syms_of_fns):
* fileio.c (syms_of_fileio):
* fileio.c (syms_of_fileio):
* eval.c (syms_of_eval):
* doc.c (syms_of_doc):
* dispnew.c (syms_of_display):
* dired.c (syms_of_dired):
* dbusbind.c (syms_of_dbusbind):
* data.c (syms_of_data):
* composite.c (syms_of_composite):
* coding.c (syms_of_coding):
* cmds.c (syms_of_cmds):
* charset.c (define_charset_internal, syms_of_character):
* ccl.c (syms_of_ccl):
* category.c (syms_of_category, init_category_once):
* casetab.c (syms_of_casetab):
* casefiddle.c (syms_of_casefiddle):
* callint.c (syms_of_callint):
* bytecode.c (syms_of_bytecode):
* buffer.c (keys_of_buffer, syms_of_buffer):
* alloc.c (syms_of_alloc):
* process.c (syms_of_process, init_process):
* lread.c (syms_of_lread, init_obarray):
* font.c (build_style_table):
* emacs.c (syms_of_emacs, main): Replace calls to intern with
intern_c_string, calls to make_pure_string with
make_pure_c_string. Use pure_cons instead of Fcons.
* process.c (socket_options): Make it const.
(set_socket_option, init_process): Use a const pointer.

8
src/alloc.c
View file

@ -31,8 +31,6 @@ along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
#undef INLINE
#endif
/* Note that this declares bzero on OSF/1. How dumb. */
#include <signal.h>
#ifdef HAVE_GTK_AND_PTHREAD
@ -6396,7 +6394,7 @@ This means that certain objects should be allocated in shared (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 ("post-gc-hook");
Qpost_gc_hook = intern_c_string ("post-gc-hook");
staticpro (&Qpost_gc_hook);
DEFVAR_LISP ("memory-signal-data", &Vmemory_signal_data,
@ -6412,10 +6410,10 @@ This means that certain objects should be allocated in shared (pure) space. */)
Vmemory_full = Qnil;
staticpro (&Qgc_cons_threshold);
Qgc_cons_threshold = intern ("gc-cons-threshold");
Qgc_cons_threshold = intern_c_string ("gc-cons-threshold");
staticpro (&Qchar_table_extra_slots);
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
DEFVAR_LISP ("gc-elapsed", &Vgc_elapsed,
doc: /* Accumulated time elapsed in garbage collections.

58
src/buffer.c
View file

@ -5162,7 +5162,7 @@ init_buffer_once ()
/* Must do these before making the first buffer! */
/* real setup is done in bindings.el */
buffer_defaults.mode_line_format = build_string ("%-");
buffer_defaults.mode_line_format = make_pure_c_string ("%-");
buffer_defaults.header_line_format = Qnil;
buffer_defaults.abbrev_mode = Qnil;
buffer_defaults.overwrite_mode = Qnil;
@ -5304,25 +5304,25 @@ init_buffer_once ()
QSFundamental = build_string ("Fundamental");
Qfundamental_mode = intern ("fundamental-mode");
Qfundamental_mode = intern_c_string ("fundamental-mode");
buffer_defaults.major_mode = Qfundamental_mode;
Qmode_class = intern ("mode-class");
Qmode_class = intern_c_string ("mode-class");
Qprotected_field = intern ("protected-field");
Qprotected_field = intern_c_string ("protected-field");
Qpermanent_local = intern ("permanent-local");
Qpermanent_local = intern_c_string ("permanent-local");
Qkill_buffer_hook = intern ("kill-buffer-hook");
Qkill_buffer_hook = intern_c_string ("kill-buffer-hook");
Fput (Qkill_buffer_hook, Qpermanent_local, Qt);
Qucs_set_table_for_input = intern ("ucs-set-table-for-input");
Qucs_set_table_for_input = intern_c_string ("ucs-set-table-for-input");
/* super-magic invisible buffer */
Vprin1_to_string_buffer = Fget_buffer_create (build_string (" prin1"));
Vprin1_to_string_buffer = Fget_buffer_create (make_pure_c_string (" prin1"));
Vbuffer_alist = Qnil;
Fset_buffer (Fget_buffer_create (build_string ("*scratch*")));
Fset_buffer (Fget_buffer_create (make_pure_c_string ("*scratch*")));
inhibit_modification_hooks = 0;
}
@ -5451,45 +5451,45 @@ syms_of_buffer ()
staticpro (&Vbuffer_alist);
staticpro (&Qprotected_field);
staticpro (&Qpermanent_local);
Qpermanent_local_hook = intern ("permanent-local-hook");
Qpermanent_local_hook = intern_c_string ("permanent-local-hook");
staticpro (&Qpermanent_local_hook);
staticpro (&Qkill_buffer_hook);
Qoverlayp = intern ("overlayp");
Qoverlayp = intern_c_string ("overlayp");
staticpro (&Qoverlayp);
Qevaporate = intern ("evaporate");
Qevaporate = intern_c_string ("evaporate");
staticpro (&Qevaporate);
Qmodification_hooks = intern ("modification-hooks");
Qmodification_hooks = intern_c_string ("modification-hooks");
staticpro (&Qmodification_hooks);
Qinsert_in_front_hooks = intern ("insert-in-front-hooks");
Qinsert_in_front_hooks = intern_c_string ("insert-in-front-hooks");
staticpro (&Qinsert_in_front_hooks);
Qinsert_behind_hooks = intern ("insert-behind-hooks");
Qinsert_behind_hooks = intern_c_string ("insert-behind-hooks");
staticpro (&Qinsert_behind_hooks);
Qget_file_buffer = intern ("get-file-buffer");
Qget_file_buffer = intern_c_string ("get-file-buffer");
staticpro (&Qget_file_buffer);
Qpriority = intern ("priority");
Qpriority = intern_c_string ("priority");
staticpro (&Qpriority);
Qwindow = intern ("window");
Qwindow = intern_c_string ("window");
staticpro (&Qwindow);
Qbefore_string = intern ("before-string");
Qbefore_string = intern_c_string ("before-string");
staticpro (&Qbefore_string);
Qafter_string = intern ("after-string");
Qafter_string = intern_c_string ("after-string");
staticpro (&Qafter_string);
Qfirst_change_hook = intern ("first-change-hook");
Qfirst_change_hook = intern_c_string ("first-change-hook");
staticpro (&Qfirst_change_hook);
Qbefore_change_functions = intern ("before-change-functions");
Qbefore_change_functions = intern_c_string ("before-change-functions");
staticpro (&Qbefore_change_functions);
Qafter_change_functions = intern ("after-change-functions");
Qafter_change_functions = intern_c_string ("after-change-functions");
staticpro (&Qafter_change_functions);
/* The next one is initialized in init_buffer_once. */
staticpro (&Qucs_set_table_for_input);
Qkill_buffer_query_functions = intern ("kill-buffer-query-functions");
Qkill_buffer_query_functions = intern_c_string ("kill-buffer-query-functions");
staticpro (&Qkill_buffer_query_functions);
Fput (Qprotected_field, Qerror_conditions,
Fcons (Qprotected_field, Fcons (Qerror, Qnil)));
pure_cons (Qprotected_field, pure_cons (Qerror, Qnil)));
Fput (Qprotected_field, Qerror_message,
build_string ("Attempt to modify a protected field"));
make_pure_c_string ("Attempt to modify a protected field"));
/* All these use DEFVAR_LISP_NOPRO because the slots in
buffer_defaults will all be marked via Vbuffer_defaults. */
@ -5769,7 +5769,7 @@ use the function `set-buffer-multibyte' to change a buffer's representation.
Changing its default value with `setq-default' is supported.
See also variable `default-enable-multibyte-characters' and Info node
`(elisp)Text Representations'. */);
XSYMBOL (intern ("enable-multibyte-characters"))->constant = 1;
XSYMBOL (intern_c_string ("enable-multibyte-characters"))->constant = 1;
DEFVAR_PER_BUFFER ("buffer-file-coding-system",
&current_buffer->buffer_file_coding_system, Qnil,
@ -6278,7 +6278,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 ("change-major-mode-hook");
Qchange_major_mode_hook = intern_c_string ("change-major-mode-hook");
staticpro (&Qchange_major_mode_hook);
defsubr (&Sbuffer_live_p);
@ -6340,7 +6340,7 @@ keys_of_buffer ()
/* This must not be in syms_of_buffer, because Qdisabled is not
initialized when that function gets called. */
Fput (intern ("erase-buffer"), Qdisabled, Qt);
Fput (intern_c_string ("erase-buffer"), Qdisabled, Qt);
}
/* arch-tag: e48569bf-69a9-4b65-a23b-8e68769436e1

4
src/bytecode.c
View file

@ -1679,7 +1679,7 @@ If the third argument is incorrect, Emacs may crash. */)
void
syms_of_bytecode ()
{
Qbytecode = intern ("byte-code");
Qbytecode = intern_c_string ("byte-code");
staticpro (&Qbytecode);
defsubr (&Sbyte_code);
@ -1702,7 +1702,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 ("byte-code-meter");
Qbyte_code_meter = intern_c_string ("byte-code-meter");
staticpro (&Qbyte_code_meter);
{
int i = 256;

37
src/callint.c
View file

@ -905,46 +905,45 @@ syms_of_callint ()
callint_message = Qnil;
staticpro (&callint_message);
preserved_fns = Fcons (intern ("region-beginning"),
Fcons (intern ("region-end"),
Fcons (intern ("point"),
Fcons (intern ("mark"), Qnil))));
staticpro (&preserved_fns);
preserved_fns = pure_cons (intern_c_string ("region-beginning"),
pure_cons (intern_c_string ("region-end"),
pure_cons (intern_c_string ("point"),
pure_cons (intern_c_string ("mark"), Qnil))));
Qlist = intern ("list");
Qlist = intern_c_string ("list");
staticpro (&Qlist);
Qlet = intern ("let");
Qlet = intern_c_string ("let");
staticpro (&Qlet);
Qif = intern ("if");
Qif = intern_c_string ("if");
staticpro (&Qif);
Qwhen = intern ("when");
Qwhen = intern_c_string ("when");
staticpro (&Qwhen);
Qletx = intern ("let*");
Qletx = intern_c_string ("let*");
staticpro (&Qletx);
Qsave_excursion = intern ("save-excursion");
Qsave_excursion = intern_c_string ("save-excursion");
staticpro (&Qsave_excursion);
Qprogn = intern ("progn");
Qprogn = intern_c_string ("progn");
staticpro (&Qprogn);
Qminus = intern ("-");
Qminus = intern_c_string ("-");
staticpro (&Qminus);
Qplus = intern ("+");
Qplus = intern_c_string ("+");
staticpro (&Qplus);
Qhandle_shift_selection = intern ("handle-shift-selection");
Qhandle_shift_selection = intern_c_string ("handle-shift-selection");
staticpro (&Qhandle_shift_selection);
Qcall_interactively = intern ("call-interactively");
Qcall_interactively = intern_c_string ("call-interactively");
staticpro (&Qcall_interactively);
Qcommand_debug_status = intern ("command-debug-status");
Qcommand_debug_status = intern_c_string ("command-debug-status");
staticpro (&Qcommand_debug_status);
Qenable_recursive_minibuffers = intern ("enable-recursive-minibuffers");
Qenable_recursive_minibuffers = intern_c_string ("enable-recursive-minibuffers");
staticpro (&Qenable_recursive_minibuffers);
Qmouse_leave_buffer_hook = intern ("mouse-leave-buffer-hook");
Qmouse_leave_buffer_hook = intern_c_string ("mouse-leave-buffer-hook");
staticpro (&Qmouse_leave_buffer_hook);
DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,

2
src/casefiddle.c
View file

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

6
src/casetab.c
View file

@ -254,13 +254,13 @@ init_casetab_once ()
{
register int i;
Lisp_Object down, up;
Qcase_table = intern ("case-table");
Qcase_table = intern_c_string ("case-table");
staticpro (&Qcase_table);
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
/* Now we are ready to set up this property, so we can
create char tables. */
@ -298,7 +298,7 @@ init_casetab_once ()
void
syms_of_casetab ()
{
Qcase_table_p = intern ("case-table-p");
Qcase_table_p = intern_c_string ("case-table-p");
staticpro (&Qcase_table_p);
staticpro (&Vascii_canon_table);

10
src/category.c
View file

@ -467,13 +467,13 @@ void
init_category_once ()
{
/* This has to be done here, before we call Fmake_char_table. */
Qcategory_table = intern ("category-table");
Qcategory_table = intern_c_string ("category-table");
staticpro (&Qcategory_table);
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
/* Now we are ready to set up this property, so we can
create category tables. */
@ -489,11 +489,11 @@ init_category_once ()
void
syms_of_category ()
{
Qcategoryp = intern ("categoryp");
Qcategoryp = intern_c_string ("categoryp");
staticpro (&Qcategoryp);
Qcategorysetp = intern ("categorysetp");
Qcategorysetp = intern_c_string ("categorysetp");
staticpro (&Qcategorysetp);
Qcategory_table_p = intern ("category-table-p");
Qcategory_table_p = intern_c_string ("category-table-p");
staticpro (&Qcategory_table_p);
DEFVAR_LISP ("word-combining-categories", &Vword_combining_categories,

12
src/ccl.c
View file

@ -2323,22 +2323,22 @@ syms_of_ccl ()
staticpro (&Vccl_program_table);
Vccl_program_table = Fmake_vector (make_number (32), Qnil);
Qccl = intern ("ccl");
Qccl = intern_c_string ("ccl");
staticpro (&Qccl);
Qcclp = intern ("cclp");
Qcclp = intern_c_string ("cclp");
staticpro (&Qcclp);
Qccl_program = intern ("ccl-program");
Qccl_program = intern_c_string ("ccl-program");
staticpro (&Qccl_program);
Qccl_program_idx = intern ("ccl-program-idx");
Qccl_program_idx = intern_c_string ("ccl-program-idx");
staticpro (&Qccl_program_idx);
Qcode_conversion_map = intern ("code-conversion-map");
Qcode_conversion_map = intern_c_string ("code-conversion-map");
staticpro (&Qcode_conversion_map);
Qcode_conversion_map_id = intern ("code-conversion-map-id");
Qcode_conversion_map_id = intern_c_string ("code-conversion-map-id");
staticpro (&Qcode_conversion_map_id);
DEFVAR_LISP ("code-conversion-map-vector", &Vcode_conversion_map_vector,

2
src/character.c
View file

@ -1142,7 +1142,7 @@ It has one extra slot whose value is a list of script symbols. */);
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
DEFSYM (Qchar_script_table, "char-script-table");
Fput (Qchar_script_table, Qchar_table_extra_slots, make_number (1));
Vchar_script_table = Fmake_char_table (Qchar_script_table, Qnil);

14
src/charset.c
View file

@ -1323,19 +1323,19 @@ define_charset_internal (name, dimension, code_space, min_code, max_code,
args[charset_arg_superset] = Qnil;
args[charset_arg_unify_map] = Qnil;
plist[0] = intern (":name");
plist[0] = intern_c_string (":name");
plist[1] = args[charset_arg_name];
plist[2] = intern (":dimension");
plist[2] = intern_c_string (":dimension");
plist[3] = args[charset_arg_dimension];
plist[4] = intern (":code-space");
plist[4] = intern_c_string (":code-space");
plist[5] = args[charset_arg_code_space];
plist[6] = intern (":iso-final-char");
plist[6] = intern_c_string (":iso-final-char");
plist[7] = args[charset_arg_iso_final];
plist[8] = intern (":emacs-mule-id");
plist[8] = intern_c_string (":emacs-mule-id");
plist[9] = args[charset_arg_emacs_mule_id];
plist[10] = intern (":ascii-compatible-p");
plist[10] = intern_c_string (":ascii-compatible-p");
plist[11] = args[charset_arg_ascii_compatible_p];
plist[12] = intern (":code-offset");
plist[12] = intern_c_string (":code-offset");
plist[13] = args[charset_arg_code_offset];
args[charset_arg_plist] = Flist (14, plist);

8
src/cmds.c
View file

@ -589,16 +589,16 @@ internal_self_insert (c, noautofill)
void
syms_of_cmds ()
{
Qkill_backward_chars = intern ("kill-backward-chars");
Qkill_backward_chars = intern_c_string ("kill-backward-chars");
staticpro (&Qkill_backward_chars);
Qkill_forward_chars = intern ("kill-forward-chars");
Qkill_forward_chars = intern_c_string ("kill-forward-chars");
staticpro (&Qkill_forward_chars);
Qoverwrite_mode_binary = intern ("overwrite-mode-binary");
Qoverwrite_mode_binary = intern_c_string ("overwrite-mode-binary");
staticpro (&Qoverwrite_mode_binary);
Qexpand_abbrev = intern ("expand-abbrev");
Qexpand_abbrev = intern_c_string ("expand-abbrev");
staticpro (&Qexpand_abbrev);
DEFVAR_LISP ("self-insert-face", &Vself_insert_face,

80
src/coding.c
View file

@ -10415,7 +10415,7 @@ syms_of_coding ()
Vcode_conversion_reused_workbuf = Qnil;
staticpro (&Vcode_conversion_workbuf_name);
Vcode_conversion_workbuf_name = build_string (" *code-conversion-work*");
Vcode_conversion_workbuf_name = make_pure_c_string (" *code-conversion-work*");
reused_workbuf_in_use = 0;
@ -10476,14 +10476,14 @@ syms_of_coding ()
DEFSYM (Qcoding_system_error, "coding-system-error");
Fput (Qcoding_system_error, Qerror_conditions,
Fcons (Qcoding_system_error, Fcons (Qerror, Qnil)));
pure_cons (Qcoding_system_error, pure_cons (Qerror, Qnil)));
Fput (Qcoding_system_error, Qerror_message,
build_string ("Invalid coding system"));
make_pure_c_string ("Invalid coding system"));
/* Intern this now in case it isn't already done.
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
DEFSYM (Qtranslation_table, "translation-table");
Fput (Qtranslation_table, Qchar_table_extra_slots, make_number (2));
@ -10509,48 +10509,48 @@ syms_of_coding ()
staticpro (&Vcoding_category_table);
/* Followings are target of code detection. */
ASET (Vcoding_category_table, coding_category_iso_7,
intern ("coding-category-iso-7"));
intern_c_string ("coding-category-iso-7"));
ASET (Vcoding_category_table, coding_category_iso_7_tight,
intern ("coding-category-iso-7-tight"));
intern_c_string ("coding-category-iso-7-tight"));
ASET (Vcoding_category_table, coding_category_iso_8_1,
intern ("coding-category-iso-8-1"));
intern_c_string ("coding-category-iso-8-1"));
ASET (Vcoding_category_table, coding_category_iso_8_2,
intern ("coding-category-iso-8-2"));
intern_c_string ("coding-category-iso-8-2"));
ASET (Vcoding_category_table, coding_category_iso_7_else,
intern ("coding-category-iso-7-else"));
intern_c_string ("coding-category-iso-7-else"));
ASET (Vcoding_category_table, coding_category_iso_8_else,
intern ("coding-category-iso-8-else"));
intern_c_string ("coding-category-iso-8-else"));
ASET (Vcoding_category_table, coding_category_utf_8_auto,
intern ("coding-category-utf-8-auto"));
intern_c_string ("coding-category-utf-8-auto"));
ASET (Vcoding_category_table, coding_category_utf_8_nosig,
intern ("coding-category-utf-8"));
intern_c_string ("coding-category-utf-8"));
ASET (Vcoding_category_table, coding_category_utf_8_sig,
intern ("coding-category-utf-8-sig"));
intern_c_string ("coding-category-utf-8-sig"));
ASET (Vcoding_category_table, coding_category_utf_16_be,
intern ("coding-category-utf-16-be"));
intern_c_string ("coding-category-utf-16-be"));
ASET (Vcoding_category_table, coding_category_utf_16_auto,
intern ("coding-category-utf-16-auto"));
intern_c_string ("coding-category-utf-16-auto"));
ASET (Vcoding_category_table, coding_category_utf_16_le,
intern ("coding-category-utf-16-le"));
intern_c_string ("coding-category-utf-16-le"));
ASET (Vcoding_category_table, coding_category_utf_16_be_nosig,
intern ("coding-category-utf-16-be-nosig"));
intern_c_string ("coding-category-utf-16-be-nosig"));
ASET (Vcoding_category_table, coding_category_utf_16_le_nosig,
intern ("coding-category-utf-16-le-nosig"));
intern_c_string ("coding-category-utf-16-le-nosig"));
ASET (Vcoding_category_table, coding_category_charset,
intern ("coding-category-charset"));
intern_c_string ("coding-category-charset"));
ASET (Vcoding_category_table, coding_category_sjis,
intern ("coding-category-sjis"));
intern_c_string ("coding-category-sjis"));
ASET (Vcoding_category_table, coding_category_big5,
intern ("coding-category-big5"));
intern_c_string ("coding-category-big5"));
ASET (Vcoding_category_table, coding_category_ccl,
intern ("coding-category-ccl"));
intern_c_string ("coding-category-ccl"));
ASET (Vcoding_category_table, coding_category_emacs_mule,
intern ("coding-category-emacs-mule"));
intern_c_string ("coding-category-emacs-mule"));
/* Followings are NOT target of code detection. */
ASET (Vcoding_category_table, coding_category_raw_text,
intern ("coding-category-raw-text"));
intern_c_string ("coding-category-raw-text"));
ASET (Vcoding_category_table, coding_category_undecided,
intern ("coding-category-undecided"));
intern_c_string ("coding-category-undecided"));
DEFSYM (Qinsufficient_source, "insufficient-source");
DEFSYM (Qinconsistent_eol, "inconsistent-eol");
@ -10751,22 +10751,22 @@ Also used for decoding keyboard input on X Window system. */);
DEFVAR_LISP ("eol-mnemonic-unix", &eol_mnemonic_unix,
doc: /*
*String displayed in mode line for UNIX-like (LF) end-of-line format. */);
eol_mnemonic_unix = build_string (":");
eol_mnemonic_unix = make_pure_c_string (":");
DEFVAR_LISP ("eol-mnemonic-dos", &eol_mnemonic_dos,
doc: /*
*String displayed in mode line for DOS-like (CRLF) end-of-line format. */);
eol_mnemonic_dos = build_string ("\\");
eol_mnemonic_dos = make_pure_c_string ("\\");
DEFVAR_LISP ("eol-mnemonic-mac", &eol_mnemonic_mac,
doc: /*
*String displayed in mode line for MAC-like (CR) end-of-line format. */);
eol_mnemonic_mac = build_string ("/");
eol_mnemonic_mac = make_pure_c_string ("/");
DEFVAR_LISP ("eol-mnemonic-undecided", &eol_mnemonic_undecided,
doc: /*
*String displayed in mode line when end-of-line format is not yet determined. */);
eol_mnemonic_undecided = build_string (":");
eol_mnemonic_undecided = make_pure_c_string (":");
DEFVAR_LISP ("enable-character-translation", &Venable_character_translation,
doc: /*
@ -10891,25 +10891,25 @@ internal character representation. */);
for (i = 0; i < coding_arg_max; i++)
args[i] = Qnil;
plist[0] = intern (":name");
plist[0] = intern_c_string (":name");
plist[1] = args[coding_arg_name] = Qno_conversion;
plist[2] = intern (":mnemonic");
plist[2] = intern_c_string (":mnemonic");
plist[3] = args[coding_arg_mnemonic] = make_number ('=');
plist[4] = intern (":coding-type");
plist[4] = intern_c_string (":coding-type");
plist[5] = args[coding_arg_coding_type] = Qraw_text;
plist[6] = intern (":ascii-compatible-p");
plist[6] = intern_c_string (":ascii-compatible-p");
plist[7] = args[coding_arg_ascii_compatible_p] = Qt;
plist[8] = intern (":default-char");
plist[8] = intern_c_string (":default-char");
plist[9] = args[coding_arg_default_char] = make_number (0);
plist[10] = intern (":for-unibyte");
plist[10] = intern_c_string (":for-unibyte");
plist[11] = args[coding_arg_for_unibyte] = Qt;
plist[12] = intern (":docstring");
plist[13] = build_string ("Do no conversion.\n\
plist[12] = intern_c_string (":docstring");
plist[13] = make_pure_c_string ("Do no conversion.\n\
\n\
When you visit a file with this coding, the file is read into a\n\
unibyte buffer as is, thus each byte of a file is treated as a\n\
character.");
plist[14] = intern (":eol-type");
plist[14] = intern_c_string (":eol-type");
plist[15] = args[coding_arg_eol_type] = Qunix;
args[coding_arg_plist] = Flist (16, plist);
Fdefine_coding_system_internal (coding_arg_max, args);
@ -10919,10 +10919,10 @@ character.");
plist[5] = args[coding_arg_coding_type] = Qundecided;
/* This is already set.
plist[7] = args[coding_arg_ascii_compatible_p] = Qt; */
plist[8] = intern (":charset-list");
plist[8] = intern_c_string (":charset-list");
plist[9] = args[coding_arg_charset_list] = Fcons (Qascii, Qnil);
plist[11] = args[coding_arg_for_unibyte] = Qnil;
plist[13] = build_string ("No conversion on encoding, automatic conversion on decoding.");
plist[13] = make_pure_c_string ("No conversion on encoding, automatic conversion on decoding.");
plist[15] = args[coding_arg_eol_type] = Qnil;
args[coding_arg_plist] = Flist (16, plist);
Fdefine_coding_system_internal (coding_arg_max, args);

8
src/composite.c
View file

@ -1711,7 +1711,7 @@ syms_of_composite ()
{
int i;
Qcomposition = intern ("composition");
Qcomposition = intern_c_string ("composition");
staticpro (&Qcomposition);
/* Make a hash table for static composition. */
@ -1772,12 +1772,12 @@ inserted or deleted to keep `composition' property of buffer text
valid.
The default value is the function `compose-chars-after'. */);
Vcompose_chars_after_function = intern ("compose-chars-after");
Vcompose_chars_after_function = intern_c_string ("compose-chars-after");
Qauto_composed = intern ("auto-composed");
Qauto_composed = intern_c_string ("auto-composed");
staticpro (&Qauto_composed);
Qauto_composition_function = intern ("auto-composition-function");
Qauto_composition_function = intern_c_string ("auto-composition-function");
staticpro (&Qauto_composition_function);
DEFVAR_LISP ("auto-composition-function", &Vauto_composition_function,

262
src/data.c
View file

@ -2860,208 +2860,208 @@ syms_of_data ()
{
Lisp_Object error_tail, arith_tail;
Qquote = intern ("quote");
Qlambda = intern ("lambda");
Qsubr = intern ("subr");
Qerror_conditions = intern ("error-conditions");
Qerror_message = intern ("error-message");
Qtop_level = intern ("top-level");
Qquote = intern_c_string ("quote");
Qlambda = intern_c_string ("lambda");
Qsubr = intern_c_string ("subr");
Qerror_conditions = intern_c_string ("error-conditions");
Qerror_message = intern_c_string ("error-message");
Qtop_level = intern_c_string ("top-level");
Qerror = intern ("error");
Qquit = intern ("quit");
Qwrong_type_argument = intern ("wrong-type-argument");
Qargs_out_of_range = intern ("args-out-of-range");
Qvoid_function = intern ("void-function");
Qcyclic_function_indirection = intern ("cyclic-function-indirection");
Qcyclic_variable_indirection = intern ("cyclic-variable-indirection");
Qvoid_variable = intern ("void-variable");
Qsetting_constant = intern ("setting-constant");
Qinvalid_read_syntax = intern ("invalid-read-syntax");
Qerror = intern_c_string ("error");
Qquit = intern_c_string ("quit");
Qwrong_type_argument = intern_c_string ("wrong-type-argument");
Qargs_out_of_range = intern_c_string ("args-out-of-range");
Qvoid_function = intern_c_string ("void-function");
Qcyclic_function_indirection = intern_c_string ("cyclic-function-indirection");
Qcyclic_variable_indirection = intern_c_string ("cyclic-variable-indirection");
Qvoid_variable = intern_c_string ("void-variable");
Qsetting_constant = intern_c_string ("setting-constant");
Qinvalid_read_syntax = intern_c_string ("invalid-read-syntax");
Qinvalid_function = intern ("invalid-function");
Qwrong_number_of_arguments = intern ("wrong-number-of-arguments");
Qno_catch = intern ("no-catch");
Qend_of_file = intern ("end-of-file");
Qarith_error = intern ("arith-error");
Qbeginning_of_buffer = intern ("beginning-of-buffer");
Qend_of_buffer = intern ("end-of-buffer");
Qbuffer_read_only = intern ("buffer-read-only");
Qtext_read_only = intern ("text-read-only");
Qmark_inactive = intern ("mark-inactive");
Qinvalid_function = intern_c_string ("invalid-function");
Qwrong_number_of_arguments = intern_c_string ("wrong-number-of-arguments");
Qno_catch = intern_c_string ("no-catch");
Qend_of_file = intern_c_string ("end-of-file");
Qarith_error = intern_c_string ("arith-error");
Qbeginning_of_buffer = intern_c_string ("beginning-of-buffer");
Qend_of_buffer = intern_c_string ("end-of-buffer");
Qbuffer_read_only = intern_c_string ("buffer-read-only");
Qtext_read_only = intern_c_string ("text-read-only");
Qmark_inactive = intern_c_string ("mark-inactive");
Qlistp = intern ("listp");
Qconsp = intern ("consp");
Qsymbolp = intern ("symbolp");
Qkeywordp = intern ("keywordp");
Qintegerp = intern ("integerp");
Qnatnump = intern ("natnump");
Qwholenump = intern ("wholenump");
Qstringp = intern ("stringp");
Qarrayp = intern ("arrayp");
Qsequencep = intern ("sequencep");
Qbufferp = intern ("bufferp");
Qvectorp = intern ("vectorp");
Qchar_or_string_p = intern ("char-or-string-p");
Qmarkerp = intern ("markerp");
Qbuffer_or_string_p = intern ("buffer-or-string-p");
Qinteger_or_marker_p = intern ("integer-or-marker-p");
Qboundp = intern ("boundp");
Qfboundp = intern ("fboundp");
Qlistp = intern_c_string ("listp");
Qconsp = intern_c_string ("consp");
Qsymbolp = intern_c_string ("symbolp");
Qkeywordp = intern_c_string ("keywordp");
Qintegerp = intern_c_string ("integerp");
Qnatnump = intern_c_string ("natnump");
Qwholenump = intern_c_string ("wholenump");
Qstringp = intern_c_string ("stringp");
Qarrayp = intern_c_string ("arrayp");
Qsequencep = intern_c_string ("sequencep");
Qbufferp = intern_c_string ("bufferp");
Qvectorp = intern_c_string ("vectorp");
Qchar_or_string_p = intern_c_string ("char-or-string-p");
Qmarkerp = intern_c_string ("markerp");
Qbuffer_or_string_p = intern_c_string ("buffer-or-string-p");
Qinteger_or_marker_p = intern_c_string ("integer-or-marker-p");
Qboundp = intern_c_string ("boundp");
Qfboundp = intern_c_string ("fboundp");
Qfloatp = intern ("floatp");
Qnumberp = intern ("numberp");
Qnumber_or_marker_p = intern ("number-or-marker-p");
Qfloatp = intern_c_string ("floatp");
Qnumberp = intern_c_string ("numberp");
Qnumber_or_marker_p = intern_c_string ("number-or-marker-p");
Qchar_table_p = intern ("char-table-p");
Qvector_or_char_table_p = intern ("vector-or-char-table-p");
Qchar_table_p = intern_c_string ("char-table-p");
Qvector_or_char_table_p = intern_c_string ("vector-or-char-table-p");
Qsubrp = intern ("subrp");
Qunevalled = intern ("unevalled");
Qmany = intern ("many");
Qsubrp = intern_c_string ("subrp");
Qunevalled = intern_c_string ("unevalled");
Qmany = intern_c_string ("many");
Qcdr = intern ("cdr");
Qcdr = intern_c_string ("cdr");
/* Handle automatic advice activation */
Qad_advice_info = intern ("ad-advice-info");
Qad_activate_internal = intern ("ad-activate-internal");
Qad_advice_info = intern_c_string ("ad-advice-info");
Qad_activate_internal = intern_c_string ("ad-activate-internal");
error_tail = Fcons (Qerror, Qnil);
error_tail = pure_cons (Qerror, Qnil);
/* ERROR is used as a signaler for random errors for which nothing else is right */
Fput (Qerror, Qerror_conditions,
error_tail);
Fput (Qerror, Qerror_message,
build_string ("error"));
make_pure_c_string ("error"));
Fput (Qquit, Qerror_conditions,
Fcons (Qquit, Qnil));
pure_cons (Qquit, Qnil));
Fput (Qquit, Qerror_message,
build_string ("Quit"));
make_pure_c_string ("Quit"));
Fput (Qwrong_type_argument, Qerror_conditions,
Fcons (Qwrong_type_argument, error_tail));
pure_cons (Qwrong_type_argument, error_tail));
Fput (Qwrong_type_argument, Qerror_message,
build_string ("Wrong type argument"));
make_pure_c_string ("Wrong type argument"));
Fput (Qargs_out_of_range, Qerror_conditions,
Fcons (Qargs_out_of_range, error_tail));
pure_cons (Qargs_out_of_range, error_tail));
Fput (Qargs_out_of_range, Qerror_message,
build_string ("Args out of range"));
make_pure_c_string ("Args out of range"));
Fput (Qvoid_function, Qerror_conditions,
Fcons (Qvoid_function, error_tail));
pure_cons (Qvoid_function, error_tail));
Fput (Qvoid_function, Qerror_message,
build_string ("Symbol's function definition is void"));
make_pure_c_string ("Symbol's function definition is void"));
Fput (Qcyclic_function_indirection, Qerror_conditions,
Fcons (Qcyclic_function_indirection, error_tail));
pure_cons (Qcyclic_function_indirection, error_tail));
Fput (Qcyclic_function_indirection, Qerror_message,
build_string ("Symbol's chain of function indirections contains a loop"));
make_pure_c_string ("Symbol's chain of function indirections contains a loop"));
Fput (Qcyclic_variable_indirection, Qerror_conditions,
Fcons (Qcyclic_variable_indirection, error_tail));
pure_cons (Qcyclic_variable_indirection, error_tail));
Fput (Qcyclic_variable_indirection, Qerror_message,
build_string ("Symbol's chain of variable indirections contains a loop"));
make_pure_c_string ("Symbol's chain of variable indirections contains a loop"));
Qcircular_list = intern ("circular-list");
Qcircular_list = intern_c_string ("circular-list");
staticpro (&Qcircular_list);
Fput (Qcircular_list, Qerror_conditions,
Fcons (Qcircular_list, error_tail));
pure_cons (Qcircular_list, error_tail));
Fput (Qcircular_list, Qerror_message,
build_string ("List contains a loop"));
make_pure_c_string ("List contains a loop"));
Fput (Qvoid_variable, Qerror_conditions,
Fcons (Qvoid_variable, error_tail));
pure_cons (Qvoid_variable, error_tail));
Fput (Qvoid_variable, Qerror_message,
build_string ("Symbol's value as variable is void"));
make_pure_c_string ("Symbol's value as variable is void"));
Fput (Qsetting_constant, Qerror_conditions,
Fcons (Qsetting_constant, error_tail));
pure_cons (Qsetting_constant, error_tail));
Fput (Qsetting_constant, Qerror_message,
build_string ("Attempt to set a constant symbol"));
make_pure_c_string ("Attempt to set a constant symbol"));
Fput (Qinvalid_read_syntax, Qerror_conditions,
Fcons (Qinvalid_read_syntax, error_tail));
pure_cons (Qinvalid_read_syntax, error_tail));
Fput (Qinvalid_read_syntax, Qerror_message,
build_string ("Invalid read syntax"));
make_pure_c_string ("Invalid read syntax"));
Fput (Qinvalid_function, Qerror_conditions,
Fcons (Qinvalid_function, error_tail));
pure_cons (Qinvalid_function, error_tail));
Fput (Qinvalid_function, Qerror_message,
build_string ("Invalid function"));
make_pure_c_string ("Invalid function"));
Fput (Qwrong_number_of_arguments, Qerror_conditions,
Fcons (Qwrong_number_of_arguments, error_tail));
pure_cons (Qwrong_number_of_arguments, error_tail));
Fput (Qwrong_number_of_arguments, Qerror_message,
build_string ("Wrong number of arguments"));
make_pure_c_string ("Wrong number of arguments"));
Fput (Qno_catch, Qerror_conditions,
Fcons (Qno_catch, error_tail));
pure_cons (Qno_catch, error_tail));
Fput (Qno_catch, Qerror_message,
build_string ("No catch for tag"));
make_pure_c_string ("No catch for tag"));
Fput (Qend_of_file, Qerror_conditions,
Fcons (Qend_of_file, error_tail));
pure_cons (Qend_of_file, error_tail));
Fput (Qend_of_file, Qerror_message,
build_string ("End of file during parsing"));
make_pure_c_string ("End of file during parsing"));
arith_tail = Fcons (Qarith_error, error_tail);
arith_tail = pure_cons (Qarith_error, error_tail);
Fput (Qarith_error, Qerror_conditions,
arith_tail);
Fput (Qarith_error, Qerror_message,
build_string ("Arithmetic error"));
make_pure_c_string ("Arithmetic error"));
Fput (Qbeginning_of_buffer, Qerror_conditions,
Fcons (Qbeginning_of_buffer, error_tail));
pure_cons (Qbeginning_of_buffer, error_tail));
Fput (Qbeginning_of_buffer, Qerror_message,
build_string ("Beginning of buffer"));
make_pure_c_string ("Beginning of buffer"));
Fput (Qend_of_buffer, Qerror_conditions,
Fcons (Qend_of_buffer, error_tail));
pure_cons (Qend_of_buffer, error_tail));
Fput (Qend_of_buffer, Qerror_message,
build_string ("End of buffer"));
make_pure_c_string ("End of buffer"));
Fput (Qbuffer_read_only, Qerror_conditions,
Fcons (Qbuffer_read_only, error_tail));
pure_cons (Qbuffer_read_only, error_tail));
Fput (Qbuffer_read_only, Qerror_message,
build_string ("Buffer is read-only"));
make_pure_c_string ("Buffer is read-only"));
Fput (Qtext_read_only, Qerror_conditions,
Fcons (Qtext_read_only, error_tail));
pure_cons (Qtext_read_only, error_tail));
Fput (Qtext_read_only, Qerror_message,
build_string ("Text is read-only"));
make_pure_c_string ("Text is read-only"));
Qrange_error = intern ("range-error");
Qdomain_error = intern ("domain-error");
Qsingularity_error = intern ("singularity-error");
Qoverflow_error = intern ("overflow-error");
Qunderflow_error = intern ("underflow-error");
Qrange_error = intern_c_string ("range-error");
Qdomain_error = intern_c_string ("domain-error");
Qsingularity_error = intern_c_string ("singularity-error");
Qoverflow_error = intern_c_string ("overflow-error");
Qunderflow_error = intern_c_string ("underflow-error");
Fput (Qdomain_error, Qerror_conditions,
Fcons (Qdomain_error, arith_tail));
pure_cons (Qdomain_error, arith_tail));
Fput (Qdomain_error, Qerror_message,
build_string ("Arithmetic domain error"));
make_pure_c_string ("Arithmetic domain error"));
Fput (Qrange_error, Qerror_conditions,
Fcons (Qrange_error, arith_tail));
pure_cons (Qrange_error, arith_tail));
Fput (Qrange_error, Qerror_message,
build_string ("Arithmetic range error"));
make_pure_c_string ("Arithmetic range error"));
Fput (Qsingularity_error, Qerror_conditions,
Fcons (Qsingularity_error, Fcons (Qdomain_error, arith_tail)));
pure_cons (Qsingularity_error, Fcons (Qdomain_error, arith_tail)));
Fput (Qsingularity_error, Qerror_message,
build_string ("Arithmetic singularity error"));
make_pure_c_string ("Arithmetic singularity error"));
Fput (Qoverflow_error, Qerror_conditions,
Fcons (Qoverflow_error, Fcons (Qdomain_error, arith_tail)));
pure_cons (Qoverflow_error, Fcons (Qdomain_error, arith_tail)));
Fput (Qoverflow_error, Qerror_message,
build_string ("Arithmetic overflow error"));
make_pure_c_string ("Arithmetic overflow error"));
Fput (Qunderflow_error, Qerror_conditions,
Fcons (Qunderflow_error, Fcons (Qdomain_error, arith_tail)));
pure_cons (Qunderflow_error, Fcons (Qdomain_error, arith_tail)));
Fput (Qunderflow_error, Qerror_message,
build_string ("Arithmetic underflow error"));
make_pure_c_string ("Arithmetic underflow error"));
staticpro (&Qrange_error);
staticpro (&Qdomain_error);
@ -3132,24 +3132,24 @@ syms_of_data ()
staticpro (&Qad_activate_internal);
/* Types that type-of returns. */
Qinteger = intern ("integer");
Qsymbol = intern ("symbol");
Qstring = intern ("string");
Qcons = intern ("cons");
Qmarker = intern ("marker");
Qoverlay = intern ("overlay");
Qfloat = intern ("float");
Qwindow_configuration = intern ("window-configuration");
Qprocess = intern ("process");
Qwindow = intern ("window");
/* Qsubr = intern ("subr"); */
Qcompiled_function = intern ("compiled-function");
Qbuffer = intern ("buffer");
Qframe = intern ("frame");
Qvector = intern ("vector");
Qchar_table = intern ("char-table");
Qbool_vector = intern ("bool-vector");
Qhash_table = intern ("hash-table");
Qinteger = intern_c_string ("integer");
Qsymbol = intern_c_string ("symbol");
Qstring = intern_c_string ("string");
Qcons = intern_c_string ("cons");
Qmarker = intern_c_string ("marker");
Qoverlay = intern_c_string ("overlay");
Qfloat = intern_c_string ("float");
Qwindow_configuration = intern_c_string ("window-configuration");
Qprocess = intern_c_string ("process");
Qwindow = intern_c_string ("window");
/* Qsubr = intern_c_string ("subr"); */
Qcompiled_function = intern_c_string ("compiled-function");
Qbuffer = intern_c_string ("buffer");
Qframe = intern_c_string ("frame");
Qvector = intern_c_string ("vector");
Qchar_table = intern_c_string ("char-table");
Qbool_vector = intern_c_string ("bool-vector");
Qhash_table = intern_c_string ("hash-table");
DEFSYM (Qfont_spec, "font-spec");
DEFSYM (Qfont_entity, "font-entity");
@ -3276,12 +3276,12 @@ syms_of_data ()
DEFVAR_LISP ("most-positive-fixnum", &Vmost_positive_fixnum,
doc: /* The largest value that is representable in a Lisp integer. */);
Vmost_positive_fixnum = make_number (MOST_POSITIVE_FIXNUM);
XSYMBOL (intern ("most-positive-fixnum"))->constant = 1;
XSYMBOL (intern_c_string ("most-positive-fixnum"))->constant = 1;
DEFVAR_LISP ("most-negative-fixnum", &Vmost_negative_fixnum,
doc: /* The smallest value that is representable in a Lisp integer. */);
Vmost_negative_fixnum = make_number (MOST_NEGATIVE_FIXNUM);
XSYMBOL (intern ("most-negative-fixnum"))->constant = 1;
XSYMBOL (intern_c_string ("most-negative-fixnum"))->constant = 1;
}
SIGTYPE

62
src/dbusbind.c
View file

@ -1972,104 +1972,104 @@ void
syms_of_dbusbind ()
{
Qdbus_init_bus = intern ("dbus-init-bus");
Qdbus_init_bus = intern_c_string ("dbus-init-bus");
staticpro (&Qdbus_init_bus);
defsubr (&Sdbus_init_bus);
Qdbus_get_unique_name = intern ("dbus-get-unique-name");
Qdbus_get_unique_name = intern_c_string ("dbus-get-unique-name");
staticpro (&Qdbus_get_unique_name);
defsubr (&Sdbus_get_unique_name);
Qdbus_call_method = intern ("dbus-call-method");
Qdbus_call_method = intern_c_string ("dbus-call-method");
staticpro (&Qdbus_call_method);
defsubr (&Sdbus_call_method);
Qdbus_call_method_asynchronously = intern ("dbus-call-method-asynchronously");
Qdbus_call_method_asynchronously = intern_c_string ("dbus-call-method-asynchronously");
staticpro (&Qdbus_call_method_asynchronously);
defsubr (&Sdbus_call_method_asynchronously);
Qdbus_method_return_internal = intern ("dbus-method-return-internal");
Qdbus_method_return_internal = intern_c_string ("dbus-method-return-internal");
staticpro (&Qdbus_method_return_internal);
defsubr (&Sdbus_method_return_internal);
Qdbus_method_error_internal = intern ("dbus-method-error-internal");
Qdbus_method_error_internal = intern_c_string ("dbus-method-error-internal");
staticpro (&Qdbus_method_error_internal);
defsubr (&Sdbus_method_error_internal);
Qdbus_send_signal = intern ("dbus-send-signal");
Qdbus_send_signal = intern_c_string ("dbus-send-signal");
staticpro (&Qdbus_send_signal);
defsubr (&Sdbus_send_signal);
Qdbus_register_signal = intern ("dbus-register-signal");
Qdbus_register_signal = intern_c_string ("dbus-register-signal");
staticpro (&Qdbus_register_signal);
defsubr (&Sdbus_register_signal);
Qdbus_register_method = intern ("dbus-register-method");
Qdbus_register_method = intern_c_string ("dbus-register-method");
staticpro (&Qdbus_register_method);
defsubr (&Sdbus_register_method);
Qdbus_error = intern ("dbus-error");
Qdbus_error = intern_c_string ("dbus-error");
staticpro (&Qdbus_error);
Fput (Qdbus_error, Qerror_conditions,
list2 (Qdbus_error, Qerror));
Fput (Qdbus_error, Qerror_message,
build_string ("D-Bus error"));
make_pure_c_string ("D-Bus error"));
QCdbus_system_bus = intern (":system");
QCdbus_system_bus = intern_c_string (":system");
staticpro (&QCdbus_system_bus);
QCdbus_session_bus = intern (":session");
QCdbus_session_bus = intern_c_string (":session");
staticpro (&QCdbus_session_bus);
QCdbus_timeout = intern (":timeout");
QCdbus_timeout = intern_c_string (":timeout");
staticpro (&QCdbus_timeout);
QCdbus_type_byte = intern (":byte");
QCdbus_type_byte = intern_c_string (":byte");
staticpro (&QCdbus_type_byte);
QCdbus_type_boolean = intern (":boolean");
QCdbus_type_boolean = intern_c_string (":boolean");
staticpro (&QCdbus_type_boolean);
QCdbus_type_int16 = intern (":int16");
QCdbus_type_int16 = intern_c_string (":int16");
staticpro (&QCdbus_type_int16);
QCdbus_type_uint16 = intern (":uint16");
QCdbus_type_uint16 = intern_c_string (":uint16");
staticpro (&QCdbus_type_uint16);
QCdbus_type_int32 = intern (":int32");
QCdbus_type_int32 = intern_c_string (":int32");
staticpro (&QCdbus_type_int32);
QCdbus_type_uint32 = intern (":uint32");
QCdbus_type_uint32 = intern_c_string (":uint32");
staticpro (&QCdbus_type_uint32);
QCdbus_type_int64 = intern (":int64");
QCdbus_type_int64 = intern_c_string (":int64");
staticpro (&QCdbus_type_int64);
QCdbus_type_uint64 = intern (":uint64");
QCdbus_type_uint64 = intern_c_string (":uint64");
staticpro (&QCdbus_type_uint64);
QCdbus_type_double = intern (":double");
QCdbus_type_double = intern_c_string (":double");
staticpro (&QCdbus_type_double);
QCdbus_type_string = intern (":string");
QCdbus_type_string = intern_c_string (":string");
staticpro (&QCdbus_type_string);
QCdbus_type_object_path = intern (":object-path");
QCdbus_type_object_path = intern_c_string (":object-path");
staticpro (&QCdbus_type_object_path);
QCdbus_type_signature = intern (":signature");
QCdbus_type_signature = intern_c_string (":signature");
staticpro (&QCdbus_type_signature);
QCdbus_type_array = intern (":array");
QCdbus_type_array = intern_c_string (":array");
staticpro (&QCdbus_type_array);
QCdbus_type_variant = intern (":variant");
QCdbus_type_variant = intern_c_string (":variant");
staticpro (&QCdbus_type_variant);
QCdbus_type_struct = intern (":struct");
QCdbus_type_struct = intern_c_string (":struct");
staticpro (&QCdbus_type_struct);
QCdbus_type_dict_entry = intern (":dict-entry");
QCdbus_type_dict_entry = intern_c_string (":dict-entry");
staticpro (&QCdbus_type_dict_entry);
DEFVAR_LISP ("dbus-registered-functions-table",
@ -2111,7 +2111,7 @@ message arrives. */);
Vdbus_debug = Qnil;
#endif
Fprovide (intern ("dbusbind"), Qnil);
Fprovide (intern_c_string ("dbusbind"), Qnil);
}

14
src/dired.c
View file

@ -1109,13 +1109,13 @@ Comparison is in lexicographic order and case is significant. */)
void
syms_of_dired ()
{
Qdirectory_files = intern ("directory-files");
Qdirectory_files_and_attributes = intern ("directory-files-and-attributes");
Qfile_name_completion = intern ("file-name-completion");
Qfile_name_all_completions = intern ("file-name-all-completions");
Qfile_attributes = intern ("file-attributes");
Qfile_attributes_lessp = intern ("file-attributes-lessp");
Qdefault_directory = intern ("default-directory");
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);

4
src/dispnew.c
View file

@ -7111,9 +7111,9 @@ syms_of_display ()
frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
staticpro (&frame_and_buffer_state);
Qdisplay_table = intern ("display-table");
Qdisplay_table = intern_c_string ("display-table");
staticpro (&Qdisplay_table);
Qredisplay_dont_pause = intern ("redisplay-dont-pause");
Qredisplay_dont_pause = intern_c_string ("redisplay-dont-pause");
staticpro (&Qredisplay_dont_pause);
DEFVAR_INT ("baud-rate", &baud_rate,

2
src/doc.c
View file

@ -954,7 +954,7 @@ a new string, without any text properties, is returned. */)
void
syms_of_doc ()
{
Qfunction_documentation = intern ("function-documentation");
Qfunction_documentation = intern_c_string ("function-documentation");
staticpro (&Qfunction_documentation);
DEFVAR_LISP ("internal-doc-file-name", &Vdoc_file_name,

8
src/editfns.c
View file

@ -4626,7 +4626,7 @@ syms_of_editfns ()
initial_tz = 0;
Qbuffer_access_fontify_functions
= intern ("buffer-access-fontify-functions");
= intern_c_string ("buffer-access-fontify-functions");
staticpro (&Qbuffer_access_fontify_functions);
DEFVAR_LISP ("inhibit-field-text-motion", &Vinhibit_field_text_motion,
@ -4647,7 +4647,7 @@ of the buffer being accessed. */);
/* Do this here, because init_buffer_once is too early--it won't work. */
Fset_buffer (Vprin1_to_string_buffer);
/* Make sure buffer-access-fontify-functions is nil in this buffer. */
Fset (Fmake_local_variable (intern ("buffer-access-fontify-functions")),
Fset (Fmake_local_variable (intern_c_string ("buffer-access-fontify-functions")),
Qnil);
Fset_buffer (obuf);
}
@ -4690,9 +4690,9 @@ functions if all the text being accessed has this property. */);
defsubr (&Sregion_end);
staticpro (&Qfield);
Qfield = intern ("field");
Qfield = intern_c_string ("field");
staticpro (&Qboundary);
Qboundary = intern ("boundary");
Qboundary = intern_c_string ("boundary");
defsubr (&Sfield_beginning);
defsubr (&Sfield_end);
defsubr (&Sfield_string);

14
src/emacs.c
View file

@ -846,8 +846,8 @@ main (int argc, char **argv)
&& initialized)
{
Lisp_Object tem, tem2;
tem = Fsymbol_value (intern ("emacs-version"));
tem2 = Fsymbol_value (intern ("emacs-copyright"));
tem = Fsymbol_value (intern_c_string ("emacs-version"));
tem2 = Fsymbol_value (intern_c_string ("emacs-copyright"));
if (!STRINGP (tem))
{
fprintf (stderr, "Invalid value of `emacs-version'\n");
@ -1436,7 +1436,7 @@ main (int argc, char **argv)
Lisp_Object old_log_max;
Lisp_Object symbol, tail;
symbol = intern ("enable-multibyte-characters");
symbol = intern_c_string ("enable-multibyte-characters");
Fset_default (symbol, Qnil);
if (initialized)
@ -1755,11 +1755,11 @@ main (int argc, char **argv)
char *file;
/* Handle -l loadup, args passed by Makefile. */
if (argmatch (argv, argc, "-l", "--load", 3, &file, &skip_args))
Vtop_level = Fcons (intern ("load"),
Vtop_level = Fcons (intern_c_string ("load"),
Fcons (build_string (file), Qnil));
/* Unless next switch is -nl, load "loadup.el" first thing. */
if (! no_loadup)
Vtop_level = Fcons (intern ("load"),
Vtop_level = Fcons (intern_c_string ("load"),
Fcons (build_string ("loadup.el"), Qnil));
}
@ -2541,7 +2541,7 @@ from the parent process and its tty file descriptors. */)
void
syms_of_emacs ()
{
Qfile_name_handler_alist = intern ("file-name-handler-alist");
Qfile_name_handler_alist = intern_c_string ("file-name-handler-alist");
staticpro (&Qfile_name_handler_alist);
#ifndef CANNOT_DUMP
@ -2575,7 +2575,7 @@ Special values:
`cygwin' compiled using the Cygwin library.
Anything else (in Emacs 23.1, the possibilities are: aix, berkeley-unix,
hpux, irix, lynxos 3.0.1, usg-unix-v) indicates some sort of Unix system. */);
Vsystem_type = intern (SYSTEM_TYPE);
Vsystem_type = intern_c_string (SYSTEM_TYPE);
DEFVAR_LISP ("system-configuration", &Vsystem_configuration,
doc: /* Value is string indicating configuration Emacs was built for.

26
src/eval.c
View file

@ -3583,42 +3583,42 @@ To prevent this happening, set `quit-flag' to nil
before making `inhibit-quit' nil. */);
Vinhibit_quit = Qnil;
Qinhibit_quit = intern ("inhibit-quit");
Qinhibit_quit = intern_c_string ("inhibit-quit");
staticpro (&Qinhibit_quit);
Qautoload = intern ("autoload");
Qautoload = intern_c_string ("autoload");
staticpro (&Qautoload);
Qdebug_on_error = intern ("debug-on-error");
Qdebug_on_error = intern_c_string ("debug-on-error");
staticpro (&Qdebug_on_error);
Qmacro = intern ("macro");
Qmacro = intern_c_string ("macro");
staticpro (&Qmacro);
Qdeclare = intern ("declare");
Qdeclare = intern_c_string ("declare");
staticpro (&Qdeclare);
/* 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 ("exit");
Qexit = intern_c_string ("exit");
staticpro (&Qexit);
Qinteractive = intern ("interactive");
Qinteractive = intern_c_string ("interactive");
staticpro (&Qinteractive);
Qcommandp = intern ("commandp");
Qcommandp = intern_c_string ("commandp");
staticpro (&Qcommandp);
Qdefun = intern ("defun");
Qdefun = intern_c_string ("defun");
staticpro (&Qdefun);
Qand_rest = intern ("&rest");
Qand_rest = intern_c_string ("&rest");
staticpro (&Qand_rest);
Qand_optional = intern ("&optional");
Qand_optional = intern_c_string ("&optional");
staticpro (&Qand_optional);
Qdebug = intern ("debug");
Qdebug = intern_c_string ("debug");
staticpro (&Qdebug);
DEFVAR_LISP ("stack-trace-on-error", &Vstack_trace_on_error,
@ -3693,7 +3693,7 @@ DECL is a list `(declare ...)' containing the declarations.
The value the function returns is not used. */);
Vmacro_declaration_function = Qnil;
Vrun_hooks = intern ("run-hooks");
Vrun_hooks = intern_c_string ("run-hooks");
staticpro (&Vrun_hooks);
staticpro (&Vautoload_queue);

106
src/fileio.c
View file

@ -5461,40 +5461,40 @@ Fread_file_name (prompt, dir, default_filename, mustmatch, initial, predicate)
void
syms_of_fileio ()
{
Qoperations = intern ("operations");
Qexpand_file_name = intern ("expand-file-name");
Qsubstitute_in_file_name = intern ("substitute-in-file-name");
Qdirectory_file_name = intern ("directory-file-name");
Qfile_name_directory = intern ("file-name-directory");
Qfile_name_nondirectory = intern ("file-name-nondirectory");
Qunhandled_file_name_directory = intern ("unhandled-file-name-directory");
Qfile_name_as_directory = intern ("file-name-as-directory");
Qcopy_file = intern ("copy-file");
Qmake_directory_internal = intern ("make-directory-internal");
Qmake_directory = intern ("make-directory");
Qdelete_directory_internal = intern ("delete-directory-internal");
Qdelete_file = intern ("delete-file");
Qrename_file = intern ("rename-file");
Qadd_name_to_file = intern ("add-name-to-file");
Qmake_symbolic_link = intern ("make-symbolic-link");
Qfile_exists_p = intern ("file-exists-p");
Qfile_executable_p = intern ("file-executable-p");
Qfile_readable_p = intern ("file-readable-p");
Qfile_writable_p = intern ("file-writable-p");
Qfile_symlink_p = intern ("file-symlink-p");
Qaccess_file = intern ("access-file");
Qfile_directory_p = intern ("file-directory-p");
Qfile_regular_p = intern ("file-regular-p");
Qfile_accessible_directory_p = intern ("file-accessible-directory-p");
Qfile_modes = intern ("file-modes");
Qset_file_modes = intern ("set-file-modes");
Qset_file_times = intern ("set-file-times");
Qfile_newer_than_file_p = intern ("file-newer-than-file-p");
Qinsert_file_contents = intern ("insert-file-contents");
Qwrite_region = intern ("write-region");
Qverify_visited_file_modtime = intern ("verify-visited-file-modtime");
Qset_visited_file_modtime = intern ("set-visited-file-modtime");
Qauto_save_coding = intern ("auto-save-coding");
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_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");
staticpro (&Qoperations);
staticpro (&Qexpand_file_name);
@ -5531,21 +5531,21 @@ syms_of_fileio ()
staticpro (&Qset_visited_file_modtime);
staticpro (&Qauto_save_coding);
Qfile_name_history = intern ("file-name-history");
Qfile_name_history = intern_c_string ("file-name-history");
Fset (Qfile_name_history, Qnil);
staticpro (&Qfile_name_history);
Qfile_error = intern ("file-error");
Qfile_error = intern_c_string ("file-error");
staticpro (&Qfile_error);
Qfile_already_exists = intern ("file-already-exists");
Qfile_already_exists = intern_c_string ("file-already-exists");
staticpro (&Qfile_already_exists);
Qfile_date_error = intern ("file-date-error");
Qfile_date_error = intern_c_string ("file-date-error");
staticpro (&Qfile_date_error);
Qexcl = intern ("excl");
Qexcl = intern_c_string ("excl");
staticpro (&Qexcl);
#ifdef DOS_NT
Qfind_buffer_file_type = intern ("find-buffer-file-type");
Qfind_buffer_file_type = intern_c_string ("find-buffer-file-type");
staticpro (&Qfind_buffer_file_type);
#endif /* DOS_NT */
@ -5565,30 +5565,30 @@ 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 ("format-decode");
Qformat_decode = intern_c_string ("format-decode");
staticpro (&Qformat_decode);
Qformat_annotate_function = intern ("format-annotate-function");
Qformat_annotate_function = intern_c_string ("format-annotate-function");
staticpro (&Qformat_annotate_function);
Qafter_insert_file_set_coding = intern ("after-insert-file-set-coding");
Qafter_insert_file_set_coding = intern_c_string ("after-insert-file-set-coding");
staticpro (&Qafter_insert_file_set_coding);
Qcar_less_than_car = intern ("car-less-than-car");
Qcar_less_than_car = intern_c_string ("car-less-than-car");
staticpro (&Qcar_less_than_car);
Fput (Qfile_error, Qerror_conditions,
list2 (Qfile_error, Qerror));
Fpurecopy (list2 (Qfile_error, Qerror)));
Fput (Qfile_error, Qerror_message,
build_string ("File error"));
make_pure_c_string ("File error"));
Fput (Qfile_already_exists, Qerror_conditions,
list3 (Qfile_already_exists, Qfile_error, Qerror));
Fpurecopy (list3 (Qfile_already_exists, Qfile_error, Qerror)));
Fput (Qfile_already_exists, Qerror_message,
build_string ("File already exists"));
make_pure_c_string ("File already exists"));
Fput (Qfile_date_error, Qerror_conditions,
list3 (Qfile_date_error, Qfile_error, Qerror));
Fpurecopy (list3 (Qfile_date_error, Qfile_error, Qerror)));
Fput (Qfile_date_error, Qerror_message,
build_string ("Cannot set file date"));
make_pure_c_string ("Cannot set file date"));
DEFVAR_LISP ("directory-sep-char", &Vdirectory_sep_char,
doc: /* Directory separator character for built-in functions that return file names.
@ -5659,7 +5659,7 @@ buffer current. */);
Vwrite_region_annotate_functions = Qnil;
staticpro (&Qwrite_region_annotate_functions);
Qwrite_region_annotate_functions
= intern ("write-region-annotate-functions");
= intern_c_string ("write-region-annotate-functions");
DEFVAR_LISP ("write-region-post-annotation-function",
&Vwrite_region_post_annotation_function,
@ -5720,8 +5720,8 @@ A non-nil value may result in data loss! */);
When non-nil, the function `move-file-to-trash' will be used by
`delete-file' and `delete-directory'. */);
delete_by_moving_to_trash = 0;
Qdelete_by_moving_to_trash = intern ("delete-by-moving-to-trash");
Qmove_file_to_trash = intern ("move-file-to-trash");
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);
defsubr (&Sfind_file_name_handler);

52
src/fns.c
View file

@ -5153,33 +5153,33 @@ void
syms_of_fns ()
{
/* Hash table stuff. */
Qhash_table_p = intern ("hash-table-p");
Qhash_table_p = intern_c_string ("hash-table-p");
staticpro (&Qhash_table_p);
Qeq = intern ("eq");
Qeq = intern_c_string ("eq");
staticpro (&Qeq);
Qeql = intern ("eql");
Qeql = intern_c_string ("eql");
staticpro (&Qeql);
Qequal = intern ("equal");
Qequal = intern_c_string ("equal");
staticpro (&Qequal);
QCtest = intern (":test");
QCtest = intern_c_string (":test");
staticpro (&QCtest);
QCsize = intern (":size");
QCsize = intern_c_string (":size");
staticpro (&QCsize);
QCrehash_size = intern (":rehash-size");
QCrehash_size = intern_c_string (":rehash-size");
staticpro (&QCrehash_size);
QCrehash_threshold = intern (":rehash-threshold");
QCrehash_threshold = intern_c_string (":rehash-threshold");
staticpro (&QCrehash_threshold);
QCweakness = intern (":weakness");
QCweakness = intern_c_string (":weakness");
staticpro (&QCweakness);
Qkey = intern ("key");
Qkey = intern_c_string ("key");
staticpro (&Qkey);
Qvalue = intern ("value");
Qvalue = intern_c_string ("value");
staticpro (&Qvalue);
Qhash_table_test = intern ("hash-table-test");
Qhash_table_test = intern_c_string ("hash-table-test");
staticpro (&Qhash_table_test);
Qkey_or_value = intern ("key-or-value");
Qkey_or_value = intern_c_string ("key-or-value");
staticpro (&Qkey_or_value);
Qkey_and_value = intern ("key-and-value");
Qkey_and_value = intern_c_string ("key-and-value");
staticpro (&Qkey_and_value);
defsubr (&Ssxhash);
@ -5199,17 +5199,17 @@ syms_of_fns ()
defsubr (&Smaphash);
defsubr (&Sdefine_hash_table_test);
Qstring_lessp = intern ("string-lessp");
Qstring_lessp = intern_c_string ("string-lessp");
staticpro (&Qstring_lessp);
Qprovide = intern ("provide");
Qprovide = intern_c_string ("provide");
staticpro (&Qprovide);
Qrequire = intern ("require");
Qrequire = intern_c_string ("require");
staticpro (&Qrequire);
Qyes_or_no_p_history = intern ("yes-or-no-p-history");
Qyes_or_no_p_history = intern_c_string ("yes-or-no-p-history");
staticpro (&Qyes_or_no_p_history);
Qcursor_in_echo_area = intern ("cursor-in-echo-area");
Qcursor_in_echo_area = intern_c_string ("cursor-in-echo-area");
staticpro (&Qcursor_in_echo_area);
Qwidget_type = intern ("widget-type");
Qwidget_type = intern_c_string ("widget-type");
staticpro (&Qwidget_type);
staticpro (&string_char_byte_cache_string);
@ -5223,18 +5223,18 @@ syms_of_fns ()
DEFVAR_LISP ("features", &Vfeatures,
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 ("emacs"), Qnil);
Qsubfeatures = intern ("subfeatures");
Vfeatures = Fcons (intern_c_string ("emacs"), Qnil);
Qsubfeatures = intern_c_string ("subfeatures");
staticpro (&Qsubfeatures);
#ifdef HAVE_LANGINFO_CODESET
Qcodeset = intern ("codeset");
Qcodeset = intern_c_string ("codeset");
staticpro (&Qcodeset);
Qdays = intern ("days");
Qdays = intern_c_string ("days");
staticpro (&Qdays);
Qmonths = intern ("months");
Qmonths = intern_c_string ("months");
staticpro (&Qmonths);
Qpaper = intern ("paper");
Qpaper = intern_c_string ("paper");
staticpro (&Qpaper);
#endif /* HAVE_LANGINFO_CODESET */

2
src/font.c
View file

@ -5062,7 +5062,7 @@ build_style_table (entry, nelement)
elt = Fmake_vector (make_number (j + 1), Qnil);
ASET (elt, 0, make_number (entry[i].numeric));
for (j = 0; entry[i].names[j]; j++)
ASET (elt, j + 1, intern (entry[i].names[j]));
ASET (elt, j + 1, intern_c_string (entry[i].names[j]));
ASET (table, i, elt);
}
return table;

4
src/fontset.c
View file

@ -2245,7 +2245,7 @@ syms_of_fontset ()
staticpro (&Vdefault_fontset);
FONTSET_ID (Vdefault_fontset) = make_number (0);
FONTSET_NAME (Vdefault_fontset)
= build_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
= make_pure_c_string ("-*-*-*-*-*-*-*-*-*-*-*-*-fontset-default");
ASET (Vfontset_table, 0, Vdefault_fontset);
next_fontset_id = 1;
@ -2291,7 +2291,7 @@ alternate fontnames (if any) are tried instead. */);
DEFVAR_LISP ("fontset-alias-alist", &Vfontset_alias_alist,
doc: /* Alist of fontset names vs the aliases. */);
Vfontset_alias_alist = Fcons (Fcons (FONTSET_NAME (Vdefault_fontset),
build_string ("fontset-default")),
make_pure_c_string ("fontset-default")),
Qnil);
DEFVAR_LISP ("vertical-centering-font-regexp",

92
src/frame.c
View file

@ -4405,101 +4405,101 @@ frame_make_pointer_visible ()
void
syms_of_frame ()
{
Qframep = intern ("framep");
Qframep = intern_c_string ("framep");
staticpro (&Qframep);
Qframe_live_p = intern ("frame-live-p");
Qframe_live_p = intern_c_string ("frame-live-p");
staticpro (&Qframe_live_p);
Qexplicit_name = intern ("explicit-name");
Qexplicit_name = intern_c_string ("explicit-name");
staticpro (&Qexplicit_name);
Qheight = intern ("height");
Qheight = intern_c_string ("height");
staticpro (&Qheight);
Qicon = intern ("icon");
Qicon = intern_c_string ("icon");
staticpro (&Qicon);
Qminibuffer = intern ("minibuffer");
Qminibuffer = intern_c_string ("minibuffer");
staticpro (&Qminibuffer);
Qmodeline = intern ("modeline");
Qmodeline = intern_c_string ("modeline");
staticpro (&Qmodeline);
Qonly = intern ("only");
Qonly = intern_c_string ("only");
staticpro (&Qonly);
Qwidth = intern ("width");
Qwidth = intern_c_string ("width");
staticpro (&Qwidth);
Qgeometry = intern ("geometry");
Qgeometry = intern_c_string ("geometry");
staticpro (&Qgeometry);
Qicon_left = intern ("icon-left");
Qicon_left = intern_c_string ("icon-left");
staticpro (&Qicon_left);
Qicon_top = intern ("icon-top");
Qicon_top = intern_c_string ("icon-top");
staticpro (&Qicon_top);
Qleft = intern ("left");
Qleft = intern_c_string ("left");
staticpro (&Qleft);
Qright = intern ("right");
Qright = intern_c_string ("right");
staticpro (&Qright);
Quser_position = intern ("user-position");
Quser_position = intern_c_string ("user-position");
staticpro (&Quser_position);
Quser_size = intern ("user-size");
Quser_size = intern_c_string ("user-size");
staticpro (&Quser_size);
Qwindow_id = intern ("window-id");
Qwindow_id = intern_c_string ("window-id");
staticpro (&Qwindow_id);
#ifdef HAVE_X_WINDOWS
Qouter_window_id = intern ("outer-window-id");
Qouter_window_id = intern_c_string ("outer-window-id");
staticpro (&Qouter_window_id);
#endif
Qparent_id = intern ("parent-id");
Qparent_id = intern_c_string ("parent-id");
staticpro (&Qparent_id);
Qx = intern ("x");
Qx = intern_c_string ("x");
staticpro (&Qx);
Qw32 = intern ("w32");
Qw32 = intern_c_string ("w32");
staticpro (&Qw32);
Qpc = intern ("pc");
Qpc = intern_c_string ("pc");
staticpro (&Qpc);
Qmac = intern ("mac");
Qmac = intern_c_string ("mac");
staticpro (&Qmac);
Qns = intern ("ns");
Qns = intern_c_string ("ns");
staticpro (&Qns);
Qvisible = intern ("visible");
Qvisible = intern_c_string ("visible");
staticpro (&Qvisible);
Qbuffer_predicate = intern ("buffer-predicate");
Qbuffer_predicate = intern_c_string ("buffer-predicate");
staticpro (&Qbuffer_predicate);
Qbuffer_list = intern ("buffer-list");
Qbuffer_list = intern_c_string ("buffer-list");
staticpro (&Qbuffer_list);
Qburied_buffer_list = intern ("buried-buffer-list");
Qburied_buffer_list = intern_c_string ("buried-buffer-list");
staticpro (&Qburied_buffer_list);
Qdisplay_type = intern ("display-type");
Qdisplay_type = intern_c_string ("display-type");
staticpro (&Qdisplay_type);
Qbackground_mode = intern ("background-mode");
Qbackground_mode = intern_c_string ("background-mode");
staticpro (&Qbackground_mode);
Qnoelisp = intern ("noelisp");
Qnoelisp = intern_c_string ("noelisp");
staticpro (&Qnoelisp);
Qtty_color_mode = intern ("tty-color-mode");
Qtty_color_mode = intern_c_string ("tty-color-mode");
staticpro (&Qtty_color_mode);
Qtty = intern ("tty");
Qtty = intern_c_string ("tty");
staticpro (&Qtty);
Qtty_type = intern ("tty-type");
Qtty_type = intern_c_string ("tty-type");
staticpro (&Qtty_type);
Qface_set_after_frame_default = intern ("face-set-after-frame-default");
Qface_set_after_frame_default = intern_c_string ("face-set-after-frame-default");
staticpro (&Qface_set_after_frame_default);
Qfullwidth = intern ("fullwidth");
Qfullwidth = intern_c_string ("fullwidth");
staticpro (&Qfullwidth);
Qfullheight = intern ("fullheight");
Qfullheight = intern_c_string ("fullheight");
staticpro (&Qfullheight);
Qfullboth = intern ("fullboth");
Qfullboth = intern_c_string ("fullboth");
staticpro (&Qfullboth);
Qmaximized = intern ("maximized");
Qmaximized = intern_c_string ("maximized");
staticpro (&Qmaximized);
Qx_resource_name = intern ("x-resource-name");
Qx_resource_name = intern_c_string ("x-resource-name");
staticpro (&Qx_resource_name);
Qx_frame_parameter = intern ("x-frame-parameter");
Qx_frame_parameter = intern_c_string ("x-frame-parameter");
staticpro (&Qx_frame_parameter);
Qterminal = intern ("terminal");
Qterminal = intern_c_string ("terminal");
staticpro (&Qterminal);
Qterminal_live_p = intern ("terminal-live-p");
Qterminal_live_p = intern_c_string ("terminal-live-p");
staticpro (&Qterminal_live_p);
#ifdef HAVE_NS
Qns_parse_geometry = intern ("ns-parse-geometry");
Qns_parse_geometry = intern_c_string ("ns-parse-geometry");
staticpro (&Qns_parse_geometry);
#endif
@ -4508,7 +4508,7 @@ syms_of_frame ()
for (i = 0; i < sizeof (frame_parms) / sizeof (frame_parms[0]); i++)
{
Lisp_Object v = intern (frame_parms[i].name);
Lisp_Object v = intern_c_string (frame_parms[i].name);
if (frame_parms[i].variable)
{
*frame_parms[i].variable = v;
@ -4613,7 +4613,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 ("delete-frame-functions");
Qdelete_frame_functions = intern_c_string ("delete-frame-functions");
staticpro (&Qdelete_frame_functions);
DEFVAR_KBOARD ("default-minibuffer-frame", Vdefault_minibuffer_frame,

12
src/fringe.c
View file

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

64
src/image.c
View file

@ -8373,7 +8373,7 @@ list; if none is loaded, the running session of Emacs won't
support the image type. Types 'pbm and 'xbm don't need to be
listed; they are always supported. */);
Vimage_library_alist = Qnil;
Fput (intern ("image-library-alist"), Qrisky_local_variable, Qt);
Fput (intern_c_string ("image-library-alist"), Qrisky_local_variable, Qt);
DEFVAR_LISP ("max-image-size", &Vmax_image_size,
doc: /* Maximum size of images.
@ -8390,105 +8390,105 @@ non-numeric, there is no explicit limit on the size of images. */);
Vimage_type_cache = Qnil;
staticpro (&Vimage_type_cache);
Qpbm = intern ("pbm");
Qpbm = intern_c_string ("pbm");
staticpro (&Qpbm);
ADD_IMAGE_TYPE (Qpbm);
Qxbm = intern ("xbm");
Qxbm = intern_c_string ("xbm");
staticpro (&Qxbm);
ADD_IMAGE_TYPE (Qxbm);
define_image_type (&xbm_type, 1);
define_image_type (&pbm_type, 1);
Qcount = intern ("count");
Qcount = intern_c_string ("count");
staticpro (&Qcount);
QCascent = intern (":ascent");
QCascent = intern_c_string (":ascent");
staticpro (&QCascent);
QCmargin = intern (":margin");
QCmargin = intern_c_string (":margin");
staticpro (&QCmargin);
QCrelief = intern (":relief");
QCrelief = intern_c_string (":relief");
staticpro (&QCrelief);
QCconversion = intern (":conversion");
QCconversion = intern_c_string (":conversion");
staticpro (&QCconversion);
QCcolor_symbols = intern (":color-symbols");
QCcolor_symbols = intern_c_string (":color-symbols");
staticpro (&QCcolor_symbols);
QCheuristic_mask = intern (":heuristic-mask");
QCheuristic_mask = intern_c_string (":heuristic-mask");
staticpro (&QCheuristic_mask);
QCindex = intern (":index");
QCindex = intern_c_string (":index");
staticpro (&QCindex);
QCmatrix = intern (":matrix");
QCmatrix = intern_c_string (":matrix");
staticpro (&QCmatrix);
QCcolor_adjustment = intern (":color-adjustment");
QCcolor_adjustment = intern_c_string (":color-adjustment");
staticpro (&QCcolor_adjustment);
QCmask = intern (":mask");
QCmask = intern_c_string (":mask");
staticpro (&QCmask);
Qlaplace = intern ("laplace");
Qlaplace = intern_c_string ("laplace");
staticpro (&Qlaplace);
Qemboss = intern ("emboss");
Qemboss = intern_c_string ("emboss");
staticpro (&Qemboss);
Qedge_detection = intern ("edge-detection");
Qedge_detection = intern_c_string ("edge-detection");
staticpro (&Qedge_detection);
Qheuristic = intern ("heuristic");
Qheuristic = intern_c_string ("heuristic");
staticpro (&Qheuristic);
Qpostscript = intern ("postscript");
Qpostscript = intern_c_string ("postscript");
staticpro (&Qpostscript);
#ifdef HAVE_GHOSTSCRIPT
ADD_IMAGE_TYPE (Qpostscript);
QCloader = intern (":loader");
QCloader = intern_c_string (":loader");
staticpro (&QCloader);
QCbounding_box = intern (":bounding-box");
QCbounding_box = intern_c_string (":bounding-box");
staticpro (&QCbounding_box);
QCpt_width = intern (":pt-width");
QCpt_width = intern_c_string (":pt-width");
staticpro (&QCpt_width);
QCpt_height = intern (":pt-height");
QCpt_height = intern_c_string (":pt-height");
staticpro (&QCpt_height);
#endif /* HAVE_GHOSTSCRIPT */
#if defined (HAVE_XPM) || defined (HAVE_NS)
Qxpm = intern ("xpm");
Qxpm = intern_c_string ("xpm");
staticpro (&Qxpm);
ADD_IMAGE_TYPE (Qxpm);
#endif
#if defined (HAVE_JPEG) || defined (HAVE_NS)
Qjpeg = intern ("jpeg");
Qjpeg = intern_c_string ("jpeg");
staticpro (&Qjpeg);
ADD_IMAGE_TYPE (Qjpeg);
#endif
#if defined (HAVE_TIFF) || defined (HAVE_NS)
Qtiff = intern ("tiff");
Qtiff = intern_c_string ("tiff");
staticpro (&Qtiff);
ADD_IMAGE_TYPE (Qtiff);
#endif
#if defined (HAVE_GIF) || defined (HAVE_NS)
Qgif = intern ("gif");
Qgif = intern_c_string ("gif");
staticpro (&Qgif);
ADD_IMAGE_TYPE (Qgif);
#endif
#if defined (HAVE_PNG) || defined (HAVE_NS)
Qpng = intern ("png");
Qpng = intern_c_string ("png");
staticpro (&Qpng);
ADD_IMAGE_TYPE (Qpng);
#endif
#if defined (HAVE_RSVG)
Qsvg = intern ("svg");
Qsvg = intern_c_string ("svg");
staticpro (&Qsvg);
ADD_IMAGE_TYPE (Qsvg);
#ifdef HAVE_NTGUI
/* Other libraries used directly by svg code. */
Qgdk_pixbuf = intern ("gdk-pixbuf");
Qgdk_pixbuf = intern_c_string ("gdk-pixbuf");
staticpro (&Qgdk_pixbuf);
Qglib = intern ("glib");
Qglib = intern_c_string ("glib");
staticpro (&Qglib);
Qgobject = intern ("gobject");
Qgobject = intern_c_string ("gobject");
staticpro (&Qgobject);
#endif /* HAVE_NTGUI */
#endif /* HAVE_RSVG */

2
src/insdel.c
View file

@ -2409,7 +2409,7 @@ syms_of_insdel ()
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 ("inhibit-modification-hooks");
Qinhibit_modification_hooks = intern_c_string ("inhibit-modification-hooks");
staticpro (&Qinhibit_modification_hooks);
defsubr (&Scombine_after_change_execute);

120
src/keyboard.c
View file

@ -11708,14 +11708,14 @@ syms_of_keyboard ()
staticpro (&Vlispy_mouse_stem);
/* Tool-bars. */
QCimage = intern (":image");
QCimage = intern_c_string (":image");
staticpro (&QCimage);
staticpro (&Qhelp_echo);
Qhelp_echo = intern ("help-echo");
Qhelp_echo = intern_c_string ("help-echo");
staticpro (&Qrtl);
Qrtl = intern (":rtl");
Qrtl = intern_c_string (":rtl");
staticpro (&item_properties);
item_properties = Qnil;
@ -11728,135 +11728,135 @@ syms_of_keyboard ()
staticpro (&real_this_command);
real_this_command = Qnil;
Qtimer_event_handler = intern ("timer-event-handler");
Qtimer_event_handler = intern_c_string ("timer-event-handler");
staticpro (&Qtimer_event_handler);
Qdisabled_command_function = intern ("disabled-command-function");
Qdisabled_command_function = intern_c_string ("disabled-command-function");
staticpro (&Qdisabled_command_function);
Qself_insert_command = intern ("self-insert-command");
Qself_insert_command = intern_c_string ("self-insert-command");
staticpro (&Qself_insert_command);
Qforward_char = intern ("forward-char");
Qforward_char = intern_c_string ("forward-char");
staticpro (&Qforward_char);
Qbackward_char = intern ("backward-char");
Qbackward_char = intern_c_string ("backward-char");
staticpro (&Qbackward_char);
Qdisabled = intern ("disabled");
Qdisabled = intern_c_string ("disabled");
staticpro (&Qdisabled);
Qundefined = intern ("undefined");
Qundefined = intern_c_string ("undefined");
staticpro (&Qundefined);
Qpre_command_hook = intern ("pre-command-hook");
Qpre_command_hook = intern_c_string ("pre-command-hook");
staticpro (&Qpre_command_hook);
Qpost_command_hook = intern ("post-command-hook");
Qpost_command_hook = intern_c_string ("post-command-hook");
staticpro (&Qpost_command_hook);
Qdeferred_action_function = intern ("deferred-action-function");
Qdeferred_action_function = intern_c_string ("deferred-action-function");
staticpro (&Qdeferred_action_function);
Qcommand_hook_internal = intern ("command-hook-internal");
Qcommand_hook_internal = intern_c_string ("command-hook-internal");
staticpro (&Qcommand_hook_internal);
Qfunction_key = intern ("function-key");
Qfunction_key = intern_c_string ("function-key");
staticpro (&Qfunction_key);
Qmouse_click = intern ("mouse-click");
Qmouse_click = intern_c_string ("mouse-click");
staticpro (&Qmouse_click);
#if defined (WINDOWSNT)
Qlanguage_change = intern ("language-change");
Qlanguage_change = intern_c_string ("language-change");
staticpro (&Qlanguage_change);
#endif
Qdrag_n_drop = intern ("drag-n-drop");
Qdrag_n_drop = intern_c_string ("drag-n-drop");
staticpro (&Qdrag_n_drop);
Qsave_session = intern ("save-session");
Qsave_session = intern_c_string ("save-session");
staticpro (&Qsave_session);
#ifdef HAVE_DBUS
Qdbus_event = intern ("dbus-event");
Qdbus_event = intern_c_string ("dbus-event");
staticpro (&Qdbus_event);
#endif
Qmenu_enable = intern ("menu-enable");
Qmenu_enable = intern_c_string ("menu-enable");
staticpro (&Qmenu_enable);
QCenable = intern (":enable");
QCenable = intern_c_string (":enable");
staticpro (&QCenable);
QCvisible = intern (":visible");
QCvisible = intern_c_string (":visible");
staticpro (&QCvisible);
QChelp = intern (":help");
QChelp = intern_c_string (":help");
staticpro (&QChelp);
QCfilter = intern (":filter");
QCfilter = intern_c_string (":filter");
staticpro (&QCfilter);
QCbutton = intern (":button");
QCbutton = intern_c_string (":button");
staticpro (&QCbutton);
QCkeys = intern (":keys");
QCkeys = intern_c_string (":keys");
staticpro (&QCkeys);
QCkey_sequence = intern (":key-sequence");
QCkey_sequence = intern_c_string (":key-sequence");
staticpro (&QCkey_sequence);
QCtoggle = intern (":toggle");
QCtoggle = intern_c_string (":toggle");
staticpro (&QCtoggle);
QCradio = intern (":radio");
QCradio = intern_c_string (":radio");
staticpro (&QCradio);
Qmode_line = intern ("mode-line");
Qmode_line = intern_c_string ("mode-line");
staticpro (&Qmode_line);
Qvertical_line = intern ("vertical-line");
Qvertical_line = intern_c_string ("vertical-line");
staticpro (&Qvertical_line);
Qvertical_scroll_bar = intern ("vertical-scroll-bar");
Qvertical_scroll_bar = intern_c_string ("vertical-scroll-bar");
staticpro (&Qvertical_scroll_bar);
Qmenu_bar = intern ("menu-bar");
Qmenu_bar = intern_c_string ("menu-bar");
staticpro (&Qmenu_bar);
#if defined (HAVE_MOUSE) || defined (HAVE_GPM)
Qmouse_fixup_help_message = intern ("mouse-fixup-help-message");
Qmouse_fixup_help_message = intern_c_string ("mouse-fixup-help-message");
staticpro (&Qmouse_fixup_help_message);
#endif
Qabove_handle = intern ("above-handle");
Qabove_handle = intern_c_string ("above-handle");
staticpro (&Qabove_handle);
Qhandle = intern ("handle");
Qhandle = intern_c_string ("handle");
staticpro (&Qhandle);
Qbelow_handle = intern ("below-handle");
Qbelow_handle = intern_c_string ("below-handle");
staticpro (&Qbelow_handle);
Qup = intern ("up");
Qup = intern_c_string ("up");
staticpro (&Qup);
Qdown = intern ("down");
Qdown = intern_c_string ("down");
staticpro (&Qdown);
Qtop = intern ("top");
Qtop = intern_c_string ("top");
staticpro (&Qtop);
Qbottom = intern ("bottom");
Qbottom = intern_c_string ("bottom");
staticpro (&Qbottom);
Qend_scroll = intern ("end-scroll");
Qend_scroll = intern_c_string ("end-scroll");
staticpro (&Qend_scroll);
Qratio = intern ("ratio");
Qratio = intern_c_string ("ratio");
staticpro (&Qratio);
Qevent_kind = intern ("event-kind");
Qevent_kind = intern_c_string ("event-kind");
staticpro (&Qevent_kind);
Qevent_symbol_elements = intern ("event-symbol-elements");
Qevent_symbol_elements = intern_c_string ("event-symbol-elements");
staticpro (&Qevent_symbol_elements);
Qevent_symbol_element_mask = intern ("event-symbol-element-mask");
Qevent_symbol_element_mask = intern_c_string ("event-symbol-element-mask");
staticpro (&Qevent_symbol_element_mask);
Qmodifier_cache = intern ("modifier-cache");
Qmodifier_cache = intern_c_string ("modifier-cache");
staticpro (&Qmodifier_cache);
Qrecompute_lucid_menubar = intern ("recompute-lucid-menubar");
Qrecompute_lucid_menubar = intern_c_string ("recompute-lucid-menubar");
staticpro (&Qrecompute_lucid_menubar);
Qactivate_menubar_hook = intern ("activate-menubar-hook");
Qactivate_menubar_hook = intern_c_string ("activate-menubar-hook");
staticpro (&Qactivate_menubar_hook);
Qpolling_period = intern ("polling-period");
Qpolling_period = intern_c_string ("polling-period");
staticpro (&Qpolling_period);
Qinput_method_function = intern ("input-method-function");
Qinput_method_function = intern_c_string ("input-method-function");
staticpro (&Qinput_method_function);
Qinput_method_exit_on_first_char = intern ("input-method-exit-on-first-char");
Qinput_method_exit_on_first_char = intern_c_string ("input-method-exit-on-first-char");
staticpro (&Qinput_method_exit_on_first_char);
Qinput_method_use_echo_area = intern ("input-method-use-echo-area");
Qinput_method_use_echo_area = intern_c_string ("input-method-use-echo-area");
staticpro (&Qinput_method_use_echo_area);
Fset (Qinput_method_exit_on_first_char, Qnil);
@ -11872,7 +11872,7 @@ syms_of_keyboard ()
p < head_table + (sizeof (head_table) / sizeof (head_table[0]));
p++)
{
*p->var = intern (p->name);
*p->var = intern_c_string (p->name);
staticpro (p->var);
Fput (*p->var, Qevent_kind, *p->kind);
Fput (*p->var, Qevent_symbol_elements, Fcons (*p->var, Qnil));
@ -11895,7 +11895,7 @@ syms_of_keyboard ()
modifier_symbols = Fmake_vector (make_number (len), Qnil);
for (i = 0; i < len; i++)
if (modifier_names[i])
XVECTOR (modifier_symbols)->contents[i] = intern (modifier_names[i]);
XVECTOR (modifier_symbols)->contents[i] = intern_c_string (modifier_names[i]);
staticpro (&modifier_symbols);
}
@ -11908,7 +11908,7 @@ syms_of_keyboard ()
raw_keybuf = Fmake_vector (make_number (30), Qnil);
staticpro (&raw_keybuf);
Qextended_command_history = intern ("extended-command-history");
Qextended_command_history = intern_c_string ("extended-command-history");
Fset (Qextended_command_history, Qnil);
staticpro (&Qextended_command_history);
@ -12211,7 +12211,7 @@ The command loop sets this to nil before each command,
and tests the value when the command returns.
Buffer modification stores t in this variable. */);
Vdeactivate_mark = Qnil;
Qdeactivate_mark = intern ("deactivate-mark");
Qdeactivate_mark = intern_c_string ("deactivate-mark");
staticpro (&Qdeactivate_mark);
DEFVAR_LISP ("command-hook-internal", &Vcommand_hook_internal,
@ -12236,7 +12236,7 @@ might happen repeatedly and make Emacs nonfunctional. */);
DEFVAR_LISP ("echo-area-clear-hook", ...,
doc: /* Normal hook run when clearing the echo area. */);
#endif
Qecho_area_clear_hook = intern ("echo-area-clear-hook");
Qecho_area_clear_hook = intern_c_string ("echo-area-clear-hook");
staticpro (&Qecho_area_clear_hook);
Fset (Qecho_area_clear_hook, Qnil);
@ -12277,7 +12277,7 @@ and the minor mode maps regardless of `overriding-local-map'. */);
DEFVAR_LISP ("special-event-map", &Vspecial_event_map,
doc: /* Keymap defining bindings for special events to execute at low level. */);
Vspecial_event_map = Fcons (intern ("keymap"), Qnil);
Vspecial_event_map = Fcons (intern_c_string ("keymap"), Qnil);
DEFVAR_LISP ("track-mouse", &do_mouse_tracking,
doc: /* *Non-nil means generate motion events for mouse motion. */);

50
src/keymap.c
View file

@ -191,7 +191,7 @@ initial_define_key (keymap, key, defname)
int key;
char *defname;
{
store_in_keymap (keymap, make_number (key), intern (defname));
store_in_keymap (keymap, make_number (key), intern_c_string (defname));
}
void
@ -200,7 +200,7 @@ initial_define_lispy_key (keymap, keyname, defname)
char *keyname;
char *defname;
{
store_in_keymap (keymap, intern (keyname), intern (defname));
store_in_keymap (keymap, intern_c_string (keyname), intern_c_string (defname));
}
DEFUN ("keymapp", Fkeymapp, Skeymapp, 1, 1, 0,
@ -3911,14 +3911,14 @@ Return list of symbols found. */)
void
syms_of_keymap ()
{
Qkeymap = intern ("keymap");
Qkeymap = intern_c_string ("keymap");
staticpro (&Qkeymap);
staticpro (&apropos_predicate);
staticpro (&apropos_accumulate);
apropos_predicate = Qnil;
apropos_accumulate = Qnil;
Qkeymap_canonicalize = intern ("keymap-canonicalize");
Qkeymap_canonicalize = intern_c_string ("keymap-canonicalize");
staticpro (&Qkeymap_canonicalize);
/* Now we are ready to set up this property, so we can
@ -3930,19 +3930,19 @@ syms_of_keymap ()
pointed to by a C variable */
global_map = Fmake_keymap (Qnil);
Fset (intern ("global-map"), global_map);
Fset (intern_c_string ("global-map"), global_map);
current_global_map = global_map;
staticpro (&global_map);
staticpro (&current_global_map);
meta_map = Fmake_keymap (Qnil);
Fset (intern ("esc-map"), meta_map);
Ffset (intern ("ESC-prefix"), meta_map);
Fset (intern_c_string ("esc-map"), meta_map);
Ffset (intern_c_string ("ESC-prefix"), meta_map);
control_x_map = Fmake_keymap (Qnil);
Fset (intern ("ctl-x-map"), control_x_map);
Ffset (intern ("Control-X-prefix"), control_x_map);
Fset (intern_c_string ("ctl-x-map"), control_x_map);
Ffset (intern_c_string ("Control-X-prefix"), control_x_map);
exclude_keys
= Fcons (Fcons (build_string ("DEL"), build_string ("\\d")),
@ -4028,37 +4028,37 @@ preferred. */);
where_is_preferred_modifier = 0;
staticpro (&Vmouse_events);
Vmouse_events = Fcons (intern ("menu-bar"),
Fcons (intern ("tool-bar"),
Fcons (intern ("header-line"),
Fcons (intern ("mode-line"),
Fcons (intern ("mouse-1"),
Fcons (intern ("mouse-2"),
Fcons (intern ("mouse-3"),
Fcons (intern ("mouse-4"),
Fcons (intern ("mouse-5"),
Vmouse_events = pure_cons (intern_c_string ("menu-bar"),
pure_cons (intern_c_string ("tool-bar"),
pure_cons (intern_c_string ("header-line"),
pure_cons (intern_c_string ("mode-line"),
pure_cons (intern_c_string ("mouse-1"),
pure_cons (intern_c_string ("mouse-2"),
pure_cons (intern_c_string ("mouse-3"),
pure_cons (intern_c_string ("mouse-4"),
pure_cons (intern_c_string ("mouse-5"),
Qnil)))))))));
Qsingle_key_description = intern ("single-key-description");
Qsingle_key_description = intern_c_string ("single-key-description");
staticpro (&Qsingle_key_description);
Qkey_description = intern ("key-description");
Qkey_description = intern_c_string ("key-description");
staticpro (&Qkey_description);
Qkeymapp = intern ("keymapp");
Qkeymapp = intern_c_string ("keymapp");
staticpro (&Qkeymapp);
Qnon_ascii = intern ("non-ascii");
Qnon_ascii = intern_c_string ("non-ascii");
staticpro (&Qnon_ascii);
Qmenu_item = intern ("menu-item");
Qmenu_item = intern_c_string ("menu-item");
staticpro (&Qmenu_item);
Qremap = intern ("remap");
Qremap = intern_c_string ("remap");
staticpro (&Qremap);
QCadvertised_binding = intern (":advertised-binding");
QCadvertised_binding = intern_c_string (":advertised-binding");
staticpro (&QCadvertised_binding);
command_remapping_vector = Fmake_vector (make_number (2), Qremap);

66
src/lread.c
View file

@ -3917,7 +3917,7 @@ init_obarray ()
XSETFASTINT (oblength, OBARRAY_SIZE);
Qnil = Fmake_symbol (make_pure_string ("nil", 3, 3, 0));
Qnil = Fmake_symbol (make_pure_c_string ("nil"));
Vobarray = Fmake_vector (oblength, make_number (0));
initial_obarray = Vobarray;
staticpro (&initial_obarray);
@ -3932,12 +3932,12 @@ init_obarray ()
tem = &XVECTOR (Vobarray)->contents[hash];
*tem = Qnil;
Qunbound = Fmake_symbol (make_pure_string ("unbound", 7, 7, 0));
Qunbound = Fmake_symbol (make_pure_c_string ("unbound"));
XSYMBOL (Qnil)->function = Qunbound;
XSYMBOL (Qunbound)->value = Qunbound;
XSYMBOL (Qunbound)->function = Qunbound;
Qt = intern ("t");
Qt = intern_c_string ("t");
XSYMBOL (Qnil)->value = Qnil;
XSYMBOL (Qnil)->plist = Qnil;
XSYMBOL (Qt)->value = Qt;
@ -3946,7 +3946,7 @@ init_obarray ()
/* Qt is correct even if CANNOT_DUMP. loadup.el will set to nil at end. */
Vpurify_flag = Qt;
Qvariable_documentation = intern ("variable-documentation");
Qvariable_documentation = intern_c_string ("variable-documentation");
staticpro (&Qvariable_documentation);
read_buffer_size = 100 + MAX_MULTIBYTE_LENGTH;
@ -3958,7 +3958,7 @@ defsubr (sname)
struct Lisp_Subr *sname;
{
Lisp_Object sym;
sym = intern (sname->symbol_name);
sym = intern_c_string (sname->symbol_name);
XSETPVECTYPE (sname, PVEC_SUBR);
XSETSUBR (XSYMBOL (sym)->function, sname);
}
@ -4349,7 +4349,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 ("load-in-progress");
Qload_in_progress = intern_c_string ("load-in-progress");
staticpro (&Qload_in_progress);
DEFVAR_LISP ("after-load-alist", &Vafter_load_alist,
@ -4463,7 +4463,7 @@ from the file, and matches them against this regular expression.
When the regular expression matches, the file is considered to be safe
to load. See also `load-dangerous-libraries'. */);
Vbytecomp_version_regexp
= build_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
= make_pure_c_string ("^;;;.\\(in Emacs version\\|bytecomp version FSF\\)");
DEFVAR_LISP ("eval-buffer-list", &Veval_buffer_list,
doc: /* List of buffers being read from by calls to `eval-buffer' and `eval-region'. */);
@ -4472,7 +4472,7 @@ to load. See also `load-dangerous-libraries'. */);
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 ("old-style-backquotes");
Qold_style_backquotes = intern_c_string ("old-style-backquotes");
staticpro (&Qold_style_backquotes);
/* Vsource_directory was initialized in init_lread. */
@ -4480,55 +4480,55 @@ to load. See also `load-dangerous-libraries'. */);
load_descriptor_list = Qnil;
staticpro (&load_descriptor_list);
Qcurrent_load_list = intern ("current-load-list");
Qcurrent_load_list = intern_c_string ("current-load-list");
staticpro (&Qcurrent_load_list);
Qstandard_input = intern ("standard-input");
Qstandard_input = intern_c_string ("standard-input");
staticpro (&Qstandard_input);
Qread_char = intern ("read-char");
Qread_char = intern_c_string ("read-char");
staticpro (&Qread_char);
Qget_file_char = intern ("get-file-char");
Qget_file_char = intern_c_string ("get-file-char");
staticpro (&Qget_file_char);
Qget_emacs_mule_file_char = intern ("get-emacs-mule-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 ("load-force-doc-strings");
Qload_force_doc_strings = intern_c_string ("load-force-doc-strings");
staticpro (&Qload_force_doc_strings);
Qbackquote = intern ("`");
Qbackquote = intern_c_string ("`");
staticpro (&Qbackquote);
Qcomma = intern (",");
Qcomma = intern_c_string (",");
staticpro (&Qcomma);
Qcomma_at = intern (",@");
Qcomma_at = intern_c_string (",@");
staticpro (&Qcomma_at);
Qcomma_dot = intern (",.");
Qcomma_dot = intern_c_string (",.");
staticpro (&Qcomma_dot);
Qinhibit_file_name_operation = intern ("inhibit-file-name-operation");
Qinhibit_file_name_operation = intern_c_string ("inhibit-file-name-operation");
staticpro (&Qinhibit_file_name_operation);
Qascii_character = intern ("ascii-character");
Qascii_character = intern_c_string ("ascii-character");
staticpro (&Qascii_character);
Qfunction = intern ("function");
Qfunction = intern_c_string ("function");
staticpro (&Qfunction);
Qload = intern ("load");
Qload = intern_c_string ("load");
staticpro (&Qload);
Qload_file_name = intern ("load-file-name");
Qload_file_name = intern_c_string ("load-file-name");
staticpro (&Qload_file_name);
Qeval_buffer_list = intern ("eval-buffer-list");
Qeval_buffer_list = intern_c_string ("eval-buffer-list");
staticpro (&Qeval_buffer_list);
Qfile_truename = intern ("file-truename");
Qfile_truename = intern_c_string ("file-truename");
staticpro (&Qfile_truename) ;
Qdo_after_load_evaluation = intern ("do-after-load-evaluation");
Qdo_after_load_evaluation = intern_c_string ("do-after-load-evaluation");
staticpro (&Qdo_after_load_evaluation) ;
staticpro (&dump_path);
@ -4541,19 +4541,19 @@ to load. See also `load-dangerous-libraries'. */);
Vloads_in_progress = Qnil;
staticpro (&Vloads_in_progress);
Qhash_table = intern ("hash-table");
Qhash_table = intern_c_string ("hash-table");
staticpro (&Qhash_table);
Qdata = intern ("data");
Qdata = intern_c_string ("data");
staticpro (&Qdata);
Qtest = intern ("test");
Qtest = intern_c_string ("test");
staticpro (&Qtest);
Qsize = intern ("size");
Qsize = intern_c_string ("size");
staticpro (&Qsize);
Qweakness = intern ("weakness");
Qweakness = intern_c_string ("weakness");
staticpro (&Qweakness);
Qrehash_size = intern ("rehash-size");
Qrehash_size = intern_c_string ("rehash-size");
staticpro (&Qrehash_size);
Qrehash_threshold = intern ("rehash-threshold");
Qrehash_threshold = intern_c_string ("rehash-threshold");
staticpro (&Qrehash_threshold);
}

4
src/macros.c
View file

@ -376,9 +376,9 @@ init_macros ()
void
syms_of_macros ()
{
Qexecute_kbd_macro = intern ("execute-kbd-macro");
Qexecute_kbd_macro = intern_c_string ("execute-kbd-macro");
staticpro (&Qexecute_kbd_macro);
Qkbd_macro_termination_hook = intern ("kbd-macro-termination-hook");
Qkbd_macro_termination_hook = intern_c_string ("kbd-macro-termination-hook");
staticpro (&Qkbd_macro_termination_hook);
defsubr (&Sstart_kbd_macro);

34
src/minibuf.c
View file

@ -2074,57 +2074,57 @@ syms_of_minibuf ()
minibuf_save_list = Qnil;
staticpro (&minibuf_save_list);
Qcompletion_ignore_case = intern ("completion-ignore-case");
Qcompletion_ignore_case = intern_c_string ("completion-ignore-case");
staticpro (&Qcompletion_ignore_case);
Qread_file_name_internal = intern ("read-file-name-internal");
Qread_file_name_internal = intern_c_string ("read-file-name-internal");
staticpro (&Qread_file_name_internal);
Qminibuffer_default = intern ("minibuffer-default");
Qminibuffer_default = intern_c_string ("minibuffer-default");
staticpro (&Qminibuffer_default);
Fset (Qminibuffer_default, Qnil);
Qminibuffer_completion_table = intern ("minibuffer-completion-table");
Qminibuffer_completion_table = intern_c_string ("minibuffer-completion-table");
staticpro (&Qminibuffer_completion_table);
Qminibuffer_completion_confirm = intern ("minibuffer-completion-confirm");
Qminibuffer_completion_confirm = intern_c_string ("minibuffer-completion-confirm");
staticpro (&Qminibuffer_completion_confirm);
Qminibuffer_completion_predicate = intern ("minibuffer-completion-predicate");
Qminibuffer_completion_predicate = intern_c_string ("minibuffer-completion-predicate");
staticpro (&Qminibuffer_completion_predicate);
staticpro (&last_minibuf_string);
last_minibuf_string = Qnil;
Quser_variable_p = intern ("user-variable-p");
Quser_variable_p = intern_c_string ("user-variable-p");
staticpro (&Quser_variable_p);
Qminibuffer_history = intern ("minibuffer-history");
Qminibuffer_history = intern_c_string ("minibuffer-history");
staticpro (&Qminibuffer_history);
Qbuffer_name_history = intern ("buffer-name-history");
Qbuffer_name_history = intern_c_string ("buffer-name-history");
staticpro (&Qbuffer_name_history);
Fset (Qbuffer_name_history, Qnil);
Qminibuffer_setup_hook = intern ("minibuffer-setup-hook");
Qminibuffer_setup_hook = intern_c_string ("minibuffer-setup-hook");
staticpro (&Qminibuffer_setup_hook);
Qminibuffer_exit_hook = intern ("minibuffer-exit-hook");
Qminibuffer_exit_hook = intern_c_string ("minibuffer-exit-hook");
staticpro (&Qminibuffer_exit_hook);
Qhistory_length = intern ("history-length");
Qhistory_length = intern_c_string ("history-length");
staticpro (&Qhistory_length);
Qcurrent_input_method = intern ("current-input-method");
Qcurrent_input_method = intern_c_string ("current-input-method");
staticpro (&Qcurrent_input_method);
Qactivate_input_method = intern ("activate-input-method");
Qactivate_input_method = intern_c_string ("activate-input-method");
staticpro (&Qactivate_input_method);
Qcase_fold_search = intern ("case-fold-search");
Qcase_fold_search = intern_c_string ("case-fold-search");
staticpro (&Qcase_fold_search);
Qread_expression_history = intern ("read-expression-history");
Qread_expression_history = intern_c_string ("read-expression-history");
staticpro (&Qread_expression_history);
DEFVAR_LISP ("read-buffer-function", &Vread_buffer_function,
@ -2257,7 +2257,7 @@ properties. */);
/* We use `intern' here instead of Qread_only to avoid
initialization-order problems. */
Vminibuffer_prompt_properties
= Fcons (intern ("read-only"), Fcons (Qt, Qnil));
= Fcons (intern_c_string ("read-only"), Fcons (Qt, Qnil));
DEFVAR_LISP ("read-expression-map", &Vread_expression_map,
doc: /* Minibuffer keymap used for reading Lisp expressions. */);

14
src/print.c
View file

@ -2386,7 +2386,7 @@ print_interval (interval, printcharfun)
void
syms_of_print ()
{
Qtemp_buffer_setup_hook = intern ("temp-buffer-setup-hook");
Qtemp_buffer_setup_hook = intern_c_string ("temp-buffer-setup-hook");
staticpro (&Qtemp_buffer_setup_hook);
DEFVAR_LISP ("standard-output", &Vstandard_output,
@ -2396,7 +2396,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 ("standard-output");
Qstandard_output = intern_c_string ("standard-output");
staticpro (&Qstandard_output);
DEFVAR_LISP ("float-output-format", &Vfloat_output_format,
@ -2416,7 +2416,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 ("float-output-format");
Qfloat_output_format = intern_c_string ("float-output-format");
staticpro (&Qfloat_output_format);
DEFVAR_LISP ("print-length", &Vprint_length,
@ -2522,16 +2522,16 @@ priorities. */);
defsubr (&Sredirect_debugging_output);
#endif
Qexternal_debugging_output = intern ("external-debugging-output");
Qexternal_debugging_output = intern_c_string ("external-debugging-output");
staticpro (&Qexternal_debugging_output);
Qprint_escape_newlines = intern ("print-escape-newlines");
Qprint_escape_newlines = intern_c_string ("print-escape-newlines");
staticpro (&Qprint_escape_newlines);
Qprint_escape_multibyte = intern ("print-escape-multibyte");
Qprint_escape_multibyte = intern_c_string ("print-escape-multibyte");
staticpro (&Qprint_escape_multibyte);
Qprint_escape_nonascii = intern ("print-escape-nonascii");
Qprint_escape_nonascii = intern_c_string ("print-escape-nonascii");
staticpro (&Qprint_escape_nonascii);
print_prune_charset_plist = Qnil;

230
src/process.c
View file

@ -7317,7 +7317,7 @@ init_process ()
const struct socket_options *sopt;
#define ADD_SUBFEATURE(key, val) \
subfeatures = Fcons (Fcons (key, Fcons (val, Qnil)), subfeatures)
subfeatures = pure_cons (pure_cons (key, pure_cons (val, Qnil)), subfeatures)
#ifdef NON_BLOCKING_CONNECT
ADD_SUBFEATURE (QCnowait, Qt);
@ -7340,9 +7340,9 @@ init_process ()
#endif
for (sopt = socket_options; sopt->name; sopt++)
subfeatures = Fcons (intern (sopt->name), subfeatures);
subfeatures = pure_cons (intern_c_string (sopt->name), subfeatures);
Fprovide (intern ("make-network-process"), subfeatures);
Fprovide (intern_c_string ("make-network-process"), subfeatures);
}
#endif /* HAVE_SOCKETS */
@ -7363,109 +7363,109 @@ init_process ()
void
syms_of_process ()
{
Qprocessp = intern ("processp");
Qprocessp = intern_c_string ("processp");
staticpro (&Qprocessp);
Qrun = intern ("run");
Qrun = intern_c_string ("run");
staticpro (&Qrun);
Qstop = intern ("stop");
Qstop = intern_c_string ("stop");
staticpro (&Qstop);
Qsignal = intern ("signal");
Qsignal = intern_c_string ("signal");
staticpro (&Qsignal);
/* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
here again.
Qexit = intern ("exit");
Qexit = intern_c_string ("exit");
staticpro (&Qexit); */
Qopen = intern ("open");
Qopen = intern_c_string ("open");
staticpro (&Qopen);
Qclosed = intern ("closed");
Qclosed = intern_c_string ("closed");
staticpro (&Qclosed);
Qconnect = intern ("connect");
Qconnect = intern_c_string ("connect");
staticpro (&Qconnect);
Qfailed = intern ("failed");
Qfailed = intern_c_string ("failed");
staticpro (&Qfailed);
Qlisten = intern ("listen");
Qlisten = intern_c_string ("listen");
staticpro (&Qlisten);
Qlocal = intern ("local");
Qlocal = intern_c_string ("local");
staticpro (&Qlocal);
Qipv4 = intern ("ipv4");
Qipv4 = intern_c_string ("ipv4");
staticpro (&Qipv4);
#ifdef AF_INET6
Qipv6 = intern ("ipv6");
Qipv6 = intern_c_string ("ipv6");
staticpro (&Qipv6);
#endif
Qdatagram = intern ("datagram");
Qdatagram = intern_c_string ("datagram");
staticpro (&Qdatagram);
QCport = intern (":port");
QCport = intern_c_string (":port");
staticpro (&QCport);
QCspeed = intern (":speed");
QCspeed = intern_c_string (":speed");
staticpro (&QCspeed);
QCprocess = intern (":process");
QCprocess = intern_c_string (":process");
staticpro (&QCprocess);
QCbytesize = intern (":bytesize");
QCbytesize = intern_c_string (":bytesize");
staticpro (&QCbytesize);
QCstopbits = intern (":stopbits");
QCstopbits = intern_c_string (":stopbits");
staticpro (&QCstopbits);
QCparity = intern (":parity");
QCparity = intern_c_string (":parity");
staticpro (&QCparity);
Qodd = intern ("odd");
Qodd = intern_c_string ("odd");
staticpro (&Qodd);
Qeven = intern ("even");
Qeven = intern_c_string ("even");
staticpro (&Qeven);
QCflowcontrol = intern (":flowcontrol");
QCflowcontrol = intern_c_string (":flowcontrol");
staticpro (&QCflowcontrol);
Qhw = intern ("hw");
Qhw = intern_c_string ("hw");
staticpro (&Qhw);
Qsw = intern ("sw");
Qsw = intern_c_string ("sw");
staticpro (&Qsw);
QCsummary = intern (":summary");
QCsummary = intern_c_string (":summary");
staticpro (&QCsummary);
Qreal = intern ("real");
Qreal = intern_c_string ("real");
staticpro (&Qreal);
Qnetwork = intern ("network");
Qnetwork = intern_c_string ("network");
staticpro (&Qnetwork);
Qserial = intern ("serial");
Qserial = intern_c_string ("serial");
staticpro (&Qserial);
QCname = intern (":name");
QCname = intern_c_string (":name");
staticpro (&QCname);
QCbuffer = intern (":buffer");
QCbuffer = intern_c_string (":buffer");
staticpro (&QCbuffer);
QChost = intern (":host");
QChost = intern_c_string (":host");
staticpro (&QChost);
QCservice = intern (":service");
QCservice = intern_c_string (":service");
staticpro (&QCservice);
QCtype = intern (":type");
QCtype = intern_c_string (":type");
staticpro (&QCtype);
QClocal = intern (":local");
QClocal = intern_c_string (":local");
staticpro (&QClocal);
QCremote = intern (":remote");
QCremote = intern_c_string (":remote");
staticpro (&QCremote);
QCcoding = intern (":coding");
QCcoding = intern_c_string (":coding");
staticpro (&QCcoding);
QCserver = intern (":server");
QCserver = intern_c_string (":server");
staticpro (&QCserver);
QCnowait = intern (":nowait");
QCnowait = intern_c_string (":nowait");
staticpro (&QCnowait);
QCsentinel = intern (":sentinel");
QCsentinel = intern_c_string (":sentinel");
staticpro (&QCsentinel);
QClog = intern (":log");
QClog = intern_c_string (":log");
staticpro (&QClog);
QCnoquery = intern (":noquery");
QCnoquery = intern_c_string (":noquery");
staticpro (&QCnoquery);
QCstop = intern (":stop");
QCstop = intern_c_string (":stop");
staticpro (&QCstop);
QCoptions = intern (":options");
QCoptions = intern_c_string (":options");
staticpro (&QCoptions);
QCplist = intern (":plist");
QCplist = intern_c_string (":plist");
staticpro (&QCplist);
Qlast_nonmenu_event = intern ("last-nonmenu-event");
Qlast_nonmenu_event = intern_c_string ("last-nonmenu-event");
staticpro (&Qlast_nonmenu_event);
staticpro (&Vprocess_alist);
@ -7473,67 +7473,67 @@ syms_of_process ()
staticpro (&deleted_pid_list);
#endif
Qeuid = intern ("euid");
Qeuid = intern_c_string ("euid");
staticpro (&Qeuid);
Qegid = intern ("egid");
Qegid = intern_c_string ("egid");
staticpro (&Qegid);
Quser = intern ("user");
Quser = intern_c_string ("user");
staticpro (&Quser);
Qgroup = intern ("group");
Qgroup = intern_c_string ("group");
staticpro (&Qgroup);
Qcomm = intern ("comm");
Qcomm = intern_c_string ("comm");
staticpro (&Qcomm);
Qstate = intern ("state");
Qstate = intern_c_string ("state");
staticpro (&Qstate);
Qppid = intern ("ppid");
Qppid = intern_c_string ("ppid");
staticpro (&Qppid);
Qpgrp = intern ("pgrp");
Qpgrp = intern_c_string ("pgrp");
staticpro (&Qpgrp);
Qsess = intern ("sess");
Qsess = intern_c_string ("sess");
staticpro (&Qsess);
Qttname = intern ("ttname");
Qttname = intern_c_string ("ttname");
staticpro (&Qttname);
Qtpgid = intern ("tpgid");
Qtpgid = intern_c_string ("tpgid");
staticpro (&Qtpgid);
Qminflt = intern ("minflt");
Qminflt = intern_c_string ("minflt");
staticpro (&Qminflt);
Qmajflt = intern ("majflt");
Qmajflt = intern_c_string ("majflt");
staticpro (&Qmajflt);
Qcminflt = intern ("cminflt");
Qcminflt = intern_c_string ("cminflt");
staticpro (&Qcminflt);
Qcmajflt = intern ("cmajflt");
Qcmajflt = intern_c_string ("cmajflt");
staticpro (&Qcmajflt);
Qutime = intern ("utime");
Qutime = intern_c_string ("utime");
staticpro (&Qutime);
Qstime = intern ("stime");
Qstime = intern_c_string ("stime");
staticpro (&Qstime);
Qtime = intern ("time");
Qtime = intern_c_string ("time");
staticpro (&Qtime);
Qcutime = intern ("cutime");
Qcutime = intern_c_string ("cutime");
staticpro (&Qcutime);
Qcstime = intern ("cstime");
Qcstime = intern_c_string ("cstime");
staticpro (&Qcstime);
Qctime = intern ("ctime");
Qctime = intern_c_string ("ctime");
staticpro (&Qctime);
Qpri = intern ("pri");
Qpri = intern_c_string ("pri");
staticpro (&Qpri);
Qnice = intern ("nice");
Qnice = intern_c_string ("nice");
staticpro (&Qnice);
Qthcount = intern ("thcount");
Qthcount = intern_c_string ("thcount");
staticpro (&Qthcount);
Qstart = intern ("start");
Qstart = intern_c_string ("start");
staticpro (&Qstart);
Qvsize = intern ("vsize");
Qvsize = intern_c_string ("vsize");
staticpro (&Qvsize);
Qrss = intern ("rss");
Qrss = intern_c_string ("rss");
staticpro (&Qrss);
Qetime = intern ("etime");
Qetime = intern_c_string ("etime");
staticpro (&Qetime);
Qpcpu = intern ("pcpu");
Qpcpu = intern_c_string ("pcpu");
staticpro (&Qpcpu);
Qpmem = intern ("pmem");
Qpmem = intern_c_string ("pmem");
staticpro (&Qpmem);
Qargs = intern ("args");
Qargs = intern_c_string ("args");
staticpro (&Qargs);
DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes,
@ -8003,75 +8003,75 @@ init_process ()
void
syms_of_process ()
{
QCtype = intern (":type");
QCtype = intern_c_string (":type");
staticpro (&QCtype);
QCname = intern (":name");
QCname = intern_c_string (":name");
staticpro (&QCname);
QCtype = intern (":type");
QCtype = intern_c_string (":type");
staticpro (&QCtype);
QCname = intern (":name");
QCname = intern_c_string (":name");
staticpro (&QCname);
Qeuid = intern ("euid");
Qeuid = intern_c_string ("euid");
staticpro (&Qeuid);
Qegid = intern ("egid");
Qegid = intern_c_string ("egid");
staticpro (&Qegid);
Quser = intern ("user");
Quser = intern_c_string ("user");
staticpro (&Quser);
Qgroup = intern ("group");
Qgroup = intern_c_string ("group");
staticpro (&Qgroup);
Qcomm = intern ("comm");
Qcomm = intern_c_string ("comm");
staticpro (&Qcomm);
Qstate = intern ("state");
Qstate = intern_c_string ("state");
staticpro (&Qstate);
Qppid = intern ("ppid");
Qppid = intern_c_string ("ppid");
staticpro (&Qppid);
Qpgrp = intern ("pgrp");
Qpgrp = intern_c_string ("pgrp");
staticpro (&Qpgrp);
Qsess = intern ("sess");
Qsess = intern_c_string ("sess");
staticpro (&Qsess);
Qttname = intern ("ttname");
Qttname = intern_c_string ("ttname");
staticpro (&Qttname);
Qtpgid = intern ("tpgid");
Qtpgid = intern_c_string ("tpgid");
staticpro (&Qtpgid);
Qminflt = intern ("minflt");
Qminflt = intern_c_string ("minflt");
staticpro (&Qminflt);
Qmajflt = intern ("majflt");
Qmajflt = intern_c_string ("majflt");
staticpro (&Qmajflt);
Qcminflt = intern ("cminflt");
Qcminflt = intern_c_string ("cminflt");
staticpro (&Qcminflt);
Qcmajflt = intern ("cmajflt");
Qcmajflt = intern_c_string ("cmajflt");
staticpro (&Qcmajflt);
Qutime = intern ("utime");
Qutime = intern_c_string ("utime");
staticpro (&Qutime);
Qstime = intern ("stime");
Qstime = intern_c_string ("stime");
staticpro (&Qstime);
Qtime = intern ("time");
Qtime = intern_c_string ("time");
staticpro (&Qtime);
Qcutime = intern ("cutime");
Qcutime = intern_c_string ("cutime");
staticpro (&Qcutime);
Qcstime = intern ("cstime");
Qcstime = intern_c_string ("cstime");
staticpro (&Qcstime);
Qctime = intern ("ctime");
Qctime = intern_c_string ("ctime");
staticpro (&Qctime);
Qpri = intern ("pri");
Qpri = intern_c_string ("pri");
staticpro (&Qpri);
Qnice = intern ("nice");
Qnice = intern_c_string ("nice");
staticpro (&Qnice);
Qthcount = intern ("thcount");
Qthcount = intern_c_string ("thcount");
staticpro (&Qthcount);
Qstart = intern ("start");
Qstart = intern_c_string ("start");
staticpro (&Qstart);
Qvsize = intern ("vsize");
Qvsize = intern_c_string ("vsize");
staticpro (&Qvsize);
Qrss = intern ("rss");
Qrss = intern_c_string ("rss");
staticpro (&Qrss);
Qetime = intern ("etime");
Qetime = intern_c_string ("etime");
staticpro (&Qetime);
Qpcpu = intern ("pcpu");
Qpcpu = intern_c_string ("pcpu");
staticpro (&Qpcpu);
Qpmem = intern ("pmem");
Qpmem = intern_c_string ("pmem");
staticpro (&Qpmem);
Qargs = intern ("args");
Qargs = intern_c_string ("args");
staticpro (&Qargs);
defsubr (&Sget_buffer_process);

12
src/search.c
View file

@ -3290,20 +3290,20 @@ syms_of_search ()
}
searchbuf_head = &searchbufs[0];
Qsearch_failed = intern ("search-failed");
Qsearch_failed = intern_c_string ("search-failed");
staticpro (&Qsearch_failed);
Qinvalid_regexp = intern ("invalid-regexp");
Qinvalid_regexp = intern_c_string ("invalid-regexp");
staticpro (&Qinvalid_regexp);
Fput (Qsearch_failed, Qerror_conditions,
Fcons (Qsearch_failed, Fcons (Qerror, Qnil)));
pure_cons (Qsearch_failed, pure_cons (Qerror, Qnil)));
Fput (Qsearch_failed, Qerror_message,
build_string ("Search failed"));
make_pure_c_string ("Search failed"));
Fput (Qinvalid_regexp, Qerror_conditions,
Fcons (Qinvalid_regexp, Fcons (Qerror, Qnil)));
pure_cons (Qinvalid_regexp, pure_cons (Qerror, Qnil)));
Fput (Qinvalid_regexp, Qerror_message,
build_string ("Invalid regexp"));
make_pure_c_string ("Invalid regexp"));
last_thing_searched = Qnil;
staticpro (&last_thing_searched);

8
src/sound.c
View file

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

14
src/syntax.c
View file

@ -3332,13 +3332,13 @@ init_syntax_once ()
Lisp_Object temp;
/* This has to be done here, before we call Fmake_char_table. */
Qsyntax_table = intern ("syntax-table");
Qsyntax_table = intern_c_string ("syntax-table");
staticpro (&Qsyntax_table);
/* Intern this now in case it isn't already done.
/* Intern_C_String this now in case it isn't already done.
Setting this variable twice is harmless.
But don't staticpro it here--that is done in alloc.c. */
Qchar_table_extra_slots = intern ("char-table-extra-slots");
Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
/* Create objects which can be shared among syntax tables. */
Vsyntax_code_object = Fmake_vector (make_number (Smax), Qnil);
@ -3418,7 +3418,7 @@ init_syntax_once ()
void
syms_of_syntax ()
{
Qsyntax_table_p = intern ("syntax-table-p");
Qsyntax_table_p = intern_c_string ("syntax-table-p");
staticpro (&Qsyntax_table_p);
staticpro (&Vsyntax_code_object);
@ -3431,12 +3431,12 @@ syms_of_syntax ()
/* Defined in regex.c */
staticpro (&re_match_object);
Qscan_error = intern ("scan-error");
Qscan_error = intern_c_string ("scan-error");
staticpro (&Qscan_error);
Fput (Qscan_error, Qerror_conditions,
Fcons (Qscan_error, Fcons (Qerror, Qnil)));
pure_cons (Qscan_error, pure_cons (Qerror, Qnil)));
Fput (Qscan_error, Qerror_message,
build_string ("Scan error"));
make_pure_c_string ("Scan error"));
DEFVAR_BOOL ("parse-sexp-ignore-comments", &parse_sexp_ignore_comments,
doc: /* Non-nil means `forward-sexp', etc., should treat comments as whitespace. */);

6
src/terminal.c
View file

@ -566,9 +566,9 @@ 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 ("delete-terminal-functions");
Qdelete_terminal_functions = intern_c_string ("delete-terminal-functions");
staticpro (&Qdelete_terminal_functions);
Qrun_hook_with_args = intern ("run-hook-with-args");
Qrun_hook_with_args = intern_c_string ("run-hook-with-args");
staticpro (&Qrun_hook_with_args);
defsubr (&Sdelete_terminal);
@ -580,7 +580,7 @@ or some time later. */);
defsubr (&Sterminal_parameter);
defsubr (&Sset_terminal_parameter);
Fprovide (intern ("multi-tty"), Qnil);
Fprovide (intern_c_string ("multi-tty"), Qnil);
}
/* arch-tag: e9af6f27-b483-47dc-bb1a-730c1c5cab03

38
src/textprop.c
View file

@ -2300,7 +2300,7 @@ inherits it if NONSTICKINESS is nil. The `front-sticky' and
`rear-nonsticky' properties of the character override NONSTICKINESS. */);
/* Text property `syntax-table' should be nonsticky by default. */
Vtext_property_default_nonsticky
= Fcons (Fcons (intern ("syntax-table"), Qt), Qnil);
= Fcons (Fcons (intern_c_string ("syntax-table"), Qt), Qnil);
staticpro (&interval_insert_behind_hooks);
staticpro (&interval_insert_in_front_hooks);
@ -2311,44 +2311,44 @@ inherits it if NONSTICKINESS is nil. The `front-sticky' and
/* Common attributes one might give text */
staticpro (&Qforeground);
Qforeground = intern ("foreground");
Qforeground = intern_c_string ("foreground");
staticpro (&Qbackground);
Qbackground = intern ("background");
Qbackground = intern_c_string ("background");
staticpro (&Qfont);
Qfont = intern ("font");
Qfont = intern_c_string ("font");
staticpro (&Qstipple);
Qstipple = intern ("stipple");
Qstipple = intern_c_string ("stipple");
staticpro (&Qunderline);
Qunderline = intern ("underline");
Qunderline = intern_c_string ("underline");
staticpro (&Qread_only);
Qread_only = intern ("read-only");
Qread_only = intern_c_string ("read-only");
staticpro (&Qinvisible);
Qinvisible = intern ("invisible");
Qinvisible = intern_c_string ("invisible");
staticpro (&Qintangible);
Qintangible = intern ("intangible");
Qintangible = intern_c_string ("intangible");
staticpro (&Qcategory);
Qcategory = intern ("category");
Qcategory = intern_c_string ("category");
staticpro (&Qlocal_map);
Qlocal_map = intern ("local-map");
Qlocal_map = intern_c_string ("local-map");
staticpro (&Qfront_sticky);
Qfront_sticky = intern ("front-sticky");
Qfront_sticky = intern_c_string ("front-sticky");
staticpro (&Qrear_nonsticky);
Qrear_nonsticky = intern ("rear-nonsticky");
Qrear_nonsticky = intern_c_string ("rear-nonsticky");
staticpro (&Qmouse_face);
Qmouse_face = intern ("mouse-face");
Qmouse_face = intern_c_string ("mouse-face");
staticpro (&Qminibuffer_prompt);
Qminibuffer_prompt = intern ("minibuffer-prompt");
Qminibuffer_prompt = intern_c_string ("minibuffer-prompt");
/* Properties that text might use to specify certain actions */
staticpro (&Qmouse_left);
Qmouse_left = intern ("mouse-left");
Qmouse_left = intern_c_string ("mouse-left");
staticpro (&Qmouse_entered);
Qmouse_entered = intern ("mouse-entered");
Qmouse_entered = intern_c_string ("mouse-entered");
staticpro (&Qpoint_left);
Qpoint_left = intern ("point-left");
Qpoint_left = intern_c_string ("point-left");
staticpro (&Qpoint_entered);
Qpoint_entered = intern ("point-entered");
Qpoint_entered = intern_c_string ("point-entered");
defsubr (&Stext_properties_at);
defsubr (&Sget_text_property);

4
src/undo.c
View file

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

4
src/w32fns.c
View file

@ -6968,9 +6968,9 @@ syms_of_w32fns ()
Fput (Qundefined_color, Qerror_conditions,
Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
Fput (Qundefined_color, Qerror_message,
build_string ("Undefined color"));
make_pure_c_string ("Undefined color"));
staticpro (&w32_grabbed_keys);
w32_grabbed_keys = Qnil;

18
src/window.c
View file

@ -7170,33 +7170,33 @@ init_window ()
void
syms_of_window ()
{
Qscroll_up = intern ("scroll-up");
Qscroll_up = intern_c_string ("scroll-up");
staticpro (&Qscroll_up);
Qscroll_down = intern ("scroll-down");
Qscroll_down = intern_c_string ("scroll-down");
staticpro (&Qscroll_down);
Qwindow_size_fixed = intern ("window-size-fixed");
Qwindow_size_fixed = intern_c_string ("window-size-fixed");
staticpro (&Qwindow_size_fixed);
Fset (Qwindow_size_fixed, Qnil);
staticpro (&Qwindow_configuration_change_hook);
Qwindow_configuration_change_hook
= intern ("window-configuration-change-hook");
= intern_c_string ("window-configuration-change-hook");
Qwindowp = intern ("windowp");
Qwindowp = intern_c_string ("windowp");
staticpro (&Qwindowp);
Qwindow_configuration_p = intern ("window-configuration-p");
Qwindow_configuration_p = intern_c_string ("window-configuration-p");
staticpro (&Qwindow_configuration_p);
Qwindow_live_p = intern ("window-live-p");
Qwindow_live_p = intern_c_string ("window-live-p");
staticpro (&Qwindow_live_p);
Qdisplay_buffer = intern ("display-buffer");
Qdisplay_buffer = intern_c_string ("display-buffer");
staticpro (&Qdisplay_buffer);
Qtemp_buffer_show_hook = intern ("temp-buffer-show-hook");
Qtemp_buffer_show_hook = intern_c_string ("temp-buffer-show-hook");
staticpro (&Qtemp_buffer_show_hook);
staticpro (&Vwindow_list);

134
src/xdisp.c
View file

@ -24619,7 +24619,7 @@ syms_of_xdisp ()
Vmessage_stack = Qnil;
staticpro (&Vmessage_stack);
Qinhibit_redisplay = intern ("inhibit-redisplay");
Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
staticpro (&Qinhibit_redisplay);
message_dolog_marker1 = Fmake_marker ();
@ -24645,133 +24645,133 @@ syms_of_xdisp ()
defsubr (&Sinvisible_p);
staticpro (&Qmenu_bar_update_hook);
Qmenu_bar_update_hook = intern ("menu-bar-update-hook");
Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
staticpro (&Qoverriding_terminal_local_map);
Qoverriding_terminal_local_map = intern ("overriding-terminal-local-map");
Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
staticpro (&Qoverriding_local_map);
Qoverriding_local_map = intern ("overriding-local-map");
Qoverriding_local_map = intern_c_string ("overriding-local-map");
staticpro (&Qwindow_scroll_functions);
Qwindow_scroll_functions = intern ("window-scroll-functions");
Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
staticpro (&Qwindow_text_change_functions);
Qwindow_text_change_functions = intern ("window-text-change-functions");
Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
staticpro (&Qredisplay_end_trigger_functions);
Qredisplay_end_trigger_functions = intern ("redisplay-end-trigger-functions");
Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
staticpro (&Qinhibit_point_motion_hooks);
Qinhibit_point_motion_hooks = intern ("inhibit-point-motion-hooks");
Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
Qeval = intern ("eval");
Qeval = intern_c_string ("eval");
staticpro (&Qeval);
QCdata = intern (":data");
QCdata = intern_c_string (":data");
staticpro (&QCdata);
Qdisplay = intern ("display");
Qdisplay = intern_c_string ("display");
staticpro (&Qdisplay);
Qspace_width = intern ("space-width");
Qspace_width = intern_c_string ("space-width");
staticpro (&Qspace_width);
Qraise = intern ("raise");
Qraise = intern_c_string ("raise");
staticpro (&Qraise);
Qslice = intern ("slice");
Qslice = intern_c_string ("slice");
staticpro (&Qslice);
Qspace = intern ("space");
Qspace = intern_c_string ("space");
staticpro (&Qspace);
Qmargin = intern ("margin");
Qmargin = intern_c_string ("margin");
staticpro (&Qmargin);
Qpointer = intern ("pointer");
Qpointer = intern_c_string ("pointer");
staticpro (&Qpointer);
Qleft_margin = intern ("left-margin");
Qleft_margin = intern_c_string ("left-margin");
staticpro (&Qleft_margin);
Qright_margin = intern ("right-margin");
Qright_margin = intern_c_string ("right-margin");
staticpro (&Qright_margin);
Qcenter = intern ("center");
Qcenter = intern_c_string ("center");
staticpro (&Qcenter);
Qline_height = intern ("line-height");
Qline_height = intern_c_string ("line-height");
staticpro (&Qline_height);
QCalign_to = intern (":align-to");
QCalign_to = intern_c_string (":align-to");
staticpro (&QCalign_to);
QCrelative_width = intern (":relative-width");
QCrelative_width = intern_c_string (":relative-width");
staticpro (&QCrelative_width);
QCrelative_height = intern (":relative-height");
QCrelative_height = intern_c_string (":relative-height");
staticpro (&QCrelative_height);
QCeval = intern (":eval");
QCeval = intern_c_string (":eval");
staticpro (&QCeval);
QCpropertize = intern (":propertize");
QCpropertize = intern_c_string (":propertize");
staticpro (&QCpropertize);
QCfile = intern (":file");
QCfile = intern_c_string (":file");
staticpro (&QCfile);
Qfontified = intern ("fontified");
Qfontified = intern_c_string ("fontified");
staticpro (&Qfontified);
Qfontification_functions = intern ("fontification-functions");
Qfontification_functions = intern_c_string ("fontification-functions");
staticpro (&Qfontification_functions);
Qtrailing_whitespace = intern ("trailing-whitespace");
Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
staticpro (&Qtrailing_whitespace);
Qescape_glyph = intern ("escape-glyph");
Qescape_glyph = intern_c_string ("escape-glyph");
staticpro (&Qescape_glyph);
Qnobreak_space = intern ("nobreak-space");
Qnobreak_space = intern_c_string ("nobreak-space");
staticpro (&Qnobreak_space);
Qimage = intern ("image");
Qimage = intern_c_string ("image");
staticpro (&Qimage);
QCmap = intern (":map");
QCmap = intern_c_string (":map");
staticpro (&QCmap);
QCpointer = intern (":pointer");
QCpointer = intern_c_string (":pointer");
staticpro (&QCpointer);
Qrect = intern ("rect");
Qrect = intern_c_string ("rect");
staticpro (&Qrect);
Qcircle = intern ("circle");
Qcircle = intern_c_string ("circle");
staticpro (&Qcircle);
Qpoly = intern ("poly");
Qpoly = intern_c_string ("poly");
staticpro (&Qpoly);
Qmessage_truncate_lines = intern ("message-truncate-lines");
Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
staticpro (&Qmessage_truncate_lines);
Qgrow_only = intern ("grow-only");
Qgrow_only = intern_c_string ("grow-only");
staticpro (&Qgrow_only);
Qinhibit_menubar_update = intern ("inhibit-menubar-update");
Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
staticpro (&Qinhibit_menubar_update);
Qinhibit_eval_during_redisplay = intern ("inhibit-eval-during-redisplay");
Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
staticpro (&Qinhibit_eval_during_redisplay);
Qposition = intern ("position");
Qposition = intern_c_string ("position");
staticpro (&Qposition);
Qbuffer_position = intern ("buffer-position");
Qbuffer_position = intern_c_string ("buffer-position");
staticpro (&Qbuffer_position);
Qobject = intern ("object");
Qobject = intern_c_string ("object");
staticpro (&Qobject);
Qbar = intern ("bar");
Qbar = intern_c_string ("bar");
staticpro (&Qbar);
Qhbar = intern ("hbar");
Qhbar = intern_c_string ("hbar");
staticpro (&Qhbar);
Qbox = intern ("box");
Qbox = intern_c_string ("box");
staticpro (&Qbox);
Qhollow = intern ("hollow");
Qhollow = intern_c_string ("hollow");
staticpro (&Qhollow);
Qhand = intern ("hand");
Qhand = intern_c_string ("hand");
staticpro (&Qhand);
Qarrow = intern ("arrow");
Qarrow = intern_c_string ("arrow");
staticpro (&Qarrow);
Qtext = intern ("text");
Qtext = intern_c_string ("text");
staticpro (&Qtext);
Qrisky_local_variable = intern ("risky-local-variable");
Qrisky_local_variable = intern_c_string ("risky-local-variable");
staticpro (&Qrisky_local_variable);
Qinhibit_free_realized_faces = intern ("inhibit-free-realized-faces");
Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
staticpro (&Qinhibit_free_realized_faces);
list_of_error = Fcons (Fcons (intern ("error"),
Fcons (intern ("void-variable"), Qnil)),
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 ("last-arrow-position");
Qlast_arrow_position = intern_c_string ("last-arrow-position");
staticpro (&Qlast_arrow_position);
Qlast_arrow_string = intern ("last-arrow-string");
Qlast_arrow_string = intern_c_string ("last-arrow-string");
staticpro (&Qlast_arrow_string);
Qoverlay_arrow_string = intern ("overlay-arrow-string");
Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
staticpro (&Qoverlay_arrow_string);
Qoverlay_arrow_bitmap = intern ("overlay-arrow-bitmap");
Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
staticpro (&Qoverlay_arrow_bitmap);
echo_buffer[0] = echo_buffer[1] = Qnil;
@ -24859,7 +24859,7 @@ See also `overlay-arrow-position'. */);
The symbols on this list are examined during redisplay to determine
where to display overlay arrows. */);
Voverlay_arrow_variable_list
= Fcons (intern ("overlay-arrow-position"), Qnil);
= Fcons (intern_c_string ("overlay-arrow-position"), Qnil);
DEFVAR_INT ("scroll-step", &scroll_step,
doc: /* *The number of lines to try scrolling a window by when point moves out.
@ -24953,12 +24953,12 @@ and is used only on frames for which no explicit name has been set
\(see `modify-frame-parameters'). */);
Vicon_title_format
= Vframe_title_format
= Fcons (intern ("multiple-frames"),
= Fcons (intern_c_string ("multiple-frames"),
Fcons (build_string ("%b"),
Fcons (Fcons (empty_unibyte_string,
Fcons (intern ("invocation-name"),
Fcons (intern_c_string ("invocation-name"),
Fcons (build_string ("@"),
Fcons (intern ("system-name"),
Fcons (intern_c_string ("system-name"),
Qnil)))),
Qnil)));
@ -25101,7 +25101,7 @@ the frame's other specifications determine how to blink the cursor off. */);
DEFVAR_BOOL ("auto-hscroll-mode", &automatic_hscrolling_p,
doc: /* *Non-nil means scroll the display automatically to make point visible. */);
automatic_hscrolling_p = 1;
Qauto_hscroll_mode = intern ("auto-hscroll-mode");
Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
staticpro (&Qauto_hscroll_mode);
DEFVAR_INT ("hscroll-margin", &hscroll_margin,
@ -25159,7 +25159,7 @@ property.
To add a prefix to non-continuation lines, use `line-prefix'. */);
Vwrap_prefix = Qnil;
staticpro (&Qwrap_prefix);
Qwrap_prefix = intern ("wrap-prefix");
Qwrap_prefix = intern_c_string ("wrap-prefix");
Fmake_variable_buffer_local (Qwrap_prefix);
DEFVAR_LISP ("line-prefix", &Vline_prefix,
@ -25173,7 +25173,7 @@ property.
To add a prefix to continuation lines, use `wrap-prefix'. */);
Vline_prefix = Qnil;
staticpro (&Qline_prefix);
Qline_prefix = intern ("line-prefix");
Qline_prefix = intern_c_string ("line-prefix");
Fmake_variable_buffer_local (Qline_prefix);
DEFVAR_BOOL ("inhibit-eval-during-redisplay", &inhibit_eval_during_redisplay,

142
src/xfaces.c
View file

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

26
src/xfns.c
View file

@ -5786,17 +5786,17 @@ syms_of_xfns ()
/* 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 ("none");
Qnone = intern_c_string ("none");
staticpro (&Qnone);
Qsuppress_icon = intern ("suppress-icon");
Qsuppress_icon = intern_c_string ("suppress-icon");
staticpro (&Qsuppress_icon);
Qundefined_color = intern ("undefined-color");
Qundefined_color = intern_c_string ("undefined-color");
staticpro (&Qundefined_color);
Qcompound_text = intern ("compound-text");
Qcompound_text = intern_c_string ("compound-text");
staticpro (&Qcompound_text);
Qcancel_timer = intern ("cancel-timer");
Qcancel_timer = intern_c_string ("cancel-timer");
staticpro (&Qcancel_timer);
Qfont_param = intern ("font-parameter");
Qfont_param = intern_c_string ("font-parameter");
staticpro (&Qfont_param);
/* This is the end of symbol initialization. */
@ -5806,9 +5806,9 @@ syms_of_xfns ()
Fput (Qundefined_color, Qerror_conditions,
Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
Fput (Qundefined_color, Qerror_message,
build_string ("Undefined color"));
make_pure_c_string ("Undefined color"));
DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
doc: /* The shape of the pointer when over text.
@ -5905,12 +5905,12 @@ The default is to just show an arrow and pressing on that arrow shows
the tool bar buttons. */);
x_gtk_whole_detached_tool_bar = 0;
Fprovide (intern ("x"), Qnil);
Fprovide (intern_c_string ("x"), Qnil);
#ifdef USE_X_TOOLKIT
Fprovide (intern ("x-toolkit"), Qnil);
Fprovide (intern_c_string ("x-toolkit"), Qnil);
#ifdef USE_MOTIF
Fprovide (intern ("motif"), Qnil);
Fprovide (intern_c_string ("motif"), Qnil);
DEFVAR_LISP ("motif-version-string", &Vmotif_version_string,
doc: /* Version info for LessTif/Motif. */);
@ -5923,8 +5923,8 @@ the tool bar buttons. */);
is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
But for a user it is a toolkit for X, and indeed, configure
accepts --with-x-toolkit=gtk. */
Fprovide (intern ("x-toolkit"), Qnil);
Fprovide (intern ("gtk"), Qnil);
Fprovide (intern_c_string ("x-toolkit"), Qnil);
Fprovide (intern_c_string ("gtk"), Qnil);
DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string,
doc: /* Version info for GTK+. */);

6
src/xmenu.c
View file

@ -2919,7 +2919,7 @@ DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_
void
syms_of_xmenu ()
{
Qdebug_on_next_call = intern ("debug-on-next-call");
Qdebug_on_next_call = intern_c_string ("debug-on-next-call");
staticpro (&Qdebug_on_next_call);
#ifdef USE_X_TOOLKIT
@ -2932,8 +2932,8 @@ syms_of_xmenu ()
#if defined (USE_GTK) || defined (USE_X_TOOLKIT)
defsubr (&Sx_menu_bar_open_internal);
Ffset (intern ("accelerate-menu"),
intern (Sx_menu_bar_open_internal.symbol_name));
Ffset (intern_c_string ("accelerate-menu"),
intern_c_string (Sx_menu_bar_open_internal.symbol_name));
#endif
#ifdef HAVE_MENUS

54
src/xselect.c
View file

@ -3010,38 +3010,38 @@ A value of 0 means wait as long as necessary. This is initialized from the
\"*selectionTimeout\" resource. */);
x_selection_timeout = 0;
QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY);
QSECONDARY = intern ("SECONDARY"); staticpro (&QSECONDARY);
QSTRING = intern ("STRING"); staticpro (&QSTRING);
QINTEGER = intern ("INTEGER"); staticpro (&QINTEGER);
QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
QTIMESTAMP = intern ("TIMESTAMP"); staticpro (&QTIMESTAMP);
QTEXT = intern ("TEXT"); staticpro (&QTEXT);
QCOMPOUND_TEXT = intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT);
QUTF8_STRING = intern ("UTF8_STRING"); staticpro (&QUTF8_STRING);
QDELETE = intern ("DELETE"); staticpro (&QDELETE);
QMULTIPLE = intern ("MULTIPLE"); staticpro (&QMULTIPLE);
QINCR = intern ("INCR"); staticpro (&QINCR);
QEMACS_TMP = intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP);
QTARGETS = intern ("TARGETS"); staticpro (&QTARGETS);
QATOM = intern ("ATOM"); staticpro (&QATOM);
QATOM_PAIR = intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR);
QNULL = intern ("NULL"); staticpro (&QNULL);
Qcompound_text_with_extensions = intern ("compound-text-with-extensions");
QPRIMARY = intern_c_string ("PRIMARY"); staticpro (&QPRIMARY);
QSECONDARY = intern_c_string ("SECONDARY"); staticpro (&QSECONDARY);
QSTRING = intern_c_string ("STRING"); staticpro (&QSTRING);
QINTEGER = intern_c_string ("INTEGER"); staticpro (&QINTEGER);
QCLIPBOARD = intern_c_string ("CLIPBOARD"); staticpro (&QCLIPBOARD);
QTIMESTAMP = intern_c_string ("TIMESTAMP"); staticpro (&QTIMESTAMP);
QTEXT = intern_c_string ("TEXT"); staticpro (&QTEXT);
QCOMPOUND_TEXT = intern_c_string ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT);
QUTF8_STRING = intern_c_string ("UTF8_STRING"); staticpro (&QUTF8_STRING);
QDELETE = intern_c_string ("DELETE"); staticpro (&QDELETE);
QMULTIPLE = intern_c_string ("MULTIPLE"); staticpro (&QMULTIPLE);
QINCR = intern_c_string ("INCR"); staticpro (&QINCR);
QEMACS_TMP = intern_c_string ("_EMACS_TMP_"); staticpro (&QEMACS_TMP);
QTARGETS = intern_c_string ("TARGETS"); staticpro (&QTARGETS);
QATOM = intern_c_string ("ATOM"); staticpro (&QATOM);
QATOM_PAIR = intern_c_string ("ATOM_PAIR"); staticpro (&QATOM_PAIR);
QNULL = intern_c_string ("NULL"); staticpro (&QNULL);
Qcompound_text_with_extensions = intern_c_string ("compound-text-with-extensions");
staticpro (&Qcompound_text_with_extensions);
#ifdef CUT_BUFFER_SUPPORT
QCUT_BUFFER0 = intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0);
QCUT_BUFFER1 = intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1);
QCUT_BUFFER2 = intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2);
QCUT_BUFFER3 = intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3);
QCUT_BUFFER4 = intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4);
QCUT_BUFFER5 = intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5);
QCUT_BUFFER6 = intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6);
QCUT_BUFFER7 = intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7);
QCUT_BUFFER0 = intern_c_string ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0);
QCUT_BUFFER1 = intern_c_string ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1);
QCUT_BUFFER2 = intern_c_string ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2);
QCUT_BUFFER3 = intern_c_string ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3);
QCUT_BUFFER4 = intern_c_string ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4);
QCUT_BUFFER5 = intern_c_string ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5);
QCUT_BUFFER6 = intern_c_string ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6);
QCUT_BUFFER7 = intern_c_string ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7);
#endif
Qforeign_selection = intern ("foreign-selection");
Qforeign_selection = intern_c_string ("foreign-selection");
staticpro (&Qforeign_selection);
}

24
src/xterm.c
View file

@ -10830,10 +10830,10 @@ syms_of_xterm ()
last_mouse_scroll_bar = Qnil;
staticpro (&Qvendor_specific_keysyms);
Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
Qvendor_specific_keysyms = intern_c_string ("vendor-specific-keysyms");
staticpro (&Qlatin_1);
Qlatin_1 = intern ("latin-1");
Qlatin_1 = intern_c_string ("latin-1");
staticpro (&last_mouse_press_frame);
last_mouse_press_frame = Qnil;
@ -10842,7 +10842,7 @@ syms_of_xterm ()
xg_default_icon_file = build_string ("icons/hicolor/scalable/apps/emacs.svg");
staticpro (&xg_default_icon_file);
Qx_gtk_map_stock = intern ("x-gtk-map-stock");
Qx_gtk_map_stock = intern_c_string ("x-gtk-map-stock");
staticpro (&Qx_gtk_map_stock);
#endif
@ -10880,13 +10880,13 @@ A value of nil means Emacs doesn't use X toolkit scroll bars.
Otherwise, value is a symbol describing the X toolkit. */);
#ifdef USE_TOOLKIT_SCROLL_BARS
#ifdef USE_MOTIF
Vx_toolkit_scroll_bars = intern ("motif");
Vx_toolkit_scroll_bars = intern_c_string ("motif");
#elif defined HAVE_XAW3D
Vx_toolkit_scroll_bars = intern ("xaw3d");
Vx_toolkit_scroll_bars = intern_c_string ("xaw3d");
#elif USE_GTK
Vx_toolkit_scroll_bars = intern ("gtk");
Vx_toolkit_scroll_bars = intern_c_string ("gtk");
#else
Vx_toolkit_scroll_bars = intern ("xaw");
Vx_toolkit_scroll_bars = intern_c_string ("xaw");
#endif
#else
Vx_toolkit_scroll_bars = Qnil;
@ -10895,14 +10895,14 @@ Otherwise, value is a symbol describing the X toolkit. */);
staticpro (&last_mouse_motion_frame);
last_mouse_motion_frame = Qnil;
Qmodifier_value = intern ("modifier-value");
Qalt = intern ("alt");
Qmodifier_value = intern_c_string ("modifier-value");
Qalt = intern_c_string ("alt");
Fput (Qalt, Qmodifier_value, make_number (alt_modifier));
Qhyper = intern ("hyper");
Qhyper = intern_c_string ("hyper");
Fput (Qhyper, Qmodifier_value, make_number (hyper_modifier));
Qmeta = intern ("meta");
Qmeta = intern_c_string ("meta");
Fput (Qmeta, Qmodifier_value, make_number (meta_modifier));
Qsuper = intern ("super");
Qsuper = intern_c_string ("super");
Fput (Qsuper, Qmodifier_value, make_number (super_modifier));
DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym,