first working example of mvc. multiple views of a slider are kept in sync

55 files changed, 912 insertions, 1565 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 78fca60ca28..e21412187c7 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,124 @@
+2011-06-25  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use gnulib's dup2 module instead of rolling our own.
+        * sysdep.c (dup2) [!HAVE_DUP2]: Remove; gnulib now does this.
+
+2011-06-25  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * dispnew.c (scrolling_window): Before scrolling, turn off a
+        mouse-highlight in the window being scrolled.
+
+2011-06-24  Juanma Barranquero  <lekktu@gmail.com>
+
+        Move DEFSYM to lisp.h and use everywhere.
+
+        * character.h (DEFSYM): Move declaration...
+        * lisp.h (DEFSYM): ...here.
+
+        * gnutls.c:
+        * minibuf.c:
+        * w32menu.c:
+        * w32proc.c:
+        * w32select.c: Don't include character.h.
+
+        * alloc.c (syms_of_alloc):
+        * buffer.c (syms_of_buffer):
+        * bytecode.c (syms_of_bytecode):
+        * callint.c (syms_of_callint):
+        * casefiddle.c (syms_of_casefiddle):
+        * casetab.c (init_casetab_once):
+        * category.c (init_category_once, syms_of_category):
+        * ccl.c (syms_of_ccl):
+        * cmds.c (syms_of_cmds):
+        * composite.c (syms_of_composite):
+        * dbusbind.c (syms_of_dbusbind):
+        * dired.c (syms_of_dired):
+        * dispnew.c (syms_of_display):
+        * doc.c (syms_of_doc):
+        * editfns.c (syms_of_editfns):
+        * emacs.c (syms_of_emacs):
+        * eval.c (syms_of_eval):
+        * fileio.c (syms_of_fileio):
+        * fns.c (syms_of_fns):
+        * frame.c (syms_of_frame):
+        * fringe.c (syms_of_fringe):
+        * insdel.c (syms_of_insdel):
+        * keymap.c (syms_of_keymap):
+        * lread.c (init_obarray, syms_of_lread):
+        * macros.c (syms_of_macros):
+        * msdos.c (syms_of_msdos):
+        * print.c (syms_of_print):
+        * process.c (syms_of_process):
+        * search.c (syms_of_search):
+        * sound.c (syms_of_sound):
+        * syntax.c (init_syntax_once, syms_of_syntax):
+        * terminal.c (syms_of_terminal):
+        * textprop.c (syms_of_textprop):
+        * undo.c (syms_of_undo):
+        * w32.c (globals_of_w32):
+        * window.c (syms_of_window):
+        * xdisp.c (syms_of_xdisp):
+        * xfaces.c (syms_of_xfaces):
+        * xfns.c (syms_of_xfns):
+        * xmenu.c (syms_of_xmenu):
+        * xsettings.c (syms_of_xsettings):
+        * xterm.c (syms_of_xterm): Use DEFSYM.
+
+2011-06-24  Teodor Zlatanov  <tzz@lifelogs.com>
+
+        * gnutls.c (syms_of_gnutls): Use the DEFSYM macro from character.h.
+
+2011-06-23  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Integer and buffer overflow fixes (Bug#8873).
+
+        * print.c (printchar, strout): Check for string overflow.
+        (PRINTPREPARE, printchar, strout):
+        Don't set size unless allocation succeeds.
+
+        * minibuf.c (read_minibuf_noninteractive): Use ptrdiff_t, not int,
+        for sizes.  Check for string overflow more accurately.
+        Simplify newline removal at end; this suppresses a GCC 4.6.0 warning.
+
+        * macros.c: Integer and buffer overflow fixes.
+        * keyboard.h (struct keyboard.kbd_macro_bufsize):
+        * macros.c (Fstart_kbd_macro, store_kbd_macro_char):
+        Use ptrdiff_t, not int, for sizes.
+        Don't increment bufsize until after realloc succeeds.
+        Check for size-calculation overflow.
+        (Fstart_kbd_macro): Use EMACS_INT, not int, for XINT result.
+
+        * lisp.h (DEFVAR_KBOARD): Use offsetof instead of char * finagling.
+
+        * lread.c: Integer overflow fixes.
+        (read_integer): Radix is now EMACS_INT, not int,
+        to improve quality of diagnostics for out-of-range radices.
+        Calculate buffer size correctly for out-of-range radices.
+        (read1): Check for integer overflow in radices, and in
+        read-circle numbers.
+        (read_escape): Avoid int overflow.
+        (Fload, openp, read_buffer_size, read1)
+        (substitute_object_recurse, read_vector, read_list, map_obarray):
+        Use ptrdiff_t, not int, for sizes.
+        (read1): Use EMACS_INT, not int, for sizes.
+        Check for size overflow.
+
+        * image.c (cache_image): Check for size arithmetic overflow.
+
+        * lread.c: Integer overflow issues.
+        (saved_doc_string_size, saved_doc_string_length)
+        (prev_saved_doc_string_size, prev_saved_doc_string_length):
+        Now ptrdiff_t, not int.
+        (read1): Don't assume doc string length fits in int.  Check for
+        out-of-range doc string lengths.
+        (read_list): Don't assume file position fits in int.
+        (read_escape): Check for hex character overflow.
+
+2011-06-22  Leo Liu  <sdl.web@gmail.com>
+
+        * minibuf.c (Fcompleting_read_default, Vcompleting_read_function):
+        Move to minibuffer.el.
+
 2011-06-22  Paul Eggert  <eggert@cs.ucla.edu>
 
         Fixes for GLYPH_DEBUG found by GCC 4.6.0 static checking.
@@ -250,7 +371,7 @@
 
         * fns.c (secure_hash): Rename from crypto_hash_function and change
         the first arg to accept symbols.
-        (Fsecure_hash): New primtive.
+        (Fsecure_hash): New primitive.
         (syms_of_fns): New symbols.
 
 2011-06-20  Deniz Dogan  <deniz@dogan.se>
diff --git a/src/alloc.c b/src/alloc.c
index 69623d103c3..43befd722bb 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -6251,8 +6251,7 @@ do hash-consing of the objects allocated to pure space.  */);
   DEFVAR_LISP ("post-gc-hook", Vpost_gc_hook,
                doc: /* Hook run after garbage collection has finished.  */);
   Vpost_gc_hook = Qnil;
-  Qpost_gc_hook = intern_c_string ("post-gc-hook");
-  staticpro (&Qpost_gc_hook);
+  DEFSYM (Qpost_gc_hook, "post-gc-hook");
 
   DEFVAR_LISP ("memory-signal-data", Vmemory_signal_data,
                doc: /* Precomputed `signal' argument for memory-full error.  */);
@@ -6266,11 +6265,8 @@ do hash-consing of the objects allocated to pure space.  */);
                doc: /* Non-nil means Emacs cannot get much more Lisp memory.  */);
   Vmemory_full = Qnil;
 
-  staticpro (&Qgc_cons_threshold);
-  Qgc_cons_threshold = intern_c_string ("gc-cons-threshold");
-
-  staticpro (&Qchar_table_extra_slots);
-  Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
+  DEFSYM (Qgc_cons_threshold, "gc-cons-threshold");
+  DEFSYM (Qchar_table_extra_slots, "char-table-extra-slots");
 
   DEFVAR_LISP ("gc-elapsed", Vgc_elapsed,
                doc: /* Accumulated time elapsed in garbage collections.
diff --git a/src/buffer.c b/src/buffer.c
index 238923a2ba0..006153b0424 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5209,39 +5209,26 @@ syms_of_buffer (void)
   staticpro (&Vbuffer_alist);
   staticpro (&Qprotected_field);
   staticpro (&Qpermanent_local);
-  Qpermanent_local_hook = intern_c_string ("permanent-local-hook");
-  staticpro (&Qpermanent_local_hook);
   staticpro (&Qkill_buffer_hook);
-  Qoverlayp = intern_c_string ("overlayp");
-  staticpro (&Qoverlayp);
-  Qevaporate = intern_c_string ("evaporate");
-  staticpro (&Qevaporate);
-  Qmodification_hooks = intern_c_string ("modification-hooks");
-  staticpro (&Qmodification_hooks);
-  Qinsert_in_front_hooks = intern_c_string ("insert-in-front-hooks");
-  staticpro (&Qinsert_in_front_hooks);
-  Qinsert_behind_hooks = intern_c_string ("insert-behind-hooks");
-  staticpro (&Qinsert_behind_hooks);
-  Qget_file_buffer = intern_c_string ("get-file-buffer");
-  staticpro (&Qget_file_buffer);
-  Qpriority = intern_c_string ("priority");
-  staticpro (&Qpriority);
-  Qbefore_string = intern_c_string ("before-string");
-  staticpro (&Qbefore_string);
-  Qafter_string = intern_c_string ("after-string");
-  staticpro (&Qafter_string);
-  Qfirst_change_hook = intern_c_string ("first-change-hook");
-  staticpro (&Qfirst_change_hook);
-  Qbefore_change_functions = intern_c_string ("before-change-functions");
-  staticpro (&Qbefore_change_functions);
-  Qafter_change_functions = intern_c_string ("after-change-functions");
-  staticpro (&Qafter_change_functions);
+
+  DEFSYM (Qpermanent_local_hook, "permanent-local-hook");
+  DEFSYM (Qoverlayp, "overlayp");
+  DEFSYM (Qevaporate, "evaporate");
+  DEFSYM (Qmodification_hooks, "modification-hooks");
+  DEFSYM (Qinsert_in_front_hooks, "insert-in-front-hooks");
+  DEFSYM (Qinsert_behind_hooks, "insert-behind-hooks");
+  DEFSYM (Qget_file_buffer, "get-file-buffer");
+  DEFSYM (Qpriority, "priority");
+  DEFSYM (Qbefore_string, "before-string");
+  DEFSYM (Qafter_string, "after-string");
+  DEFSYM (Qfirst_change_hook, "first-change-hook");
+  DEFSYM (Qbefore_change_functions, "before-change-functions");
+  DEFSYM (Qafter_change_functions, "after-change-functions");
+  DEFSYM (Qkill_buffer_query_functions, "kill-buffer-query-functions");
+
   /* The next one is initialized in init_buffer_once.  */
   staticpro (&Qucs_set_table_for_input);
 
-  Qkill_buffer_query_functions = intern_c_string ("kill-buffer-query-functions");
-  staticpro (&Qkill_buffer_query_functions);
-
   Fput (Qprotected_field, Qerror_conditions,
         pure_cons (Qprotected_field, pure_cons (Qerror, Qnil)));
   Fput (Qprotected_field, Qerror_message,
@@ -6035,8 +6022,7 @@ If any of them returns nil, the buffer is not killed.  */);
                doc: /* Normal hook run before changing the major mode of a buffer.
 The function `kill-all-local-variables' runs this before doing anything else.  */);
   Vchange_major_mode_hook = Qnil;
-  Qchange_major_mode_hook = intern_c_string ("change-major-mode-hook");
-  staticpro (&Qchange_major_mode_hook);
+  DEFSYM (Qchange_major_mode_hook, "change-major-mode-hook");
 
   DEFVAR_LISP ("buffer-list-update-hook", Vbuffer_list_update_hook,
                doc: /* Hook run when the buffer list changes.
@@ -6044,8 +6030,7 @@ Functions running this hook are `get-buffer-create',
 `make-indirect-buffer', `rename-buffer', `kill-buffer',
 `record-buffer' and `unrecord-buffer'.  */);
   Vbuffer_list_update_hook = Qnil;
-  Qbuffer_list_update_hook = intern_c_string ("buffer-list-update-hook");
-  staticpro (&Qbuffer_list_update_hook);
+  DEFSYM (Qbuffer_list_update_hook, "buffer-list-update-hook");
 
   defsubr (&Sbuffer_live_p);
   defsubr (&Sbuffer_list);
