* 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.

* 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.

51 files changed, 1054 insertions, 1003 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index cde49c410b9..a0deac67367 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -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.
 
diff --git a/src/alloc.c b/src/alloc.c
index a074bfe2d72..97c4c45733d 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -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.
diff --git a/src/buffer.c b/src/buffer.c
index 2fc7a8b3a7c..5359c7cf69c 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -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
diff --git a/src/bytecode.c b/src/bytecode.c
index 4a1e2da3556..2768ed81f99 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -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;
diff --git a/src/callint.c b/src/callint.c
index a9f8f231462..371dd55dec9 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -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,
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 112198b3225..f9f19927313 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -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);
diff --git a/src/casetab.c b/src/casetab.c
index 5ae4ee2b5f2..ca8979bdb3c 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -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);
diff --git a/src/category.c b/src/category.c
index 88337ff4fe7..7d7553411e6 100644
--- a/src/category.c
+++ b/src/category.c
@@ -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,
diff --git a/src/ccl.c b/src/ccl.c
index 03600158049..a2dcc920e45 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -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,
diff --git a/src/character.c b/src/character.c
index 33d6969be89..ff2f4a716d8 100644
--- a/src/character.c
+++ b/src/character.c
@@ -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);
diff --git a/src/charset.c b/src/charset.c
index cfdf95565a7..32d5fc52c7a 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -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);
diff --git a/src/cmds.c b/src/cmds.c
index 5b5c6de817e..69b967aa7e2 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -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,
diff --git a/src/coding.c b/src/coding.c
index 678bafaa9ea..b13766e3076 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -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);
diff --git a/src/composite.c b/src/composite.c
index a654b5e8088..f7bfc28973a 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -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,
diff --git a/src/data.c b/src/data.c
index 6d469e161db..fc50658dd7c 100644
--- a/src/data.c
+++ b/src/data.c
@@ -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");
-
-  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");
-
-  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");
-
-  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");
-
-  Qfloatp = intern ("floatp");
-  Qnumberp = intern ("numberp");
-  Qnumber_or_marker_p = intern ("number-or-marker-p");
-
-  Qchar_table_p = intern ("char-table-p");
-  Qvector_or_char_table_p = intern ("vector-or-char-table-p");
-
-  Qsubrp = intern ("subrp");
-  Qunevalled = intern ("unevalled");
-  Qmany = intern ("many");
-
-  Qcdr = intern ("cdr");
+  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_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_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_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_c_string ("floatp");
+  Qnumberp = intern_c_string ("numberp");
+  Qnumber_or_marker_p = intern_c_string ("number-or-marker-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_c_string ("subrp");
+  Qunevalled = intern_c_string ("unevalled");
+  Qmany = intern_c_string ("many");
+
+  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
diff --git a/src/dbusbind.c b/src/dbusbind.c
index c2512e687c7..10ae8700cb0 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -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);
 
 }
 
diff --git a/src/dired.c b/src/dired.c
index 5aedd045870..630693fe634 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -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);
diff --git a/src/dispnew.c b/src/dispnew.c
index ba50b001980..0039ec0d181 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -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,
diff --git a/src/doc.c b/src/doc.c
index 6a53e0d3f74..dd933909f7a 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -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,
diff --git a/src/editfns.c b/src/editfns.c
index 806e75dc0f1..8cf182dff0f 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -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);
diff --git a/src/emacs.c b/src/emacs.c
index ce34f11591b..4099a4f4795 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -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.
diff --git a/src/eval.c b/src/eval.c
index 3945a1b7a55..1c975003318 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -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);
diff --git a/src/fileio.c b/src/fileio.c
index c61604ac31d..bdab1d6180d 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -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);
diff --git a/src/fns.c b/src/fns.c
index 10d755ccea7..09bad09551d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -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 */
 
diff --git a/src/font.c b/src/font.c
index dd9b6d374be..bab3d9f821c 100644
--- a/src/font.c
+++ b/src/font.c
@@ -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;
diff --git a/src/fontset.c b/src/fontset.c
index cba84dc2458..30620e511c8 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -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",
diff --git a/src/frame.c b/src/frame.c
index 2884c16c551..b3c3b83735b 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -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,
diff --git a/src/fringe.c b/src/fringe.c
index df62bee0edc..2cea24b1dcd 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -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);
diff --git a/src/image.c b/src/image.c
index 62e69b330d0..55ceec326c4 100644
--- a/src/image.c
+++ b/src/image.c
@@ -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  */
diff --git a/src/insdel.c b/src/insdel.c
index 27901164842..bdd450558bd 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -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);
diff --git a/src/keyboard.c b/src/keyboard.c
index b7399a651b7..a6bfb08e5d8 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -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.  */);
diff --git a/src/keymap.c b/src/keymap.c
index 2dddeab998d..edf535f7610 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -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"),
-                         Qnil)))))))));
-
-
-  Qsingle_key_description = intern ("single-key-description");
+  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_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);
diff --git a/src/lread.c b/src/lread.c
index 517f14baf56..a75836f0462 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -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);
 }
 
diff --git a/src/macros.c b/src/macros.c
index 0d69b9203cf..f070df0ad34 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -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);
diff --git a/src/minibuf.c b/src/minibuf.c
index 5cf89f286a1..3c070d6fbab 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -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.  */);
diff --git a/src/print.c b/src/print.c
index f90ec27a0a4..14fed114325 100644
--- a/src/print.c
+++ b/src/print.c
@@ -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;
diff --git a/src/process.c b/src/process.c
index 7cb85d73aad..08495d2d8bd 100644
--- a/src/process.c
+++ b/src/process.c
@@ -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);
diff --git a/src/search.c b/src/search.c
index 8bfe61d5f6d..e0546f4f998 100644
--- a/src/search.c
+++ b/src/search.c
@@ -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);
diff --git a/src/sound.c b/src/sound.c
index 6f1f5385978..3747dc8a849 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -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);
diff --git a/src/syntax.c b/src/syntax.c
index 048f0ee6637..203792960ca 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -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.  */);
diff --git a/src/terminal.c b/src/terminal.c
index c89f2e60005..ad259126511 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -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
diff --git a/src/textprop.c b/src/textprop.c
index e82af12d90a..3df5cc9204d 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -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);
diff --git a/src/undo.c b/src/undo.c
index f2a37cb4083..8dcd393444c 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -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;
diff --git a/src/w32fns.c b/src/w32fns.c
index db7fdfbed9a..a99e094d9c2 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -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;
diff --git a/src/window.c b/src/window.c
index 26165e701b1..13c14e76375 100644
--- a/src/window.c
+++ b/src/window.c
@@ -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);
diff --git a/src/xdisp.c b/src/xdisp.c
index f88750447aa..5b6fdf83fe7 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -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,
diff --git a/src/xfaces.c b/src/xfaces.c
index f120dfcbb54..2b6df6406f5 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -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);
diff --git a/src/xfns.c b/src/xfns.c
index b9217617e30..8fd46fa1a0e 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -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+.  */);
diff --git a/src/xmenu.c b/src/xmenu.c
index a2c9fbaaeaf..836376646d9 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -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
diff --git a/src/xselect.c b/src/xselect.c
index 79e0c0a280b..935c441ed52 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -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);
 }
 
diff --git a/src/xterm.c b/src/xterm.c
index 16aa12abbaa..1ba367c9989 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -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,