diff --git a/src/bytecode.c b/src/bytecode.c
index 58b26c79b84..9ed29e94b54 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1840,8 +1840,7 @@ exec_byte_code (Lisp_Object bytestr, Lisp_Object vector, Lisp_Object maxdepth,
 void
 syms_of_bytecode (void)
 {
-  Qbytecode = intern_c_string ("byte-code");
-  staticpro (&Qbytecode);
+  DEFSYM (Qbytecode, "byte-code");
 
   defsubr (&Sbyte_code);
 
@@ -1863,8 +1862,7 @@ integer, it is incremented each time that symbol's function is called.  */);
 
   byte_metering_on = 0;
   Vbyte_code_meter = Fmake_vector (make_number (256), make_number (0));
-  Qbyte_code_meter = intern_c_string ("byte-code-meter");
-  staticpro (&Qbyte_code_meter);
+  DEFSYM (Qbyte_code_meter, "byte-code-meter");
   {
     int i = 256;
     while (i--)
diff --git a/src/callint.c b/src/callint.c
index dc5e6a4c37a..4d0a2a07921 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -896,41 +896,20 @@ syms_of_callint (void)
                                 pure_cons (intern_c_string ("point"),
                                        pure_cons (intern_c_string ("mark"), Qnil))));
 
-  Qlist = intern_c_string ("list");
-  staticpro (&Qlist);
-  Qlet = intern_c_string ("let");
-  staticpro (&Qlet);
-  Qif = intern_c_string ("if");
-  staticpro (&Qif);
-  Qwhen = intern_c_string ("when");
-  staticpro (&Qwhen);
-  Qletx = intern_c_string ("let*");
-  staticpro (&Qletx);
-  Qsave_excursion = intern_c_string ("save-excursion");
-  staticpro (&Qsave_excursion);
-  Qprogn = intern_c_string ("progn");
-  staticpro (&Qprogn);
-
-  Qminus = intern_c_string ("-");
-  staticpro (&Qminus);
-
-  Qplus = intern_c_string ("+");
-  staticpro (&Qplus);
-
-  Qhandle_shift_selection = intern_c_string ("handle-shift-selection");
-  staticpro (&Qhandle_shift_selection);
-
-  Qcall_interactively = intern_c_string ("call-interactively");
-  staticpro (&Qcall_interactively);
-
-  Qcommand_debug_status = intern_c_string ("command-debug-status");
-  staticpro (&Qcommand_debug_status);
-
-  Qenable_recursive_minibuffers = intern_c_string ("enable-recursive-minibuffers");
-  staticpro (&Qenable_recursive_minibuffers);
-
-  Qmouse_leave_buffer_hook = intern_c_string ("mouse-leave-buffer-hook");
-  staticpro (&Qmouse_leave_buffer_hook);
+  DEFSYM (Qlist, "list");
+  DEFSYM (Qlet, "let");
+  DEFSYM (Qif, "if");
+  DEFSYM (Qwhen, "when");
+  DEFSYM (Qletx, "let*");
+  DEFSYM (Qsave_excursion, "save-excursion");
+  DEFSYM (Qprogn, "progn");
+  DEFSYM (Qminus, "-");
+  DEFSYM (Qplus, "+");
+  DEFSYM (Qhandle_shift_selection, "handle-shift-selection");
+  DEFSYM (Qcall_interactively, "call-interactively");
+  DEFSYM (Qcommand_debug_status, "command-debug-status");
+  DEFSYM (Qenable_recursive_minibuffers, "enable-recursive-minibuffers");
+  DEFSYM (Qmouse_leave_buffer_hook, "mouse-leave-buffer-hook");
 
   DEFVAR_KBOARD ("prefix-arg", Vprefix_arg,
                  doc: /* The value of the prefix argument for the next editing command.
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 1a0a62f273c..50ad4eeda74 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -417,8 +417,7 @@ With negative argument, capitalize previous words but do not move.  */)
 void
 syms_of_casefiddle (void)
 {
-  Qidentity = intern_c_string ("identity");
-  staticpro (&Qidentity);
+  DEFSYM (Qidentity, "identity");
   defsubr (&Supcase);
   defsubr (&Sdowncase);
   defsubr (&Scapitalize);
diff --git a/src/casetab.c b/src/casetab.c
index 29120dd08ce..3433b313c03 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -244,8 +244,7 @@ init_casetab_once (void)
 {
   register int i;
   Lisp_Object down, up;
-  Qcase_table = intern_c_string ("case-table");
-  staticpro (&Qcase_table);
+  DEFSYM (Qcase_table, "case-table");
 
   /* Intern this now in case it isn't already done.
      Setting this variable twice is harmless.
@@ -288,8 +287,7 @@ init_casetab_once (void)
 void
 syms_of_casetab (void)
 {
-  Qcase_table_p = intern_c_string ("case-table-p");
-  staticpro (&Qcase_table_p);
+  DEFSYM (Qcase_table_p, "case-table-p");
 
   staticpro (&Vascii_canon_table);
   staticpro (&Vascii_downcase_table);
diff --git a/src/category.c b/src/category.c
index 23fd874c824..08eadb04730 100644
--- a/src/category.c
+++ b/src/category.c
@@ -453,8 +453,7 @@ void
 init_category_once (void)
 {
   /* This has to be done here, before we call Fmake_char_table.  */
-  Qcategory_table = intern_c_string ("category-table");
-  staticpro (&Qcategory_table);
+  DEFSYM (Qcategory_table, "category-table");
 
   /* Intern this now in case it isn't already done.
      Setting this variable twice is harmless.
@@ -475,12 +474,9 @@ init_category_once (void)
 void
 syms_of_category (void)
 {
-  Qcategoryp = intern_c_string ("categoryp");
-  staticpro (&Qcategoryp);
-  Qcategorysetp = intern_c_string ("categorysetp");
-  staticpro (&Qcategorysetp);
-  Qcategory_table_p = intern_c_string ("category-table-p");
-  staticpro (&Qcategory_table_p);
+  DEFSYM (Qcategoryp, "categoryp");
+  DEFSYM (Qcategorysetp, "categorysetp");
+  DEFSYM (Qcategory_table_p, "category-table-p");
 
   DEFVAR_LISP ("word-combining-categories", Vword_combining_categories,
                doc: /* List of pair (cons) of categories to determine word boundary.
diff --git a/src/ccl.c b/src/ccl.c
index 30d151f00a0..9cfcbfe8703 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -2305,23 +2305,12 @@ syms_of_ccl (void)
   staticpro (&Vccl_program_table);
   Vccl_program_table = Fmake_vector (make_number (32), Qnil);
 
-  Qccl = intern_c_string ("ccl");
-  staticpro (&Qccl);
-
-  Qcclp = intern_c_string ("cclp");
-  staticpro (&Qcclp);
-
-  Qccl_program = intern_c_string ("ccl-program");
-  staticpro (&Qccl_program);
-
-  Qccl_program_idx = intern_c_string ("ccl-program-idx");
-  staticpro (&Qccl_program_idx);
-
-  Qcode_conversion_map = intern_c_string ("code-conversion-map");
-  staticpro (&Qcode_conversion_map);
-
-  Qcode_conversion_map_id = intern_c_string ("code-conversion-map-id");
-  staticpro (&Qcode_conversion_map_id);
+  DEFSYM (Qccl, "ccl");
+  DEFSYM (Qcclp, "cclp");
+  DEFSYM (Qccl_program, "ccl-program");
+  DEFSYM (Qccl_program_idx, "ccl-program-idx");
+  DEFSYM (Qcode_conversion_map, "code-conversion-map");
+  DEFSYM (Qcode_conversion_map_id, "code-conversion-map-id");
 
   DEFVAR_LISP ("code-conversion-map-vector", Vcode_conversion_map_vector,
                doc: /* Vector of code conversion maps.  */);
diff --git a/src/character.h b/src/character.h
index 9a45e7f0033..3bc21ac0f2b 100644
--- a/src/character.h
+++ b/src/character.h
@@ -628,7 +628,4 @@ extern Lisp_Object string_escape_byte8 (Lisp_Object);
 #define GET_TRANSLATION_TABLE(id) \
   (XCDR(XVECTOR(Vtranslation_table_vector)->contents[(id)]))
 
-#define DEFSYM(sym, name)       \
-  do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
-
 #endif /* EMACS_CHARACTER_H */
diff --git a/src/cmds.c b/src/cmds.c
index 5dc4d2bfe30..f49cfc221be 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -511,20 +511,11 @@ internal_self_insert (int c, EMACS_INT n)
 void
 syms_of_cmds (void)
 {
-  Qkill_backward_chars = intern_c_string ("kill-backward-chars");
-  staticpro (&Qkill_backward_chars);
-
-  Qkill_forward_chars = intern_c_string ("kill-forward-chars");
-  staticpro (&Qkill_forward_chars);
-
-  Qoverwrite_mode_binary = intern_c_string ("overwrite-mode-binary");
-  staticpro (&Qoverwrite_mode_binary);
-
-  Qexpand_abbrev = intern_c_string ("expand-abbrev");
-  staticpro (&Qexpand_abbrev);
-
-  Qpost_self_insert_hook = intern_c_string ("post-self-insert-hook");
-  staticpro (&Qpost_self_insert_hook);
+  DEFSYM (Qkill_backward_chars, "kill-backward-chars");
+  DEFSYM (Qkill_forward_chars, "kill-forward-chars");
+  DEFSYM (Qoverwrite_mode_binary, "overwrite-mode-binary");
+  DEFSYM (Qexpand_abbrev, "expand-abbrev");
+  DEFSYM (Qpost_self_insert_hook, "post-self-insert-hook");
 
   DEFVAR_LISP ("post-self-insert-hook", Vpost_self_insert_hook,
                doc: /* Hook run at the end of `self-insert-command'.
diff --git a/src/composite.c b/src/composite.c
index 796c5a58de6..de9775d18f5 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1937,8 +1937,7 @@ syms_of_composite (void)
 {
   int i;
 
-  Qcomposition = intern_c_string ("composition");
-  staticpro (&Qcomposition);
+  DEFSYM (Qcomposition, "composition");
 
   /* Make a hash table for static composition.  */
   {
@@ -1997,11 +1996,8 @@ valid.
 The default value is the function `compose-chars-after'.  */);
   Vcompose_chars_after_function = intern_c_string ("compose-chars-after");
 
-  Qauto_composed = intern_c_string ("auto-composed");
-  staticpro (&Qauto_composed);
-
-  Qauto_composition_function = intern_c_string ("auto-composition-function");
-  staticpro (&Qauto_composition_function);
+  DEFSYM (Qauto_composed, "auto-composed");
+  DEFSYM (Qauto_composition_function, "auto-composition-function");
 
   DEFVAR_LISP ("auto-composition-mode", Vauto_composition_mode,
                doc: /* Non-nil if Auto-Composition mode is enabled.
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 302b93146fd..4828f4e968d 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -2189,142 +2189,76 @@ void
 syms_of_dbusbind (void)
 {
 
-  Qdbus_init_bus = intern_c_string ("dbus-init-bus");
-  staticpro (&Qdbus_init_bus);
+  DEFSYM (Qdbus_init_bus, "dbus-init-bus");
   defsubr (&Sdbus_init_bus);
 
-  Qdbus_close_bus = intern_c_string ("dbus-close-bus");
-  staticpro (&Qdbus_close_bus);
+  DEFSYM (Qdbus_close_bus, "dbus-close-bus");
   defsubr (&Sdbus_close_bus);
 
-  Qdbus_get_unique_name = intern_c_string ("dbus-get-unique-name");
-  staticpro (&Qdbus_get_unique_name);
+  DEFSYM (Qdbus_get_unique_name, "dbus-get-unique-name");
   defsubr (&Sdbus_get_unique_name);
 
-  Qdbus_call_method = intern_c_string ("dbus-call-method");
-  staticpro (&Qdbus_call_method);
+  DEFSYM (Qdbus_call_method, "dbus-call-method");
   defsubr (&Sdbus_call_method);
 
-  Qdbus_call_method_asynchronously
-    = intern_c_string ("dbus-call-method-asynchronously");
-  staticpro (&Qdbus_call_method_asynchronously);
+  DEFSYM (Qdbus_call_method_asynchronously, "dbus-call-method-asynchronously");
   defsubr (&Sdbus_call_method_asynchronously);
 
-  Qdbus_method_return_internal
-    = intern_c_string ("dbus-method-return-internal");
-  staticpro (&Qdbus_method_return_internal);
+  DEFSYM (Qdbus_method_return_internal, "dbus-method-return-internal");
   defsubr (&Sdbus_method_return_internal);
 
-  Qdbus_method_error_internal = intern_c_string ("dbus-method-error-internal");
-  staticpro (&Qdbus_method_error_internal);
+  DEFSYM (Qdbus_method_error_internal, "dbus-method-error-internal");
   defsubr (&Sdbus_method_error_internal);
 
-  Qdbus_send_signal = intern_c_string ("dbus-send-signal");
-  staticpro (&Qdbus_send_signal);
+  DEFSYM (Qdbus_send_signal, "dbus-send-signal");
   defsubr (&Sdbus_send_signal);
 
-  Qdbus_register_service = intern_c_string ("dbus-register-service");
-  staticpro (&Qdbus_register_service);
+  DEFSYM (Qdbus_register_service, "dbus-register-service");
   defsubr (&Sdbus_register_service);
 
-  Qdbus_register_signal = intern_c_string ("dbus-register-signal");
-  staticpro (&Qdbus_register_signal);
+  DEFSYM (Qdbus_register_signal, "dbus-register-signal");
   defsubr (&Sdbus_register_signal);
 
-  Qdbus_register_method = intern_c_string ("dbus-register-method");
-  staticpro (&Qdbus_register_method);
+  DEFSYM (Qdbus_register_method, "dbus-register-method");
   defsubr (&Sdbus_register_method);
 
-  Qdbus_error = intern_c_string ("dbus-error");
-  staticpro (&Qdbus_error);
+  DEFSYM (Qdbus_error, "dbus-error");
   Fput (Qdbus_error, Qerror_conditions,
         list2 (Qdbus_error, Qerror));
   Fput (Qdbus_error, Qerror_message,
         make_pure_c_string ("D-Bus error"));
 
-  QCdbus_system_bus = intern_c_string (":system");
-  staticpro (&QCdbus_system_bus);
-
-  QCdbus_session_bus = intern_c_string (":session");
-  staticpro (&QCdbus_session_bus);
-
-  QCdbus_request_name_allow_replacement
-    = intern_c_string (":allow-replacement");
-  staticpro (&QCdbus_request_name_allow_replacement);
-
-  QCdbus_request_name_replace_existing = intern_c_string (":replace-existing");
-  staticpro (&QCdbus_request_name_replace_existing);
-
-  QCdbus_request_name_do_not_queue = intern_c_string (":do-not-queue");
-  staticpro (&QCdbus_request_name_do_not_queue);
-
-  QCdbus_request_name_reply_primary_owner = intern_c_string (":primary-owner");
-  staticpro (&QCdbus_request_name_reply_primary_owner);
-
-  QCdbus_request_name_reply_exists = intern_c_string (":exists");
-  staticpro (&QCdbus_request_name_reply_exists);
-
-  QCdbus_request_name_reply_in_queue = intern_c_string (":in-queue");
-  staticpro (&QCdbus_request_name_reply_in_queue);
-
-  QCdbus_request_name_reply_already_owner = intern_c_string (":already-owner");
-  staticpro (&QCdbus_request_name_reply_already_owner);
-
-  QCdbus_timeout = intern_c_string (":timeout");
-  staticpro (&QCdbus_timeout);
-
-  QCdbus_type_byte = intern_c_string (":byte");
-  staticpro (&QCdbus_type_byte);
-
-  QCdbus_type_boolean = intern_c_string (":boolean");
-  staticpro (&QCdbus_type_boolean);
-
-  QCdbus_type_int16 = intern_c_string (":int16");
-  staticpro (&QCdbus_type_int16);
-
-  QCdbus_type_uint16 = intern_c_string (":uint16");
-  staticpro (&QCdbus_type_uint16);
-
-  QCdbus_type_int32 = intern_c_string (":int32");
-  staticpro (&QCdbus_type_int32);
-
-  QCdbus_type_uint32 = intern_c_string (":uint32");
-  staticpro (&QCdbus_type_uint32);
-
-  QCdbus_type_int64 = intern_c_string (":int64");
-  staticpro (&QCdbus_type_int64);
-
-  QCdbus_type_uint64 = intern_c_string (":uint64");
-  staticpro (&QCdbus_type_uint64);
-
-  QCdbus_type_double = intern_c_string (":double");
-  staticpro (&QCdbus_type_double);
-
-  QCdbus_type_string = intern_c_string (":string");
-  staticpro (&QCdbus_type_string);
-
-  QCdbus_type_object_path = intern_c_string (":object-path");
-  staticpro (&QCdbus_type_object_path);
-
-  QCdbus_type_signature = intern_c_string (":signature");
-  staticpro (&QCdbus_type_signature);
+  DEFSYM (QCdbus_system_bus, ":system");
+  DEFSYM (QCdbus_session_bus, ":session");
+  DEFSYM (QCdbus_request_name_allow_replacement, ":allow-replacement");
+  DEFSYM (QCdbus_request_name_replace_existing, ":replace-existing");
+  DEFSYM (QCdbus_request_name_do_not_queue, ":do-not-queue");
+  DEFSYM (QCdbus_request_name_reply_primary_owner, ":primary-owner");
+  DEFSYM (QCdbus_request_name_reply_exists, ":exists");
+  DEFSYM (QCdbus_request_name_reply_in_queue, ":in-queue");
+  DEFSYM (QCdbus_request_name_reply_already_owner, ":already-owner");
+  DEFSYM (QCdbus_timeout, ":timeout");
+  DEFSYM (QCdbus_type_byte, ":byte");
+  DEFSYM (QCdbus_type_boolean, ":boolean");
+  DEFSYM (QCdbus_type_int16, ":int16");
+  DEFSYM (QCdbus_type_uint16, ":uint16");
+  DEFSYM (QCdbus_type_int32, ":int32");
+  DEFSYM (QCdbus_type_uint32, ":uint32");
+  DEFSYM (QCdbus_type_int64, ":int64");
+  DEFSYM (QCdbus_type_uint64, ":uint64");
+  DEFSYM (QCdbus_type_double, ":double");
+  DEFSYM (QCdbus_type_string, ":string");
+  DEFSYM (QCdbus_type_object_path, ":object-path");
+  DEFSYM (QCdbus_type_signature, ":signature");
 
 #ifdef DBUS_TYPE_UNIX_FD
-  QCdbus_type_unix_fd = intern_c_string (":unix-fd");
-  staticpro (&QCdbus_type_unix_fd);
+  DEFSYM (QCdbus_type_unix_fd, ":unix-fd");
 #endif
 
-  QCdbus_type_array = intern_c_string (":array");
-  staticpro (&QCdbus_type_array);
-
-  QCdbus_type_variant = intern_c_string (":variant");
-  staticpro (&QCdbus_type_variant);
-
-  QCdbus_type_struct = intern_c_string (":struct");
-  staticpro (&QCdbus_type_struct);
-
-  QCdbus_type_dict_entry = intern_c_string (":dict-entry");
-  staticpro (&QCdbus_type_dict_entry);
+  DEFSYM (QCdbus_type_array, ":array");
+  DEFSYM (QCdbus_type_variant, ":variant");
+  DEFSYM (QCdbus_type_struct, ":struct");
+  DEFSYM (QCdbus_type_dict_entry, ":dict-entry");
 
   DEFVAR_LISP ("dbus-registered-buses",
                Vdbus_registered_buses,
diff --git a/src/dired.c b/src/dired.c
index 3ab1ba8a900..415f9ac5ae5 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -1017,21 +1017,13 @@ Comparison is in lexicographic order and case is significant.  */)
 void
 syms_of_dired (void)
 {
-  Qdirectory_files = intern_c_string ("directory-files");
-  Qdirectory_files_and_attributes = intern_c_string ("directory-files-and-attributes");
-  Qfile_name_completion = intern_c_string ("file-name-completion");
-  Qfile_name_all_completions = intern_c_string ("file-name-all-completions");
-  Qfile_attributes = intern_c_string ("file-attributes");
-  Qfile_attributes_lessp = intern_c_string ("file-attributes-lessp");
-  Qdefault_directory = intern_c_string ("default-directory");
-
-  staticpro (&Qdirectory_files);
-  staticpro (&Qdirectory_files_and_attributes);
-  staticpro (&Qfile_name_completion);
-  staticpro (&Qfile_name_all_completions);
-  staticpro (&Qfile_attributes);
-  staticpro (&Qfile_attributes_lessp);
-  staticpro (&Qdefault_directory);
+  DEFSYM (Qdirectory_files, "directory-files");
+  DEFSYM (Qdirectory_files_and_attributes, "directory-files-and-attributes");
+  DEFSYM (Qfile_name_completion, "file-name-completion");
+  DEFSYM (Qfile_name_all_completions, "file-name-all-completions");
+  DEFSYM (Qfile_attributes, "file-attributes");
+  DEFSYM (Qfile_attributes_lessp, "file-attributes-lessp");
+  DEFSYM (Qdefault_directory, "default-directory");
 
   defsubr (&Sdirectory_files);
   defsubr (&Sdirectory_files_and_attributes);
diff --git a/src/dispnew.c b/src/dispnew.c
index 52fec0305fb..bde90d847ce 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -4551,6 +4551,7 @@ scrolling_window (struct window *w, int header_line_p)
         /* Copy on the display.  */
         if (r->current_y != r->desired_y)
           {
+            rif->clear_window_mouse_face (w);
             rif->scroll_run_hook (w, r);
 
             /* Invalidate runs that copy from where we copied to.  */
@@ -6446,10 +6447,8 @@ syms_of_display (void)
   frame_and_buffer_state = Fmake_vector (make_number (20), Qlambda);
   staticpro (&frame_and_buffer_state);
 
-  Qdisplay_table = intern_c_string ("display-table");
-  staticpro (&Qdisplay_table);
-  Qredisplay_dont_pause = intern_c_string ("redisplay-dont-pause");
-  staticpro (&Qredisplay_dont_pause);
+  DEFSYM (Qdisplay_table, "display-table");
+  DEFSYM (Qredisplay_dont_pause, "redisplay-dont-pause");
 
   DEFVAR_INT ("baud-rate", baud_rate,
               doc: /* *The output baud rate of the terminal.
diff --git a/src/doc.c b/src/doc.c
index 48e0936510b..69646f5af51 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -945,8 +945,7 @@ a new string, without any text properties, is returned.  */)
 void
 syms_of_doc (void)
 {
-  Qfunction_documentation = intern_c_string ("function-documentation");
-  staticpro (&Qfunction_documentation);
+  DEFSYM (Qfunction_documentation, "function-documentation");
 
   DEFVAR_LISP ("internal-doc-file-name", Vdoc_file_name,
                doc: /* Name of file containing documentation strings of built-in symbols.  */);
diff --git a/src/editfns.c b/src/editfns.c
index c0c0e530265..5328b714b0f 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -4738,9 +4738,7 @@ syms_of_editfns (void)
   environbuf = 0;
   initial_tz = 0;
 
-  Qbuffer_access_fontify_functions
-    = intern_c_string ("buffer-access-fontify-functions");
-  staticpro (&Qbuffer_access_fontify_functions);
+  DEFSYM (Qbuffer_access_fontify_functions, "buffer-access-fontify-functions");
 
   DEFVAR_LISP ("inhibit-field-text-motion", Vinhibit_field_text_motion,
                doc: /* Non-nil means text motion commands don't notice fields.  */);
@@ -4802,10 +4800,8 @@ functions if all the text being accessed has this property.  */);
   defsubr (&Sregion_beginning);
   defsubr (&Sregion_end);
 
-  staticpro (&Qfield);
-  Qfield = intern_c_string ("field");
-  staticpro (&Qboundary);
-  Qboundary = intern_c_string ("boundary");
+  DEFSYM (Qfield, "field");
+  DEFSYM (Qboundary, "boundary");
   defsubr (&Sfield_beginning);
   defsubr (&Sfield_end);
   defsubr (&Sfield_string);
diff --git a/src/emacs.c b/src/emacs.c
index ba76adf7192..bfefa2bfa51 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -2378,10 +2378,8 @@ from the parent process and its tty file descriptors.  */)
 void
 syms_of_emacs (void)
 {
-  Qfile_name_handler_alist = intern_c_string ("file-name-handler-alist");
-  staticpro (&Qfile_name_handler_alist);
-  Qrisky_local_variable = intern_c_string ("risky-local-variable");
-  staticpro (&Qrisky_local_variable);
+  DEFSYM (Qfile_name_handler_alist, "file-name-handler-alist");
+  DEFSYM (Qrisky_local_variable, "risky-local-variable");
 
 #ifndef CANNOT_DUMP
   defsubr (&Sdump_emacs);
diff --git a/src/eval.c b/src/eval.c
index be582775fea..6ca8eacb100 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -3694,46 +3694,23 @@ To prevent this happening, set `quit-flag' to nil
 before making `inhibit-quit' nil.  */);
   Vinhibit_quit = Qnil;
 
-  Qinhibit_quit = intern_c_string ("inhibit-quit");
-  staticpro (&Qinhibit_quit);
-
-  Qautoload = intern_c_string ("autoload");
-  staticpro (&Qautoload);
-
-  Qdebug_on_error = intern_c_string ("debug-on-error");
-  staticpro (&Qdebug_on_error);
-
-  Qmacro = intern_c_string ("macro");
-  staticpro (&Qmacro);
-
-  Qdeclare = intern_c_string ("declare");
-  staticpro (&Qdeclare);
+  DEFSYM (Qinhibit_quit, "inhibit-quit");
+  DEFSYM (Qautoload, "autoload");
+  DEFSYM (Qdebug_on_error, "debug-on-error");
+  DEFSYM (Qmacro, "macro");
+  DEFSYM (Qdeclare, "declare");
 
   /* Note that the process handling also uses Qexit, but we don't want
      to staticpro it twice, so we just do it here.  */
-  Qexit = intern_c_string ("exit");
-  staticpro (&Qexit);
-
-  Qinteractive = intern_c_string ("interactive");
-  staticpro (&Qinteractive);
-
-  Qcommandp = intern_c_string ("commandp");
-  staticpro (&Qcommandp);
-
-  Qdefun = intern_c_string ("defun");
-  staticpro (&Qdefun);
-
-  Qand_rest = intern_c_string ("&rest");
-  staticpro (&Qand_rest);
-
-  Qand_optional = intern_c_string ("&optional");
-  staticpro (&Qand_optional);
-
-  Qclosure = intern_c_string ("closure");
-  staticpro (&Qclosure);
+  DEFSYM (Qexit, "exit");
 
-  Qdebug = intern_c_string ("debug");
-  staticpro (&Qdebug);
+  DEFSYM (Qinteractive, "interactive");
+  DEFSYM (Qcommandp, "commandp");
+  DEFSYM (Qdefun, "defun");
+  DEFSYM (Qand_rest, "&rest");
+  DEFSYM (Qand_optional, "&optional");
+  DEFSYM (Qclosure, "closure");
+  DEFSYM (Qdebug, "debug");
 
   DEFVAR_LISP ("debug-on-error", Vdebug_on_error,
                doc: /* *Non-nil means enter debugger if an error is signaled.
@@ -3807,9 +3784,7 @@ The value the function returns is not used.  */);
    Every element of this list can be either a cons (VAR . VAL)
    specifying a lexical binding, or a single symbol VAR indicating
    that this variable should use dynamic scoping.  */
-  Qinternal_interpreter_environment
-    = intern_c_string ("internal-interpreter-environment");
-  staticpro (&Qinternal_interpreter_environment);
+  DEFSYM (Qinternal_interpreter_environment, "internal-interpreter-environment");
   DEFVAR_LISP ("internal-interpreter-environment",
                 Vinternal_interpreter_environment,
                doc: /* If non-nil, the current lexical environment of the lisp interpreter.
@@ -3821,8 +3796,7 @@ alist of active lexical bindings.  */);
      (Just imagine if someone makes it buffer-local).  */
   Funintern (Qinternal_interpreter_environment, Qnil);
 
-  Vrun_hooks = intern_c_string ("run-hooks");
-  staticpro (&Vrun_hooks);
+  DEFSYM (Vrun_hooks, "run-hooks");
 
   staticpro (&Vautoload_queue);
   Vautoload_queue = Qnil;
diff --git a/src/fileio.c b/src/fileio.c
index 824df8172e7..27fef42960a 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5425,92 +5425,50 @@ Fread_file_name (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filena
 void
 syms_of_fileio (void)
 {
-  Qoperations = intern_c_string ("operations");
-  Qexpand_file_name = intern_c_string ("expand-file-name");
-  Qsubstitute_in_file_name = intern_c_string ("substitute-in-file-name");
-  Qdirectory_file_name = intern_c_string ("directory-file-name");
-  Qfile_name_directory = intern_c_string ("file-name-directory");
-  Qfile_name_nondirectory = intern_c_string ("file-name-nondirectory");
-  Qunhandled_file_name_directory = intern_c_string ("unhandled-file-name-directory");
-  Qfile_name_as_directory = intern_c_string ("file-name-as-directory");
-  Qcopy_file = intern_c_string ("copy-file");
-  Qmake_directory_internal = intern_c_string ("make-directory-internal");
-  Qmake_directory = intern_c_string ("make-directory");
-  Qdelete_directory_internal = intern_c_string ("delete-directory-internal");
-  Qdelete_file = intern_c_string ("delete-file");
-  Qrename_file = intern_c_string ("rename-file");
-  Qadd_name_to_file = intern_c_string ("add-name-to-file");
-  Qmake_symbolic_link = intern_c_string ("make-symbolic-link");
-  Qfile_exists_p = intern_c_string ("file-exists-p");
-  Qfile_executable_p = intern_c_string ("file-executable-p");
-  Qfile_readable_p = intern_c_string ("file-readable-p");
-  Qfile_writable_p = intern_c_string ("file-writable-p");
-  Qfile_symlink_p = intern_c_string ("file-symlink-p");
-  Qaccess_file = intern_c_string ("access-file");
-  Qfile_directory_p = intern_c_string ("file-directory-p");
-  Qfile_regular_p = intern_c_string ("file-regular-p");
-  Qfile_accessible_directory_p = intern_c_string ("file-accessible-directory-p");
-  Qfile_modes = intern_c_string ("file-modes");
-  Qset_file_modes = intern_c_string ("set-file-modes");
-  Qset_file_times = intern_c_string ("set-file-times");
-  Qfile_selinux_context = intern_c_string("file-selinux-context");
-  Qset_file_selinux_context = intern_c_string("set-file-selinux-context");
-  Qfile_newer_than_file_p = intern_c_string ("file-newer-than-file-p");
-  Qinsert_file_contents = intern_c_string ("insert-file-contents");
-  Qwrite_region = intern_c_string ("write-region");
-  Qverify_visited_file_modtime = intern_c_string ("verify-visited-file-modtime");
-  Qset_visited_file_modtime = intern_c_string ("set-visited-file-modtime");
-  Qauto_save_coding = intern_c_string ("auto-save-coding");
-
-  staticpro (&Qoperations);
-  staticpro (&Qexpand_file_name);
-  staticpro (&Qsubstitute_in_file_name);
-  staticpro (&Qdirectory_file_name);
-  staticpro (&Qfile_name_directory);
-  staticpro (&Qfile_name_nondirectory);
-  staticpro (&Qunhandled_file_name_directory);
-  staticpro (&Qfile_name_as_directory);
-  staticpro (&Qcopy_file);
-  staticpro (&Qmake_directory_internal);
-  staticpro (&Qmake_directory);
-  staticpro (&Qdelete_directory_internal);
-  staticpro (&Qdelete_file);
-  staticpro (&Qrename_file);
-  staticpro (&Qadd_name_to_file);
-  staticpro (&Qmake_symbolic_link);
-  staticpro (&Qfile_exists_p);
-  staticpro (&Qfile_executable_p);
-  staticpro (&Qfile_readable_p);
-  staticpro (&Qfile_writable_p);
-  staticpro (&Qaccess_file);
-  staticpro (&Qfile_symlink_p);
-  staticpro (&Qfile_directory_p);
-  staticpro (&Qfile_regular_p);
-  staticpro (&Qfile_accessible_directory_p);
-  staticpro (&Qfile_modes);
-  staticpro (&Qset_file_modes);
-  staticpro (&Qset_file_times);
-  staticpro (&Qfile_selinux_context);
-  staticpro (&Qset_file_selinux_context);
-  staticpro (&Qfile_newer_than_file_p);
-  staticpro (&Qinsert_file_contents);
-  staticpro (&Qwrite_region);
-  staticpro (&Qverify_visited_file_modtime);
-  staticpro (&Qset_visited_file_modtime);
-  staticpro (&Qauto_save_coding);
-
-  Qfile_name_history = intern_c_string ("file-name-history");
+  DEFSYM (Qoperations, "operations");
+  DEFSYM (Qexpand_file_name, "expand-file-name");
+  DEFSYM (Qsubstitute_in_file_name, "substitute-in-file-name");
+  DEFSYM (Qdirectory_file_name, "directory-file-name");
+  DEFSYM (Qfile_name_directory, "file-name-directory");
+  DEFSYM (Qfile_name_nondirectory, "file-name-nondirectory");
+  DEFSYM (Qunhandled_file_name_directory, "unhandled-file-name-directory");
+  DEFSYM (Qfile_name_as_directory, "file-name-as-directory");
+  DEFSYM (Qcopy_file, "copy-file");
+  DEFSYM (Qmake_directory_internal, "make-directory-internal");
+  DEFSYM (Qmake_directory, "make-directory");
+  DEFSYM (Qdelete_directory_internal, "delete-directory-internal");
+  DEFSYM (Qdelete_file, "delete-file");
+  DEFSYM (Qrename_file, "rename-file");
+  DEFSYM (Qadd_name_to_file, "add-name-to-file");
+  DEFSYM (Qmake_symbolic_link, "make-symbolic-link");
+  DEFSYM (Qfile_exists_p, "file-exists-p");
+  DEFSYM (Qfile_executable_p, "file-executable-p");
+  DEFSYM (Qfile_readable_p, "file-readable-p");
+  DEFSYM (Qfile_writable_p, "file-writable-p");
+  DEFSYM (Qfile_symlink_p, "file-symlink-p");
+  DEFSYM (Qaccess_file, "access-file");
+  DEFSYM (Qfile_directory_p, "file-directory-p");
+  DEFSYM (Qfile_regular_p, "file-regular-p");
+  DEFSYM (Qfile_accessible_directory_p, "file-accessible-directory-p");
+  DEFSYM (Qfile_modes, "file-modes");
+  DEFSYM (Qset_file_modes, "set-file-modes");
+  DEFSYM (Qset_file_times, "set-file-times");
+  DEFSYM (Qfile_selinux_context, "file-selinux-context");
+  DEFSYM (Qset_file_selinux_context, "set-file-selinux-context");
+  DEFSYM (Qfile_newer_than_file_p, "file-newer-than-file-p");
+  DEFSYM (Qinsert_file_contents, "insert-file-contents");
+  DEFSYM (Qwrite_region, "write-region");
+  DEFSYM (Qverify_visited_file_modtime, "verify-visited-file-modtime");
+  DEFSYM (Qset_visited_file_modtime, "set-visited-file-modtime");
+  DEFSYM (Qauto_save_coding, "auto-save-coding");
+
+  DEFSYM (Qfile_name_history, "file-name-history");
   Fset (Qfile_name_history, Qnil);
-  staticpro (&Qfile_name_history);
 
-  Qfile_error = intern_c_string ("file-error");
-  staticpro (&Qfile_error);
-  Qfile_already_exists = intern_c_string ("file-already-exists");
-  staticpro (&Qfile_already_exists);
-  Qfile_date_error = intern_c_string ("file-date-error");
-  staticpro (&Qfile_date_error);
-  Qexcl = intern_c_string ("excl");
-  staticpro (&Qexcl);
+  DEFSYM (Qfile_error, "file-error");
+  DEFSYM (Qfile_already_exists, "file-already-exists");
+  DEFSYM (Qfile_date_error, "file-date-error");
+  DEFSYM (Qexcl, "excl");
 
   DEFVAR_LISP ("file-name-coding-system", Vfile_name_coding_system,
                doc: /* *Coding system for encoding file names.
@@ -5528,15 +5486,10 @@ instead use `file-name-coding-system' to get a constant encoding
 of file names regardless of the current language environment.  */);
   Vdefault_file_name_coding_system = Qnil;
 
-  Qformat_decode = intern_c_string ("format-decode");
-  staticpro (&Qformat_decode);
-  Qformat_annotate_function = intern_c_string ("format-annotate-function");
-  staticpro (&Qformat_annotate_function);
-  Qafter_insert_file_set_coding = intern_c_string ("after-insert-file-set-coding");
-  staticpro (&Qafter_insert_file_set_coding);
-
-  Qcar_less_than_car = intern_c_string ("car-less-than-car");
-  staticpro (&Qcar_less_than_car);
+  DEFSYM (Qformat_decode, "format-decode");
+  DEFSYM (Qformat_annotate_function, "format-annotate-function");
+  DEFSYM (Qafter_insert_file_set_coding, "after-insert-file-set-coding");
+  DEFSYM (Qcar_less_than_car, "car-less-than-car");
 
   Fput (Qfile_error, Qerror_conditions,
         Fpurecopy (list2 (Qfile_error, Qerror)));
@@ -5615,9 +5568,7 @@ After `write-region' completes, Emacs calls the function stored in
 current when building the annotations (i.e., at least once), with that
 buffer current.  */);
   Vwrite_region_annotate_functions = Qnil;
-  staticpro (&Qwrite_region_annotate_functions);
-  Qwrite_region_annotate_functions
-    = intern_c_string ("write-region-annotate-functions");
+  DEFSYM (Qwrite_region_annotate_functions, "write-region-annotate-functions");
 
   DEFVAR_LISP ("write-region-post-annotation-function",
                Vwrite_region_post_annotation_function,
@@ -5681,12 +5632,10 @@ This includes interactive calls to `delete-file' and
 `delete-directory' and the Dired deletion commands.  */);
   delete_by_moving_to_trash = 0;
   Qdelete_by_moving_to_trash = intern_c_string ("delete-by-moving-to-trash");
-  Qmove_file_to_trash = intern_c_string ("move-file-to-trash");
-  staticpro (&Qmove_file_to_trash);
-  Qcopy_directory = intern_c_string ("copy-directory");
-  staticpro (&Qcopy_directory);
-  Qdelete_directory = intern_c_string ("delete-directory");
-  staticpro (&Qdelete_directory);
+
+  DEFSYM (Qmove_file_to_trash, "move-file-to-trash");
+  DEFSYM (Qcopy_directory, "copy-directory");
+  DEFSYM (Qdelete_directory, "delete-directory");
 
   defsubr (&Sfind_file_name_handler);
   defsubr (&Sfile_name_directory);
diff --git a/src/fns.c b/src/fns.c
index 5bf274030a3..b6fe2a7f7b6 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -4854,34 +4854,20 @@ syms_of_fns (void)
   DEFSYM (Qsha512, "sha512");
 
   /* Hash table stuff.  */
-  Qhash_table_p = intern_c_string ("hash-table-p");
-  staticpro (&Qhash_table_p);
-  Qeq = intern_c_string ("eq");
-  staticpro (&Qeq);
-  Qeql = intern_c_string ("eql");
-  staticpro (&Qeql);
-  Qequal = intern_c_string ("equal");
-  staticpro (&Qequal);
-  QCtest = intern_c_string (":test");
-  staticpro (&QCtest);
-  QCsize = intern_c_string (":size");
-  staticpro (&QCsize);
-  QCrehash_size = intern_c_string (":rehash-size");
-  staticpro (&QCrehash_size);
-  QCrehash_threshold = intern_c_string (":rehash-threshold");
-  staticpro (&QCrehash_threshold);
-  QCweakness = intern_c_string (":weakness");
-  staticpro (&QCweakness);
-  Qkey = intern_c_string ("key");
-  staticpro (&Qkey);
-  Qvalue = intern_c_string ("value");
-  staticpro (&Qvalue);
-  Qhash_table_test = intern_c_string ("hash-table-test");
-  staticpro (&Qhash_table_test);
-  Qkey_or_value = intern_c_string ("key-or-value");
-  staticpro (&Qkey_or_value);
-  Qkey_and_value = intern_c_string ("key-and-value");
-  staticpro (&Qkey_and_value);
+  DEFSYM (Qhash_table_p, "hash-table-p");
+  DEFSYM (Qeq, "eq");
+  DEFSYM (Qeql, "eql");
+  DEFSYM (Qequal, "equal");
+  DEFSYM (QCtest, ":test");
+  DEFSYM (QCsize, ":size");
+  DEFSYM (QCrehash_size, ":rehash-size");
+  DEFSYM (QCrehash_threshold, ":rehash-threshold");
+  DEFSYM (QCweakness, ":weakness");
+  DEFSYM (Qkey, "key");
+  DEFSYM (Qvalue, "value");
+  DEFSYM (Qhash_table_test, "hash-table-test");
+  DEFSYM (Qkey_or_value, "key-or-value");
+  DEFSYM (Qkey_and_value, "key-and-value");
 
   defsubr (&Ssxhash);
   defsubr (&Smake_hash_table);
@@ -4900,18 +4886,12 @@ syms_of_fns (void)
   defsubr (&Smaphash);
   defsubr (&Sdefine_hash_table_test);
 
-  Qstring_lessp = intern_c_string ("string-lessp");
-  staticpro (&Qstring_lessp);
-  Qprovide = intern_c_string ("provide");
-  staticpro (&Qprovide);
-  Qrequire = intern_c_string ("require");
-  staticpro (&Qrequire);
-  Qyes_or_no_p_history = intern_c_string ("yes-or-no-p-history");
-  staticpro (&Qyes_or_no_p_history);
-  Qcursor_in_echo_area = intern_c_string ("cursor-in-echo-area");
-  staticpro (&Qcursor_in_echo_area);
-  Qwidget_type = intern_c_string ("widget-type");
-  staticpro (&Qwidget_type);
+  DEFSYM (Qstring_lessp, "string-lessp");
+  DEFSYM (Qprovide, "provide");
+  DEFSYM (Qrequire, "require");
+  DEFSYM (Qyes_or_no_p_history, "yes-or-no-p-history");
+  DEFSYM (Qcursor_in_echo_area, "cursor-in-echo-area");
+  DEFSYM (Qwidget_type, "widget-type");
 
   staticpro (&string_char_byte_cache_string);
   string_char_byte_cache_string = Qnil;
@@ -4925,18 +4905,13 @@ syms_of_fns (void)
     doc: /* A list of symbols which are the features of the executing Emacs.
 Used by `featurep' and `require', and altered by `provide'.  */);
   Vfeatures = Fcons (intern_c_string ("emacs"), Qnil);
-  Qsubfeatures = intern_c_string ("subfeatures");
-  staticpro (&Qsubfeatures);
+  DEFSYM (Qsubfeatures, "subfeatures");
 
 #ifdef HAVE_LANGINFO_CODESET
-  Qcodeset = intern_c_string ("codeset");
-  staticpro (&Qcodeset);
-  Qdays = intern_c_string ("days");
-  staticpro (&Qdays);
-  Qmonths = intern_c_string ("months");
-  staticpro (&Qmonths);
-  Qpaper = intern_c_string ("paper");
-  staticpro (&Qpaper);
+  DEFSYM (Qcodeset, "codeset");
+  DEFSYM (Qdays, "days");
+  DEFSYM (Qmonths, "months");
+  DEFSYM (Qpaper, "paper");
 #endif  /* HAVE_LANGINFO_CODESET */
 
   DEFVAR_BOOL ("use-dialog-box", use_dialog_box,
diff --git a/src/frame.c b/src/frame.c
index 27a31fac3e7..635996ca424 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -4240,104 +4240,58 @@ selected frame.  This is useful when `make-pointer-invisible' is set.  */)
 void
 syms_of_frame (void)
 {
-  Qframep = intern_c_string ("framep");
-  staticpro (&Qframep);
-  Qframe_live_p = intern_c_string ("frame-live-p");
-  staticpro (&Qframe_live_p);
-  Qexplicit_name = intern_c_string ("explicit-name");
-  staticpro (&Qexplicit_name);
-  Qheight = intern_c_string ("height");
-  staticpro (&Qheight);
-  Qicon = intern_c_string ("icon");
-  staticpro (&Qicon);
-  Qminibuffer = intern_c_string ("minibuffer");
-  staticpro (&Qminibuffer);
-  Qmodeline = intern_c_string ("modeline");
-  staticpro (&Qmodeline);
-  Qonly = intern_c_string ("only");
-  staticpro (&Qonly);
-  Qwidth = intern_c_string ("width");
-  staticpro (&Qwidth);
-  Qgeometry = intern_c_string ("geometry");
-  staticpro (&Qgeometry);
-  Qicon_left = intern_c_string ("icon-left");
-  staticpro (&Qicon_left);
-  Qicon_top = intern_c_string ("icon-top");
-  staticpro (&Qicon_top);
-  Qtooltip = intern_c_string ("tooltip");
-  staticpro (&Qtooltip);
-  Qleft = intern_c_string ("left");
-  staticpro (&Qleft);
-  Qright = intern_c_string ("right");
-  staticpro (&Qright);
-  Quser_position = intern_c_string ("user-position");
-  staticpro (&Quser_position);
-  Quser_size = intern_c_string ("user-size");
-  staticpro (&Quser_size);
-  Qwindow_id = intern_c_string ("window-id");
-  staticpro (&Qwindow_id);
+  DEFSYM (Qframep, "framep");
+  DEFSYM (Qframe_live_p, "frame-live-p");
+  DEFSYM (Qexplicit_name, "explicit-name");
+  DEFSYM (Qheight, "height");
+  DEFSYM (Qicon, "icon");
+  DEFSYM (Qminibuffer, "minibuffer");
+  DEFSYM (Qmodeline, "modeline");
+  DEFSYM (Qonly, "only");
+  DEFSYM (Qwidth, "width");
+  DEFSYM (Qgeometry, "geometry");
+  DEFSYM (Qicon_left, "icon-left");
+  DEFSYM (Qicon_top, "icon-top");
+  DEFSYM (Qtooltip, "tooltip");
+  DEFSYM (Qleft, "left");
+  DEFSYM (Qright, "right");
+  DEFSYM (Quser_position, "user-position");
+  DEFSYM (Quser_size, "user-size");
+  DEFSYM (Qwindow_id, "window-id");
 #ifdef HAVE_X_WINDOWS
-  Qouter_window_id = intern_c_string ("outer-window-id");
-  staticpro (&Qouter_window_id);
+  DEFSYM (Qouter_window_id, "outer-window-id");
 #endif
-  Qparent_id = intern_c_string ("parent-id");
-  staticpro (&Qparent_id);
-  Qx = intern_c_string ("x");
-  staticpro (&Qx);
-  Qw32 = intern_c_string ("w32");
-  staticpro (&Qw32);
-  Qpc = intern_c_string ("pc");
-  staticpro (&Qpc);
-  Qmac = intern_c_string ("mac");
-  staticpro (&Qmac);
-  Qns = intern_c_string ("ns");
-  staticpro (&Qns);
-  Qvisible = intern_c_string ("visible");
-  staticpro (&Qvisible);
-  Qbuffer_predicate = intern_c_string ("buffer-predicate");
-  staticpro (&Qbuffer_predicate);
-  Qbuffer_list = intern_c_string ("buffer-list");
-  staticpro (&Qbuffer_list);
-  Qburied_buffer_list = intern_c_string ("buried-buffer-list");
-  staticpro (&Qburied_buffer_list);
-  Qdisplay_type = intern_c_string ("display-type");
-  staticpro (&Qdisplay_type);
-  Qbackground_mode = intern_c_string ("background-mode");
-  staticpro (&Qbackground_mode);
-  Qnoelisp = intern_c_string ("noelisp");
-  staticpro (&Qnoelisp);
-  Qtty_color_mode = intern_c_string ("tty-color-mode");
-  staticpro (&Qtty_color_mode);
-  Qtty = intern_c_string ("tty");
-  staticpro (&Qtty);
-  Qtty_type = intern_c_string ("tty-type");
-  staticpro (&Qtty_type);
-
-  Qface_set_after_frame_default = intern_c_string ("face-set-after-frame-default");
-  staticpro (&Qface_set_after_frame_default);
-
-  Qfullwidth = intern_c_string ("fullwidth");
-  staticpro (&Qfullwidth);
-  Qfullheight = intern_c_string ("fullheight");
-  staticpro (&Qfullheight);
-  Qfullboth = intern_c_string ("fullboth");
-  staticpro (&Qfullboth);
-  Qmaximized = intern_c_string ("maximized");
-  staticpro (&Qmaximized);
-  Qx_resource_name = intern_c_string ("x-resource-name");
-  staticpro (&Qx_resource_name);
-
-  Qx_frame_parameter = intern_c_string ("x-frame-parameter");
-  staticpro (&Qx_frame_parameter);
-
-  Qterminal = intern_c_string ("terminal");
-  staticpro (&Qterminal);
-  Qterminal_live_p = intern_c_string ("terminal-live-p");
-  staticpro (&Qterminal_live_p);
+  DEFSYM (Qparent_id, "parent-id");
+  DEFSYM (Qx, "x");
+  DEFSYM (Qw32, "w32");
+  DEFSYM (Qpc, "pc");
+  DEFSYM (Qmac, "mac");
+  DEFSYM (Qns, "ns");
+  DEFSYM (Qvisible, "visible");
+  DEFSYM (Qbuffer_predicate, "buffer-predicate");
+  DEFSYM (Qbuffer_list, "buffer-list");
+  DEFSYM (Qburied_buffer_list, "buried-buffer-list");
+  DEFSYM (Qdisplay_type, "display-type");
+  DEFSYM (Qbackground_mode, "background-mode");
+  DEFSYM (Qnoelisp, "noelisp");
+  DEFSYM (Qtty_color_mode, "tty-color-mode");
+  DEFSYM (Qtty, "tty");
+  DEFSYM (Qtty_type, "tty-type");
+
+  DEFSYM (Qface_set_after_frame_default, "face-set-after-frame-default");
+
+  DEFSYM (Qfullwidth, "fullwidth");
+  DEFSYM (Qfullheight, "fullheight");
+  DEFSYM (Qfullboth, "fullboth");
+  DEFSYM (Qmaximized, "maximized");
+  DEFSYM (Qx_resource_name, "x-resource-name");
+  DEFSYM (Qx_frame_parameter, "x-frame-parameter");
+
+  DEFSYM (Qterminal, "terminal");
+  DEFSYM (Qterminal_live_p, "terminal-live-p");
 
 #ifdef HAVE_NS
-  Qns_parse_geometry = intern_c_string ("ns-parse-geometry");
-  staticpro (&Qns_parse_geometry);
+  DEFSYM (Qns_parse_geometry, "ns-parse-geometry");
 #endif
 
   {
@@ -4451,8 +4405,7 @@ actually deleted, or some time later (or even both when an earlier function
 in `delete-frame-functions' (indirectly) calls `delete-frame'
 recursively).  */);
   Vdelete_frame_functions = Qnil;
-  Qdelete_frame_functions = intern_c_string ("delete-frame-functions");
-  staticpro (&Qdelete_frame_functions);
+  DEFSYM (Qdelete_frame_functions, "delete-frame-functions");
 
   DEFVAR_LISP ("menu-bar-mode", Vmenu_bar_mode,
                doc: /* Non-nil if Menu-Bar mode is enabled.
diff --git a/src/fringe.c b/src/fringe.c
index d886ac48852..a4dc9433aff 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1738,18 +1738,12 @@ Return nil if POS is not visible in WINDOW.  */)
 void
 syms_of_fringe (void)
 {
-  Qtruncation = intern_c_string ("truncation");
-  staticpro (&Qtruncation);
-  Qcontinuation = intern_c_string ("continuation");
-  staticpro (&Qcontinuation);
-  Qoverlay_arrow = intern_c_string ("overlay-arrow");
-  staticpro (&Qoverlay_arrow);
-  Qempty_line = intern_c_string ("empty-line");
-  staticpro (&Qempty_line);
-  Qtop_bottom = intern_c_string ("top-bottom");
-  staticpro (&Qtop_bottom);
-  Qhollow_small = intern_c_string ("hollow-small");
-  staticpro (&Qhollow_small);
+  DEFSYM (Qtruncation, "truncation");
+  DEFSYM (Qcontinuation, "continuation");
+  DEFSYM (Qoverlay_arrow, "overlay-arrow");
+  DEFSYM (Qempty_line, "empty-line");
+  DEFSYM (Qtop_bottom, "top-bottom");
+  DEFSYM (Qhollow_small, "hollow-small");
 
   defsubr (&Sdestroy_fringe_bitmap);
   defsubr (&Sdefine_fringe_bitmap);
diff --git a/src/gnutls.c b/src/gnutls.c
index 9342ce7912e..b59d0b265f2 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -1101,72 +1101,36 @@ syms_of_gnutls (void)
 {
   gnutls_global_initialized = 0;
 
-  Qgnutls_dll = intern_c_string ("gnutls");
-  staticpro (&Qgnutls_dll);
-
-  Qgnutls_log_level = intern_c_string ("gnutls-log-level");
-  staticpro (&Qgnutls_log_level);
-
-  Qgnutls_code = intern_c_string ("gnutls-code");
-  staticpro (&Qgnutls_code);
-
-  Qgnutls_anon = intern_c_string ("gnutls-anon");
-  staticpro (&Qgnutls_anon);
-
-  Qgnutls_x509pki = intern_c_string ("gnutls-x509pki");
-  staticpro (&Qgnutls_x509pki);
-
-  Qgnutls_bootprop_hostname = intern_c_string (":hostname");
-  staticpro (&Qgnutls_bootprop_hostname);
-
-  Qgnutls_bootprop_priority = intern_c_string (":priority");
-  staticpro (&Qgnutls_bootprop_priority);
-
-  Qgnutls_bootprop_trustfiles = intern_c_string (":trustfiles");
-  staticpro (&Qgnutls_bootprop_trustfiles);
-
-  Qgnutls_bootprop_keylist = intern_c_string (":keylist");
-  staticpro (&Qgnutls_bootprop_keylist);
-
-  Qgnutls_bootprop_crlfiles = intern_c_string (":crlfiles");
-  staticpro (&Qgnutls_bootprop_crlfiles);
-
-  Qgnutls_bootprop_callbacks = intern_c_string (":callbacks");
-  staticpro (&Qgnutls_bootprop_callbacks);
-
-  Qgnutls_bootprop_callbacks_verify = intern_c_string ("verify");
-  staticpro (&Qgnutls_bootprop_callbacks_verify);
-
-  Qgnutls_bootprop_loglevel = intern_c_string (":loglevel");
-  staticpro (&Qgnutls_bootprop_loglevel);
-
-  Qgnutls_bootprop_verify_flags = intern_c_string (":verify-flags");
-  staticpro (&Qgnutls_bootprop_verify_flags);
-
-  Qgnutls_bootprop_verify_hostname_error = intern_c_string (":verify-error");
-  staticpro (&Qgnutls_bootprop_verify_error);
-
-  Qgnutls_bootprop_verify_hostname_error = intern_c_string (":verify-hostname-error");
-  staticpro (&Qgnutls_bootprop_verify_hostname_error);
-
-  Qgnutls_e_interrupted = intern_c_string ("gnutls-e-interrupted");
-  staticpro (&Qgnutls_e_interrupted);
+  DEFSYM(Qgnutls_dll, "gnutls");
+  DEFSYM(Qgnutls_log_level, "gnutls-log-level");
+  DEFSYM(Qgnutls_code, "gnutls-code");
+  DEFSYM(Qgnutls_anon, "gnutls-anon");
+  DEFSYM(Qgnutls_x509pki, "gnutls-x509pki");
+  DEFSYM(Qgnutls_bootprop_hostname, ":hostname");
+  DEFSYM(Qgnutls_bootprop_priority, ":priority");
+  DEFSYM(Qgnutls_bootprop_trustfiles, ":trustfiles");
+  DEFSYM(Qgnutls_bootprop_keylist, ":keylist");
+  DEFSYM(Qgnutls_bootprop_crlfiles, ":crlfiles");
+  DEFSYM(Qgnutls_bootprop_callbacks, ":callbacks");
+  DEFSYM(Qgnutls_bootprop_callbacks_verify, "verify");
+  DEFSYM(Qgnutls_bootprop_loglevel, ":loglevel");
+  DEFSYM(Qgnutls_bootprop_verify_flags, ":verify-flags");
+  DEFSYM(Qgnutls_bootprop_verify_hostname_error, ":verify-error");
+  DEFSYM(Qgnutls_bootprop_verify_hostname_error, ":verify-hostname-error");
+
+  DEFSYM(Qgnutls_e_interrupted, "gnutls-e-interrupted");
   Fput (Qgnutls_e_interrupted, Qgnutls_code,
         make_number (GNUTLS_E_INTERRUPTED));
 
-  Qgnutls_e_again = intern_c_string ("gnutls-e-again");
-  staticpro (&Qgnutls_e_again);
+  DEFSYM(Qgnutls_e_again, "gnutls-e-again");
   Fput (Qgnutls_e_again, Qgnutls_code,
         make_number (GNUTLS_E_AGAIN));
 
-  Qgnutls_e_invalid_session = intern_c_string ("gnutls-e-invalid-session");
-  staticpro (&Qgnutls_e_invalid_session);
+  DEFSYM(Qgnutls_e_invalid_session, "gnutls-e-invalid-session");
   Fput (Qgnutls_e_invalid_session, Qgnutls_code,
         make_number (GNUTLS_E_INVALID_SESSION));
 
-  Qgnutls_e_not_ready_for_handshake =
-    intern_c_string ("gnutls-e-not-ready-for-handshake");
-  staticpro (&Qgnutls_e_not_ready_for_handshake);
+  DEFSYM(Qgnutls_e_not_ready_for_handshake, "gnutls-e-not-ready-for-handshake");
   Fput (Qgnutls_e_not_ready_for_handshake, Qgnutls_code,
         make_number (GNUTLS_E_APPLICATION_ERROR_MIN));
 
diff --git a/src/image.c b/src/image.c
index a9785e5d00f..6e8440fb431 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1836,6 +1836,8 @@ cache_image (struct frame *f, struct image *img)
   /* If no free slot found, maybe enlarge c->images.  */
   if (i == c->used && c->used == c->size)
     {
+      if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *c->images / 2 < c->size)
+        memory_full (SIZE_MAX);
       c->size *= 2;
       c->images = (struct image **) xrealloc (c->images,
                                               c->size * sizeof *c->images);
diff --git a/src/insdel.c b/src/insdel.c
index 64fd4797dc0..b6639f3ad8b 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -2222,8 +2222,7 @@ syms_of_insdel (void)
 This affects `before-change-functions' and `after-change-functions',
 as well as hooks attached to text properties and overlays.  */);
   inhibit_modification_hooks = 0;
-  Qinhibit_modification_hooks = intern_c_string ("inhibit-modification-hooks");
-  staticpro (&Qinhibit_modification_hooks);
+  DEFSYM (Qinhibit_modification_hooks, "inhibit-modification-hooks");
 
   defsubr (&Scombine_after_change_execute);
 }
diff --git a/src/keyboard.h b/src/keyboard.h
index 20763c35f3a..91008a3ea24 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -123,7 +123,7 @@ struct kboard
     Lisp_Object *kbd_macro_end;
 
     /* Allocated size of kbd_macro_buffer.  */
-    int kbd_macro_bufsize;
+    ptrdiff_t kbd_macro_bufsize;
 
     /* Last anonymous kbd macro defined.  */
     Lisp_Object KBOARD_INTERNAL_FIELD (Vlast_kbd_macro);
diff --git a/src/keymap.c b/src/keymap.c
index 6ef2a716b6d..ac7f651e283 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -3774,15 +3774,13 @@ Return list of symbols found.  */)
 void
 syms_of_keymap (void)
 {
-  Qkeymap = intern_c_string ("keymap");
-  staticpro (&Qkeymap);
+  DEFSYM (Qkeymap, "keymap");
   staticpro (&apropos_predicate);
   staticpro (&apropos_accumulate);
   apropos_predicate = Qnil;
   apropos_accumulate = Qnil;
 
-  Qkeymap_canonicalize = intern_c_string ("keymap-canonicalize");
-  staticpro (&Qkeymap_canonicalize);
+  DEFSYM (Qkeymap_canonicalize, "keymap-canonicalize");
 
   /* Now we are ready to set up this property, so we can
      create char tables.  */
@@ -3902,27 +3900,13 @@ preferred.  */);
                   pure_cons (intern_c_string ("mouse-5"),
                              Qnil)))))))));
 
-
-  Qsingle_key_description = intern_c_string ("single-key-description");
-  staticpro (&Qsingle_key_description);
-
-  Qkey_description = intern_c_string ("key-description");
-  staticpro (&Qkey_description);
-
-  Qkeymapp = intern_c_string ("keymapp");
-  staticpro (&Qkeymapp);
-
-  Qnon_ascii = intern_c_string ("non-ascii");
-  staticpro (&Qnon_ascii);
-
-  Qmenu_item = intern_c_string ("menu-item");
-  staticpro (&Qmenu_item);
-
-  Qremap = intern_c_string ("remap");
-  staticpro (&Qremap);
-
-  QCadvertised_binding = intern_c_string (":advertised-binding");
-  staticpro (&QCadvertised_binding);
+  DEFSYM (Qsingle_key_description, "single-key-description");
+  DEFSYM (Qkey_description, "key-description");
+  DEFSYM (Qkeymapp, "keymapp");
+  DEFSYM (Qnon_ascii, "non-ascii");
+  DEFSYM (Qmenu_item, "menu-item");
+  DEFSYM (Qremap, "remap");
+  DEFSYM (QCadvertised_binding, ":advertised-binding");
 
   command_remapping_vector = Fmake_vector (make_number (2), Qremap);
   staticpro (&command_remapping_vector);
diff --git a/src/lisp.h b/src/lisp.h
index 4c9543bdfe8..762d34abb9c 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1162,6 +1162,9 @@ struct Lisp_Symbol
 
 #define SYMBOL_CONSTANT_P(sym)   XSYMBOL (sym)->constant
 
+#define DEFSYM(sym, name)       \
+  do { (sym) = intern_c_string ((name)); staticpro (&(sym)); } while (0)
+
 
 /***********************************************************************
                              Hash Tables
@@ -1980,10 +1983,7 @@ extern void defvar_kboard (struct Lisp_Kboard_Objfwd *, const char *, int);
 #define DEFVAR_KBOARD(lname, vname, doc)                        \
   do {                                                          \
     static struct Lisp_Kboard_Objfwd ko_fwd;                    \
-    defvar_kboard (&ko_fwd,                                     \
-                   lname,                                       \
-                   (int)((char *)(&current_kboard->vname ## _)  \
-                         - (char *)current_kboard));            \
+    defvar_kboard (&ko_fwd, lname, offsetof (KBOARD, vname ## _)); \
   } while (0)
 
 
diff --git a/src/lread.c b/src/lread.c
index e75d61ae985..f937fa39f0f 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -120,9 +120,9 @@ static EMACS_INT readchar_count;
 /* This contains the last string skipped with #@.  */
 static char *saved_doc_string;
 /* Length of buffer allocated in saved_doc_string.  */
-static int saved_doc_string_size;
+static ptrdiff_t saved_doc_string_size;
 /* Length of actual data in saved_doc_string.  */
-static int saved_doc_string_length;
+static ptrdiff_t saved_doc_string_length;
 /* This is the file position that string came from.  */
 static file_offset saved_doc_string_position;
 
@@ -131,9 +131,9 @@ static file_offset saved_doc_string_position;
    is put in saved_doc_string.  */
 static char *prev_saved_doc_string;
 /* Length of buffer allocated in prev_saved_doc_string.  */
-static int prev_saved_doc_string_size;
+static ptrdiff_t prev_saved_doc_string_size;
 /* Length of actual data in prev_saved_doc_string.  */
-static int prev_saved_doc_string_length;
+static ptrdiff_t prev_saved_doc_string_length;
 /* This is the file position that string came from.  */
 static file_offset prev_saved_doc_string_position;
 
@@ -1069,9 +1069,9 @@ Return t if the file exists and loads successfully.  */)
 
   /* Avoid weird lossage with null string as arg,
      since it would try to load a directory as a Lisp file */
-  if (SCHARS (file) > 0)
+  if (SBYTES (file) > 0)
     {
-      int size = SBYTES (file);
+      ptrdiff_t size = SBYTES (file);
 
       found = Qnil;
       GCPRO2 (file, found);
@@ -1472,7 +1472,7 @@ openp (Lisp_Object path, Lisp_Object str, Lisp_Object suffixes, Lisp_Object *sto
       for (tail = NILP (suffixes) ? Fcons (empty_unibyte_string, Qnil) : suffixes;
            CONSP (tail); tail = XCDR (tail))
         {
-          int lsuffix = SBYTES (XCAR (tail));
+          ptrdiff_t lsuffix = SBYTES (XCAR (tail));
           Lisp_Object handler;
           int exists;
 
@@ -2037,7 +2037,7 @@ read0 (Lisp_Object readcharfun)
             Fmake_string (make_number (1), make_number (c)));
 }
 
-static int read_buffer_size;
+static ptrdiff_t read_buffer_size;
 static char *read_buffer;
 
 /* Read a \-escape sequence, assuming we already read the `\'.
@@ -2208,7 +2208,9 @@ read_escape (Lisp_Object readcharfun, int stringp)
                 UNREAD (c);
                 break;
               }
-            count++;
+            if (MAX_CHAR < i)
+              error ("Hex character out of range: \\x%x...", i);
+            count += count < 3;
           }
 
         if (count < 3 && i >= 0x80)
@@ -2236,10 +2238,7 @@ read_escape (Lisp_Object readcharfun, int stringp)
             else if (c >= 'a' && c <= 'f')  i = (i << 4) + (c - 'a') + 10;
             else if (c >= 'A' && c <= 'F')  i = (i << 4) + (c - 'A') + 10;
             else
-              {
-                error ("Non-hex digit used for Unicode escape");
-                break;
-              }
+              error ("Non-hex digit used for Unicode escape");
           }
         if (i > 0x10FFFF)
           error ("Non-Unicode character: 0x%x", i);
@@ -2278,10 +2277,12 @@ digit_to_number (int character, int base)
    range.  */
 
 static Lisp_Object
-read_integer (Lisp_Object readcharfun, int radix)
+read_integer (Lisp_Object readcharfun, EMACS_INT radix)
 {
-  /* Room for sign, leading 0, other digits, trailing null byte.  */
-  char buf[1 + 1 + sizeof (uintmax_t) * CHAR_BIT + 1];
+  /* Room for sign, leading 0, other digits, trailing null byte.
+     Also, room for invalid syntax diagnostic.  */
+  char buf[max (1 + 1 + sizeof (uintmax_t) * CHAR_BIT + 1,
+                sizeof "integer, radix " + INT_STRLEN_BOUND (EMACS_INT))];
 
   int valid = -1; /* 1 if valid, 0 if not, -1 if incomplete.  */
 
@@ -2333,7 +2334,7 @@ read_integer (Lisp_Object readcharfun, int radix)
 
   if (! valid)
     {
-      sprintf (buf, "integer, radix %d", radix);
+      sprintf (buf, "integer, radix %"pI"d", radix);
       invalid_syntax (buf);
     }
 
@@ -2471,7 +2472,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
               if (c == '[')
                 {
                   Lisp_Object tmp;
-                  int depth, size;
+                  EMACS_INT depth, size;
 
                   tmp = read_vector (readcharfun, 0);
                   if (!INTEGERP (AREF (tmp, 0)))
@@ -2497,7 +2498,7 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
           if (c == '"')
             {
               Lisp_Object tmp, val;
-              int size_in_chars
+              EMACS_INT size_in_chars
                 = ((XFASTINT (length) + BOOL_VECTOR_BITS_PER_CHAR - 1)
                    / BOOL_VECTOR_BITS_PER_CHAR);
 
@@ -2569,13 +2570,16 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
          and function definitions.  */
       if (c == '@')
         {
-          int i, nskip = 0;
+          enum { extra = 100 };
+          ptrdiff_t i, nskip = 0;
 
           load_each_byte = 1;
           /* Read a decimal integer.  */
           while ((c = READCHAR) >= 0
                  && c >= '0' && c <= '9')
             {
+              if ((STRING_BYTES_BOUND - extra) / 10 <= nskip)
+                string_overflow ();
               nskip *= 10;
               nskip += c - '0';
             }
@@ -2594,9 +2598,9 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
                  with prev_saved_doc_string, so we save two strings.  */
               {
                 char *temp = saved_doc_string;
-                int temp_size = saved_doc_string_size;
+                ptrdiff_t temp_size = saved_doc_string_size;
                 file_offset temp_pos = saved_doc_string_position;
-                int temp_len = saved_doc_string_length;
+                ptrdiff_t temp_len = saved_doc_string_length;
 
                 saved_doc_string = prev_saved_doc_string;
                 saved_doc_string_size = prev_saved_doc_string_size;
@@ -2611,12 +2615,12 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
 
               if (saved_doc_string_size == 0)
                 {
-                  saved_doc_string_size = nskip + 100;
+                  saved_doc_string_size = nskip + extra;
                   saved_doc_string = (char *) xmalloc (saved_doc_string_size);
                 }
               if (nskip > saved_doc_string_size)
                 {
-                  saved_doc_string_size = nskip + 100;
+                  saved_doc_string_size = nskip + extra;
                   saved_doc_string = (char *) xrealloc (saved_doc_string,
                                                         saved_doc_string_size);
                 }
@@ -2661,49 +2665,60 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
       /* Reader forms that can reuse previously read objects.  */
       if (c >= '0' && c <= '9')
         {
-          int n = 0;
+          EMACS_INT n = 0;
           Lisp_Object tem;
 
           /* Read a non-negative integer.  */
           while (c >= '0' && c <= '9')
             {
-              n *= 10;
-              n += c - '0';
+              if (MOST_POSITIVE_FIXNUM / 10 < n
+                  || MOST_POSITIVE_FIXNUM < n * 10 + c - '0')
+                n = MOST_POSITIVE_FIXNUM + 1;
+              else
+                n = n * 10 + c - '0';
               c = READCHAR;
             }
-          /* #n=object returns object, but associates it with n for #n#.  */
-          if (c == '=' && !NILP (Vread_circle))
+
+          if (n <= MOST_POSITIVE_FIXNUM)
             {
-              /* Make a placeholder for #n# to use temporarily */
-              Lisp_Object placeholder;
-              Lisp_Object cell;
+              if (c == 'r' || c == 'R')
+                return read_integer (readcharfun, n);
 
-              placeholder = Fcons (Qnil, Qnil);
-              cell = Fcons (make_number (n), placeholder);
-              read_objects = Fcons (cell, read_objects);
+              if (! NILP (Vread_circle))
+                {
+                  /* #n=object returns object, but associates it with
+                      n for #n#.  */
+                  if (c == '=')
+                    {
+                      /* Make a placeholder for #n# to use temporarily */
+                      Lisp_Object placeholder;
+                      Lisp_Object cell;
 
-              /* Read the object itself. */
-              tem = read0 (readcharfun);
+                      placeholder = Fcons (Qnil, Qnil);
+                      cell = Fcons (make_number (n), placeholder);
+                      read_objects = Fcons (cell, read_objects);
 
-              /* Now put it everywhere the placeholder was... */
-              substitute_object_in_subtree (tem, placeholder);
+                      /* Read the object itself. */
+                      tem = read0 (readcharfun);
 
-              /* ...and #n# will use the real value from now on.  */
-              Fsetcdr (cell, tem);
+                      /* Now put it everywhere the placeholder was... */
+                      substitute_object_in_subtree (tem, placeholder);
 
-              return tem;
-            }
-          /* #n# returns a previously read object.  */
-          if (c == '#' && !NILP (Vread_circle))
-            {
-              tem = Fassq (make_number (n), read_objects);
-              if (CONSP (tem))
-                return XCDR (tem);
-              /* Fall through to error message.  */
-            }
-          else if (c == 'r' ||  c == 'R')
-            return read_integer (readcharfun, n);
+                      /* ...and #n# will use the real value from now on.  */
+                      Fsetcdr (cell, tem);
+
+                      return tem;
+                    }
 
+                  /* #n# returns a previously read object.  */
+                  if (c == '#')
+                    {
+                      tem = Fassq (make_number (n), read_objects);
+                      if (CONSP (tem))
+                        return XCDR (tem);
+                    }
+                }
+            }
           /* Fall through to error message.  */
         }
       else if (c == 'x' || c == 'X')
@@ -2846,14 +2861,16 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
            a single-byte character.  */
         int force_singlebyte = 0;
         int cancel = 0;
-        int nchars = 0;
+        ptrdiff_t nchars = 0;
 
         while ((ch = READCHAR) >= 0
                && ch != '\"')
           {
             if (end - p < MAX_MULTIBYTE_LENGTH)
               {
-                int offset = p - read_buffer;
+                ptrdiff_t offset = p - read_buffer;
+                if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
+                  memory_full (SIZE_MAX);
                 read_buffer = (char *) xrealloc (read_buffer,
                                                  read_buffer_size *= 2);
                 p = read_buffer + offset;
@@ -2996,7 +3013,9 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
             {
               if (end - p < MAX_MULTIBYTE_LENGTH)
                 {
-                  int offset = p - read_buffer;
+                  ptrdiff_t offset = p - read_buffer;
+                  if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
+                    memory_full (SIZE_MAX);
                   read_buffer = (char *) xrealloc (read_buffer,
                                                    read_buffer_size *= 2);
                   p = read_buffer + offset;
@@ -3023,7 +3042,9 @@ read1 (register Lisp_Object readcharfun, int *pch, int first_in_list)
 
           if (p == end)
             {
-              int offset = p - read_buffer;
+              ptrdiff_t offset = p - read_buffer;
+              if (min (PTRDIFF_MAX, SIZE_MAX) / 2 < read_buffer_size)
+                memory_full (SIZE_MAX);
               read_buffer = (char *) xrealloc (read_buffer,
                                                read_buffer_size *= 2);
               p = read_buffer + offset;
@@ -3135,7 +3156,7 @@ substitute_object_recurse (Lisp_Object object, Lisp_Object placeholder, Lisp_Obj
     {
     case Lisp_Vectorlike:
       {
-        int i, length = 0;
+        ptrdiff_t i, length = 0;
         if (BOOL_VECTOR_P (subtree))
           return subtree;               /* No sub-objects anyway.  */
         else if (CHAR_TABLE_P (subtree) || SUB_CHAR_TABLE_P (subtree)
@@ -3358,8 +3379,7 @@ string_to_number (char const *string, int base, int ignore_trailing)
 static Lisp_Object
 read_vector (Lisp_Object readcharfun, int bytecodeflag)
 {
-  register int i;
-  register int size;
+  ptrdiff_t i, size;
   register Lisp_Object *ptr;
   register Lisp_Object tem, item, vector;
   register struct Lisp_Cons *otem;
@@ -3528,15 +3548,15 @@ read_list (int flag, register Lisp_Object readcharfun)
                          doc string, caller must make it
                          multibyte.  */
 
-                      int pos = XINT (XCDR (val));
+                      EMACS_INT pos = XINT (XCDR (val));
                       /* Position is negative for user variables.  */
                       if (pos < 0) pos = -pos;
                       if (pos >= saved_doc_string_position
                           && pos < (saved_doc_string_position
                                     + saved_doc_string_length))
                         {
-                          int start = pos - saved_doc_string_position;
-                          int from, to;
+                          ptrdiff_t start = pos - saved_doc_string_position;
+                          ptrdiff_t from, to;
 
                           /* Process quoting with ^A,
                              and find the end of the string,
@@ -3567,8 +3587,9 @@ read_list (int flag, register Lisp_Object readcharfun)
                                && pos < (prev_saved_doc_string_position
                                          + prev_saved_doc_string_length))
                         {
-                          int start = pos - prev_saved_doc_string_position;
-                          int from, to;
+                          ptrdiff_t start =
+                            pos - prev_saved_doc_string_position;
+                          ptrdiff_t from, to;
 
                           /* Process quoting with ^A,
                              and find the end of the string,
@@ -3891,7 +3912,7 @@ hash_string (const char *ptr, size_t len)
 void
 map_obarray (Lisp_Object obarray, void (*fn) (Lisp_Object, Lisp_Object), Lisp_Object arg)
 {
-  register int i;
+  ptrdiff_t i;
   register Lisp_Object tail;
   CHECK_VECTOR (obarray);
   for (i = ASIZE (obarray) - 1; i >= 0; i--)
@@ -3962,8 +3983,7 @@ init_obarray (void)
   /* Qt is correct even if CANNOT_DUMP.  loadup.el will set to nil at end.  */
   Vpurify_flag = Qt;
 
-  Qvariable_documentation = intern_c_string ("variable-documentation");
-  staticpro (&Qvariable_documentation);
+  DEFSYM (Qvariable_documentation, "variable-documentation");
 
   read_buffer_size = 100 + MAX_MULTIBYTE_LENGTH;
   read_buffer = (char *) xmalloc (read_buffer_size);
@@ -3991,7 +4011,7 @@ defalias (sname, string)
 #endif /* NOTDEF */
 
 /* Define an "integer variable"; a symbol whose value is forwarded to a
-   C variable of type int.  Sample call (munged w "xx" to fool make-docfile):
+   C variable of type EMACS_INT.  Sample call (with "xx" to fool make-docfile):
    DEFxxVAR_INT ("emacs-priority", &emacs_priority, "Documentation");  */
 void
 defvar_int (struct Lisp_Intfwd *i_fwd,
@@ -4371,8 +4391,7 @@ customize `jka-compr-load-suffixes' rather than the present variable.  */);
 
   DEFVAR_BOOL ("load-in-progress", load_in_progress,
                doc: /* Non-nil if inside of `load'.  */);
-  Qload_in_progress = intern_c_string ("load-in-progress");
-  staticpro (&Qload_in_progress);
+  DEFSYM (Qload_in_progress, "load-in-progress");
 
   DEFVAR_LISP ("after-load-alist", Vafter_load_alist,
                doc: /* An alist of expressions to be evalled when particular files are loaded.
@@ -4503,67 +4522,34 @@ This variable is automatically set from the file variables of an interpreted
   DEFVAR_LISP ("old-style-backquotes", Vold_style_backquotes,
                doc: /* Set to non-nil when `read' encounters an old-style backquote.  */);
   Vold_style_backquotes = Qnil;
-  Qold_style_backquotes = intern_c_string ("old-style-backquotes");
-  staticpro (&Qold_style_backquotes);
+  DEFSYM (Qold_style_backquotes, "old-style-backquotes");
 
   /* Vsource_directory was initialized in init_lread.  */
 
   load_descriptor_list = Qnil;
   staticpro (&load_descriptor_list);
 
-  Qcurrent_load_list = intern_c_string ("current-load-list");
-  staticpro (&Qcurrent_load_list);
-
-  Qstandard_input = intern_c_string ("standard-input");
-  staticpro (&Qstandard_input);
-
-  Qread_char = intern_c_string ("read-char");
-  staticpro (&Qread_char);
-
-  Qget_file_char = intern_c_string ("get-file-char");
-  staticpro (&Qget_file_char);
-
-  Qget_emacs_mule_file_char = intern_c_string ("get-emacs-mule-file-char");
-  staticpro (&Qget_emacs_mule_file_char);
-
-  Qload_force_doc_strings = intern_c_string ("load-force-doc-strings");
-  staticpro (&Qload_force_doc_strings);
-
-  Qbackquote = intern_c_string ("`");
-  staticpro (&Qbackquote);
-  Qcomma = intern_c_string (",");
-  staticpro (&Qcomma);
-  Qcomma_at = intern_c_string (",@");
-  staticpro (&Qcomma_at);
-  Qcomma_dot = intern_c_string (",.");
-  staticpro (&Qcomma_dot);
-
-  Qinhibit_file_name_operation = intern_c_string ("inhibit-file-name-operation");
-  staticpro (&Qinhibit_file_name_operation);
-
-  Qascii_character = intern_c_string ("ascii-character");
-  staticpro (&Qascii_character);
-
-  Qfunction = intern_c_string ("function");
-  staticpro (&Qfunction);
-
-  Qload = intern_c_string ("load");
-  staticpro (&Qload);
-
-  Qload_file_name = intern_c_string ("load-file-name");
-  staticpro (&Qload_file_name);
-
-  Qeval_buffer_list = intern_c_string ("eval-buffer-list");
-  staticpro (&Qeval_buffer_list);
-
-  Qfile_truename = intern_c_string ("file-truename");
-  staticpro (&Qfile_truename) ;
-
-  Qdir_ok = intern_c_string ("dir-ok");
-  staticpro (&Qdir_ok);
-
-  Qdo_after_load_evaluation = intern_c_string ("do-after-load-evaluation");
-  staticpro (&Qdo_after_load_evaluation) ;
+  DEFSYM (Qcurrent_load_list, "current-load-list");
+  DEFSYM (Qstandard_input, "standard-input");
+  DEFSYM (Qread_char, "read-char");
+  DEFSYM (Qget_file_char, "get-file-char");
+  DEFSYM (Qget_emacs_mule_file_char, "get-emacs-mule-file-char");
+  DEFSYM (Qload_force_doc_strings, "load-force-doc-strings");
+
+  DEFSYM (Qbackquote, "`");
+  DEFSYM (Qcomma, ",");
+  DEFSYM (Qcomma_at, ",@");
+  DEFSYM (Qcomma_dot, ",.");
+
+  DEFSYM (Qinhibit_file_name_operation, "inhibit-file-name-operation");
+  DEFSYM (Qascii_character, "ascii-character");
+  DEFSYM (Qfunction, "function");
+  DEFSYM (Qload, "load");
+  DEFSYM (Qload_file_name, "load-file-name");
+  DEFSYM (Qeval_buffer_list, "eval-buffer-list");
+  DEFSYM (Qfile_truename, "file-truename");
+  DEFSYM (Qdir_ok, "dir-ok");
+  DEFSYM (Qdo_after_load_evaluation, "do-after-load-evaluation");
 
   staticpro (&dump_path);
 
@@ -4575,18 +4561,11 @@ This variable is automatically set from the file variables of an interpreted
   Vloads_in_progress = Qnil;
   staticpro (&Vloads_in_progress);
 
-  Qhash_table = intern_c_string ("hash-table");
-  staticpro (&Qhash_table);
-  Qdata = intern_c_string ("data");
-  staticpro (&Qdata);
-  Qtest = intern_c_string ("test");
-  staticpro (&Qtest);
-  Qsize = intern_c_string ("size");
-  staticpro (&Qsize);
-  Qweakness = intern_c_string ("weakness");
-  staticpro (&Qweakness);
-  Qrehash_size = intern_c_string ("rehash-size");
-  staticpro (&Qrehash_size);
-  Qrehash_threshold = intern_c_string ("rehash-threshold");
-  staticpro (&Qrehash_threshold);
+  DEFSYM (Qhash_table, "hash-table");
+  DEFSYM (Qdata, "data");
+  DEFSYM (Qtest, "test");
+  DEFSYM (Qsize, "size");
+  DEFSYM (Qweakness, "weakness");
+  DEFSYM (Qrehash_size, "rehash-size");
+  DEFSYM (Qrehash_threshold, "rehash-threshold");
 }
diff --git a/src/macros.c b/src/macros.c
index 3523e513d6a..60f30c3fbbe 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -71,10 +71,10 @@ macro before appending to it. */)
     {
       if (current_kboard->kbd_macro_bufsize > 200)
         {
-          current_kboard->kbd_macro_bufsize = 30;
           current_kboard->kbd_macro_buffer
             = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
                                        30 * sizeof (Lisp_Object));
+          current_kboard->kbd_macro_bufsize = 30;
         }
       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
       current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
@@ -82,7 +82,8 @@ macro before appending to it. */)
     }
   else
     {
-      int i, len;
+      ptrdiff_t i;
+      EMACS_INT len;
       int cvt;
 
       /* Check the type of last-kbd-macro in case Lisp code changed it.  */
@@ -94,10 +95,13 @@ macro before appending to it. */)
          has put another macro there.  */
       if (current_kboard->kbd_macro_bufsize < len + 30)
         {
-          current_kboard->kbd_macro_bufsize = len + 30;
+          if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (Lisp_Object) - 30
+              < current_kboard->kbd_macro_bufsize)
+            memory_full (SIZE_MAX);
           current_kboard->kbd_macro_buffer
             = (Lisp_Object *)xrealloc (current_kboard->kbd_macro_buffer,
                                        (len + 30) * sizeof (Lisp_Object));
+          current_kboard->kbd_macro_bufsize = len + 30;
         }
 
       /* Must convert meta modifier when copying string to vector.  */
@@ -191,14 +195,17 @@ store_kbd_macro_char (Lisp_Object c)
     {
       if (kb->kbd_macro_ptr - kb->kbd_macro_buffer == kb->kbd_macro_bufsize)
         {
-          int ptr_offset, end_offset, nbytes;
+          ptrdiff_t ptr_offset, end_offset, nbytes;
 
           ptr_offset = kb->kbd_macro_ptr - kb->kbd_macro_buffer;
           end_offset = kb->kbd_macro_end - kb->kbd_macro_buffer;
-          kb->kbd_macro_bufsize *= 2;
-          nbytes = kb->kbd_macro_bufsize * sizeof *kb->kbd_macro_buffer;
+          if (min (PTRDIFF_MAX, SIZE_MAX) / sizeof *kb->kbd_macro_buffer / 2
+              < kb->kbd_macro_bufsize)
+            memory_full (SIZE_MAX);
+          nbytes = kb->kbd_macro_bufsize * 2 * sizeof *kb->kbd_macro_buffer;
           kb->kbd_macro_buffer
             = (Lisp_Object *) xrealloc (kb->kbd_macro_buffer, nbytes);
+          kb->kbd_macro_bufsize *= 2;
           kb->kbd_macro_ptr = kb->kbd_macro_buffer + ptr_offset;
           kb->kbd_macro_end = kb->kbd_macro_buffer + end_offset;
         }
@@ -360,15 +367,13 @@ init_macros (void)
 void
 syms_of_macros (void)
 {
-  Qexecute_kbd_macro = intern_c_string ("execute-kbd-macro");
-  staticpro (&Qexecute_kbd_macro);
+  DEFSYM (Qexecute_kbd_macro, "execute-kbd-macro");
 
   DEFVAR_LISP ("kbd-macro-termination-hook", Vkbd_macro_termination_hook,
                doc: /* Normal hook run whenever a keyboard macro terminates.
 This is run whether the macro ends normally or prematurely due to an error.  */);
   Vkbd_macro_termination_hook = Qnil;
-  Qkbd_macro_termination_hook = intern_c_string ("kbd-macro-termination-hook");
-  staticpro (&Qkbd_macro_termination_hook);
+  DEFSYM (Qkbd_macro_termination_hook, "kbd-macro-termination-hook");
 
   defsubr (&Sstart_kbd_macro);
   defsubr (&Send_kbd_macro);
diff --git a/src/minibuf.c b/src/minibuf.c
index ca2f22df9ed..cf37c337be4 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -25,7 +25,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
-#include "character.h"
 #include "dispextern.h"
 #include "keyboard.h"
 #include "frame.h"
@@ -72,7 +71,6 @@ Lisp_Object Qcompletion_ignore_case;
 static Lisp_Object Qminibuffer_completion_table;
 static Lisp_Object Qminibuffer_completion_predicate;
 static Lisp_Object Qminibuffer_completion_confirm;
-static Lisp_Object Qcompleting_read_default;
 static Lisp_Object Quser_variable_p;
 
 static Lisp_Object Qminibuffer_default;
@@ -237,7 +235,7 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
                              Lisp_Object defalt,
                              int allow_props, int inherit_input_method)
 {
-  size_t size, len;
+  ptrdiff_t size, len;
   char *line, *s;
   Lisp_Object val;
 
@@ -247,12 +245,12 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
   val = Qnil;
   size = 100;
   len = 0;
-  line = (char *) xmalloc (size * sizeof *line);
+  line = (char *) xmalloc (size);
   while ((s = fgets (line + len, size - len, stdin)) != NULL
          && (len = strlen (line),
              len == size - 1 && line[len - 1] != '\n'))
     {
-      if ((size_t) -1 / 2 < size)
+      if (STRING_BYTES_BOUND / 2 < size)
         memory_full (SIZE_MAX);
       size *= 2;
       line = (char *) xrealloc (line, size);
@@ -260,11 +258,9 @@ read_minibuf_noninteractive (Lisp_Object map, Lisp_Object initial,
 
   if (s)
     {
-      len = strlen (line);
-
-      if (len > 0 && line[len - 1] == '\n')
-        line[--len] = '\0';
-
+      char *nl = strchr (line, '\n');
+      if (nl)
+        *nl = '\0';
       val = build_string (line);
       xfree (line);
     }
@@ -1694,7 +1690,7 @@ See also `completing-read-function'.  */)
   (Lisp_Object prompt, Lisp_Object collection, Lisp_Object predicate, Lisp_Object require_match, Lisp_Object initial_input, Lisp_Object hist, Lisp_Object def, Lisp_Object inherit_input_method)
 {
   Lisp_Object args[9];
-  args[0] = Vcompleting_read_function;
+  args[0] = Fsymbol_value (intern ("completing-read-function"));
   args[1] = prompt;
   args[2] = collection;
   args[3] = predicate;
@@ -1705,76 +1701,6 @@ See also `completing-read-function'.  */)
   args[8] = inherit_input_method;
   return Ffuncall (9, args);
 }
-
-DEFUN ("completing-read-default", Fcompleting_read_default, Scompleting_read_default, 2, 8, 0,
-       doc: /* Default method for reading from the minibuffer with completion.
-See `completing-read' for the meaning of the arguments.  */)
-  (Lisp_Object prompt, Lisp_Object collection, Lisp_Object predicate, Lisp_Object require_match, Lisp_Object initial_input, Lisp_Object hist, Lisp_Object def, Lisp_Object inherit_input_method)
-{
-  Lisp_Object val, histvar, histpos, position;
-  Lisp_Object init;
-  int pos = 0;
-  int count = SPECPDL_INDEX ();
-  struct gcpro gcpro1;
-
-  init = initial_input;
-  GCPRO1 (def);
-
-  specbind (Qminibuffer_completion_table, collection);
-  specbind (Qminibuffer_completion_predicate, predicate);
-  specbind (Qminibuffer_completion_confirm,
-            EQ (require_match, Qt) ? Qnil : require_match);
-
-  position = Qnil;
-  if (!NILP (init))
-    {
-      if (CONSP (init))
-        {
-          position = Fcdr (init);
-          init = Fcar (init);
-        }
-      CHECK_STRING (init);
-      if (!NILP (position))
-        {
-          CHECK_NUMBER (position);
-          /* Convert to distance from end of input.  */
-          pos = XINT (position) - SCHARS (init);
-        }
-    }
-
-  if (SYMBOLP (hist))
-    {
-      histvar = hist;
-      histpos = Qnil;
-    }
-  else
-    {
-      histvar = Fcar_safe (hist);
-      histpos = Fcdr_safe (hist);
-    }
-  if (NILP (histvar))
-    histvar = Qminibuffer_history;
-  if (NILP (histpos))
-    XSETFASTINT (histpos, 0);
-
-  val = read_minibuf (NILP (require_match)
-                      ? (NILP (Vminibuffer_completing_file_name)
-                         || EQ (Vminibuffer_completing_file_name, Qlambda)
-                         ? Vminibuffer_local_completion_map
-                         : Vminibuffer_local_filename_completion_map)
-                      : (NILP (Vminibuffer_completing_file_name)
-                         || EQ (Vminibuffer_completing_file_name, Qlambda)
-                         ? Vminibuffer_local_must_match_map
-                         : Vminibuffer_local_filename_must_match_map),
-                      init, prompt, make_number (pos), 0,
-                      histvar, histpos, def, 0,
-                      !NILP (inherit_input_method));
-
-  if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
-    val = CONSP (def) ? XCAR (def) : def;
-
-  RETURN_UNGCPRO (unbind_to (count, val));
-}
 
 Lisp_Object Fassoc_string (register Lisp_Object key, Lisp_Object list, Lisp_Object case_fold);
 
@@ -2013,7 +1939,6 @@ syms_of_minibuf (void)
   minibuf_save_list = Qnil;
   staticpro (&minibuf_save_list);
 
-  DEFSYM (Qcompleting_read_default, "completing-read-default");
   DEFSYM (Qcompletion_ignore_case, "completion-ignore-case");
   DEFSYM (Qread_file_name_internal, "read-file-name-internal");
   DEFSYM (Qminibuffer_default, "minibuffer-default");
@@ -2132,12 +2057,6 @@ If the value is `confirm-after-completion', the user may exit with an
                doc: /* Non-nil means completing file names.  */);
   Vminibuffer_completing_file_name = Qnil;
 
-  DEFVAR_LISP ("completing-read-function",
-               Vcompleting_read_function,
-               doc: /* The function called by `completing-read' to do the work.
-It should accept the same arguments as `completing-read'.  */);
-  Vcompleting_read_function = Qcompleting_read_default;
-
   DEFVAR_LISP ("minibuffer-help-form", Vminibuffer_help_form,
                doc: /* Value that `help-form' takes on inside the minibuffer.  */);
   Vminibuffer_help_form = Qnil;
@@ -2214,5 +2133,4 @@ properties.  */);
   defsubr (&Stest_completion);
   defsubr (&Sassoc_string);
   defsubr (&Scompleting_read);
-  defsubr (&Scompleting_read_default);
 }
diff --git a/src/msdos.c b/src/msdos.c
index 73804df55cc..3f12bc85cbe 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -4267,8 +4267,7 @@ syms_of_msdos (void)
 #ifndef HAVE_X_WINDOWS
 
   /* The following two are from xfns.c:  */
-  Qreverse = intern_c_string ("reverse");
-  staticpro (&Qreverse);
+  DEFSYM (Qreverse, "reverse");
 
   DEFVAR_LISP ("dos-unsupported-char-glyph", Vdos_unsupported_char_glyph,
                doc: /* *Glyph to display instead of chars not supported by current codepage.
diff --git a/src/print.c b/src/print.c
index d07f89702cc..14b4326bb6f 100644
--- a/src/print.c
+++ b/src/print.c
@@ -159,8 +159,9 @@ int print_output_debug_flag EXTERNALLY_VISIBLE = 1;
          }                                                              \
        else                                                             \
          {                                                              \
-           print_buffer_size = 1000;                                    \
-           print_buffer = (char *) xmalloc (print_buffer_size);         \
+           ptrdiff_t new_size = 1000;                                   \
+           print_buffer = (char *) xmalloc (new_size);                  \
+           print_buffer_size = new_size;                                \
            free_print_buffer = 1;                                       \
          }                                                              \
        print_buffer_pos = 0;                                            \
@@ -235,9 +236,15 @@ printchar (unsigned int ch, Lisp_Object fun)
 
       if (NILP (fun))
         {
-          if (print_buffer_pos_byte + len >= print_buffer_size)
-            print_buffer = (char *) xrealloc (print_buffer,
-                                              print_buffer_size *= 2);
+          if (print_buffer_size - len <= print_buffer_pos_byte)
+            {
+              ptrdiff_t new_size;
+              if (STRING_BYTES_BOUND / 2 < print_buffer_size)
+                string_overflow ();
+              new_size = print_buffer_size * 2;
+              print_buffer = (char *) xrealloc (print_buffer, new_size);
+              print_buffer_size = new_size;
+            }
           memcpy (print_buffer + print_buffer_pos_byte, str, len);
           print_buffer_pos += 1;
           print_buffer_pos_byte += len;
@@ -280,11 +287,14 @@ strout (const char *ptr, EMACS_INT size, EMACS_INT size_byte,
 
   if (NILP (printcharfun))
     {
-      if (print_buffer_pos_byte + size_byte > print_buffer_size)
+      if (print_buffer_size - size_byte < print_buffer_pos_byte)
         {
-          print_buffer_size = print_buffer_size * 2 + size_byte;
-          print_buffer = (char *) xrealloc (print_buffer,
-                                            print_buffer_size);
+          ptrdiff_t new_size;
+          if (STRING_BYTES_BOUND / 2 - size_byte < print_buffer_size)
+            string_overflow ();
+          new_size = print_buffer_size * 2 + size_byte;
+          print_buffer = (char *) xrealloc (print_buffer, new_size);
+          print_buffer_size = new_size;
         }
       memcpy (print_buffer + print_buffer_pos_byte, ptr, size_byte);
       print_buffer_pos += size;
@@ -2059,8 +2069,7 @@ print_interval (INTERVAL interval, Lisp_Object printcharfun)
 void
 syms_of_print (void)
 {
-  Qtemp_buffer_setup_hook = intern_c_string ("temp-buffer-setup-hook");
-  staticpro (&Qtemp_buffer_setup_hook);
+  DEFSYM (Qtemp_buffer_setup_hook, "temp-buffer-setup-hook");
 
   DEFVAR_LISP ("standard-output", Vstandard_output,
                doc: /* Output stream `print' uses by default for outputting a character.
@@ -2069,8 +2078,7 @@ It may also be a buffer (output is inserted before point)
 or a marker (output is inserted and the marker is advanced)
 or the symbol t (output appears in the echo area).  */);
   Vstandard_output = Qt;
-  Qstandard_output = intern_c_string ("standard-output");
-  staticpro (&Qstandard_output);
+  DEFSYM (Qstandard_output, "standard-output");
 
   DEFVAR_LISP ("float-output-format", Vfloat_output_format,
                doc: /* The format descriptor string used to print floats.
@@ -2089,8 +2097,7 @@ decimal point.  0 is not allowed with `e' or `g'.
 A value of nil means to use the shortest notation
 that represents the number without losing information.  */);
   Vfloat_output_format = Qnil;
-  Qfloat_output_format = intern_c_string ("float-output-format");
-  staticpro (&Qfloat_output_format);
+  DEFSYM (Qfloat_output_format, "float-output-format");
 
   DEFVAR_LISP ("print-length", Vprint_length,
                doc: /* Maximum length of list to print before abbreviating.
@@ -2195,17 +2202,10 @@ priorities.  */);
   defsubr (&Sredirect_debugging_output);
 #endif
 
-  Qexternal_debugging_output = intern_c_string ("external-debugging-output");
-  staticpro (&Qexternal_debugging_output);
-
-  Qprint_escape_newlines = intern_c_string ("print-escape-newlines");
-  staticpro (&Qprint_escape_newlines);
-
-  Qprint_escape_multibyte = intern_c_string ("print-escape-multibyte");
-  staticpro (&Qprint_escape_multibyte);
-
-  Qprint_escape_nonascii = intern_c_string ("print-escape-nonascii");
-  staticpro (&Qprint_escape_nonascii);
+  DEFSYM (Qexternal_debugging_output, "external-debugging-output");
+  DEFSYM (Qprint_escape_newlines, "print-escape-newlines");
+  DEFSYM (Qprint_escape_multibyte, "print-escape-multibyte");
+  DEFSYM (Qprint_escape_nonascii, "print-escape-nonascii");
 
   print_prune_charset_plist = Qnil;
   staticpro (&print_prune_charset_plist);
diff --git a/src/process.c b/src/process.c
index 0040d14a0f6..c46437fe8cb 100644
--- a/src/process.c
+++ b/src/process.c
@@ -7236,14 +7236,10 @@ syms_of_process (void)
 {
 #ifdef subprocesses
 
-  Qprocessp = intern_c_string ("processp");
-  staticpro (&Qprocessp);
-  Qrun = intern_c_string ("run");
-  staticpro (&Qrun);
-  Qstop = intern_c_string ("stop");
-  staticpro (&Qstop);
-  Qsignal = intern_c_string ("signal");
-  staticpro (&Qsignal);
+  DEFSYM (Qprocessp, "processp");
+  DEFSYM (Qrun, "run");
+  DEFSYM (Qstop, "stop");
+  DEFSYM (Qsignal, "signal");
 
   /* Qexit is already staticpro'd by syms_of_eval; don't staticpro it
      here again.
@@ -7251,92 +7247,52 @@ syms_of_process (void)
      Qexit = intern_c_string ("exit");
      staticpro (&Qexit); */
 
-  Qopen = intern_c_string ("open");
-  staticpro (&Qopen);
-  Qclosed = intern_c_string ("closed");
-  staticpro (&Qclosed);
-  Qconnect = intern_c_string ("connect");
-  staticpro (&Qconnect);
-  Qfailed = intern_c_string ("failed");
-  staticpro (&Qfailed);
-  Qlisten = intern_c_string ("listen");
-  staticpro (&Qlisten);
-  Qlocal = intern_c_string ("local");
-  staticpro (&Qlocal);
-  Qipv4 = intern_c_string ("ipv4");
-  staticpro (&Qipv4);
+  DEFSYM (Qopen, "open");
+  DEFSYM (Qclosed, "closed");
+  DEFSYM (Qconnect, "connect");
+  DEFSYM (Qfailed, "failed");
+  DEFSYM (Qlisten, "listen");
+  DEFSYM (Qlocal, "local");
+  DEFSYM (Qipv4, "ipv4");
 #ifdef AF_INET6
-  Qipv6 = intern_c_string ("ipv6");
-  staticpro (&Qipv6);
-#endif
-  Qdatagram = intern_c_string ("datagram");
-  staticpro (&Qdatagram);
-  Qseqpacket = intern_c_string ("seqpacket");
-  staticpro (&Qseqpacket);
-
-  QCport = intern_c_string (":port");
-  staticpro (&QCport);
-  QCspeed = intern_c_string (":speed");
-  staticpro (&QCspeed);
-  QCprocess = intern_c_string (":process");
-  staticpro (&QCprocess);
-
-  QCbytesize = intern_c_string (":bytesize");
-  staticpro (&QCbytesize);
-  QCstopbits = intern_c_string (":stopbits");
-  staticpro (&QCstopbits);
-  QCparity = intern_c_string (":parity");
-  staticpro (&QCparity);
-  Qodd = intern_c_string ("odd");
-  staticpro (&Qodd);
-  Qeven = intern_c_string ("even");
-  staticpro (&Qeven);
-  QCflowcontrol = intern_c_string (":flowcontrol");
-  staticpro (&QCflowcontrol);
-  Qhw = intern_c_string ("hw");
-  staticpro (&Qhw);
-  Qsw = intern_c_string ("sw");
-  staticpro (&Qsw);
-  QCsummary = intern_c_string (":summary");
-  staticpro (&QCsummary);
-
-  Qreal = intern_c_string ("real");
-  staticpro (&Qreal);
-  Qnetwork = intern_c_string ("network");
-  staticpro (&Qnetwork);
-  Qserial = intern_c_string ("serial");
-  staticpro (&Qserial);
-  QCbuffer = intern_c_string (":buffer");
-  staticpro (&QCbuffer);
-  QChost = intern_c_string (":host");
-  staticpro (&QChost);
-  QCservice = intern_c_string (":service");
-  staticpro (&QCservice);
-  QClocal = intern_c_string (":local");
-  staticpro (&QClocal);
-  QCremote = intern_c_string (":remote");
-  staticpro (&QCremote);
-  QCcoding = intern_c_string (":coding");
-  staticpro (&QCcoding);
-  QCserver = intern_c_string (":server");
-  staticpro (&QCserver);
-  QCnowait = intern_c_string (":nowait");
-  staticpro (&QCnowait);
-  QCsentinel = intern_c_string (":sentinel");
-  staticpro (&QCsentinel);
-  QClog = intern_c_string (":log");
-  staticpro (&QClog);
-  QCnoquery = intern_c_string (":noquery");
-  staticpro (&QCnoquery);
-  QCstop = intern_c_string (":stop");
-  staticpro (&QCstop);
-  QCoptions = intern_c_string (":options");
-  staticpro (&QCoptions);
-  QCplist = intern_c_string (":plist");
-  staticpro (&QCplist);
-
-  Qlast_nonmenu_event = intern_c_string ("last-nonmenu-event");
-  staticpro (&Qlast_nonmenu_event);
+  DEFSYM (Qipv6, "ipv6");
+#endif
+  DEFSYM (Qdatagram, "datagram");
+  DEFSYM (Qseqpacket, "seqpacket");
+
+  DEFSYM (QCport, ":port");
+  DEFSYM (QCspeed, ":speed");
+  DEFSYM (QCprocess, ":process");
+
+  DEFSYM (QCbytesize, ":bytesize");
+  DEFSYM (QCstopbits, ":stopbits");
+  DEFSYM (QCparity, ":parity");
+  DEFSYM (Qodd, "odd");
+  DEFSYM (Qeven, "even");
+  DEFSYM (QCflowcontrol, ":flowcontrol");
+  DEFSYM (Qhw, "hw");
+  DEFSYM (Qsw, "sw");
+  DEFSYM (QCsummary, ":summary");
+
+  DEFSYM (Qreal, "real");
+  DEFSYM (Qnetwork, "network");
+  DEFSYM (Qserial, "serial");
+  DEFSYM (QCbuffer, ":buffer");
+  DEFSYM (QChost, ":host");
+  DEFSYM (QCservice, ":service");
+  DEFSYM (QClocal, ":local");
+  DEFSYM (QCremote, ":remote");
+  DEFSYM (QCcoding, ":coding");
+  DEFSYM (QCserver, ":server");
+  DEFSYM (QCnowait, ":nowait");
+  DEFSYM (QCsentinel, ":sentinel");
+  DEFSYM (QClog, ":log");
+  DEFSYM (QCnoquery, ":noquery");
+  DEFSYM (QCstop, ":stop");
+  DEFSYM (QCoptions, ":options");
+  DEFSYM (QCplist, ":plist");
+
+  DEFSYM (Qlast_nonmenu_event, "last-nonmenu-event");
 
   staticpro (&Vprocess_alist);
 #ifdef SIGCHLD
@@ -7345,73 +7301,40 @@ syms_of_process (void)
 
 #endif  /* subprocesses */
 
-  QCname = intern_c_string (":name");
-  staticpro (&QCname);
-  QCtype = intern_c_string (":type");
-  staticpro (&QCtype);
-
-  Qeuid = intern_c_string ("euid");
-  staticpro (&Qeuid);
-  Qegid = intern_c_string ("egid");
-  staticpro (&Qegid);
-  Quser = intern_c_string ("user");
-  staticpro (&Quser);
-  Qgroup = intern_c_string ("group");
-  staticpro (&Qgroup);
-  Qcomm = intern_c_string ("comm");
-  staticpro (&Qcomm);
-  Qstate = intern_c_string ("state");
-  staticpro (&Qstate);
-  Qppid = intern_c_string ("ppid");
-  staticpro (&Qppid);
-  Qpgrp = intern_c_string ("pgrp");
-  staticpro (&Qpgrp);
-  Qsess = intern_c_string ("sess");
-  staticpro (&Qsess);
-  Qttname = intern_c_string ("ttname");
-  staticpro (&Qttname);
-  Qtpgid = intern_c_string ("tpgid");
-  staticpro (&Qtpgid);
-  Qminflt = intern_c_string ("minflt");
-  staticpro (&Qminflt);
-  Qmajflt = intern_c_string ("majflt");
-  staticpro (&Qmajflt);
-  Qcminflt = intern_c_string ("cminflt");
-  staticpro (&Qcminflt);
-  Qcmajflt = intern_c_string ("cmajflt");
-  staticpro (&Qcmajflt);
-  Qutime = intern_c_string ("utime");
-  staticpro (&Qutime);
-  Qstime = intern_c_string ("stime");
-  staticpro (&Qstime);
-  Qtime = intern_c_string ("time");
-  staticpro (&Qtime);
-  Qcutime = intern_c_string ("cutime");
-  staticpro (&Qcutime);
-  Qcstime = intern_c_string ("cstime");
-  staticpro (&Qcstime);
-  Qctime = intern_c_string ("ctime");
-  staticpro (&Qctime);
-  Qpri = intern_c_string ("pri");
-  staticpro (&Qpri);
-  Qnice = intern_c_string ("nice");
-  staticpro (&Qnice);
-  Qthcount = intern_c_string ("thcount");
-  staticpro (&Qthcount);
-  Qstart = intern_c_string ("start");
-  staticpro (&Qstart);
-  Qvsize = intern_c_string ("vsize");
-  staticpro (&Qvsize);
-  Qrss = intern_c_string ("rss");
-  staticpro (&Qrss);
-  Qetime = intern_c_string ("etime");
-  staticpro (&Qetime);
-  Qpcpu = intern_c_string ("pcpu");
-  staticpro (&Qpcpu);
-  Qpmem = intern_c_string ("pmem");
-  staticpro (&Qpmem);
-  Qargs = intern_c_string ("args");
-  staticpro (&Qargs);
+  DEFSYM (QCname, ":name");
+  DEFSYM (QCtype, ":type");
+
+  DEFSYM (Qeuid, "euid");
+  DEFSYM (Qegid, "egid");
+  DEFSYM (Quser, "user");
+  DEFSYM (Qgroup, "group");
+  DEFSYM (Qcomm, "comm");
+  DEFSYM (Qstate, "state");
+  DEFSYM (Qppid, "ppid");
+  DEFSYM (Qpgrp, "pgrp");
+  DEFSYM (Qsess, "sess");
+  DEFSYM (Qttname, "ttname");
+  DEFSYM (Qtpgid, "tpgid");
+  DEFSYM (Qminflt, "minflt");
+  DEFSYM (Qmajflt, "majflt");
+  DEFSYM (Qcminflt, "cminflt");
+  DEFSYM (Qcmajflt, "cmajflt");
+  DEFSYM (Qutime, "utime");
+  DEFSYM (Qstime, "stime");
+  DEFSYM (Qtime, "time");
+  DEFSYM (Qcutime, "cutime");
+  DEFSYM (Qcstime, "cstime");
+  DEFSYM (Qctime, "ctime");
+  DEFSYM (Qpri, "pri");
+  DEFSYM (Qnice, "nice");
+  DEFSYM (Qthcount, "thcount");
+  DEFSYM (Qstart, "start");
+  DEFSYM (Qvsize, "vsize");
+  DEFSYM (Qrss, "rss");
+  DEFSYM (Qetime, "etime");
+  DEFSYM (Qpcpu, "pcpu");
+  DEFSYM (Qpmem, "pmem");
+  DEFSYM (Qargs, "args");
 
   DEFVAR_BOOL ("delete-exited-processes", delete_exited_processes,
                doc: /* *Non-nil means delete processes immediately when they exit.
diff --git a/src/search.c b/src/search.c
index 6c835f2cc64..d29a51c695b 100644
--- a/src/search.c
+++ b/src/search.c
@@ -3181,10 +3181,8 @@ syms_of_search (void)
     }
   searchbuf_head = &searchbufs[0];
 
-  Qsearch_failed = intern_c_string ("search-failed");
-  staticpro (&Qsearch_failed);
-  Qinvalid_regexp = intern_c_string ("invalid-regexp");
-  staticpro (&Qinvalid_regexp);
+  DEFSYM (Qsearch_failed, "search-failed");
+  DEFSYM (Qinvalid_regexp, "invalid-regexp");
 
   Fput (Qsearch_failed, Qerror_conditions,
         pure_cons (Qsearch_failed, pure_cons (Qerror, Qnil)));
diff --git a/src/sound.c b/src/sound.c
index 0e71e66352e..07c7dab0ada 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -1477,14 +1477,10 @@ Internal use only, use `play-sound' instead.  */)
 void
 syms_of_sound (void)
 {
-  QCdevice = intern_c_string(":device");
-  staticpro (&QCdevice);
-  QCvolume = intern_c_string (":volume");
-  staticpro (&QCvolume);
-  Qsound = intern_c_string ("sound");
-  staticpro (&Qsound);
-  Qplay_sound_functions = intern_c_string ("play-sound-functions");
-  staticpro (&Qplay_sound_functions);
+  DEFSYM (QCdevice, ":device");
+  DEFSYM (QCvolume, ":volume");
+  DEFSYM (Qsound, "sound");
+  DEFSYM (Qplay_sound_functions, "play-sound-functions");
 
   defsubr (&Splay_sound_internal);
 }
diff --git a/src/syntax.c b/src/syntax.c
index 82103cfa3d4..8c2d5ded21f 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -3362,8 +3362,7 @@ init_syntax_once (void)
   Lisp_Object temp;
 
   /* This has to be done here, before we call Fmake_char_table.  */
-  Qsyntax_table = intern_c_string ("syntax-table");
-  staticpro (&Qsyntax_table);
+  DEFSYM (Qsyntax_table, "syntax-table");
 
   /* Intern_C_String this now in case it isn't already done.
      Setting this variable twice is harmless.
@@ -3448,8 +3447,7 @@ init_syntax_once (void)
 void
 syms_of_syntax (void)
 {
-  Qsyntax_table_p = intern_c_string ("syntax-table-p");
-  staticpro (&Qsyntax_table_p);
+  DEFSYM (Qsyntax_table_p, "syntax-table-p");
 
   staticpro (&Vsyntax_code_object);
 
@@ -3461,8 +3459,7 @@ syms_of_syntax (void)
   /* Defined in regex.c */
   staticpro (&re_match_object);
 
-  Qscan_error = intern_c_string ("scan-error");
-  staticpro (&Qscan_error);
+  DEFSYM (Qscan_error, "scan-error");
   Fput (Qscan_error, Qerror_conditions,
         pure_cons (Qscan_error, pure_cons (Qerror, Qnil)));
   Fput (Qscan_error, Qerror_message,
diff --git a/src/sysdep.c b/src/sysdep.c
index 5ad3389dd8f..3a73b1a467b 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -2012,37 +2012,6 @@ perror (void)
 }
 #endif /* HPUX and not HAVE_PERROR */
 
-#ifndef HAVE_DUP2
-
-/*
- *      Emulate BSD dup2.  First close newd if it already exists.
- *      Then, attempt to dup oldd.  If not successful, call dup2 recursively
- *      until we are, then close the unsuccessful ones.
- */
-
-int
-dup2 (int oldd, int newd)
-{
-  register int fd, ret;
-
-  emacs_close (newd);
-
-#ifdef F_DUPFD
-  return fcntl (oldd, F_DUPFD, newd);
-#else
-  fd = dup (old);
-  if (fd == -1)
-    return -1;
-  if (fd == new)
-    return new;
-  ret = dup2 (old,new);
-  emacs_close (fd);
-  return ret;
-#endif
-}
-
-#endif /* not HAVE_DUP2 */
-
 /*
  *      Gettimeofday.  Simulate as much as possible.  Only accurate
  *      to nearest second.  Emacs doesn't use tzp so ignore it for now.
diff --git a/src/terminal.c b/src/terminal.c
index c135c0f93ef..67577adf3b4 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -555,10 +555,8 @@ Each function is called with argument, the terminal.
 This may be called just before actually deleting the terminal,
 or some time later.  */);
   Vdelete_terminal_functions = Qnil;
-  Qdelete_terminal_functions = intern_c_string ("delete-terminal-functions");
-  staticpro (&Qdelete_terminal_functions);
-  Qrun_hook_with_args = intern_c_string ("run-hook-with-args");
-  staticpro (&Qrun_hook_with_args);
+  DEFSYM (Qdelete_terminal_functions, "delete-terminal-functions");
+  DEFSYM (Qrun_hook_with_args, "run-hook-with-args");
 
   defsubr (&Sdelete_terminal);
   defsubr (&Sframe_terminal);
diff --git a/src/textprop.c b/src/textprop.c
index dd8695f7af8..87f1675047b 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -2242,45 +2242,27 @@ inherits it if NONSTICKINESS is nil.  The `front-sticky' and
 
   /* Common attributes one might give text */
 
-  staticpro (&Qforeground);
-  Qforeground = intern_c_string ("foreground");
-  staticpro (&Qbackground);
-  Qbackground = intern_c_string ("background");
-  staticpro (&Qfont);
-  Qfont = intern_c_string ("font");
-  staticpro (&Qstipple);
-  Qstipple = intern_c_string ("stipple");
-  staticpro (&Qunderline);
-  Qunderline = intern_c_string ("underline");
-  staticpro (&Qread_only);
-  Qread_only = intern_c_string ("read-only");
-  staticpro (&Qinvisible);
-  Qinvisible = intern_c_string ("invisible");
-  staticpro (&Qintangible);
-  Qintangible = intern_c_string ("intangible");
-  staticpro (&Qcategory);
-  Qcategory = intern_c_string ("category");
-  staticpro (&Qlocal_map);
-  Qlocal_map = intern_c_string ("local-map");
-  staticpro (&Qfront_sticky);
-  Qfront_sticky = intern_c_string ("front-sticky");
-  staticpro (&Qrear_nonsticky);
-  Qrear_nonsticky = intern_c_string ("rear-nonsticky");
-  staticpro (&Qmouse_face);
-  Qmouse_face = intern_c_string ("mouse-face");
-  staticpro (&Qminibuffer_prompt);
-  Qminibuffer_prompt = intern_c_string ("minibuffer-prompt");
+  DEFSYM (Qforeground, "foreground");
+  DEFSYM (Qbackground, "background");
+  DEFSYM (Qfont, "font");
+  DEFSYM (Qstipple, "stipple");
+  DEFSYM (Qunderline, "underline");
+  DEFSYM (Qread_only, "read-only");
+  DEFSYM (Qinvisible, "invisible");
+  DEFSYM (Qintangible, "intangible");
+  DEFSYM (Qcategory, "category");
+  DEFSYM (Qlocal_map, "local-map");
+  DEFSYM (Qfront_sticky, "front-sticky");
+  DEFSYM (Qrear_nonsticky, "rear-nonsticky");
+  DEFSYM (Qmouse_face, "mouse-face");
+  DEFSYM (Qminibuffer_prompt, "minibuffer-prompt");
 
   /* Properties that text might use to specify certain actions */
 
-  staticpro (&Qmouse_left);
-  Qmouse_left = intern_c_string ("mouse-left");
-  staticpro (&Qmouse_entered);
-  Qmouse_entered = intern_c_string ("mouse-entered");
-  staticpro (&Qpoint_left);
-  Qpoint_left = intern_c_string ("point-left");
-  staticpro (&Qpoint_entered);
-  Qpoint_entered = intern_c_string ("point-entered");
+  DEFSYM (Qmouse_left, "mouse-left");
+  DEFSYM (Qmouse_entered, "mouse-entered");
+  DEFSYM (Qpoint_left, "point-left");
+  DEFSYM (Qpoint_entered, "point-entered");
 
   defsubr (&Stext_properties_at);
   defsubr (&Sget_text_property);
diff --git a/src/undo.c b/src/undo.c
index e7e9ae5632e..7e121e8b27d 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -637,11 +637,8 @@ Return what remains of the list.  */)
 void
 syms_of_undo (void)
 {
-  Qinhibit_read_only = intern_c_string ("inhibit-read-only");
-  staticpro (&Qinhibit_read_only);
-
-  Qapply = intern_c_string ("apply");
-  staticpro (&Qapply);
+  DEFSYM (Qinhibit_read_only, "inhibit-read-only");
+  DEFSYM (Qapply, "apply");
 
   pending_boundary = Qnil;
   staticpro (&pending_boundary);
diff --git a/src/w32.c b/src/w32.c
index d81fdf3305d..53bf2e811e2 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -5960,8 +5960,7 @@ globals_of_w32 (void)
   get_process_times_fn = (GetProcessTimes_Proc)
     GetProcAddress (kernel32, "GetProcessTimes");
 
-  QCloaded_from = intern_c_string (":loaded-from");
-  staticpro (&QCloaded_from);
+  DEFSYM (QCloaded_from, ":loaded-from");
 
   Vlibrary_cache = Qnil;
   staticpro (&Vlibrary_cache);
diff --git a/src/w32menu.c b/src/w32menu.c
index e2f6de7f0c8..c31a8c1fd96 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -33,7 +33,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "blockinput.h"
 #include "buffer.h"
 #include "charset.h"
-#include "character.h"
 #include "coding.h"
 #include "menu.h"
 
diff --git a/src/w32proc.c b/src/w32proc.c
index e94d9aa3254..47cbf57d9ea 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -51,7 +51,6 @@ extern BOOL WINAPI IsValidLocale (LCID, DWORD);
 #endif
 
 #include "lisp.h"
-#include "character.h"
 #include "w32.h"
 #include "w32heap.h"
 #include "systime.h"
diff --git a/src/w32select.c b/src/w32select.c
index ef0cb3adc24..e3225c3f996 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -80,7 +80,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "blockinput.h"
 #include "charset.h"
 #include "coding.h"
-#include "character.h"
 #include "composite.h"
 
 
diff --git a/src/window.c b/src/window.c
index a5f95ea7883..ebfe318defd 100644
--- a/src/window.c
+++ b/src/window.c
@@ -6443,69 +6443,30 @@ init_window (void)
 void
 syms_of_window (void)
 {
-  Qscroll_up = intern_c_string ("scroll-up");
-  staticpro (&Qscroll_up);
-
-  Qscroll_down = intern_c_string ("scroll-down");
-  staticpro (&Qscroll_down);
-
-  Qscroll_command = intern_c_string ("scroll-command");
-  staticpro (&Qscroll_command);
+  DEFSYM (Qscroll_up, "scroll-up");
+  DEFSYM (Qscroll_down, "scroll-down");
+  DEFSYM (Qscroll_command, "scroll-command");
 
   Fput (Qscroll_up, Qscroll_command, Qt);
   Fput (Qscroll_down, Qscroll_command, Qt);
 
-  staticpro (&Qwindow_configuration_change_hook);
-  Qwindow_configuration_change_hook
-    = intern_c_string ("window-configuration-change-hook");
-
-  Qwindowp = intern_c_string ("windowp");
-  staticpro (&Qwindowp);
-
-  Qwindow_configuration_p = intern_c_string ("window-configuration-p");
-  staticpro (&Qwindow_configuration_p);
-
-  Qwindow_live_p = intern_c_string ("window-live-p");
-  staticpro (&Qwindow_live_p);
-
-  Qwindow_deletable_p = intern_c_string ("window-deletable-p");
-  staticpro (&Qwindow_deletable_p);
-
-  Qdelete_window = intern_c_string ("delete-window");
-  staticpro (&Qdelete_window);
-
-  Qresize_root_window = intern_c_string ("resize-root-window");
-  staticpro (&Qresize_root_window);
-
-  Qresize_root_window_vertically = intern_c_string ("resize-root-window-vertically");
-  staticpro (&Qresize_root_window_vertically);
-
-  Qsafe = intern_c_string ("safe");
-  staticpro (&Qsafe);
-
-  Qdisplay_buffer = intern_c_string ("display-buffer");
-  staticpro (&Qdisplay_buffer);
-
-  Qreplace_buffer_in_windows = intern_c_string ("replace-buffer-in-windows");
-  staticpro (&Qreplace_buffer_in_windows);
-
-  Qrecord_window_buffer = intern_c_string ("record-window-buffer");
-  staticpro (&Qrecord_window_buffer);
-
-  Qget_mru_window = intern_c_string ("get-mru-window");
-  staticpro (&Qget_mru_window);
-
-  Qtemp_buffer_show_hook = intern_c_string ("temp-buffer-show-hook");
-  staticpro (&Qtemp_buffer_show_hook);
-
-  Qabove = intern_c_string ("above");
-  staticpro (&Qabove);
-
-  Qbelow = intern_c_string ("below");
-  staticpro (&Qbelow);
-
-  Qauto_buffer_name = intern_c_string ("auto-buffer-name");
-  staticpro (&Qauto_buffer_name);
+  DEFSYM (Qwindow_configuration_change_hook, "window-configuration-change-hook");
+  DEFSYM (Qwindowp, "windowp");
+  DEFSYM (Qwindow_configuration_p, "window-configuration-p");
+  DEFSYM (Qwindow_live_p, "window-live-p");
+  DEFSYM (Qwindow_deletable_p, "window-deletable-p");
+  DEFSYM (Qdelete_window, "delete-window");
+  DEFSYM (Qresize_root_window, "resize-root-window");
+  DEFSYM (Qresize_root_window_vertically, "resize-root-window-vertically");
+  DEFSYM (Qsafe, "safe");
+  DEFSYM (Qdisplay_buffer, "display-buffer");
+  DEFSYM (Qreplace_buffer_in_windows, "replace-buffer-in-windows");
+  DEFSYM (Qrecord_window_buffer, "record-window-buffer");
+  DEFSYM (Qget_mru_window, "get-mru-window");
+  DEFSYM (Qtemp_buffer_show_hook, "temp-buffer-show-hook");
+  DEFSYM (Qabove, "above");
+  DEFSYM (Qbelow, "below");
+  DEFSYM (Qauto_buffer_name, "auto-buffer-name");
 
   staticpro (&Vwindow_list);
 
diff --git a/src/xdisp.c b/src/xdisp.c
index c48610b37f2..44521ede97e 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -26661,8 +26661,7 @@ syms_of_xdisp (void)
   Vmessage_stack = Qnil;
   staticpro (&Vmessage_stack);
 
-  Qinhibit_redisplay = intern_c_string ("inhibit-redisplay");
-  staticpro (&Qinhibit_redisplay);
+  DEFSYM (Qinhibit_redisplay, "inhibit-redisplay");
 
   message_dolog_marker1 = Fmake_marker ();
   staticpro (&message_dolog_marker1);
@@ -26687,141 +26686,72 @@ syms_of_xdisp (void)
   defsubr (&Sinvisible_p);
   defsubr (&Scurrent_bidi_paragraph_direction);
 
-  staticpro (&Qmenu_bar_update_hook);
-  Qmenu_bar_update_hook = intern_c_string ("menu-bar-update-hook");
-
-  staticpro (&Qoverriding_terminal_local_map);
-  Qoverriding_terminal_local_map = intern_c_string ("overriding-terminal-local-map");
-
-  staticpro (&Qoverriding_local_map);
-  Qoverriding_local_map = intern_c_string ("overriding-local-map");
-
-  staticpro (&Qwindow_scroll_functions);
-  Qwindow_scroll_functions = intern_c_string ("window-scroll-functions");
-
-  staticpro (&Qwindow_text_change_functions);
-  Qwindow_text_change_functions = intern_c_string ("window-text-change-functions");
-
-  staticpro (&Qredisplay_end_trigger_functions);
-  Qredisplay_end_trigger_functions = intern_c_string ("redisplay-end-trigger-functions");
-
-  staticpro (&Qinhibit_point_motion_hooks);
-  Qinhibit_point_motion_hooks = intern_c_string ("inhibit-point-motion-hooks");
-
-  Qeval = intern_c_string ("eval");
-  staticpro (&Qeval);
-
-  QCdata = intern_c_string (":data");
-  staticpro (&QCdata);
-  Qdisplay = intern_c_string ("display");
-  staticpro (&Qdisplay);
-  Qspace_width = intern_c_string ("space-width");
-  staticpro (&Qspace_width);
-  Qraise = intern_c_string ("raise");
-  staticpro (&Qraise);
-  Qslice = intern_c_string ("slice");
-  staticpro (&Qslice);
-  Qspace = intern_c_string ("space");
-  staticpro (&Qspace);
-  Qmargin = intern_c_string ("margin");
-  staticpro (&Qmargin);
-  Qpointer = intern_c_string ("pointer");
-  staticpro (&Qpointer);
-  Qleft_margin = intern_c_string ("left-margin");
-  staticpro (&Qleft_margin);
-  Qright_margin = intern_c_string ("right-margin");
-  staticpro (&Qright_margin);
-  Qcenter = intern_c_string ("center");
-  staticpro (&Qcenter);
-  Qline_height = intern_c_string ("line-height");
-  staticpro (&Qline_height);
-  QCalign_to = intern_c_string (":align-to");
-  staticpro (&QCalign_to);
-  QCrelative_width = intern_c_string (":relative-width");
-  staticpro (&QCrelative_width);
-  QCrelative_height = intern_c_string (":relative-height");
-  staticpro (&QCrelative_height);
-  QCeval = intern_c_string (":eval");
-  staticpro (&QCeval);
-  QCpropertize = intern_c_string (":propertize");
-  staticpro (&QCpropertize);
-  QCfile = intern_c_string (":file");
-  staticpro (&QCfile);
-  Qfontified = intern_c_string ("fontified");
-  staticpro (&Qfontified);
-  Qfontification_functions = intern_c_string ("fontification-functions");
-  staticpro (&Qfontification_functions);
-  Qtrailing_whitespace = intern_c_string ("trailing-whitespace");
-  staticpro (&Qtrailing_whitespace);
-  Qescape_glyph = intern_c_string ("escape-glyph");
-  staticpro (&Qescape_glyph);
-  Qnobreak_space = intern_c_string ("nobreak-space");
-  staticpro (&Qnobreak_space);
-  Qimage = intern_c_string ("image");
-  staticpro (&Qimage);
-  Qtext = intern_c_string ("text");
-  staticpro (&Qtext);
-  Qboth = intern_c_string ("both");
-  staticpro (&Qboth);
-  Qboth_horiz = intern_c_string ("both-horiz");
-  staticpro (&Qboth_horiz);
-  Qtext_image_horiz = intern_c_string ("text-image-horiz");
-  staticpro (&Qtext_image_horiz);
-  QCmap = intern_c_string (":map");
-  staticpro (&QCmap);
-  QCpointer = intern_c_string (":pointer");
-  staticpro (&QCpointer);
-  Qrect = intern_c_string ("rect");
-  staticpro (&Qrect);
-  Qcircle = intern_c_string ("circle");
-  staticpro (&Qcircle);
-  Qpoly = intern_c_string ("poly");
-  staticpro (&Qpoly);
-  Qmessage_truncate_lines = intern_c_string ("message-truncate-lines");
-  staticpro (&Qmessage_truncate_lines);
-  Qgrow_only = intern_c_string ("grow-only");
-  staticpro (&Qgrow_only);
-  Qinhibit_menubar_update = intern_c_string ("inhibit-menubar-update");
-  staticpro (&Qinhibit_menubar_update);
-  Qinhibit_eval_during_redisplay = intern_c_string ("inhibit-eval-during-redisplay");
-  staticpro (&Qinhibit_eval_during_redisplay);
-  Qposition = intern_c_string ("position");
-  staticpro (&Qposition);
-  Qbuffer_position = intern_c_string ("buffer-position");
-  staticpro (&Qbuffer_position);
-  Qobject = intern_c_string ("object");
-  staticpro (&Qobject);
-  Qbar = intern_c_string ("bar");
-  staticpro (&Qbar);
-  Qhbar = intern_c_string ("hbar");
-  staticpro (&Qhbar);
-  Qbox = intern_c_string ("box");
-  staticpro (&Qbox);
-  Qhollow = intern_c_string ("hollow");
-  staticpro (&Qhollow);
-  Qhand = intern_c_string ("hand");
-  staticpro (&Qhand);
-  Qarrow = intern_c_string ("arrow");
-  staticpro (&Qarrow);
-  Qtext = intern_c_string ("text");
-  staticpro (&Qtext);
-  Qinhibit_free_realized_faces = intern_c_string ("inhibit-free-realized-faces");
-  staticpro (&Qinhibit_free_realized_faces);
+  DEFSYM (Qmenu_bar_update_hook, "menu-bar-update-hook");
+  DEFSYM (Qoverriding_terminal_local_map, "overriding-terminal-local-map");
+  DEFSYM (Qoverriding_local_map, "overriding-local-map");
+  DEFSYM (Qwindow_scroll_functions, "window-scroll-functions");
+  DEFSYM (Qwindow_text_change_functions, "window-text-change-functions");
+  DEFSYM (Qredisplay_end_trigger_functions, "redisplay-end-trigger-functions");
+  DEFSYM (Qinhibit_point_motion_hooks, "inhibit-point-motion-hooks");
+  DEFSYM (Qeval, "eval");
+  DEFSYM (QCdata, ":data");
+  DEFSYM (Qdisplay, "display");
+  DEFSYM (Qspace_width, "space-width");
+  DEFSYM (Qraise, "raise");
+  DEFSYM (Qslice, "slice");
+  DEFSYM (Qspace, "space");
+  DEFSYM (Qmargin, "margin");
+  DEFSYM (Qpointer, "pointer");
+  DEFSYM (Qleft_margin, "left-margin");
+  DEFSYM (Qright_margin, "right-margin");
+  DEFSYM (Qcenter, "center");
+  DEFSYM (Qline_height, "line-height");
+  DEFSYM (QCalign_to, ":align-to");
+  DEFSYM (QCrelative_width, ":relative-width");
+  DEFSYM (QCrelative_height, ":relative-height");
+  DEFSYM (QCeval, ":eval");
+  DEFSYM (QCpropertize, ":propertize");
+  DEFSYM (QCfile, ":file");
+  DEFSYM (Qfontified, "fontified");
+  DEFSYM (Qfontification_functions, "fontification-functions");
+  DEFSYM (Qtrailing_whitespace, "trailing-whitespace");
+  DEFSYM (Qescape_glyph, "escape-glyph");
+  DEFSYM (Qnobreak_space, "nobreak-space");
+  DEFSYM (Qimage, "image");
+  DEFSYM (Qtext, "text");
+  DEFSYM (Qboth, "both");
+  DEFSYM (Qboth_horiz, "both-horiz");
+  DEFSYM (Qtext_image_horiz, "text-image-horiz");
+  DEFSYM (QCmap, ":map");
+  DEFSYM (QCpointer, ":pointer");
+  DEFSYM (Qrect, "rect");
+  DEFSYM (Qcircle, "circle");
+  DEFSYM (Qpoly, "poly");
+  DEFSYM (Qmessage_truncate_lines, "message-truncate-lines");
+  DEFSYM (Qgrow_only, "grow-only");
+  DEFSYM (Qinhibit_menubar_update, "inhibit-menubar-update");
+  DEFSYM (Qinhibit_eval_during_redisplay, "inhibit-eval-during-redisplay");
+  DEFSYM (Qposition, "position");
+  DEFSYM (Qbuffer_position, "buffer-position");
+  DEFSYM (Qobject, "object");
+  DEFSYM (Qbar, "bar");
+  DEFSYM (Qhbar, "hbar");
+  DEFSYM (Qbox, "box");
+  DEFSYM (Qhollow, "hollow");
+  DEFSYM (Qhand, "hand");
+  DEFSYM (Qarrow, "arrow");
+  DEFSYM (Qtext, "text");
+  DEFSYM (Qinhibit_free_realized_faces, "inhibit-free-realized-faces");
 
   list_of_error = Fcons (Fcons (intern_c_string ("error"),
                                 Fcons (intern_c_string ("void-variable"), Qnil)),
                          Qnil);
   staticpro (&list_of_error);
 
-  Qlast_arrow_position = intern_c_string ("last-arrow-position");
-  staticpro (&Qlast_arrow_position);
-  Qlast_arrow_string = intern_c_string ("last-arrow-string");
-  staticpro (&Qlast_arrow_string);
-
-  Qoverlay_arrow_string = intern_c_string ("overlay-arrow-string");
-  staticpro (&Qoverlay_arrow_string);
-  Qoverlay_arrow_bitmap = intern_c_string ("overlay-arrow-bitmap");
-  staticpro (&Qoverlay_arrow_bitmap);
+  DEFSYM (Qlast_arrow_position, "last-arrow-position");
+  DEFSYM (Qlast_arrow_string, "last-arrow-string");
+  DEFSYM (Qoverlay_arrow_string, "overlay-arrow-string");
+  DEFSYM (Qoverlay_arrow_bitmap, "overlay-arrow-bitmap");
 
   echo_buffer[0] = echo_buffer[1] = Qnil;
   staticpro (&echo_buffer[0]);
@@ -26855,10 +26785,8 @@ syms_of_xdisp (void)
   staticpro (&previous_help_echo_string);
   help_echo_pos = -1;
 
-  Qright_to_left = intern_c_string ("right-to-left");
-  staticpro (&Qright_to_left);
-  Qleft_to_right = intern_c_string ("left-to-right");
-  staticpro (&Qleft_to_right);
+  DEFSYM (Qright_to_left, "right-to-left");
+  DEFSYM (Qleft_to_right, "left-to-right");
 
 #ifdef HAVE_WINDOW_SYSTEM
   DEFVAR_BOOL ("x-stretch-cursor", x_stretch_cursor_p,
@@ -27178,8 +27106,7 @@ the frame's other specifications determine how to blink the cursor off.  */);
 If non-nil, windows are automatically scrolled horizontally to make
 point visible.  */);
   automatic_hscrolling_p = 1;
-  Qauto_hscroll_mode = intern_c_string ("auto-hscroll-mode");
-  staticpro (&Qauto_hscroll_mode);
+  DEFSYM (Qauto_hscroll_mode, "auto-hscroll-mode");
 
   DEFVAR_INT ("hscroll-margin", hscroll_margin,
     doc: /* *How many columns away from the window edge point is allowed to get
@@ -27235,8 +27162,7 @@ property.
 
 To add a prefix to non-continuation lines, use `line-prefix'.  */);
   Vwrap_prefix = Qnil;
-  staticpro (&Qwrap_prefix);
-  Qwrap_prefix = intern_c_string ("wrap-prefix");
+  DEFSYM (Qwrap_prefix, "wrap-prefix");
   Fmake_variable_buffer_local (Qwrap_prefix);
 
   DEFVAR_LISP ("line-prefix", Vline_prefix,
@@ -27249,8 +27175,7 @@ property.
 
 To add a prefix to continuation lines, use `wrap-prefix'.  */);
   Vline_prefix = Qnil;
-  staticpro (&Qline_prefix);
-  Qline_prefix = intern_c_string ("line-prefix");
+  DEFSYM (Qline_prefix, "line-prefix");
   Fmake_variable_buffer_local (Qline_prefix);
 
   DEFVAR_BOOL ("inhibit-eval-during-redisplay", inhibit_eval_during_redisplay,
diff --git a/src/xfaces.c b/src/xfaces.c
index 5833633c2e7..4f06bd3ba55 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6393,153 +6393,82 @@ DEFUN ("show-face-resources", Fshow_face_resources, Sshow_face_resources,
 void
 syms_of_xfaces (void)
 {
-  Qface = intern_c_string ("face");
-  staticpro (&Qface);
-  Qface_no_inherit = intern_c_string ("face-no-inherit");
-  staticpro (&Qface_no_inherit);
-  Qbitmap_spec_p = intern_c_string ("bitmap-spec-p");
-  staticpro (&Qbitmap_spec_p);
-  Qframe_set_background_mode = intern_c_string ("frame-set-background-mode");
-  staticpro (&Qframe_set_background_mode);
+  DEFSYM (Qface, "face");
+  DEFSYM (Qface_no_inherit, "face-no-inherit");
+  DEFSYM (Qbitmap_spec_p, "bitmap-spec-p");
+  DEFSYM (Qframe_set_background_mode, "frame-set-background-mode");
 
   /* Lisp face attribute keywords.  */
-  QCfamily = intern_c_string (":family");
-  staticpro (&QCfamily);
-  QCheight = intern_c_string (":height");
-  staticpro (&QCheight);
-  QCweight = intern_c_string (":weight");
-  staticpro (&QCweight);
-  QCslant = intern_c_string (":slant");
-  staticpro (&QCslant);
-  QCunderline = intern_c_string (":underline");
-  staticpro (&QCunderline);
-  QCinverse_video = intern_c_string (":inverse-video");
-  staticpro (&QCinverse_video);
-  QCreverse_video = intern_c_string (":reverse-video");
-  staticpro (&QCreverse_video);
-  QCforeground = intern_c_string (":foreground");
-  staticpro (&QCforeground);
-  QCbackground = intern_c_string (":background");
-  staticpro (&QCbackground);
-  QCstipple = intern_c_string (":stipple");
-  staticpro (&QCstipple);
-  QCwidth = intern_c_string (":width");
-  staticpro (&QCwidth);
-  QCfont = intern_c_string (":font");
-  staticpro (&QCfont);
-  QCfontset = intern_c_string (":fontset");
-  staticpro (&QCfontset);
-  QCbold = intern_c_string (":bold");
-  staticpro (&QCbold);
-  QCitalic = intern_c_string (":italic");
-  staticpro (&QCitalic);
-  QCoverline = intern_c_string (":overline");
-  staticpro (&QCoverline);
-  QCstrike_through = intern_c_string (":strike-through");
-  staticpro (&QCstrike_through);
-  QCbox = intern_c_string (":box");
-  staticpro (&QCbox);
-  QCinherit = intern_c_string (":inherit");
-  staticpro (&QCinherit);
+  DEFSYM (QCfamily, ":family");
+  DEFSYM (QCheight, ":height");
+  DEFSYM (QCweight, ":weight");
+  DEFSYM (QCslant, ":slant");
+  DEFSYM (QCunderline, ":underline");
+  DEFSYM (QCinverse_video, ":inverse-video");
+  DEFSYM (QCreverse_video, ":reverse-video");
+  DEFSYM (QCforeground, ":foreground");
+  DEFSYM (QCbackground, ":background");
+  DEFSYM (QCstipple, ":stipple");
+  DEFSYM (QCwidth, ":width");
+  DEFSYM (QCfont, ":font");
+  DEFSYM (QCfontset, ":fontset");
+  DEFSYM (QCbold, ":bold");
+  DEFSYM (QCitalic, ":italic");
+  DEFSYM (QCoverline, ":overline");
+  DEFSYM (QCstrike_through, ":strike-through");
+  DEFSYM (QCbox, ":box");
+  DEFSYM (QCinherit, ":inherit");
 
   /* Symbols used for Lisp face attribute values.  */
-  QCcolor = intern_c_string (":color");
-  staticpro (&QCcolor);
-  QCline_width = intern_c_string (":line-width");
-  staticpro (&QCline_width);
-  QCstyle = intern_c_string (":style");
-  staticpro (&QCstyle);
-  Qreleased_button = intern_c_string ("released-button");
-  staticpro (&Qreleased_button);
-  Qpressed_button = intern_c_string ("pressed-button");
-  staticpro (&Qpressed_button);
-  Qnormal = intern_c_string ("normal");
-  staticpro (&Qnormal);
-  Qultra_light = intern_c_string ("ultra-light");
-  staticpro (&Qultra_light);
-  Qextra_light = intern_c_string ("extra-light");
-  staticpro (&Qextra_light);
-  Qlight = intern_c_string ("light");
-  staticpro (&Qlight);
-  Qsemi_light = intern_c_string ("semi-light");
-  staticpro (&Qsemi_light);
-  Qsemi_bold = intern_c_string ("semi-bold");
-  staticpro (&Qsemi_bold);
-  Qbold = intern_c_string ("bold");
-  staticpro (&Qbold);
-  Qextra_bold = intern_c_string ("extra-bold");
-  staticpro (&Qextra_bold);
-  Qultra_bold = intern_c_string ("ultra-bold");
-  staticpro (&Qultra_bold);
-  Qoblique = intern_c_string ("oblique");
-  staticpro (&Qoblique);
-  Qitalic = intern_c_string ("italic");
-  staticpro (&Qitalic);
-  Qreverse_oblique = intern_c_string ("reverse-oblique");
-  staticpro (&Qreverse_oblique);
-  Qreverse_italic = intern_c_string ("reverse-italic");
-  staticpro (&Qreverse_italic);
-  Qultra_condensed = intern_c_string ("ultra-condensed");
-  staticpro (&Qultra_condensed);
-  Qextra_condensed = intern_c_string ("extra-condensed");
-  staticpro (&Qextra_condensed);
-  Qcondensed = intern_c_string ("condensed");
-  staticpro (&Qcondensed);
-  Qsemi_condensed = intern_c_string ("semi-condensed");
-  staticpro (&Qsemi_condensed);
-  Qsemi_expanded = intern_c_string ("semi-expanded");
-  staticpro (&Qsemi_expanded);
-  Qexpanded = intern_c_string ("expanded");
-  staticpro (&Qexpanded);
-  Qextra_expanded = intern_c_string ("extra-expanded");
-  staticpro (&Qextra_expanded);
-  Qultra_expanded = intern_c_string ("ultra-expanded");
-  staticpro (&Qultra_expanded);
-  Qbackground_color = intern_c_string ("background-color");
-  staticpro (&Qbackground_color);
-  Qforeground_color = intern_c_string ("foreground-color");
-  staticpro (&Qforeground_color);
-  Qunspecified = intern_c_string ("unspecified");
-  staticpro (&Qunspecified);
-  Qignore_defface = intern_c_string (":ignore-defface");
-  staticpro (&Qignore_defface);
-
-  Qface_alias = intern_c_string ("face-alias");
-  staticpro (&Qface_alias);
-  Qdefault = intern_c_string ("default");
-  staticpro (&Qdefault);
-  Qtool_bar = intern_c_string ("tool-bar");
-  staticpro (&Qtool_bar);
-  Qregion = intern_c_string ("region");
-  staticpro (&Qregion);
-  Qfringe = intern_c_string ("fringe");
-  staticpro (&Qfringe);
-  Qheader_line = intern_c_string ("header-line");
-  staticpro (&Qheader_line);
-  Qscroll_bar = intern_c_string ("scroll-bar");
-  staticpro (&Qscroll_bar);
-  Qmenu = intern_c_string ("menu");
-  staticpro (&Qmenu);
-  Qcursor = intern_c_string ("cursor");
-  staticpro (&Qcursor);
-  Qborder = intern_c_string ("border");
-  staticpro (&Qborder);
-  Qmouse = intern_c_string ("mouse");
-  staticpro (&Qmouse);
-  Qmode_line_inactive = intern_c_string ("mode-line-inactive");
-  staticpro (&Qmode_line_inactive);
-  Qvertical_border = intern_c_string ("vertical-border");
-  staticpro (&Qvertical_border);
-  Qtty_color_desc = intern_c_string ("tty-color-desc");
-  staticpro (&Qtty_color_desc);
-  Qtty_color_standard_values = intern_c_string ("tty-color-standard-values");
-  staticpro (&Qtty_color_standard_values);
-  Qtty_color_by_index = intern_c_string ("tty-color-by-index");
-  staticpro (&Qtty_color_by_index);
-  Qtty_color_alist = intern_c_string ("tty-color-alist");
-  staticpro (&Qtty_color_alist);
-  Qscalable_fonts_allowed = intern_c_string ("scalable-fonts-allowed");
-  staticpro (&Qscalable_fonts_allowed);
+  DEFSYM (QCcolor, ":color");
+  DEFSYM (QCline_width, ":line-width");
+  DEFSYM (QCstyle, ":style");
+  DEFSYM (Qreleased_button, "released-button");
+  DEFSYM (Qpressed_button, "pressed-button");
+  DEFSYM (Qnormal, "normal");
+  DEFSYM (Qultra_light, "ultra-light");
+  DEFSYM (Qextra_light, "extra-light");
+  DEFSYM (Qlight, "light");
+  DEFSYM (Qsemi_light, "semi-light");
+  DEFSYM (Qsemi_bold, "semi-bold");
+  DEFSYM (Qbold, "bold");
+  DEFSYM (Qextra_bold, "extra-bold");
+  DEFSYM (Qultra_bold, "ultra-bold");
+  DEFSYM (Qoblique, "oblique");
+  DEFSYM (Qitalic, "italic");
+  DEFSYM (Qreverse_oblique, "reverse-oblique");
+  DEFSYM (Qreverse_italic, "reverse-italic");
+  DEFSYM (Qultra_condensed, "ultra-condensed");
+  DEFSYM (Qextra_condensed, "extra-condensed");
+  DEFSYM (Qcondensed, "condensed");
+  DEFSYM (Qsemi_condensed, "semi-condensed");
+  DEFSYM (Qsemi_expanded, "semi-expanded");
+  DEFSYM (Qexpanded, "expanded");
+  DEFSYM (Qextra_expanded, "extra-expanded");
+  DEFSYM (Qultra_expanded, "ultra-expanded");
+  DEFSYM (Qbackground_color, "background-color");
+  DEFSYM (Qforeground_color, "foreground-color");
+  DEFSYM (Qunspecified, "unspecified");
+  DEFSYM (Qignore_defface, ":ignore-defface");
+
+  DEFSYM (Qface_alias, "face-alias");
+  DEFSYM (Qdefault, "default");
+  DEFSYM (Qtool_bar, "tool-bar");
+  DEFSYM (Qregion, "region");
+  DEFSYM (Qfringe, "fringe");
+  DEFSYM (Qheader_line, "header-line");
+  DEFSYM (Qscroll_bar, "scroll-bar");
+  DEFSYM (Qmenu, "menu");
+  DEFSYM (Qcursor, "cursor");
+  DEFSYM (Qborder, "border");
+  DEFSYM (Qmouse, "mouse");
+  DEFSYM (Qmode_line_inactive, "mode-line-inactive");
+  DEFSYM (Qvertical_border, "vertical-border");
+  DEFSYM (Qtty_color_desc, "tty-color-desc");
+  DEFSYM (Qtty_color_standard_values, "tty-color-standard-values");
+  DEFSYM (Qtty_color_by_index, "tty-color-by-index");
+  DEFSYM (Qtty_color_alist, "tty-color-alist");
+  DEFSYM (Qscalable_fonts_allowed, "scalable-fonts-allowed");
 
   Vparam_value_alist = Fcons (Fcons (Qnil, Qnil), Qnil);
   staticpro (&Vparam_value_alist);
diff --git a/src/xfns.c b/src/xfns.c
index dc717f643aa..b4153973e0d 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -5797,25 +5797,18 @@ syms_of_xfns (void)
   /* The section below is built by the lisp expression at the top of the file,
      just above where these variables are declared.  */
   /*&&& init symbols here &&&*/
-  Qnone = intern_c_string ("none");
-  staticpro (&Qnone);
-  Qsuppress_icon = intern_c_string ("suppress-icon");
-  staticpro (&Qsuppress_icon);
-  Qundefined_color = intern_c_string ("undefined-color");
-  staticpro (&Qundefined_color);
-  Qcompound_text = intern_c_string ("compound-text");
-  staticpro (&Qcompound_text);
-  Qcancel_timer = intern_c_string ("cancel-timer");
-  staticpro (&Qcancel_timer);
-  Qfont_param = intern_c_string ("font-parameter");
-  staticpro (&Qfont_param);
+  DEFSYM (Qnone, "none");
+  DEFSYM (Qsuppress_icon, "suppress-icon");
+  DEFSYM (Qundefined_color, "undefined-color");
+  DEFSYM (Qcompound_text, "compound-text");
+  DEFSYM (Qcancel_timer, "cancel-timer");
+  DEFSYM (Qfont_param, "font-parameter");
   /* This is the end of symbol initialization.  */
 
   /* Text property `display' should be nonsticky by default.  */
   Vtext_property_default_nonsticky
     = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
 
-
   Fput (Qundefined_color, Qerror_conditions,
         pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
   Fput (Qundefined_color, Qerror_message,
diff --git a/src/xmenu.c b/src/xmenu.c
index 1cb71187c0c..fc629b35104 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -2559,8 +2559,7 @@ DEFUN ("menu-or-popup-active-p", Fmenu_or_popup_active_p, Smenu_or_popup_active_
 void
 syms_of_xmenu (void)
 {
-  Qdebug_on_next_call = intern_c_string ("debug-on-next-call");
-  staticpro (&Qdebug_on_next_call);
+  DEFSYM (Qdebug_on_next_call, "debug-on-next-call");
 
 #ifdef USE_X_TOOLKIT
   widget_id_tick = (1<<16);
diff --git a/src/xsettings.c b/src/xsettings.c
index e2575650df9..5412cf426f8 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -750,12 +750,9 @@ syms_of_xsettings (void)
   gconf_client = NULL;
 #endif
 
-  Qmonospace_font_name = intern_c_string ("monospace-font-name");
-  staticpro (&Qmonospace_font_name);
-  Qfont_name = intern_c_string ("font-name");
-  staticpro (&Qfont_name);
-  Qfont_render = intern_c_string ("font-render");
-  staticpro (&Qfont_render);
+  DEFSYM (Qmonospace_font_name, "monospace-font-name");
+  DEFSYM (Qfont_name, "font-name");
+  DEFSYM (Qfont_render, "font-render");
   defsubr (&Sfont_get_system_font);
   defsubr (&Sfont_get_system_normal_font);
 
@@ -778,8 +775,7 @@ If this variable is nil, Emacs ignores system font changes.  */);
 #endif
 
   current_tool_bar_style = Qnil;
-  Qtool_bar_style = intern_c_string ("tool-bar-style");
-  staticpro (&Qtool_bar_style);
+  DEFSYM (Qtool_bar_style, "tool-bar-style");
   defsubr (&Stool_bar_get_system_style);
 
   Fprovide (intern_c_string ("dynamic-setting"), Qnil);
diff --git a/src/xterm.c b/src/xterm.c
index ea0bc6bd427..ea03c04ce50 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -10730,11 +10730,8 @@ syms_of_xterm (void)
   staticpro (&last_mouse_scroll_bar);
   last_mouse_scroll_bar = Qnil;
 
-  staticpro (&Qvendor_specific_keysyms);
-  Qvendor_specific_keysyms = intern_c_string ("vendor-specific-keysyms");
-
-  staticpro (&Qlatin_1);
-  Qlatin_1 = intern_c_string ("latin-1");
+  DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
+  DEFSYM (Qlatin_1, "latin-1");
 
   staticpro (&last_mouse_press_frame);
   last_mouse_press_frame = Qnil;
@@ -10743,8 +10740,7 @@ syms_of_xterm (void)
   xg_default_icon_file = make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
   staticpro (&xg_default_icon_file);
 
-  Qx_gtk_map_stock = intern_c_string ("x-gtk-map-stock");
-  staticpro (&Qx_gtk_map_stock);
+  DEFSYM (Qx_gtk_map_stock, "x-gtk-map-stock");
 #endif
 
   DEFVAR_BOOL ("x-use-underline-position-properties",
diff --git a/src/xwidget.c b/src/xwidget.c
index 8e8bd4ca4b4..4029adb141d 100644
--- a/src/xwidget.c
+++ b/src/xwidget.c
@@ -101,6 +101,7 @@ extern Lisp_Object  QCtype;
 extern Lisp_Object QCwidth, QCheight;  
 
 #define XG_XWIDGET "emacs_xwidget"
+#define XG_XWIDGET_VIEW "emacs_xwidget_view"
 struct xwidget_view* xwidget_view_lookup(struct xwidget* xw,     struct window *w);
 
 int
@@ -201,6 +202,35 @@ gboolean xwidget_plug_removed(GtkSocket *socket,
 }
 
 
+void xwidget_slider_changed (GtkRange *range,
+                             gpointer  user_data)
+{
+  //slider value changed. change value of siblings correspondingly. but remember that changing value will again trigger signal
+  //gtk_range_set_value ()
+  //http://developer.gnome.org/gobject/unstable/gobject-Signals.html#g-signal-handler-block
+  double v;
+  printf("slider changed val:%f\n", v=gtk_range_get_value(range));
+  //code meant to be refactored
+  struct xwidget_view* xvp = g_object_get_data (G_OBJECT (range), XG_XWIDGET_VIEW);
+  struct xwidget_view* xv;
+  for (int i = 0; i < MAX_XWIDGETS; i++)
+    {
+      xv = &xwidget_views[i];
+      if(xvp->model == xv->model){
+        g_signal_handler_block( xv->widget,xv->handler_id);
+      }
+    }
+  for (int i = 0; i < MAX_XWIDGETS; i++)
+    {
+      xv = &xwidget_views[i];
+      if(xvp->model == xv->model){
+        gtk_range_set_value(xv->widget, v);
+        g_signal_handler_unblock( xv->widget,xv->handler_id);
+      }
+    }
+
+}
+
 int xwidget_view_index=0;
 
 /* initializes and does initial placement of an xwidget view on screen */
@@ -233,11 +263,12 @@ xwidget_init_view (
       //gtk_widget_modify_bg(xv->widget, GTK_STATE_NORMAL, &color);
       g_signal_connect_after(xv->widget, "plug-added", G_CALLBACK(xwidget_plug_added), "plug added");
       g_signal_connect_after(xv->widget, "plug-removed", G_CALLBACK(xwidget_plug_removed), "plug removed");              
-    } else if (EQ(xww->type, Qsocket)) {
+    } else if (EQ(xww->type, Qslider)) {
       xv->widget =
-        gtk_hscale_new (GTK_ADJUSTMENT
-                        (gtk_adjustment_new (0, 0, 100, 1, 1, 0)));
+        //gtk_hscale_new (GTK_ADJUSTMENT(gtk_adjustment_new (0.0, 0.0, 100.0, 1.0, 10.0, 10.0)));
+        gtk_hscale_new_with_range ( 0.0, 100.0, 10.0);
       gtk_scale_set_draw_value (GTK_SCALE (xv->widget), FALSE); //i think its emacs role to show text and stuff, so disable the widgets own text
+      xv->handler_id = g_signal_connect_after(xv->widget, "value-changed", G_CALLBACK(xwidget_slider_changed), "slider changed");
     } else if (EQ(xww->type, Qcairo)) {
       //Cairo view
       //uhm cairo is differentish in gtk 3. 
@@ -253,7 +284,7 @@ xwidget_init_view (
   //xw->widgetwindow = GTK_CONTAINER (gtk_offscreen_window_new ());
 
   xv->widgetwindow = GTK_CONTAINER (gtk_fixed_new ());
-  gtk_widget_set_has_window(  xv->widgetwindow, TRUE); //if gtk_fixed doesnt have a window it will surprisingly not honor setsize so that children gets clipped later. the documentation is not consistent regarding if its legal to call this method
+  gtk_widget_set_has_window(GTK_WIDGET (  xv->widgetwindow), TRUE); //if gtk_fixed doesnt have a window it will surprisingly not honor setsize so that children gets clipped later. the documentation is not consistent regarding if its legal to call this method
   //xv->widgetwindow = GTK_CONTAINER (gtk_event_box_new ());
 
   //gtk_widget_set_size_request (GTK_WIDGET (xw->widget), xw->width, xw->height);  
@@ -267,6 +298,7 @@ xwidget_init_view (
   //store some xwidget data in the gtk widgets
   g_object_set_data (G_OBJECT (xv->widget), XG_FRAME_DATA, (gpointer) (s->f)); //the emacs frame
   g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET, (gpointer) (xww)); //the xwidget
+  g_object_set_data (G_OBJECT (xv->widget), XG_XWIDGET_VIEW, (gpointer) (xv)); //the xwidget
   g_object_set_data (G_OBJECT (xv->widgetwindow), XG_XWIDGET, (gpointer) (xww)); //the xwidget  
 
   //this seems to enable xcomposition. later we need to paint ourselves somehow,
diff --git a/src/xwidget.h b/src/xwidget.h
index 9e3d4669056..3a7d92f70a7 100644
--- a/src/xwidget.h
+++ b/src/xwidget.h
@@ -41,6 +41,8 @@ struct xwidget_view{
   int x; int y;
   int clipx; int clipy;
   struct window *w;
+
+  long handler_id;
 };