57 files changed, 1894 insertions, 1553 deletions
diff --git a/src/.gdbinit b/src/.gdbinit
index 952d7392a4c..fa580cc99bf 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -650,19 +650,52 @@ If the first type printed is Lisp_Vector or Lisp_Misc,
 a second line gives the more precise type.
 end
+define pvectype
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
+  if ($size & PSEUDOVECTOR_FLAG)
+    output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
+  else
+    output PVEC_NORMAL_VECTOR
+  end
+  echo \n
+end
+document pvectype
+Print the subtype of vectorlike object.
+Takes one argument, a pointer to an object.
+end
 define xvectype
  xgetptr $
-  set $size = ((struct Lisp_Vector *) $ptr)->header.size
+  pvectype $ptr
+end
+document xvectype
+Print the subtype of vectorlike object.
+This command assumes that $ is a Lisp_Object.
+end
+define pvecsize
+  set $size = ((struct Lisp_Vector *) $arg0)->header.size
  if ($size & PSEUDOVECTOR_FLAG)
-    output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+    output ($size & PSEUDOVECTOR_SIZE_MASK)
+    echo \n
+    output (($size & PSEUDOVECTOR_REST_MASK) >> PSEUDOVECTOR_SIZE_BITS)
  else
-    output $size & ~ARRAY_MARK_FLAG
+    output ($size & ~ARRAY_MARK_FLAG)
  end
  echo \n
 end
-document xvectype
+document pvecsize
-Print the size or vector subtype of $.
+Print the size of vectorlike object.
-This command assumes that $ is a vector or pseudovector.
+Takes one argument, a pointer to an object.
+end
+define xvecsize
+  xgetptr $
+  pvecsize $ptr
+end
+document xvecsize
+Print the size of $
+This command assumes that $ is a Lisp_Object.
 end
 define xmisctype
@@ -996,7 +1029,7 @@ define xpr
  if $type == Lisp_Vectorlike
    set $size = ((struct Lisp_Vector *) $ptr)->header.size
    if ($size & PSEUDOVECTOR_FLAG)
-      set $vec = (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+      set $vec = (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
      if $vec == PVEC_NORMAL_VECTOR
        xvector
      end
@@ -1132,7 +1165,7 @@ define xbacktrace
        xgetptr ($bt->function)
        set $size = ((struct Lisp_Vector *) $ptr)->header.size
        if ($size & PSEUDOVECTOR_FLAG)
-          output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_SIZE_BITS)
+          output (enum pvec_type) (($size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
        else
          output $size & ~ARRAY_MARK_FLAG
        end
diff --git a/src/ChangeLog b/src/ChangeLog
index 87f669c5c6e..e3be3f9149d 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,554 @@
+2012-11-13  Dmitry Antipov  <dmantipov@yandex.ru>
+        Omit glyphs initialization at startup.
+        * dispnew.c (glyphs_initialized_initially_p): Remove.
+        (adjust_frame_glyphs_initially): Likewise.  Adjust users.
+        (Fredraw_frame): Move actual code from here...
+        (redraw_frame): ...to here.  Add eassert.  Adjust comment.
+        (Fredraw_display): Use redraw_frame.
+        * xdisp.c (clear_garbaged_frames): Likewise.
+2012-11-13  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (decode_mode_spec): Limit the value of WIDTH argument
+        passed to pint2str and pint2hrstr to be at most the size of the
+        frame's decode_mode_spec_buffer.  This avoids crashes with very
+        large values of FIELD_WIDTH argument to decode_mode_spec.
+        (Bug#12867)
+2012-11-13  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix a race with verify-visited-file-modtime (Bug#12863).
+        Since at least 1991 Emacs has ignored an mtime difference of no
+        more than one second, but my guess is that this was to work around
+        file system bugs that were fixed long ago.  Since the race is
+        causing problems now, let's remove that code.
+        * fileio.c (Fverify_visited_file_modtime): Do not accept a file
+        whose time stamp is off by no more than a second.  Insist that the
+        file time stamps match exactly.
+2012-11-12  Dmitry Antipov  <dmantipov@yandex.ru>
+        * frame.h (struct frame): Convert external_tool_bar member to
+        1-bit unsigned bitfield.
+        * termhooks.h (struct terminal): Remove mouse_moved member since
+        all users are long dead.  Adjust comment on mouse_position_hook.
+2012-11-12  Dmitry Antipov  <dmantipov@yandex.ru>
+        Simplify by using FOR_EACH_FRAME here and there.
+        * frame.c (next_frame, prev_frame, other_visible_frames)
+        (delete_frame, visible-frame-list): Use FOR_EACH_FRAME.
+        * w32term.c (x_window_to_scroll_bar): Likewise.
+        * window.c (window_list): Likewise.
+        * xdisp.c (x_consider_frame_title): Likewise.
+        * xfaces.c ( Fdisplay_supports_face_attributes_p): Likewise.
+        * xfns.c (x_window_to_frame, x_any_window_to_frame)
+        (x_menubar_window_to_frame, x_top_window_to_frame): Likewise.
+        * xmenu.c (menubar_id_to_frame): Likewise.
+        * xselect.c (frame_for_x_selection): Likewise.
+        * xterm.c (x_frame_of_widget, x_window_to_scroll_bar)
+        (x_window_to_menu_bar): Likewise.
+        * w32fns.c (x_window_to_frame): Likewise.  Adjust comment.
+2012-11-12  Paul Eggert  <eggert@cs.ucla.edu>
+        * data.c (Qdefalias_fset_function): Now static.
+        Another tweak to vectorlike_header change.
+        * alloc.c (struct Lisp_Vectorlike_Free, NEXT_IN_FREE_LIST):
+        Remove, and replace all uses with ...
+        (next_in_free_list, set_next_in_free_list):
+        New functions, which respect C's aliasing rules better.
+2012-11-11  Paul Eggert  <eggert@cs.ucla.edu>
+        * window.c (list4i): Rename from 'quad'.  All uses changed.
+        Needed because <sys/types.h> defines 'quad' on Solaris 10.
+2012-11-11  Juanma Barranquero  <lekktu@gmail.com>
+        * xdisp.c (start_hourglass) [HAVE_NTGUI]: Add block to silence
+        warning about mixing declarations and code in ISO C90.
+2012-11-10  Martin Rudalics  <rudalics@gmx.at>
+        * window.c (Fsplit_window_internal): Set combination limit of
+        new parent window to t iff Vwindow_combination_limit is t;
+        fixing a regression introduced with the change from 2012-09-22.
+        (Fset_window_combination_limit): Fix doc-string.
+2012-11-10  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (try_scrolling): Fix correction of aggressive-scroll
+        amount when the scroll margins are too large.  When scrolling
+        backwards in the buffer, give up if cannot reach point or the
+        scroll margin within a reasonable number of screen lines.  Fixes
+        point position in window under scroll-up/down-aggressively when
+        point is positioned many lines beyond the window top/bottom.
+        (Bug#12811)
+        * ralloc.c (relinquish): If real_morecore fails to return memory
+        to the system, don't crash; instead, leave the last heap
+        unchanged and return.  (Bug#12774)
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * lisp.h (AUTOLOADP): New macro.
+        * eval.c (Fautoload): Don't attach to loadhist, call Fdefalias instead.
+        * data.c (Ffset): Remove special ad-advice-info handling.
+        (Fdefalias): Handle autoload definitions and new Qdefalias_fset_function.
+        (Fsubr_arity): CSE.
+        (Finteractive_form): Simplify.
+        (Fquo): Don't insist on having at least 2 arguments.
+        (Qdefalias_fset_function): New var.
+2012-11-09  Jan Djärv  <jan.h.d@swipnet.se>
+        * image.c (xpm_make_color_table_h): Change to hashtest_equal.
+        * nsfont.m (Qcondensed, Qexpanded): New variables.
+        (ns_descriptor_to_entity): Restore Qcondensed, Qexpanded setting.
+        (syms_of_nsfont): Defsym Qcondensed, Qexpanded.
+2012-11-09  Dmitry Antipov  <dmantipov@yandex.ru>
+        Fix recently introduced crash on MS-Windows (Bug#12839).
+        * w32term.h (struct scroll_bar): Use convenient header.
+        (SCROLL_BAR_VEC_SIZE): Remove.
+        * w32term.c (x_scroll_bar_create): Use VECSIZE.
+2012-11-09  Dmitry Antipov  <dmantipov@yandex.ru>
+        Tweak last vectorlike_header change.
+        * alloc.c (struct Lisp_Vectorlike_Free): Special type to represent
+        vectorlike object on the free list.  This is introduced to avoid
+        some (but not all) pointer casting and aliasing problems, see
+        http://lists.gnu.org/archive/html/emacs-devel/2012-11/msg00105.html.
+        * .gdbinit (pvectype, pvecsize): New commands to examine vectorlike
+        objects.
+        (xvectype, xvecsize): Use them to examine Lisp_Object values.
+2012-11-09  Jan Djärv  <jan.h.d@swipnet.se>
+        * nsfont.m (ns_descriptor_to_entity): Qcondensed and Qexpanded has
+        been removed, so remove them here also.
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * doc.c (Fdocumentation): Handle new property
+        dynamic-docstring-function to replace the old ad-advice-info.
+2012-11-09  Paul Eggert  <eggert@cs.ucla.edu>
+        * fns.c (Qeql, hashtest_eq): Now static.
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * lisp.h (XHASH): Redefine to be imperfect and fit in a Lisp int.
+        * fns.c (hashfn_eq, hashfn_eql, sxhash):
+        * profiler.c (hashfn_profiler): Don't use XUINT on non-integers.
+        * buffer.c (compare_overlays): Use XLI rather than XHASH.
+2012-11-08  Paul Eggert  <eggert@cs.ucla.edu>
+        Use same hash function for hashfn_profiler as for hash_string etc.
+        * fns.c (SXHASH_COMBINE): Remove.  All uses replaced by sxhash_combine.
+        * lisp.h (sxhash_combine): New inline function, with the contents
+        of the old SXHASH_COMBINE.
+        * profiler.c (hashfn_profiler): Use it, instead of having a
+        special hash function containing a comparison that always yields 1.
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * xfaces.c (Qultra_light, Qreverse_oblique, Qreverse_italic)
+        (Qultra_condensed, Qextra_condensed, Qcondensed, Qsemi_condensed)
+        (Qsemi_expanded, Qextra_expanded, Qexpanded, Qultra_expanded):
+        Remove unused vars.
+2012-11-08  Jan Djärv  <jan.h.d@swipnet.se>
+        * image.c (xpm_make_color_table_h): Fix compiler error because
+        make_hash_table changed.
+2012-11-08  Thomas Kappler <tkappler@gmail.com> (tiny change)
+        * nsfont.m (ns_findfonts): Handle empty matchingDescs (Bug#11541).
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+        Use ad-hoc comparison function for the profiler's hash-tables.
+        * profiler.c (Qprofiler_backtrace_equal, hashtest_profiler): New vars.
+        (make_log): Use them.
+        (handle_profiler_signal): Don't inhibit quit any longer since we don't
+        call Fequal any more.
+        (Ffunction_equal): New function.
+        (cmpfn_profiler, hashfn_profiler): New functions.
+        (syms_of_profiler): Initialize them.
+        * lisp.h (struct hash_table_test): New struct.
+        (struct Lisp_Hash_Table): Use it.
+        * alloc.c (mark_object): Mark hash_table_test fields of hash tables.
+        * fns.c (make_hash_table): Take a struct to describe the test.
+        (cmpfn_eql, cmpfn_equal, cmpfn_user_defined, hashfn_eq, hashfn_eql)
+        (hashfn_equal, hashfn_user_defined): Adjust to new calling convention.
+        (hash_lookup, hash_remove_from_table): Move assertion checking of
+        hashfn result here.  Check hash-equality before calling cmpfn.
+        (Fmake_hash_table): Adjust call to make_hash_table.
+        (hashtest_eq, hashtest_eql, hashtest_equal): New structs.
+        (syms_of_fns): Initialize them.
+        * emacs.c (main): Move syms_of_fns earlier.
+        * xterm.c (syms_of_xterm):
+        * category.c (hash_get_category_set): Adjust call to make_hash_table.
+        * print.c (print_object): Adjust to new hash-table struct.
+        * composite.c (composition_gstring_put_cache): Adjust to new hashfn.
+2012-11-08  Eli Zaretskii  <eliz@gnu.org>
+        * w32fns.c (modifier_set): Fix handling of Scroll Lock when the
+        value of w32-scroll-lock-modifier is neither nil nor one of the
+        known key modifiers.  (Bug#12806)
+2012-11-08  Dmitry Antipov  <dmantipov@yandex.ru>
+        Shrink struct vectorlike_header to the only size field.
+        * lisp.h (enum pvec_type): Avoid explicit enum member values.
+        Adjust comment.
+        (enum More_Lisp_Bits): Change PSEUDOVECTOR_SIZE_BITS and
+        PVEC_TYPE_MASK to arrange new bitfield in the vector header.
+        (PSEUDOVECTOR_REST_BITS, PSEUDOVECTOR_REST_MASK): New members.
+        (PSEUDOVECTOR_AREA_BITS): New member used to extract subtype
+        information from the vector header.  Adjust comment.
+        (XSETPVECTYPE, XSETPVECTYPESIZE, XSETTYPED_PSEUDOVECTOR)
+        (PSEUDOVECTOR_TYPEP, DEFUN): Adjust to match new vector header
+        layout.
+        (XSETSUBR, SUBRP): Adjust to match new Lisp_Subr layout.
+        (struct vectorlike_header): Remove next member.  Adjust comment.
+        (struct Lisp_Subr): Add convenient header.  Adjust comment.
+        (allocate_pseudovector): Adjust prototype.
+        * alloc.c (mark_glyph_matrix, mark_face_cache, allocate_string)
+        (sweep_string, lisp_malloc): Remove useless prototypes.
+        (enum mem_type): Adjust comment.
+        (NEXT_IN_FREE_LIST): New macro.
+        (SETUP_ON_FREE_LIST): Adjust XSETPVECTYPESIZE usage.
+        (Fmake_bool_vector): Likewise.
+        (struct large_vector): New type to represent allocation unit for
+        the vectors with the memory footprint more than VBLOOCK_BYTES_MAX.
+        (large_vectors): Change type to struct large_vector.
+        (allocate_vector_from_block): Simplify.
+        (PSEUDOVECTOR_NBYTES): Replace with...
+        (vector_nbytes): ...new function.  Adjust users.
+        (sweep_vectors): Adjust processing of large vectors.
+        (allocate_vectorlike): Likewise.
+        (allocate_pseudovector): Change type of 3rd arg to enum pvec_type.
+        Add easserts.  Adjust XSETPVECTYPESIZE usage.
+        (allocate_buffer): Use BUFFER_PVEC_INIT.
+        (live_vector_p): Adjust to match large vector.
+        * buffer.c (init_buffer_once): Use BUFFER_PVEC_INIT.
+        * buffer.h (struct buffer): Add next member.
+        (BUFFER_LISP_SIZE, BUFFER_REST_SIZE, BUFFER_PVEC_INIT):
+        New macros.
+        (FOR_EACH_BUFFER): Adjust to match struct buffer change.
+        * fns.c (internal_equal): Adjust to match enum pvec_type change.
+        (copy_hash_table): Adjust to match vector header change.
+        * lread.c (defsubr): Use XSETPVECTYPE.
+        * .gdbinit (xpr, xbacktrace): Adjust to match vector header change.
+        (xvectype): Likewise.  Print PVEC_NORMAL_VECTOR for regular vectors.
+        (xvecsize): New command.
+2012-11-08  Dmitry Antipov  <dmantipov@yandex.ru>
+        * keyboard.c (event_to_kboard): Do not dereference
+        frame_or_window field of SELECTION_REQUEST_EVENT
+        and SELECTION_CLEAR_EVENT events (Bug#12814).
+        * xterm.h (struct selection_input_event): Adjust comment.
+2012-11-07  Eli Zaretskii  <eliz@gnu.org>
+        * w32fns.c (modifier_set): Don't report modifiers from toggle key,
+        such as Scroll Lock, if the respective keys are treated as
+        function keys, not as modifiers.  This avoids destroying non-ASCII
+        keyboard input when Scroll Lock is toggled ON.  (Bug#12806)
+2012-11-07  Dmitry Antipov  <dmantipov@yandex.ru>
+        * xfns.c (Fx_wm_set_size_hint): Use check_x_frame.  Adjust docstring.
+2012-11-06  Paul Eggert  <eggert@cs.ucla.edu>
+        Restore some duplicate definitions (Bug#12814).
+        This undoes part of the 2012-11-03 changes.  Some people build
+        with plain -g rather than with -g3, and they need the duplicate
+        definitions for .gdbinit to work; see <http://bugs.gnu.org/12814#26>.
+        * lisp.h (GCTYPEBITS, ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG, VALMASK):
+        Define as macros, as well as as enums or as constants.
+2012-11-06  Jan Djärv  <jan.h.d@swipnet.se>
+        * nsterm.m (convert_ns_to_X_keysym, keyDown:): Add NSNumericPadKeyMask
+        to keypad keys (Bug#12816).
+2012-11-06  Paul Eggert  <eggert@cs.ucla.edu>
+        Minor adjustments of recently-changed frame functions.
+        * buffer.c (Fbuffer_list): Omit CHECK_FRAME, since arg is already
+        known to be a frame (we're in the FRAMEP branch).
+        * lisp.h (Qframep): Remove decl.  frame.h declares this.
+        * window.c (quad): Args are of type EMACS_INT, not ptrdiff_t,
+        since they're meant for Lisp fixnum values.
+2012-11-06  Dmitry Antipov  <dmantipov@yandex.ru>
+        * window.c (Fwindow_combination_limit): Revert to the only
+        required argument and adjust docstring as suggested in
+        http://lists.gnu.org/archive/html/emacs-diffs/2012-11/msg01082.html
+        by Martin Rudalics <rudalics@gmx.at>.
+2012-11-06  Dmitry Antipov  <dmantipov@yandex.ru>
+        Widely used frame validity and checking functions.
+        * frame.h (decode_live_frame, decode_any_frame): Add prototypes.
+        * frame.c (decode_live_frame, decode_any_frame): New functions.
+        (delete_frame, Fredirect_frame_focus, Fframe_parameters)
+        (Fframe_parameter, Fframe_char_height, Fframe_char_width)
+        (Fframe_pixel_height, Fframe_pixel_width, Ftool_bar_pixel_width)
+        (Fframe_pointer_visible_p): Use decode_any_frame.
+        (Fmake_frame_visible, Fmake_frame_invisible, Ficonify_frame)
+        (Fraise_frame, Flower_frame, Fmodify_frame_parameters)
+        (Fset_frame_height, Fset_frame_width): Use decode_live_frame.
+        (Fframe_focus): Likewise.  Allow zero number of arguments.
+        Adjust docstring.
+        (frame_buffer_list, frame_buffer_predicate): Remove.
+        * lisp.h (frame_buffer_predicate): Remove prototype.
+        * buffer.c (Fother_buffer): Use decode_any_frame.
+        * xdisp.c (Ftool_bar_lines_needed): Likewise.
+        * xfaces.c (Fcolor_gray_p, Fcolor_supported_p): Likewise.
+        * font.c (Ffont_face_attributes, Ffont_family_list, Fopen_font)
+        (Fclose_font, Ffont_info): Use decode_live_frame.
+        * fontset.c (check_fontset_name): Likewise.
+        * terminal.c (Fframe_terminal): Likewise.
+        * w32fns.c (check_x_frame): Likewise.
+        * window.c (Fminibuffer_window, Fwindow_at)
+        (Fcurrent_window_configuration): Likewise.
+        (Frun_window_configuration_change_hook, Fwindow_resize_apply):
+        Likewise.  Allow zero number of arguments.  Adjust docstring.
+        * dispnew.c (Fredraw_frame): Likewise.
+        * xfaces.c (frame_or_selected_frame): Remove.
+        (Fx_list_fonts, Finternal_get_lisp_face_attribute, Fface_font)
+        (Finternal_lisp_face_equal_p, Finternal_lisp_face_empty_p)
+        (Fframe_face_alist): Use decode_live_frame.
+        * xfns.c (check_x_frame): Likewise.
+2012-11-06  Dmitry Antipov  <dmantipov@yandex.ru>
+        * window.c (quad): New function.
+        (Fwindow_edges, Fwindow_pixel_edges, Fwindow_inside_edges)
+        (Fwindow_absolute_pixel_edges, Fwindow_inside_absolute_pixel_edges)
+        (Fwindow_inside_pixel_edges, Fpos_visible_in_window_p)
+        (Fwindow_line_height): Use it.
+        (Fwindow_fringes): Use list3.
+        (Fwindow_scroll_bars): Use list4.
+        (Fwindow_frame, Fwindow_top_child, Fwindow_left_child)
+        (Fwindow_combination_limit): Allow zero number of arguments.
+2012-11-05  Eli Zaretskii  <eliz@gnu.org>
+        * makefile.w32-in ($(BLD)/w32fns.$(O)): Depend on $(NT_INC)/unistd.h.
+        * w32fns.c: Include unistd.h, to avoid compiler warnings on Cygwin.
+        (emacs_abort) [CYGWIN]: Don't call _open_osfhandle; instead, use
+        file descriptor 2 for standard error.  (Bug#12805)
+2012-11-05  Chong Yidong  <cyd@gnu.org>
+        * process.c (wait_reading_process_output): Revert previous change.
+2012-11-05  Paul Eggert  <eggert@cs.ucla.edu>
+        Assume at least POSIX.1-1988 for getpgrp, setpgid, setsid (Bug#12800).
+        This removes code that has been obsolete since around 1990.
+        * callproc.c (Fcall_process):
+        * emacs.c (main):
+        * process.c (create_process):
+        * term.c (dissociate_if_controlling_tty):
+        Assume setsid exists.
+        * callproc.c (child_setup): Assume setpgid exists and behaves as
+        per POSIX.1-1988 or later.
+        * conf_post.h (setpgid) [!HAVE_SETPGID]: Remove.
+        * emacs.c (shut_down_emacs):
+        * sysdep.c (sys_suspend, init_foreground_group):
+        Assume getpgrp behaves as per POSIX.1-1998 or later.
+        * msdos.c (setpgrp): Remove.
+        (tcgetpgrp, setpgid, setsid): New functions.
+        * systty.h (EMACS_GETPGRP): Remove.  All callers now use getpgrp.
+        * term.c (no_controlling_tty): Remove; unused.
+        * w32proc.c (setpgrp): Remove.
+        (setsid, tcgetpgrp): New functions.
+        Simplify by assuming __fpending.
+        * dispnew.c: Include <fpending.h>, not <stdio_ext.h>.
+        (update_frame_1): Use __fpending, not PENDING_OUTPUT_COUNT.
+        Do not assume that __fpending's result fits in int.
+2012-11-04  Paul Eggert  <eggert@cs.ucla.edu>
+        Remove EMACS_OUTQSIZE+sleep hack.
+        * dispnew.c (update_frame_1): Remove hack for terminals slower
+        than 2400 bps, which throttled Emacs by having it sleep.
+        This code hasn't worked since at least 2007, when the multi-tty stuff
+        was added, and anyway those old terminals are long dead.
+        * systty.h (EMACS_OUTQSIZE): Remove; unused.  The macro isn't used even
+        without the dispnew.c change, as dispnew.c doesn't include systty.h.
+        Fix data-loss with --version (Bug#9574).
+        * emacs.c (close_output_streams): Use strerror, not emacs_strerror,
+        as we can't assume that emacs_strerror is initialized, and strerror
+        is good enough here.
+        (main): Invoke atexit earlier, to catch earlier instances of
+        sending data to stdout and exiting, e.g., "emacs --version >/dev/full".
+2012-11-04  Michael Marchionna  <tralfaz@pacbell.net>
+        * nsterm.m: Add NSClearLineFunctionKey and keypad keys (Bug#8680).
+        (keyDown): Remap keypad keys to X11 virtual key codes.
+2012-11-03  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix data-loss with --batch (Bug#9574).
+        * emacs.c: Include <close-stream.h>.
+        (close_output_streams): New function.
+        (main): Pass it to atexit, so that Emacs closes stdout and stderr
+        and handles errors appropriately.
+        (Fkill_emacs): Don't worry about flushing, as close_output_stream
+        does that now.
+        Fix a race condition that causes Emacs to mess up glib (Bug#8855).
+        The symptom is a diagnostic "GLib-WARNING **: In call to
+        g_spawn_sync(), exit status of a child process was requested but
+        SIGCHLD action was set to SIG_IGN and ECHILD was received by
+        waitpid(), so exit status can't be returned."  The diagnostic
+        is partly wrong, as the SIGCHLD action is not set to SIG_IGN.
+        The real bug is a race condition between Emacs and glib: Emacs
+        does a waitpid (-1, ...) and reaps glib's subprocess by mistake,
+        so that glib can't find it.  Work around the bug by invoking
+        waitpid only on subprocesses that Emacs itself creates.
+        * process.c (create_process, record_child_status_change):
+        Don't use special value -1 in pid field, as the caller now must
+        know the pid rather than having the callee infer it.
+        The inference was sometimes incorrect anyway, due to another race.
+        (create_process): Set new 'alive' member if child is created.
+        (process_status_retrieved): New function.
+        (record_child_status_change): Use it.
+        Accept negative 1st argument, which means to wait for the
+        processes that Emacs already knows about.  Move special-case code
+        for DOS_NT (which lacks WNOHANG) here, from caller.  Keep track of
+        processes that have already been waited for, by testing and
+        clearing new 'alive' member.
+        (CAN_HANDLE_MULTIPLE_CHILDREN): Remove, as record_child_status_change
+        now does this internally.
+        (handle_child_signal): Let record_child_status_change do all
+        the work, since we do not want to reap all exited child processes,
+        only the child processes that Emacs itself created.
+        * process.h (Lisp_Process): New boolean member 'alive'.
+        Omit duplicate definitions no longer needed with gcc -g3.
+        * lisp.h (GCTYPEBITS, GCALIGNMENT, ARRAY_MARK_FLAG, PSEUDOVECTOR_FLAG)
+        (VALMASK, MOST_POSITIVE_FIXNUM, MOST_NEGATIVE_FIXNUM):
+        Define only as macros.  There's no longer any need to also define
+        these symbols as enums or as constants, since we now assume
+        gcc -g3 when debugging.
+2012-11-03  Eli Zaretskii  <eliz@gnu.org>
+        * lisp.mk: Adjust comments to the fact that term/internal is now
+        loaded from loadup.el.
+        * msdos.c (msdos_abort): Rename from emacs_abort, and make static.
+        (msdos_fatal_signal): New function.
+        (XMenuActivate): Adjust the call to kbd_buffer_events_waiting to
+        its argument list.
+        * conf_post.h (_GL_EXECINFO_INLINE) [MSDOS]: Define to "inline"
+        for GCC versions before 4.
+        (emacs_raise): Define to call msdos_fatal_signal.
+        * xdisp.c (init_from_display_pos): Fix initialization of the bidi
+        iterator when starting in the middle of a display or overlay
+        string.  (Bug#12745)
+2012-11-03  Chong Yidong  <cyd@gnu.org>
+        * process.c (wait_reading_process_output): Clean up the last
+        change.
+2012-11-03  Jim Paris  <jim@jtan.com>  (tiny change)
+        * process.c (wait_reading_process_output): Avoid a race condition
+        with SIGIO delivery (Bug#11536).
+2012-11-03  Chong Yidong  <cyd@gnu.org>
+        * buffer.c (cursor_type): Untabify docstring.
+2012-11-03  Dmitry Antipov  <dmantipov@yandex.ru>
+        * frame.h (struct frame): Drop can_have_scroll_bars member
+        which is meaningless for a long time.  Adjust comments.
+        (FRAME_CAN_HAVE_SCROLL_BARS): Remove.
+        * frame.c, nsfns.m, term.c, w32fns.c, xfns.c: Adjust users.
+2012-11-03  Dmitry Antipov  <dmantipov@yandex.ru>
+        * window.c (decode_next_window_args): Update window arg after
+        calling decode_live_window and so fix crash reported at
+        http://lists.gnu.org/archive/html/emacs-devel/2012-11/msg00035.html
+        by Juanma Barranquero <lekktu@gmail.com>.
+        (Fwindow_body_width, Fwindow_body_height): Simplify a bit.
+        * font.c (Ffont_at): Likewise.
+2012-11-01  Jan Djärv  <jan.h.d@swipnet.se>
+        * widget.c (resize_cb): New function.
+        (EmacsFrameRealize): Add resize_cb as event handler (Bug#12733).
+        (EmacsFrameResize): Check if all is up to date before changing frame
+        size.
+2012-11-02  Eli Zaretskii  <eliz@gnu.org>
+        Implement backtrace output for fatal errors on MS-Windows.
+        * w32fns.c (CaptureStackBackTrace_proc): New typedef.
+        (BACKTRACE_LIMIT_MAX): New macro.
+        (w32_backtrace): New function.
+        (emacs_abort): Use w32_backtrace when the user chooses not to
+        attach a debugger.  Update the text of the abort dialog.
+2012-11-02  Dmitry Antipov  <dmantipov@yandex.ru>
+        Window-related stuff cleanup here and there.
+        * dispnew.c (Finternal_show_cursor, Finternal_show_cursor_p):
+        Use decode_any_window.
+        * fringe.c (Ffringe_bitmaps_at_pos): Likewise.
+        * xdisp.c (Fformat_mode_line): Likewise.
+        * font.c (Ffont_at): Use decode_live_window.
+        * indent.c (Fcompute_motion, Fvertical_motion): Likewise.
+        * window.c (decode_next_window_args): Likewise.
+        (decode_any_window): Remove static.
+        * window.h (decode_any_window): Add prototype.
+        * lisp.h (CHECK_VALID_WINDOW, CHECK_LIVE_WINDOW): Move from here...
+        * window.h: ...to here, redefine via WINDOW_VALID_P and WINDOW_LIVE_P,
+        respectively.
+2012-11-02  Dmitry Antipov  <dmantipov@yandex.ru>
+        Remove pad from struct input_event.
+        * termhooks.h (struct input_event): Remove padding field.
+        Adjust comment.
+        * keyboard.c (event_to_kboard): Simplify because frame_or_window
+        member is never cons for a long time.  Adjust comment.
+        (mark_kboards): Adjust because SELECTION_REQUEST_EVENT and
+        SELECTION_CLEAR_EVENT has no Lisp_Objects to mark.  Add comment.
+        * xterm.c (handle_one_xevent): Do not initialize frame_or_window
+        field of SELECTION_REQUEST_EVENT and SELECTION_CLEAR_EVENT.
 2012-11-01  Eli Zaretskii  <eliz@gnu.org>
        * w32proc.c (getpgrp, setpgid): New functions.  (Bug#12776)
@@ -44,8 +595,8 @@
 2012-10-29  Daniel Colascione  <dancol@dancol.org>
-        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode): In
+        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode):
-        preparation for fixing bug#12739, move these functions from
+        In preparation for fixing bug#12739, move these functions from
        here...
        * coding.h, coding.c: ... to here, and compile them only when
@@ -628,7 +1179,7 @@
        now a supported configuration.
        * Makefile.in: consolidate image variables into LIBIMAGE; add
-        W32_OBJ and W32_LIBS. Compile new files.
+        W32_OBJ and W32_LIBS.  Compile new files.
        * conf_post.h:
        (_DebPrint) declare tracing facility for W32 debugging.  We need
diff --git a/src/alloc.c b/src/alloc.c
index 5bb528c64ab..a66a752f5dc 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -216,23 +216,19 @@ static Lisp_Object Qpost_gc_hook;
 static void mark_terminals (void);
 static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
-static void mark_glyph_matrix (struct glyph_matrix *);
-static void mark_face_cache (struct face_cache *);
 static void mark_buffer (struct buffer *);
 #if !defined REL_ALLOC || defined SYSTEM_MALLOC
 static void refill_memory_reserve (void);
 #endif
-static struct Lisp_String *allocate_string (void);
 static void compact_small_strings (void);
 static void free_large_strings (void);
-static void sweep_strings (void);
 static void free_misc (Lisp_Object);
 extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE;
-/* When scanning the C stack for live Lisp objects, Emacs keeps track
+/* When scanning the C stack for live Lisp objects, Emacs keeps track of
-   of what memory allocated via lisp_malloc is intended for what
+   what memory allocated via lisp_malloc and lisp_align_malloc is intended
-   purpose.  This enumeration specifies the type of memory.  */
+   for what purpose.  This enumeration specifies the type of memory.  */
 enum mem_type
 {
@@ -243,10 +239,9 @@ enum mem_type
  MEM_TYPE_MISC,
  MEM_TYPE_SYMBOL,
  MEM_TYPE_FLOAT,
-  /* We used to keep separate mem_types for subtypes of vectors such as
+  /* Since all non-bool pseudovectors are small enough to be
-     process, hash_table, frame, terminal, and window, but we never made
+     allocated from vector blocks, this memory type denotes
-     use of the distinction, so it only caused source-code complexity
+     large regular vectors and large bool pseudovectors.  */
-     and runtime slowdown.  Minor but pointless.  */
  MEM_TYPE_VECTORLIKE,
  /* Special type to denote vector blocks.  */
  MEM_TYPE_VECTOR_BLOCK,
@@ -254,9 +249,6 @@ enum mem_type
  MEM_TYPE_SPARE
 };
-static void *lisp_malloc (size_t, enum mem_type);
 #if GC_MARK_STACK || defined GC_MALLOC_CHECK
 #if GC_MARK_STACK == GC_USE_GCPROS_CHECK_ZOMBIES
@@ -2040,7 +2032,7 @@ LENGTH must be a number.  INIT matters only in whether it is t or nil.  */)
  val = Fmake_vector (make_number (length_in_elts + extra_bool_elts), Qnil);
  /* No Lisp_Object to trace in there.  */
-  XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0);
+  XSETPVECTYPESIZE (XVECTOR (val), PVEC_BOOL_VECTOR, 0, 0);
  p = XBOOL_VECTOR (val);
  p->size = XFASTINT (length);
@@ -2619,19 +2611,54 @@ verify (VECTOR_BLOCK_SIZE <= (1 << PSEUDOVECTOR_SIZE_BITS));
 #define VINDEX(nbytes) (((nbytes) - VBLOCK_BYTES_MIN) / roundup_size)
+/* Get and set the next field in block-allocated vectorlike objects on
+   the free list.  Doing it this way respects C's aliasing rules.
+   We could instead make 'contents' a union, but that would mean
+   changes everywhere that the code uses 'contents'.  */
+static struct Lisp_Vector *
+next_in_free_list (struct Lisp_Vector *v)
+{
+  intptr_t i = XLI (v->contents[0]);
+  return (struct Lisp_Vector *) i;
+}
+static void
+set_next_in_free_list (struct Lisp_Vector *v, struct Lisp_Vector *next)
+{
+  v->contents[0] = XIL ((intptr_t) next);
+}
 /* Common shortcut to setup vector on a free list.  */
-#define SETUP_ON_FREE_LIST(v, nbytes, index)                    \
+#define SETUP_ON_FREE_LIST(v, nbytes, tmp)              \
-  do {                                                          \
+  do {                                                  \
-    XSETPVECTYPESIZE (v, PVEC_FREE, nbytes);                    \
+    (tmp) = ((nbytes - header_size) / word_size);       \
-    eassert ((nbytes) % roundup_size == 0);                     \
+    XSETPVECTYPESIZE (v, PVEC_FREE, 0, (tmp));          \
-    (index) = VINDEX (nbytes);                                  \
+    eassert ((nbytes) % roundup_size == 0);             \
-    eassert ((index) < VECTOR_MAX_FREE_LIST_INDEX);             \
+    (tmp) = VINDEX (nbytes);                            \
-    (v)->header.next.vector = vector_free_lists[index];         \
+    eassert ((tmp) < VECTOR_MAX_FREE_LIST_INDEX);       \
-    vector_free_lists[index] = (v);                             \
+    set_next_in_free_list (v, vector_free_lists[tmp]);  \
-    total_free_vector_slots += (nbytes) / word_size;            \
+    vector_free_lists[tmp] = (v);                       \
+    total_free_vector_slots += (nbytes) / word_size;    \
  } while (0)
+/* This internal type is used to maintain the list of large vectors
+   which are allocated at their own, e.g. outside of vector blocks.  */
+struct large_vector
+{
+  union {
+    struct large_vector *vector;
+#if USE_LSB_TAG
+    /* We need to maintain ROUNDUP_SIZE alignment for the vector member.  */
+    unsigned char c[vroundup (sizeof (struct large_vector *))];
+#endif
+  } next;
+  struct Lisp_Vector v;
+};
+/* This internal type is used to maintain an underlying storage
+   for small vectors.  */
 struct vector_block
 {
  char data[VECTOR_BLOCK_BYTES];
@@ -2649,7 +2676,7 @@ static struct Lisp_Vector *vector_free_lists[VECTOR_MAX_FREE_LIST_INDEX];
 /* Singly-linked list of large vectors.  */
-static struct Lisp_Vector *large_vectors;
+static struct large_vector *large_vectors;
 /* The only vector with 0 slots, allocated from pure space.  */
@@ -2693,7 +2720,7 @@ init_vectors (void)
 static struct Lisp_Vector *
 allocate_vector_from_block (size_t nbytes)
 {
-  struct Lisp_Vector *vector, *rest;
+  struct Lisp_Vector *vector;
  struct vector_block *block;
  size_t index, restbytes;
@@ -2706,8 +2733,7 @@ allocate_vector_from_block (size_t nbytes)
  if (vector_free_lists[index])
    {
      vector = vector_free_lists[index];
-      vector_free_lists[index] = vector->header.next.vector;
+      vector_free_lists[index] = next_in_free_list (vector);
-      vector->header.next.nbytes = nbytes;
      total_free_vector_slots -= nbytes / word_size;
      return vector;
    }
@@ -2721,16 +2747,14 @@ allocate_vector_from_block (size_t nbytes)
      {
        /* This vector is larger than requested.  */
        vector = vector_free_lists[index];
-        vector_free_lists[index] = vector->header.next.vector;
+        vector_free_lists[index] = next_in_free_list (vector);
-        vector->header.next.nbytes = nbytes;
        total_free_vector_slots -= nbytes / word_size;
        /* Excess bytes are used for the smaller vector,
           which should be set on an appropriate free list.  */
        restbytes = index * roundup_size + VBLOCK_BYTES_MIN - nbytes;
        eassert (restbytes % roundup_size == 0);
-        rest = ADVANCE (vector, nbytes);
+        SETUP_ON_FREE_LIST (ADVANCE (vector, nbytes), restbytes, index);
-        SETUP_ON_FREE_LIST (rest, restbytes, index);
        return vector;
      }
@@ -2739,7 +2763,6 @@ allocate_vector_from_block (size_t nbytes)
  /* New vector will be at the beginning of this block.  */
  vector = (struct Lisp_Vector *) block->data;
-  vector->header.next.nbytes = nbytes;
  /* If the rest of space from this block is large enough
     for one-slot vector at least, set up it on a free list.  */
@@ -2747,11 +2770,10 @@ allocate_vector_from_block (size_t nbytes)
  if (restbytes >= VBLOCK_BYTES_MIN)
    {
      eassert (restbytes % roundup_size == 0);
-      rest = ADVANCE (vector, nbytes);
+      SETUP_ON_FREE_LIST (ADVANCE (vector, nbytes), restbytes, index);
-      SETUP_ON_FREE_LIST (rest, restbytes, index);
    }
  return vector;
- }
+}
 /* Nonzero if VECTOR pointer is valid pointer inside BLOCK.  */
@@ -2759,15 +2781,30 @@ allocate_vector_from_block (size_t nbytes)
  ((char *) (vector) <= (block)->data           \
   + VECTOR_BLOCK_BYTES - VBLOCK_BYTES_MIN)
-/* Number of bytes used by vector-block-allocated object.  This is the only
+/* Return the memory footprint of V in bytes.  */
-   place where we actually use the `nbytes' field of the vector-header.
-   I.e. we could get rid of the `nbytes' field by computing it based on the
-   vector-type.  */
-#define PSEUDOVECTOR_NBYTES(vector) \
+static ptrdiff_t
-  (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE)      \
+vector_nbytes (struct Lisp_Vector *v)
-   ? vector->header.size & PSEUDOVECTOR_SIZE_MASK       \
+{
-   : vector->header.next.nbytes)
+  ptrdiff_t size = v->header.size & ~ARRAY_MARK_FLAG;
+  if (size & PSEUDOVECTOR_FLAG)
+    {
+      if (PSEUDOVECTOR_TYPEP (&v->header, PVEC_BOOL_VECTOR))
+        size = (bool_header_size
+                + (((struct Lisp_Bool_Vector *) v)->size
+                   + BOOL_VECTOR_BITS_PER_CHAR - 1)
+                / BOOL_VECTOR_BITS_PER_CHAR);
+      else
+        size = (header_size
+                + ((size & PSEUDOVECTOR_SIZE_MASK)
+                   + ((size & PSEUDOVECTOR_REST_MASK)
+                      >> PSEUDOVECTOR_SIZE_BITS)) * word_size);
+    }
+  else
+    size = header_size + size * word_size;
+  return vroundup (size);
+}
 /* Reclaim space used by unmarked vectors.  */
@@ -2775,7 +2812,8 @@ static void
 sweep_vectors (void)
 {
  struct vector_block *block = vector_blocks, **bprev = &vector_blocks;
-  struct Lisp_Vector *vector, *next, **vprev = &large_vectors;
+  struct large_vector *lv, **lvprev = &large_vectors;
+  struct Lisp_Vector *vector, *next;
  total_vectors = total_vector_slots = total_free_vector_slots = 0;
  memset (vector_free_lists, 0, sizeof (vector_free_lists));
@@ -2785,6 +2823,7 @@ sweep_vectors (void)
  for (block = vector_blocks; block; block = *bprev)
    {
      bool free_this_block = 0;
+      ptrdiff_t nbytes;
      for (vector = (struct Lisp_Vector *) block->data;
           VECTOR_IN_BLOCK (vector, block); vector = next)
@@ -2793,14 +2832,16 @@ sweep_vectors (void)
            {
              VECTOR_UNMARK (vector);
              total_vectors++;
-              total_vector_slots += vector->header.next.nbytes / word_size;
+              nbytes = vector_nbytes (vector);
-              next = ADVANCE (vector, vector->header.next.nbytes);
+              total_vector_slots += nbytes / word_size;
+              next = ADVANCE (vector, nbytes);
            }
          else
            {
-              ptrdiff_t nbytes = PSEUDOVECTOR_NBYTES (vector);
+              ptrdiff_t total_bytes;
-              ptrdiff_t total_bytes = nbytes;
+              nbytes = vector_nbytes (vector);
+              total_bytes = nbytes;
              next = ADVANCE (vector, nbytes);
              /* While NEXT is not marked, try to coalesce with VECTOR,
@@ -2810,7 +2851,7 @@ sweep_vectors (void)
                {
                  if (VECTOR_MARKED_P (next))
                    break;
-                  nbytes = PSEUDOVECTOR_NBYTES (next);
+                  nbytes = vector_nbytes (next);
                  total_bytes += nbytes;
                  next = ADVANCE (next, nbytes);
                }
@@ -2844,8 +2885,9 @@ sweep_vectors (void)
  /* Sweep large vectors.  */
-  for (vector = large_vectors; vector; vector = *vprev)
+  for (lv = large_vectors; lv; lv = *lvprev)
    {
+      vector = &lv->v;
      if (VECTOR_MARKED_P (vector))
        {
          VECTOR_UNMARK (vector);
@@ -2867,12 +2909,12 @@ sweep_vectors (void)
          else
            total_vector_slots
              += header_size / word_size + vector->header.size;
-          vprev = &vector->header.next.vector;
+          lvprev = &lv->next.vector;
        }
      else
        {
-          *vprev = vector->header.next.vector;
+          *lvprev = lv->next.vector;
-          lisp_free (vector);
+          lisp_free (lv);
        }
    }
 }
@@ -2904,9 +2946,12 @@ allocate_vectorlike (ptrdiff_t len)
        p = allocate_vector_from_block (vroundup (nbytes));
      else
        {
-          p = lisp_malloc (nbytes, MEM_TYPE_VECTORLIKE);
+          struct large_vector *lv
-          p->header.next.vector = large_vectors;
+            = lisp_malloc (sizeof (*lv) + (len - 1) * word_size,
-          large_vectors = p;
+                           MEM_TYPE_VECTORLIKE);
+          lv->next.vector = large_vectors;
+          large_vectors = lv;
+          p = &lv->v;
        }
 #ifdef DOUG_LEA_MALLOC
@@ -2943,16 +2988,21 @@ allocate_vector (EMACS_INT len)
 /* Allocate other vector-like structures.  */
 struct Lisp_Vector *
-allocate_pseudovector (int memlen, int lisplen, int tag)
+allocate_pseudovector (int memlen, int lisplen, enum pvec_type tag)
 {
  struct Lisp_Vector *v = allocate_vectorlike (memlen);
  int i;
+  /* Catch bogus values.  */
+  eassert (tag <= PVEC_FONT);
+  eassert (memlen - lisplen <= (1 << PSEUDOVECTOR_REST_BITS) - 1);
+  eassert (lisplen <= (1 << PSEUDOVECTOR_SIZE_BITS) - 1);
  /* Only the first lisplen slots will be traced normally by the GC.  */
  for (i = 0; i < lisplen; ++i)
    v->contents[i] = Qnil;
-  XSETPVECTYPESIZE (v, tag, lisplen);
+  XSETPVECTYPESIZE (v, tag, lisplen, memlen - lisplen);
  return v;
 }
@@ -2961,10 +3011,9 @@ allocate_buffer (void)
 {
  struct buffer *b = lisp_malloc (sizeof *b, MEM_TYPE_BUFFER);
-  XSETPVECTYPESIZE (b, PVEC_BUFFER, (offsetof (struct buffer, own_text)
+  BUFFER_PVEC_INIT (b);
-                                     - header_size) / word_size);
  /* Put B on the chain of all buffers including killed ones.  */
-  b->header.next.buffer = all_buffers;
+  b->next = all_buffers;
  all_buffers = b;
  /* Note that the rest fields of B are not initialized.  */
  return b;
@@ -4068,16 +4117,15 @@ live_vector_p (struct mem_node *m, void *p)
      while (VECTOR_IN_BLOCK (vector, block)
             && vector <= (struct Lisp_Vector *) p)
        {
-          if (PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE))
+          if (!PSEUDOVECTOR_TYPEP (&vector->header, PVEC_FREE) && vector == p)
-            vector = ADVANCE (vector, (vector->header.size
-                                       & PSEUDOVECTOR_SIZE_MASK));
-          else if (vector == p)
            return 1;
          else
-            vector = ADVANCE (vector, vector->header.next.nbytes);
+            vector = ADVANCE (vector, vector_nbytes (vector));
        }
    }
-  else if (m->type == MEM_TYPE_VECTORLIKE && p == m->start)
+  else if (m->type == MEM_TYPE_VECTORLIKE
+           && (char *) p == ((char *) m->start
+                             + offsetof (struct large_vector, v)))
    /* This memory node corresponds to a large vector.  */
    return 1;
  return 0;
@@ -5687,7 +5735,7 @@ mark_object (Lisp_Object arg)
        if (ptr->header.size & PSEUDOVECTOR_FLAG)
          pvectype = ((ptr->header.size & PVEC_TYPE_MASK)
-                      >> PSEUDOVECTOR_SIZE_BITS);
+                      >> PSEUDOVECTOR_AREA_BITS);
        else
          pvectype = PVEC_NORMAL_VECTOR;
@@ -5766,6 +5814,9 @@ mark_object (Lisp_Object arg)
              struct Lisp_Hash_Table *h = (struct Lisp_Hash_Table *) ptr;
              mark_vectorlike (ptr);
+              mark_object (h->test.name);
+              mark_object (h->test.user_hash_function);
+              mark_object (h->test.user_cmp_function);
              /* If hash table is not weak, mark all keys and values.
                 For weak tables, mark only the vector.  */
              if (NILP (h->weak))
@@ -6317,7 +6368,7 @@ gc_sweep (void)
    for (buffer = all_buffers; buffer; buffer = *bprev)
      if (!VECTOR_MARKED_P (buffer))
        {
-          *bprev = buffer->header.next.buffer;
+          *bprev = buffer->next;
          lisp_free (buffer);
        }
      else
@@ -6326,7 +6377,7 @@ gc_sweep (void)
          /* Do not use buffer_(set|get)_intervals here.  */
          buffer->text->intervals = balance_intervals (buffer->text->intervals);
          total_buffers++;
-          bprev = &buffer->header.next.buffer;
+          bprev = &buffer->next;
        }
  }
diff --git a/src/buffer.c b/src/buffer.c
index 0b3dde27968..619a729a859 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -406,7 +406,6 @@ followed by the rest of the buffers.  */)
      Lisp_Object framelist, prevlist, tail;
      Lisp_Object args[3];
-      CHECK_FRAME (frame);
      framelist = Fcopy_sequence (XFRAME (frame)->buffer_list);
      prevlist = Fnreverse (Fcopy_sequence
                            (XFRAME (frame)->buried_buffer_list));
@@ -1543,17 +1542,11 @@ list first, followed by the list of all buffers.  If no other buffer
 exists, return the buffer `*scratch*' (creating it if necessary).  */)
  (register Lisp_Object buffer, Lisp_Object visible_ok, Lisp_Object frame)
 {
-  Lisp_Object tail, buf, pred;
+  struct frame *f = decode_any_frame (frame);
-  Lisp_Object notsogood = Qnil;
+  Lisp_Object tail = f->buffer_list, pred = f->buffer_predicate;
+  Lisp_Object buf, notsogood = Qnil;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  pred = frame_buffer_predicate (frame);
  /* Consider buffers that have been seen in the frame first.  */
-  tail = XFRAME (frame)->buffer_list;
  for (; CONSP (tail); tail = XCDR (tail))
    {
      buf = XCAR (tail);
@@ -2109,7 +2102,7 @@ set_buffer_internal_1 (register struct buffer *b)
    return;
  BUFFER_CHECK_INDIRECTION (b);
-  
  old_buf = current_buffer;
  current_buffer = b;
  last_known_column_point = -1;   /* invalidate indentation cache */
@@ -3139,8 +3132,8 @@ compare_overlays (const void *v1, const void *v2)
     between "equal" overlays.  The result can still change between
     invocations of Emacs, but it won't change in the middle of
     `find_field' (bug#6830).  */
-  if (XHASH (s1->overlay) != XHASH (s2->overlay))
+  if (!EQ (s1->overlay, s2->overlay))
-    return XHASH (s1->overlay) < XHASH (s2->overlay) ? -1 : 1;
+    return XLI (s1->overlay) < XLI (s2->overlay) ? -1 : 1;
  return 0;
 }
@@ -5112,11 +5105,6 @@ void
 init_buffer_once (void)
 {
  int idx;
-  /* If you add, remove, or reorder Lisp_Objects in a struct buffer, make
-     sure that this is still correct.  Otherwise, mark_vectorlike may not
-     trace all Lisp_Objects in buffer_defaults and buffer_local_symbols.  */
-  const int pvecsize
-    = (offsetof (struct buffer, own_text) - header_size) / word_size;
  memset (buffer_permanent_local_flags, 0, sizeof buffer_permanent_local_flags);
@@ -5139,8 +5127,8 @@ init_buffer_once (void)
  /* This is not strictly necessary, but let's make them initialized.  */
  bset_name (&buffer_defaults, build_pure_c_string (" *buffer-defaults*"));
  bset_name (&buffer_local_symbols, build_pure_c_string (" *buffer-local-symbols*"));
-  XSETPVECTYPESIZE (&buffer_defaults, PVEC_BUFFER, pvecsize);
+  BUFFER_PVEC_INIT (&buffer_defaults);
-  XSETPVECTYPESIZE (&buffer_local_symbols, PVEC_BUFFER, pvecsize);
+  BUFFER_PVEC_INIT (&buffer_local_symbols);
  /* Set up the default values of various buffer slots.  */
  /* Must do these before making the first buffer! */
@@ -6210,15 +6198,15 @@ is a member of the list.  */);
                     doc: /* Cursor to use when this buffer is in the selected window.
 Values are interpreted as follows:
-  t               use the cursor specified for the frame
+  t               use the cursor specified for the frame
-  nil             don't display a cursor
+  nil             don't display a cursor
-  box             display a filled box cursor
+  box             display a filled box cursor
-  hollow          display a hollow box cursor
+  hollow          display a hollow box cursor
-  bar             display a vertical bar cursor with default width
+  bar             display a vertical bar cursor with default width
-  (bar . WIDTH)   display a vertical bar cursor with width WIDTH
+  (bar . WIDTH)   display a vertical bar cursor with width WIDTH
-  hbar            display a horizontal bar cursor with default height
+  hbar            display a horizontal bar cursor with default height
  (hbar . HEIGHT) display a horizontal bar cursor with height HEIGHT
-  ANYTHING ELSE   display a hollow box cursor
+  ANYTHING ELSE   display a hollow box cursor
 When the buffer is displayed in a non-selected window, the
 cursor's appearance is instead controlled by the variable
diff --git a/src/buffer.h b/src/buffer.h
index 9e0e9eef0b1..fbbbf1b8434 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -482,11 +482,6 @@ struct buffer_text
 struct buffer
 {
-  /* HEADER.NEXT is the next buffer, in chain of all buffers, including killed
-     buffers.  This chain, starting from all_buffers, is used only for garbage
-     collection, in order to collect killed buffers properly.  Note that large
-     vectors and large pseudo-vector objects are all on another chain starting
-     from large_vectors.  */
  struct vectorlike_header header;
  /* The name of this buffer.  */
@@ -750,6 +745,9 @@ struct buffer
     In an indirect buffer, this is the own_text field of another buffer.  */
  struct buffer_text *text;
+  /* Next buffer, in chain of all buffers, including killed ones.  */
+  struct buffer *next;
  /* Char position of point in buffer.  */
  ptrdiff_t pt;
@@ -959,6 +957,27 @@ bset_width_table (struct buffer *b, Lisp_Object val)
  b->INTERNAL_FIELD (width_table) = val;
 }
+/* Number of Lisp_Objects at the beginning of struct buffer.
+   If you add, remove, or reorder Lisp_Objects within buffer
+   structure, make sure that this is still correct.  */
+#define BUFFER_LISP_SIZE                                                \
+  ((offsetof (struct buffer, own_text) - header_size) / word_size)
+/* Size of the struct buffer part beyond leading Lisp_Objects, in word_size
+   units.  Rounding is needed for --with-wide-int configuration.  */
+#define BUFFER_REST_SIZE                                                \
+  ((((sizeof (struct buffer) - offsetof (struct buffer, own_text))      \
+     + (word_size - 1)) & ~(word_size - 1)) / word_size)
+/* Initialize the pseudovector header of buffer object.  BUFFER_LISP_SIZE
+   is required for GC, but BUFFER_REST_SIZE is set up just to be consistent
+   with other pseudovectors.  */
+#define BUFFER_PVEC_INIT(b)                                    \
+  XSETPVECTYPESIZE (b, PVEC_BUFFER, BUFFER_LISP_SIZE, BUFFER_REST_SIZE)
 /* Convenient check whether buffer B is live.  */
 #define BUFFER_LIVE_P(b) (!NILP (BVAR (b, name)))
@@ -986,7 +1005,7 @@ extern struct buffer *all_buffers;
 /* Used to iterate over the chain above.  */
 #define FOR_EACH_BUFFER(b) \
-  for ((b) = all_buffers; (b); (b) = (b)->header.next.buffer)
+  for ((b) = all_buffers; (b); (b) = (b)->next)
 /* This points to the current buffer.  */
diff --git a/src/callproc.c b/src/callproc.c
index c236f22fc86..c7bbe36e605 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -612,11 +612,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
        if (fd[0] >= 0)
          emacs_close (fd[0]);
-#ifdef HAVE_SETSID
        setsid ();
-#else
-        setpgid (0, 0);
-#endif
        /* Emacs ignores SIGPIPE, but the child should not.  */
        signal (SIGPIPE, SIG_DFL);
@@ -1286,11 +1282,7 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
  if (err != in && err != out)
    emacs_close (err);
-#if defined HAVE_SETPGID || ! (defined USG && defined SETPGRP_RELEASES_CTTY)
+  setpgid (0, 0);
-  setpgid (pid, pid);
-#endif
-  /* setpgrp_of_tty is incorrect here; it uses input_fd.  */
  tcsetpgrp (0, pid);
  /* execvp does not accept an environment arg so the only way
diff --git a/src/category.c b/src/category.c
index fe02303f679..31cc90bca68 100644
--- a/src/category.c
+++ b/src/category.c
@@ -78,10 +78,10 @@ hash_get_category_set (Lisp_Object table, Lisp_Object category_set)
  if (NILP (XCHAR_TABLE (table)->extras[1]))
    set_char_table_extras
      (table, 1,
-       make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
+       make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE),
                        make_float (DEFAULT_REHASH_SIZE),
                        make_float (DEFAULT_REHASH_THRESHOLD),
-                        Qnil, Qnil, Qnil));
+                        Qnil));
  h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
  i = hash_lookup (h, category_set, &hash);
  if (i >= 0)
diff --git a/src/composite.c b/src/composite.c
index 6c603fab3fc..bcde0a4c9e6 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -676,7 +676,7 @@ composition_gstring_put_cache (Lisp_Object gstring, ptrdiff_t len)
  ptrdiff_t i;
  header = LGSTRING_HEADER (gstring);
-  hash = h->hashfn (h, header);
+  hash = h->test.hashfn (&h->test, header);
  if (len < 0)
    {
      ptrdiff_t j, glyph_len = LGSTRING_GLYPH_LEN (gstring);
@@ -1382,7 +1382,7 @@ composition_update_it (struct composition_it *cmp_it, ptrdiff_t charpos, ptrdiff
    }
  else
    {
-      /* automatic composition */
+      /* Automatic composition.  */
      Lisp_Object gstring = composition_gstring_from_id (cmp_it->id);
      Lisp_Object glyph;
      ptrdiff_t from;
diff --git a/src/conf_post.h b/src/conf_post.h
index 6056821d4a7..66390ddf103 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -110,15 +110,16 @@ You lose; /* Emacs for DOS must be compiled with DJGPP */
 #else
 # define lstat stat
 #endif
+/* The "portable" definition of _GL_INLINE on config.h does not work
+   with DJGPP GCC 3.4.4: it causes unresolved externals in sysdep.c,
+   although lib/execinfo.h is included and the inline functions there
+   are visible.  */
+#if __GNUC__ < 4
+# define _GL_EXECINFO_INLINE inline
+#endif
 /* End of gnulib-related stuff.  */
-#ifndef HAVE_SETPGID
+#define emacs_raise(sig) msdos_fatal_signal (sig)
-# ifdef USG
-#  define setpgid(pid, pgid) setpgrp ()
-# else
-#  define setpgid(pid, pgid) setpgrp (pid, pgid)
-# endif
-#endif
 /* Define one of these for easier conditionals.  */
 #ifdef HAVE_X_WINDOWS
diff --git a/src/data.c b/src/data.c
index abcdd4dca0d..09899400b68 100644
--- a/src/data.c
+++ b/src/data.c
@@ -81,6 +81,7 @@ Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
 static Lisp_Object Qdefun;
 Lisp_Object Qinteractive_form;
+static Lisp_Object Qdefalias_fset_function;
 static void swap_in_symval_forwarding (struct Lisp_Symbol *, struct Lisp_Buffer_Local_Value *);
@@ -444,7 +445,7 @@ DEFUN ("floatp", Ffloatp, Sfloatp, 1, 1, 0,
 }
-/* Extract and set components of lists */
+/* Extract and set components of lists.  */
 DEFUN ("car", Fcar, Scar, 1, 1, 0,
       doc: /* Return the car of LIST.  If arg is nil, return nil.
@@ -608,27 +609,18 @@ DEFUN ("fset", Ffset, Sfset, 2, 2, 0,
  (register Lisp_Object symbol, Lisp_Object definition)
 {
  register Lisp_Object function;
  CHECK_SYMBOL (symbol);
-  if (NILP (symbol) || EQ (symbol, Qt))
-    xsignal1 (Qsetting_constant, symbol);
  function = XSYMBOL (symbol)->function;
  if (!NILP (Vautoload_queue) && !EQ (function, Qunbound))
    Vautoload_queue = Fcons (Fcons (symbol, function), Vautoload_queue);
-  if (CONSP (function) && EQ (XCAR (function), Qautoload))
+  if (AUTOLOADP (function))
    Fput (symbol, Qautoload, XCDR (function));
  set_symbol_function (symbol, definition);
-  /* Handle automatic advice activation.  */
-  if (CONSP (XSYMBOL (symbol)->plist)
-      && !NILP (Fget (symbol, Qad_advice_info)))
-    {
-      call2 (Qad_activate_internal, symbol, Qnil);
-      definition = XSYMBOL (symbol)->function;
-    }
  return definition;
 }
@@ -642,15 +634,32 @@ The return value is undefined.  */)
  (register Lisp_Object symbol, Lisp_Object definition, Lisp_Object docstring)
 {
  CHECK_SYMBOL (symbol);
-  if (CONSP (XSYMBOL (symbol)->function)
-      && EQ (XCAR (XSYMBOL (symbol)->function), Qautoload))
-    LOADHIST_ATTACH (Fcons (Qt, symbol));
  if (!NILP (Vpurify_flag)
      /* If `definition' is a keymap, immutable (and copying) is wrong.  */
      && !KEYMAPP (definition))
    definition = Fpurecopy (definition);
-  definition = Ffset (symbol, definition);
-  LOADHIST_ATTACH (Fcons (Qdefun, symbol));
+  {
+    bool autoload = AUTOLOADP (definition);
+    if (NILP (Vpurify_flag) || !autoload)
+      { /* Only add autoload entries after dumping, because the ones before are
+           not useful and else we get loads of them from the loaddefs.el.  */
+        if (AUTOLOADP (XSYMBOL (symbol)->function))
+          /* Remember that the function was already an autoload.  */
+          LOADHIST_ATTACH (Fcons (Qt, symbol));
+        LOADHIST_ATTACH (Fcons (autoload ? Qautoload : Qdefun, symbol));
+      }
+  }
+  { /* Handle automatic advice activation.  */
+    Lisp_Object hook = Fget (symbol, Qdefalias_fset_function);
+    if (!NILP (hook))
+      call2 (hook, symbol, definition);
+    else
+      Ffset (symbol, definition);
+  }
  if (!NILP (docstring))
    Fput (symbol, Qfunction_documentation, docstring);
  /* We used to return `definition', but now that `defun' and `defmacro' expand
@@ -680,12 +689,10 @@ function with `&rest' args, or `unevalled' for a special form.  */)
  CHECK_SUBR (subr);
  minargs = XSUBR (subr)->min_args;
  maxargs = XSUBR (subr)->max_args;
-  if (maxargs == MANY)
+  return Fcons (make_number (minargs),
-    return Fcons (make_number (minargs), Qmany);
+                maxargs == MANY ?        Qmany
-  else if (maxargs == UNEVALLED)
+                : maxargs == UNEVALLED ? Qunevalled
-    return Fcons (make_number (minargs), Qunevalled);
+                :                        make_number (maxargs));
-  else
-    return Fcons (make_number (minargs), make_number (maxargs));
 }
 DEFUN ("subr-name", Fsubr_name, Ssubr_name, 1, 1, 0,
@@ -711,7 +718,7 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
    return Qnil;
  /* Use an `interactive-form' property if present, analogous to the
-     function-documentation property. */
+     function-documentation property.  */
  fun = cmd;
  while (SYMBOLP (fun))
    {
@@ -735,6 +742,8 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
      if ((ASIZE (fun) & PSEUDOVECTOR_SIZE_MASK) > COMPILED_INTERACTIVE)
        return list2 (Qinteractive, AREF (fun, COMPILED_INTERACTIVE));
    }
+  else if (AUTOLOADP (fun))
+    return Finteractive_form (Fautoload_do_load (fun, cmd, Qnil));
  else if (CONSP (fun))
    {
      Lisp_Object funcar = XCAR (fun);
@@ -742,14 +751,6 @@ Value, if non-nil, is a list \(interactive SPEC).  */)
        return Fassq (Qinteractive, Fcdr (Fcdr (XCDR (fun))));
      else if (EQ (funcar, Qlambda))
        return Fassq (Qinteractive, Fcdr (XCDR (fun)));
-      else if (EQ (funcar, Qautoload))
-        {
-          struct gcpro gcpro1;
-          GCPRO1 (cmd);
-          Fautoload_do_load (fun, cmd, Qnil);
-          UNGCPRO;
-          return Finteractive_form (cmd);
-        }
    }
  return Qnil;
 }
@@ -2695,10 +2696,10 @@ usage: (* &rest NUMBERS-OR-MARKERS)  */)
  return arith_driver (Amult, nargs, args);
 }
-DEFUN ("/", Fquo, Squo, 2, MANY, 0,
+DEFUN ("/", Fquo, Squo, 1, MANY, 0,
       doc: /* Return first argument divided by all the remaining arguments.
 The arguments must be numbers or markers.
-usage: (/ DIVIDEND DIVISOR &rest DIVISORS)  */)
+usage: (/ DIVIDEND &rest DIVISORS)  */)
  (ptrdiff_t nargs, Lisp_Object *args)
 {
  ptrdiff_t argnum;
@@ -3063,6 +3064,7 @@ syms_of_data (void)
  DEFSYM (Qfont_object, "font-object");
  DEFSYM (Qinteractive_form, "interactive-form");
+  DEFSYM (Qdefalias_fset_function, "defalias-fset-function");
  defsubr (&Sindirect_variable);
  defsubr (&Sinteractive_form);
diff --git a/src/dispnew.c b/src/dispnew.c
index 9f0e22fcdcb..675c06c22e9 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -53,9 +53,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "systime.h"
 #include <errno.h>
-#ifdef DISPNEW_NEEDS_STDIO_EXT
+#include <fpending.h>
-#include <stdio_ext.h>
-#endif
 #if defined (HAVE_TERM_H) && defined (GNU_LINUX)
 #include <term.h>               /* for tgetent */
@@ -143,10 +141,6 @@ struct frame *last_nonminibuf_frame;
 static bool delayed_size_change;
-/* 1 means glyph initialization has been completed at startup.  */
-static bool glyphs_initialized_initially_p;
 /* Updated window if != 0.  Set by update_window.  */
 struct window *updated_window;
@@ -1852,43 +1846,6 @@ adjust_glyphs (struct frame *f)
  unblock_input ();
 }
-/* Adjust frame glyphs when Emacs is initialized.
-   To be called from init_display.
-   We need a glyph matrix because redraw will happen soon.
-   Unfortunately, window sizes on selected_frame are not yet set to
-   meaningful values.  I believe we can assume that there are only two
-   windows on the frame---the mini-buffer and the root window.  Frame
-   height and width seem to be correct so far.  So, set the sizes of
-   windows to estimated values.  */
-static void
-adjust_frame_glyphs_initially (void)
-{
-  struct frame *sf = SELECTED_FRAME ();
-  struct window *root = XWINDOW (sf->root_window);
-  struct window *mini = XWINDOW (root->next);
-  int frame_lines = FRAME_LINES (sf);
-  int frame_cols = FRAME_COLS (sf);
-  int top_margin = FRAME_TOP_MARGIN (sf);
-  /* Do it for the root window.  */
-  wset_top_line (root, make_number (top_margin));
-  wset_total_lines (root, make_number (frame_lines - 1 - top_margin));
-  wset_total_cols (root, make_number (frame_cols));
-  /* Do it for the mini-buffer window.  */
-  wset_top_line (mini, make_number (frame_lines - 1));
-  wset_total_lines (mini, make_number (1));
-  wset_total_cols (mini, make_number (frame_cols));
-  adjust_frame_glyphs (sf);
-  glyphs_initialized_initially_p = 1;
-}
 /* Allocate/reallocate glyph matrices of a single frame F.  */
 static void
@@ -3073,21 +3030,13 @@ window_to_frame_hpos (struct window *w, int hpos)
                            Redrawing Frames
 **********************************************************************/
-DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
+/* Redraw frame F.  */
-       doc: /* Clear frame FRAME and output again what is supposed to appear on it.  */)
-  (Lisp_Object frame)
-{
-  struct frame *f;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
-  /* Ignore redraw requests, if frame has no glyphs yet.
-     (Implementation note: It still has to be checked why we are
-     called so early here).  */
-  if (!glyphs_initialized_initially_p)
-    return Qnil;
+void
+redraw_frame (struct frame *f)
+{
+  /* Error if F has no glyphs.  */
+  eassert (f->glyphs_initialized_p);
  update_begin (f);
 #ifdef MSDOS
  if (FRAME_MSDOS_P (f))
@@ -3104,22 +3053,17 @@ DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
  mark_window_display_accurate (FRAME_ROOT_WINDOW (f), 0);
  set_window_update_flags (XWINDOW (FRAME_ROOT_WINDOW (f)), 1);
  f->garbaged = 0;
-  return Qnil;
 }
+DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 0, 1, 0,
-/* Redraw frame F.  This is nothing more than a call to the Lisp
+       doc: /* Clear frame FRAME and output again what is supposed to appear on it.
-   function redraw-frame.  */
+If FRAME is omitted or nil, the selected frame is used.  */)
+  (Lisp_Object frame)
-void
-redraw_frame (struct frame *f)
 {
-  Lisp_Object frame;
+  redraw_frame (decode_live_frame (frame));
-  XSETFRAME (frame, f);
+  return Qnil;
-  Fredraw_frame (frame);
 }
 DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
       doc: /* Clear and redisplay all visible frames.  */)
  (void)
@@ -3128,7 +3072,7 @@ DEFUN ("redraw-display", Fredraw_display, Sredraw_display, 0, 0, "",
  FOR_EACH_FRAME (tail, frame)
    if (FRAME_VISIBLE_P (XFRAME (frame)))
-      Fredraw_frame (frame);
+      redraw_frame (XFRAME (frame));
  return Qnil;
 }
@@ -4647,24 +4591,10 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
              FILE *display_output = FRAME_TTY (f)->output;
              if (display_output)
                {
-                  int outq = PENDING_OUTPUT_COUNT (display_output);
+                  ptrdiff_t outq = __fpending (display_output);
                  if (outq > 900
                      || (outq > 20 && ((i - 1) % preempt_count == 0)))
-                    {
+                    fflush (display_output);
-                      fflush (display_output);
-                      if (preempt_count == 1)
-                        {
-#ifdef EMACS_OUTQSIZE
-                          if (EMACS_OUTQSIZE (0, &outq) < 0)
-                            /* Probably not a tty.  Ignore the error and reset
-                               the outq count.  */
-                            outq = PENDING_OUTPUT_COUNT (FRAME_TTY (f->output));
-#endif
-                          outq *= 10;
-                          if (baud_rate <= outq && baud_rate > 0)
-                            sleep (outq / baud_rate);
-                        }
-                    }
                }
            }
@@ -6226,7 +6156,6 @@ init_display (void)
         So call tgetent.  */
      { char b[2044]; tgetent (b, "xterm");}
 #endif
-      adjust_frame_glyphs_initially ();
      return;
    }
 #endif /* HAVE_X_WINDOWS */
@@ -6236,7 +6165,6 @@ init_display (void)
    {
      Vinitial_window_system = Qw32;
      Vwindow_system_version = make_number (1);
-      adjust_frame_glyphs_initially ();
      return;
    }
 #endif /* HAVE_NTGUI */
@@ -6250,7 +6178,6 @@ init_display (void)
    {
      Vinitial_window_system = Qns;
      Vwindow_system_version = make_number (10);
-      adjust_frame_glyphs_initially ();
      return;
    }
 #endif
@@ -6340,7 +6267,6 @@ init_display (void)
      fatal ("screen size %dx%d too big", width, height);
  }
-  adjust_frame_glyphs_initially ();
  calculate_costs (XFRAME (selected_frame));
  /* Set up faces of the initial terminal frame of a dumped Emacs.  */
@@ -6375,15 +6301,7 @@ don't show a cursor.  */)
  /* Don't change cursor state while redisplaying.  This could confuse
     output routines.  */
  if (!redisplaying_p)
-    {
+    decode_any_window (window)->cursor_off_p = NILP (show);
-      if (NILP (window))
-        window = selected_window;
-      else
-        CHECK_WINDOW (window);
-      XWINDOW (window)->cursor_off_p = NILP (show);
-    }
  return Qnil;
 }
@@ -6394,15 +6312,7 @@ DEFUN ("internal-show-cursor-p", Finternal_show_cursor_p,
 WINDOW nil or omitted means report on the selected window.  */)
  (Lisp_Object window)
 {
-  struct window *w;
+  return decode_any_window (window)->cursor_off_p ? Qnil : Qt;
-  if (NILP (window))
-    window = selected_window;
-  else
-    CHECK_WINDOW (window);
-  w = XWINDOW (window);
-  return w->cursor_off_p ? Qnil : Qt;
 }
 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
diff --git a/src/doc.c b/src/doc.c
index 9ead1addfba..1d3d1e64442 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -21,7 +21,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <config.h>
 #include <sys/types.h>
-#include <sys/file.h>   /* Must be after sys/types.h for USG*/
+#include <sys/file.h>   /* Must be after sys/types.h for USG.  */
 #include <fcntl.h>
 #include <unistd.h>
@@ -42,7 +42,7 @@ static ptrdiff_t get_doc_string_buffer_size;
 static unsigned char *read_bytecode_pointer;
-/* readchar in lread.c calls back here to fetch the next byte.
+/* `readchar' in lread.c calls back here to fetch the next byte.
   If UNREADFLAG is 1, we unread a byte.  */
 int
@@ -338,15 +338,9 @@ string is passed through `substitute-command-keys'.  */)
  doc = Qnil;
-  if (SYMBOLP (function))
-    {
-      Lisp_Object tem = Fget (function, Qfunction_documentation);
-      if (!NILP (tem))
-        return Fdocumentation_property (function, Qfunction_documentation,
-                                        raw);
-    }
  fun = Findirect_function (function, Qnil);
+  if (CONSP (fun) && EQ (XCAR (fun), Qmacro))
+    fun = XCDR (fun);
  if (SUBRP (fun))
    {
      if (XSUBR (fun)->doc == 0)
@@ -400,8 +394,6 @@ string is passed through `substitute-command-keys'.  */)
          else
            return Qnil;
        }
-      else if (EQ (funcar, Qmacro))
-        return Fdocumentation (Fcdr (fun), raw);
      else
        goto oops;
    }
@@ -411,16 +403,19 @@ string is passed through `substitute-command-keys'.  */)
      xsignal1 (Qinvalid_function, fun);
    }
-  /* Check for an advised function.  Its doc string
+  /* Check for a dynamic docstring.  These come with
-     has an `ad-advice-info' text property.  */
+     a dynamic-docstring-function text property.  */
  if (STRINGP (doc))
    {
-      Lisp_Object innerfunc;
+      Lisp_Object func
-      innerfunc = Fget_text_property (make_number (0),
+        = Fget_text_property (make_number (0),
-                                      intern ("ad-advice-info"),
+                              intern ("dynamic-docstring-function"),
                                      doc);
-      if (! NILP (innerfunc))
+      if (!NILP (func))
-        doc = call1 (intern ("ad-make-advised-docstring"), innerfunc);
+        /* Pass both `doc' and `function' since `function' can be needed, and
+           finding `doc' can be annoying: calling `documentation' is not an
+           option because it would infloop.  */
+        doc = call2 (func, doc, function);
    }
  /* If DOC is 0, it's typically because of a dumped file missing
@@ -528,6 +523,8 @@ store_function_docstring (Lisp_Object obj, ptrdiff_t offset)
        {
          tem = Fcdr (Fcdr (fun));
          if (CONSP (tem) && INTEGERP (XCAR (tem)))
+            /* FIXME: This modifies typically pure hash-cons'd data, so its
+               correctness is quite delicate.  */
            XSETCAR (tem, make_number (offset));
        }
      else if (EQ (tem, Qmacro))
diff --git a/src/emacs.c b/src/emacs.c
index 0004af359d2..1afc7c189df 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -27,6 +27,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/file.h>
 #include <unistd.h>
+#include <close-stream.h>
 #include <ignore-value.h>
 #include "lisp.h"
@@ -675,6 +676,22 @@ void (*__malloc_initialize_hook) (void) EXTERNALLY_VISIBLE = malloc_initialize_h
 #endif /* DOUG_LEA_MALLOC */
+/* Close standard output and standard error, reporting any write
+   errors as best we can.  This is intended for use with atexit.  */
+static void
+close_output_streams (void)
+{
+  if (close_stream (stdout) != 0)
+    {
+      fprintf (stderr, "Write error to standard output: %s\n",
+               strerror (errno));
+      fflush (stderr);
+      _exit (EXIT_FAILURE);
+    }
+   if (close_stream (stderr) != 0)
+     _exit (EXIT_FAILURE);
+}
 /* ARGSUSED */
 int
@@ -731,6 +748,8 @@ main (int argc, char **argv)
    unexec_init_emacs_zone ();
 #endif
+  atexit (close_output_streams);
  sort_args (argc, argv);
  argc = 0;
  while (argv[argc]) argc++;
@@ -1082,9 +1101,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
         that it is not accessible to programs started from .emacs.  */
      fcntl (daemon_pipe[1], F_SETFD, FD_CLOEXEC);
-#ifdef HAVE_SETSID
      setsid ();
-#endif
 #else /* DOS_NT */
      fprintf (stderr, "This platform does not support the -daemon flag.\n");
      exit (1);
@@ -1137,6 +1154,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
      /* Called before syms_of_fileio, because it sets up Qerror_condition.  */
      syms_of_data ();
+      syms_of_fns ();      /* Before syms_of_charset which uses hashtables.  */
      syms_of_fileio ();
      /* Before syms_of_coding to initialize Vgc_cons_threshold.  */
      syms_of_alloc ();
@@ -1148,7 +1166,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
      init_window_once ();      /* Init the window system.  */
 #ifdef HAVE_WINDOW_SYSTEM
-      init_fringe_once ();      /* Swap bitmaps if necessary. */
+      init_fringe_once ();      /* Swap bitmaps if necessary.  */
 #endif /* HAVE_WINDOW_SYSTEM */
    }
@@ -1332,7 +1350,6 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
      syms_of_lread ();
      syms_of_print ();
      syms_of_eval ();
-      syms_of_fns ();
      syms_of_floatfns ();
      syms_of_buffer ();
@@ -1869,8 +1886,6 @@ all of which are called before Emacs is actually killed.  */)
    exit_code = (XINT (arg) < 0
                 ? XINT (arg) | INT_MIN
                 : XINT (arg) & INT_MAX);
-  else if (noninteractive && (fflush (stdout) || ferror (stdout)))
-    exit_code = EXIT_FAILURE;
  else
    exit_code = EXIT_SUCCESS;
  exit (exit_code);
@@ -1900,7 +1915,7 @@ shut_down_emacs (int sig, Lisp_Object stuff)
  /* If we are controlling the terminal, reset terminal modes.  */
 #ifndef DOS_NT
  {
-    pid_t pgrp = EMACS_GETPGRP (0);
+    pid_t pgrp = getpgrp ();
    pid_t tpgrp = tcgetpgrp (0);
    if ((tpgrp != -1) && tpgrp == pgrp)
      {
diff --git a/src/eval.c b/src/eval.c
index 975204da017..dcd48cb7250 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1876,26 +1876,19 @@ this does nothing and returns nil.  */)
  CHECK_STRING (file);
  /* If function is defined and not as an autoload, don't override.  */
-  if ((CONSP (XSYMBOL (function)->function)
+  if (!EQ (XSYMBOL (function)->function, Qunbound)
-       && EQ (XCAR (XSYMBOL (function)->function), Qautoload)))
+      && !AUTOLOADP (XSYMBOL (function)->function))
-    /* Remember that the function was already an autoload.  */
-    LOADHIST_ATTACH (Fcons (Qt, function));
-  else if (!EQ (XSYMBOL (function)->function, Qunbound))
    return Qnil;
-  if (NILP (Vpurify_flag))
+  if (!NILP (Vpurify_flag) && EQ (docstring, make_number (0)))
-    /* Only add entries after dumping, because the ones before are
-       not useful and else we get loads of them from the loaddefs.el.  */
-    LOADHIST_ATTACH (Fcons (Qautoload, function));
-  else if (EQ (docstring, make_number (0)))
    /* `read1' in lread.c has found the docstring starting with "\
       and assumed the docstring will be provided by Snarf-documentation, so it
       passed us 0 instead.  But that leads to accidental sharing in purecopy's
       hash-consing, so we use a (hopefully) unique integer instead.  */
-    docstring = make_number (XUNTAG (function, Lisp_Symbol));
+    docstring = make_number (XHASH (function));
-  return Ffset (function,
+  return Fdefalias (function,
-                Fpurecopy (list5 (Qautoload, file, docstring,
+                    list5 (Qautoload, file, docstring, interactive, type),
-                                  interactive, type)));
+                    Qnil);
 }
 Lisp_Object
diff --git a/src/fileio.c b/src/fileio.c
index d47d7dd9e0b..b9541e78838 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5076,7 +5076,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
  struct stat st;
  Lisp_Object handler;
  Lisp_Object filename;
-  EMACS_TIME mtime, diff;
+  EMACS_TIME mtime;
  if (NILP (buf))
    b = current_buffer;
@@ -5101,13 +5101,7 @@ See Info node `(elisp)Modification Time' for more details.  */)
  mtime = (stat (SSDATA (filename), &st) == 0
           ? get_stat_mtime (&st)
           : time_error_value (errno));
-  if ((EMACS_TIME_EQ (mtime, b->modtime)
+  if (EMACS_TIME_EQ (mtime, b->modtime)
-       /* If both exist, accept them if they are off by one second.  */
-       || (EMACS_TIME_VALID_P (mtime) && EMACS_TIME_VALID_P (b->modtime)
-           && ((diff = (EMACS_TIME_LT (mtime, b->modtime)
-                        ? sub_emacs_time (b->modtime, mtime)
-                        : sub_emacs_time (mtime, b->modtime))),
-               EMACS_TIME_LE (diff, make_emacs_time (1, 0)))))
      && (st.st_size == b->modtime_size
          || b->modtime_size < 0))
    return Qt;
diff --git a/src/fns.c b/src/fns.c
index b1ba5ce9509..7c2222e9805 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2014,7 +2014,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
        d1 = extract_float (o1);
        d2 = extract_float (o2);
        /* If d is a NaN, then d != d. Two NaNs should be `equal' even
-           though they are not =. */
+           though they are not =.  */
        return d1 == d2 || (d1 != d1 && d2 != d2);
      }
@@ -2076,9 +2076,8 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, int depth, bool props)
           are sensible to compare, so eliminate the others now.  */
        if (size & PSEUDOVECTOR_FLAG)
          {
-            if (!(size & ((PVEC_COMPILED | PVEC_CHAR_TABLE
+            if (((size & PVEC_TYPE_MASK) >> PSEUDOVECTOR_AREA_BITS)
-                           | PVEC_SUB_CHAR_TABLE | PVEC_FONT)
+                < PVEC_COMPILED)
-                          << PSEUDOVECTOR_SIZE_BITS)))
              return 0;
            size &= PSEUDOVECTOR_SIZE_MASK;
          }
@@ -3332,8 +3331,8 @@ static struct Lisp_Hash_Table *weak_hash_tables;
 /* Various symbols.  */
-static Lisp_Object Qhash_table_p, Qkey, Qvalue;
+static Lisp_Object Qhash_table_p, Qkey, Qvalue, Qeql;
-Lisp_Object Qeq, Qeql, Qequal;
+Lisp_Object Qeq, Qequal;
 Lisp_Object QCtest, QCsize, QCrehash_size, QCrehash_threshold, QCweakness;
 static Lisp_Object Qhash_table_test, Qkey_or_value, Qkey_and_value;
@@ -3425,14 +3424,17 @@ larger_vector (Lisp_Object vec, ptrdiff_t incr_min, ptrdiff_t nitems_max)
                         Low-level Functions
 ***********************************************************************/
+static struct hash_table_test hashtest_eq;
+struct hash_table_test hashtest_eql, hashtest_equal;
 /* Compare KEY1 which has hash code HASH1 and KEY2 with hash code
   HASH2 in hash table H using `eql'.  Value is true if KEY1 and
   KEY2 are the same.  */
 static bool
-cmpfn_eql (struct Lisp_Hash_Table *h,
+cmpfn_eql (struct hash_table_test *ht,
-           Lisp_Object key1, EMACS_UINT hash1,
+           Lisp_Object key1,
-           Lisp_Object key2, EMACS_UINT hash2)
+           Lisp_Object key2)
 {
  return (FLOATP (key1)
          && FLOATP (key2)
@@ -3445,11 +3447,11 @@ cmpfn_eql (struct Lisp_Hash_Table *h,
   KEY2 are the same.  */
 static bool
-cmpfn_equal (struct Lisp_Hash_Table *h,
+cmpfn_equal (struct hash_table_test *ht,
-             Lisp_Object key1, EMACS_UINT hash1,
+             Lisp_Object key1,
-             Lisp_Object key2, EMACS_UINT hash2)
+             Lisp_Object key2)
 {
-  return hash1 == hash2 && !NILP (Fequal (key1, key2));
+  return !NILP (Fequal (key1, key2));
 }
@@ -3458,21 +3460,16 @@ cmpfn_equal (struct Lisp_Hash_Table *h,
   if KEY1 and KEY2 are the same.  */
 static bool
-cmpfn_user_defined (struct Lisp_Hash_Table *h,
+cmpfn_user_defined (struct hash_table_test *ht,
-                    Lisp_Object key1, EMACS_UINT hash1,
+                    Lisp_Object key1,
-                    Lisp_Object key2, EMACS_UINT hash2)
+                    Lisp_Object key2)
 {
-  if (hash1 == hash2)
+  Lisp_Object args[3];
-    {
-      Lisp_Object args[3];
-      args[0] = h->user_cmp_function;
+  args[0] = ht->user_cmp_function;
-      args[1] = key1;
+  args[1] = key1;
-      args[2] = key2;
+  args[2] = key2;
-      return !NILP (Ffuncall (3, args));
+  return !NILP (Ffuncall (3, args));
-    }
-  else
-    return 0;
 }
@@ -3481,54 +3478,48 @@ cmpfn_user_defined (struct Lisp_Hash_Table *h,
   in a Lisp integer.  */
 static EMACS_UINT
-hashfn_eq (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_eq (struct hash_table_test *ht, Lisp_Object key)
 {
-  EMACS_UINT hash = XUINT (key) ^ XTYPE (key);
+  EMACS_UINT hash = XHASH (key) ^ XTYPE (key);
-  eassert ((hash & ~INTMASK) == 0);
  return hash;
 }
 /* Value is a hash code for KEY for use in hash table H which uses
   `eql' to compare keys.  The hash code returned is guaranteed to fit
   in a Lisp integer.  */
 static EMACS_UINT
-hashfn_eql (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_eql (struct hash_table_test *ht, Lisp_Object key)
 {
  EMACS_UINT hash;
  if (FLOATP (key))
    hash = sxhash (key, 0);
  else
-    hash = XUINT (key) ^ XTYPE (key);
+    hash = XHASH (key) ^ XTYPE (key);
-  eassert ((hash & ~INTMASK) == 0);
  return hash;
 }
 /* Value is a hash code for KEY for use in hash table H which uses
   `equal' to compare keys.  The hash code returned is guaranteed to fit
   in a Lisp integer.  */
 static EMACS_UINT
-hashfn_equal (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_equal (struct hash_table_test *ht, Lisp_Object key)
 {
  EMACS_UINT hash = sxhash (key, 0);
-  eassert ((hash & ~INTMASK) == 0);
  return hash;
 }
 /* Value is a hash code for KEY for use in hash table H which uses as
   user-defined function to compare keys.  The hash code returned is
   guaranteed to fit in a Lisp integer.  */
 static EMACS_UINT
-hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
+hashfn_user_defined (struct hash_table_test *ht, Lisp_Object key)
 {
  Lisp_Object args[2], hash;
-  args[0] = h->user_hash_function;
+  args[0] = ht->user_hash_function;
  args[1] = key;
  hash = Ffuncall (2, args);
  if (!INTEGERP (hash))
@@ -3564,9 +3555,9 @@ hashfn_user_defined (struct Lisp_Hash_Table *h, Lisp_Object key)
   one of the symbols `key', `value', `key-or-value', or `key-and-value'.  */
 Lisp_Object
-make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
+make_hash_table (struct hash_table_test test,
-                 Lisp_Object rehash_threshold, Lisp_Object weak,
+                 Lisp_Object size, Lisp_Object rehash_size,
-                 Lisp_Object user_test, Lisp_Object user_hash)
+                 Lisp_Object rehash_threshold, Lisp_Object weak)
 {
  struct Lisp_Hash_Table *h;
  Lisp_Object table;
@@ -3575,7 +3566,7 @@ make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
  double index_float;
  /* Preconditions.  */
-  eassert (SYMBOLP (test));
+  eassert (SYMBOLP (test.name));
  eassert (INTEGERP (size) && XINT (size) >= 0);
  eassert ((INTEGERP (rehash_size) && XINT (rehash_size) > 0)
           || (FLOATP (rehash_size) && 1 < XFLOAT_DATA (rehash_size)));
@@ -3599,29 +3590,6 @@ make_hash_table (Lisp_Object test, Lisp_Object size, Lisp_Object rehash_size,
  /* Initialize hash table slots.  */
  h->test = test;
-  if (EQ (test, Qeql))
-    {
-      h->cmpfn = cmpfn_eql;
-      h->hashfn = hashfn_eql;
-    }
-  else if (EQ (test, Qeq))
-    {
-      h->cmpfn = NULL;
-      h->hashfn = hashfn_eq;
-    }
-  else if (EQ (test, Qequal))
-    {
-      h->cmpfn = cmpfn_equal;
-      h->hashfn = hashfn_equal;
-    }
-  else
-    {
-      h->user_cmp_function = user_test;
-      h->user_hash_function = user_hash;
-      h->cmpfn = cmpfn_user_defined;
-      h->hashfn = hashfn_user_defined;
-    }
  h->weak = weak;
  h->rehash_threshold = rehash_threshold;
  h->rehash_size = rehash_size;
@@ -3661,12 +3629,9 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
 {
  Lisp_Object table;
  struct Lisp_Hash_Table *h2;
-  struct Lisp_Vector *next;
  h2 = allocate_hash_table ();
-  next = h2->header.next.vector;
  *h2 = *h1;
-  h2->header.next.vector = next;
  h2->key_and_value = Fcopy_sequence (h1->key_and_value);
  h2->hash = Fcopy_sequence (h1->hash);
  h2->next = Fcopy_sequence (h1->next);
@@ -3780,7 +3745,8 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
  ptrdiff_t start_of_bucket;
  Lisp_Object idx;
-  hash_code = h->hashfn (h, key);
+  hash_code = h->test.hashfn (&h->test, key);
+  eassert ((hash_code & ~INTMASK) == 0);
  if (hash)
    *hash = hash_code;
@@ -3792,9 +3758,9 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, EMACS_UINT *hash)
    {
      ptrdiff_t i = XFASTINT (idx);
      if (EQ (key, HASH_KEY (h, i))
-          || (h->cmpfn
+          || (h->test.cmpfn
-              && h->cmpfn (h, key, hash_code,
+              && hash_code == XUINT (HASH_HASH (h, i))
-                           HASH_KEY (h, i), XUINT (HASH_HASH (h, i)))))
+              && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
        break;
      idx = HASH_NEXT (h, i);
    }
@@ -3845,7 +3811,8 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
  ptrdiff_t start_of_bucket;
  Lisp_Object idx, prev;
-  hash_code = h->hashfn (h, key);
+  hash_code = h->test.hashfn (&h->test, key);
+  eassert ((hash_code & ~INTMASK) == 0);
  start_of_bucket = hash_code % ASIZE (h->index);
  idx = HASH_INDEX (h, start_of_bucket);
  prev = Qnil;
@@ -3856,9 +3823,9 @@ hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
      ptrdiff_t i = XFASTINT (idx);
      if (EQ (key, HASH_KEY (h, i))
-          || (h->cmpfn
+          || (h->test.cmpfn
-              && h->cmpfn (h, key, hash_code,
+              && hash_code == XUINT (HASH_HASH (h, i))
-                           HASH_KEY (h, i), XUINT (HASH_HASH (h, i)))))
+              && h->test.cmpfn (&h->test, key, HASH_KEY (h, i))))
        {
          /* Take entry out of collision chain.  */
          if (NILP (prev))
@@ -4070,13 +4037,6 @@ sweep_weak_hash_tables (void)
 #define SXHASH_MAX_LEN   7
-/* Combine two integers X and Y for hashing.  The result might not fit
-   into a Lisp integer.  */
-#define SXHASH_COMBINE(X, Y)                                            \
-  ((((EMACS_UINT) (X) << 4) + ((EMACS_UINT) (X) >> (BITS_PER_EMACS_INT - 4))) \
-   + (EMACS_UINT) (Y))
 /* Hash X, returning a value that fits into a Lisp integer.  */
 #define SXHASH_REDUCE(X) \
  ((((X) ^ (X) >> (BITS_PER_EMACS_INT - FIXNUM_BITS))) & INTMASK)
@@ -4095,7 +4055,7 @@ hash_string (char const *ptr, ptrdiff_t len)
  while (p != end)
    {
      c = *p++;
-      hash = SXHASH_COMBINE (hash, c);
+      hash = sxhash_combine (hash, c);
    }
  return hash;
@@ -4129,7 +4089,7 @@ sxhash_float (double val)
  u.val = val;
  memset (&u.val + 1, 0, sizeof u - sizeof u.val);
  for (i = 0; i < WORDS_PER_DOUBLE; i++)
-    hash = SXHASH_COMBINE (hash, u.word[i]);
+    hash = sxhash_combine (hash, u.word[i]);
  return SXHASH_REDUCE (hash);
 }
@@ -4148,13 +4108,13 @@ sxhash_list (Lisp_Object list, int depth)
         list = XCDR (list), ++i)
      {
        EMACS_UINT hash2 = sxhash (XCAR (list), depth + 1);
-        hash = SXHASH_COMBINE (hash, hash2);
+        hash = sxhash_combine (hash, hash2);
      }
  if (!NILP (list))
    {
      EMACS_UINT hash2 = sxhash (list, depth + 1);
-      hash = SXHASH_COMBINE (hash, hash2);
+      hash = sxhash_combine (hash, hash2);
    }
  return SXHASH_REDUCE (hash);
@@ -4174,7 +4134,7 @@ sxhash_vector (Lisp_Object vec, int depth)
  for (i = 0; i < n; ++i)
    {
      EMACS_UINT hash2 = sxhash (AREF (vec, i), depth + 1);
-      hash = SXHASH_COMBINE (hash, hash2);
+      hash = sxhash_combine (hash, hash2);
    }
  return SXHASH_REDUCE (hash);
@@ -4190,7 +4150,7 @@ sxhash_bool_vector (Lisp_Object vec)
  n = min (SXHASH_MAX_LEN, XBOOL_VECTOR (vec)->header.size);
  for (i = 0; i < n; ++i)
-    hash = SXHASH_COMBINE (hash, XBOOL_VECTOR (vec)->data[i]);
+    hash = sxhash_combine (hash, XBOOL_VECTOR (vec)->data[i]);
  return SXHASH_REDUCE (hash);
 }
@@ -4214,7 +4174,7 @@ sxhash (Lisp_Object obj, int depth)
      break;
    case Lisp_Misc:
-      hash = XUINT (obj);
+      hash = XHASH (obj);
      break;
    case Lisp_Symbol:
@@ -4238,7 +4198,7 @@ sxhash (Lisp_Object obj, int depth)
      else
        /* Others are `equal' if they are `eq', so let's take their
           address as hash.  */
-        hash = XUINT (obj);
+        hash = XHASH (obj);
      break;
    case Lisp_Cons:
@@ -4307,7 +4267,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
  (ptrdiff_t nargs, Lisp_Object *args)
 {
  Lisp_Object test, size, rehash_size, rehash_threshold, weak;
-  Lisp_Object user_test, user_hash;
+  struct hash_table_test testdesc;
  char *used;
  ptrdiff_t i;
@@ -4319,7 +4279,13 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
  /* See if there's a `:test TEST' among the arguments.  */
  i = get_key_arg (QCtest, nargs, args, used);
  test = i ? args[i] : Qeql;
-  if (!EQ (test, Qeq) && !EQ (test, Qeql) && !EQ (test, Qequal))
+  if (EQ (test, Qeq))
+    testdesc = hashtest_eq;
+  else if (EQ (test, Qeql))
+    testdesc = hashtest_eql;
+  else if (EQ (test, Qequal))
+    testdesc = hashtest_equal;
+  else
    {
      /* See if it is a user-defined test.  */
      Lisp_Object prop;
@@ -4327,11 +4293,12 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
      prop = Fget (test, Qhash_table_test);
      if (!CONSP (prop) || !CONSP (XCDR (prop)))
        signal_error ("Invalid hash table test", test);
-      user_test = XCAR (prop);
+      testdesc.name = test;
-      user_hash = XCAR (XCDR (prop));
+      testdesc.user_cmp_function = XCAR (prop);
+      testdesc.user_hash_function = XCAR (XCDR (prop));
+      testdesc.hashfn = hashfn_user_defined;
+      testdesc.cmpfn = cmpfn_user_defined;
    }
-  else
-    user_test = user_hash = Qnil;
  /* See if there's a `:size SIZE' argument.  */
  i = get_key_arg (QCsize, nargs, args, used);
@@ -4373,8 +4340,7 @@ usage: (make-hash-table &rest KEYWORD-ARGS)  */)
    if (!used[i])
      signal_error ("Invalid argument list", args[i]);
-  return make_hash_table (test, size, rehash_size, rehash_threshold, weak,
+  return make_hash_table (testdesc, size, rehash_size, rehash_threshold, weak);
-                          user_test, user_hash);
 }
@@ -4428,7 +4394,7 @@ DEFUN ("hash-table-test", Fhash_table_test, Shash_table_test, 1, 1, 0,
       doc: /* Return the test TABLE uses.  */)
  (Lisp_Object table)
 {
-  return check_hash_table (table)->test;
+  return check_hash_table (table)->test.name;
 }
@@ -4992,4 +4958,14 @@ this variable.  */);
  defsubr (&Smd5);
  defsubr (&Ssecure_hash);
  defsubr (&Slocale_info);
+  {
+    struct hash_table_test
+      eq = { Qeq, Qnil, Qnil, NULL, hashfn_eq },
+      eql = { Qeql, Qnil, Qnil, cmpfn_eql, hashfn_eql },
+      equal = { Qequal, Qnil, Qnil, cmpfn_equal, hashfn_equal };
+    hashtest_eq = eq;
+    hashtest_eql = eql;
+    hashtest_equal = equal;
+  }
 }
diff --git a/src/font.c b/src/font.c
index e79ce5d80bc..41dbfd7a757 100644
--- a/src/font.c
+++ b/src/font.c
@@ -3993,16 +3993,11 @@ The optional argument FRAME specifies the frame that the face attributes
 are to be displayed on.  If omitted, the selected frame is used.  */)
  (Lisp_Object font, Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
  Lisp_Object plist[10];
  Lisp_Object val;
  int n = 0;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (STRINGP (font))
    {
      int fontset = fs_query_fontset (font, 0);
@@ -4152,18 +4147,15 @@ how close they are to PREFER.  */)
 DEFUN ("font-family-list", Ffont_family_list, Sfont_family_list, 0, 1, 0,
       doc: /* List available font families on the current frame.
-Optional argument FRAME, if non-nil, specifies the target frame.  */)
+If FRAME is omitted or nil, the selected frame is used.  */)
  (Lisp_Object frame)
 {
-  FRAME_PTR f;
+  struct frame *f = decode_live_frame (frame);
  struct font_driver_list *driver_list;
-  Lisp_Object list;
+  Lisp_Object list = Qnil;
+  XSETFRAME (frame, f);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
-  list = Qnil;
  for (driver_list = f->font_driver_list; driver_list;
       driver_list = driver_list->next)
    if (driver_list->driver->list_family)
@@ -4531,11 +4523,9 @@ DEFUN ("open-font", Fopen_font, Sopen_font, 1, 3, 0,
  (Lisp_Object font_entity, Lisp_Object size, Lisp_Object frame)
 {
  EMACS_INT isize;
+  struct frame *f = decode_live_frame (frame);
  CHECK_FONT_ENTITY (font_entity);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
  if (NILP (size))
    isize = XINT (AREF (font_entity, FONT_SIZE_INDEX));
@@ -4543,7 +4533,7 @@ DEFUN ("open-font", Fopen_font, Sopen_font, 1, 3, 0,
    {
      CHECK_NUMBER_OR_FLOAT (size);
      if (FLOATP (size))
-        isize = POINT_TO_PIXEL (XFLOAT_DATA (size), XFRAME (frame)->resy);
+        isize = POINT_TO_PIXEL (XFLOAT_DATA (size), f->resy);
      else
        isize = XINT (size);
      if (! (INT_MIN <= isize && isize <= INT_MAX))
@@ -4551,7 +4541,7 @@ DEFUN ("open-font", Fopen_font, Sopen_font, 1, 3, 0,
      if (isize == 0)
        isize = 120;
    }
-  return font_open_entity (XFRAME (frame), font_entity, isize);
+  return font_open_entity (f, font_entity, isize);
 }
 DEFUN ("close-font", Fclose_font, Sclose_font, 1, 2, 0,
@@ -4559,10 +4549,7 @@ DEFUN ("close-font", Fclose_font, Sclose_font, 1, 2, 0,
  (Lisp_Object font_object, Lisp_Object frame)
 {
  CHECK_FONT_OBJECT (font_object);
-  if (NILP (frame))
+  font_close_object (decode_live_frame (frame), font_object);
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  font_close_object (XFRAME (frame), font_object);
  return Qnil;
 }
@@ -4765,13 +4752,8 @@ Optional third arg STRING, if non-nil, is a string containing the target
 character at index specified by POSITION.  */)
  (Lisp_Object position, Lisp_Object window, Lisp_Object string)
 {
-  struct window *w;
+  struct window *w = decode_live_window (window);
-  ptrdiff_t pos;
-  if (NILP (window))
-    window = selected_window;
-  CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
  if (NILP (string))
    {
      if (XBUFFER (w->buffer) != current_buffer)
@@ -4779,7 +4761,6 @@ character at index specified by POSITION.  */)
      CHECK_NUMBER_COERCE_MARKER (position);
      if (! (BEGV <= XINT (position) && XINT (position) < ZV))
        args_out_of_range_3 (position, make_number (BEGV), make_number (ZV));
-      pos = XINT (position);
    }
  else
    {
@@ -4787,10 +4768,9 @@ character at index specified by POSITION.  */)
      CHECK_STRING (string);
      if (! (0 <= XINT (position) && XINT (position) < SCHARS (string)))
        args_out_of_range (string, position);
-      pos = XINT (position);
    }
-  return font_at (-1, pos, NULL, w, string);
+  return font_at (-1, XINT (position), NULL, w, string);
 }
 #if 0
@@ -4854,7 +4834,7 @@ where
 If the named font is not yet loaded, return nil.  */)
  (Lisp_Object name, Lisp_Object frame)
 {
-  FRAME_PTR f;
+  struct frame *f;
  struct font *font;
  Lisp_Object info;
  Lisp_Object font_object;
@@ -4863,10 +4843,7 @@ If the named font is not yet loaded, return nil.  */)
  if (! FONTP (name))
    CHECK_STRING (name);
-  if (NILP (frame))
+  f = decode_live_frame (frame);
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (STRINGP (name))
    {
diff --git a/src/fontset.c b/src/fontset.c
index da745b31ca1..b76a216bac2 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1326,17 +1326,14 @@ static Lisp_Object
 check_fontset_name (Lisp_Object name, Lisp_Object *frame)
 {
  int id;
+  struct frame *f = decode_live_frame (*frame);
-  if (NILP (*frame))
+  XSETFRAME (*frame, f);
-    *frame = selected_frame;
-  CHECK_LIVE_FRAME (*frame);
  if (EQ (name, Qt))
    return Vdefault_fontset;
  if (NILP (name))
-    {
+    id = FRAME_FONTSET (f);
-      id = FRAME_FONTSET (XFRAME (*frame));
-    }
  else
    {
      CHECK_STRING (name);
diff --git a/src/frame.c b/src/frame.c
index 79893abf826..d580bf7f148 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -131,7 +131,24 @@ fset_minibuffer_window (struct frame *f, Lisp_Object val)
  f->minibuffer_window = val;
 }
+struct frame *
+decode_live_frame (register Lisp_Object frame)
+{
+  if (NILP (frame))
+    frame = selected_frame;
+  CHECK_LIVE_FRAME (frame);
+  return XFRAME (frame);
+}
+struct frame *
+decode_any_frame (register Lisp_Object frame)
+{
+  if (NILP (frame))
+    frame = selected_frame;
+  CHECK_FRAME (frame);
+  return XFRAME (frame);
+}
 static void
 set_menu_bar_lines_1 (Lisp_Object window, int n)
 {
@@ -502,7 +519,6 @@ make_initial_frame (void)
  FRAME_FOREGROUND_PIXEL (f) = FACE_TTY_DEFAULT_FG_COLOR;
  FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
  FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
  /* The default value of menu-bar-mode is t.  */
@@ -551,7 +567,6 @@ make_terminal_frame (struct terminal *terminal)
  FRAME_BACKGROUND_PIXEL (f) = FACE_TTY_DEFAULT_BG_COLOR;
 #endif /* not MSDOS */
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
  FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
  FRAME_MENU_BAR_LINES(f) = NILP (Vmenu_bar_mode) ? 0 : 1;
@@ -891,7 +906,7 @@ DEFUN ("frame-list", Fframe_list, Sframe_list,
 static Lisp_Object
 next_frame (Lisp_Object frame, Lisp_Object minibuf)
 {
-  Lisp_Object tail;
+  Lisp_Object f, tail;
  int passed = 0;
  /* There must always be at least one frame in Vframe_list.  */
@@ -903,12 +918,8 @@ next_frame (Lisp_Object frame, Lisp_Object minibuf)
  CHECK_LIVE_FRAME (frame);
  while (1)
-    for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+    FOR_EACH_FRAME (tail, f)
      {
-        Lisp_Object f;
-        f = XCAR (tail);
        if (passed
            && ((!FRAME_TERMCAP_P (XFRAME (f)) && !FRAME_TERMCAP_P (XFRAME (frame))
                 && FRAME_KBOARD (XFRAME (f)) == FRAME_KBOARD (XFRAME (frame)))
@@ -969,22 +980,13 @@ next_frame (Lisp_Object frame, Lisp_Object minibuf)
 static Lisp_Object
 prev_frame (Lisp_Object frame, Lisp_Object minibuf)
 {
-  Lisp_Object tail;
+  Lisp_Object f, tail, prev = Qnil;
-  Lisp_Object prev;
  /* There must always be at least one frame in Vframe_list.  */
-  if (! CONSP (Vframe_list))
+  eassert (CONSP (Vframe_list));
-    emacs_abort ();
-  prev = Qnil;
+  FOR_EACH_FRAME (tail, f)
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
    {
-      Lisp_Object f;
-      f = XCAR (tail);
-      if (!FRAMEP (f))
-        emacs_abort ();
      if (EQ (frame, f) && !NILP (prev))
        return prev;
@@ -1085,11 +1087,10 @@ Otherwise, include all frames.  */)
 static int
 other_visible_frames (FRAME_PTR f)
 {
-  Lisp_Object frames;
+  Lisp_Object frames, this;
-  for (frames = Vframe_list; CONSP (frames); frames = XCDR (frames))
+  FOR_EACH_FRAME (frames, this)
    {
-      Lisp_Object this = XCAR (frames);
      if (f == XFRAME (this))
        continue;
@@ -1120,23 +1121,12 @@ other_visible_frames (FRAME_PTR f)
 Lisp_Object
 delete_frame (Lisp_Object frame, Lisp_Object force)
 {
-  struct frame *f;
+  struct frame *f = decode_any_frame (frame);
  struct frame *sf = SELECTED_FRAME ();
  struct kboard *kb;
  int minibuffer_selected, is_tooltip_frame;
-  if (EQ (frame, Qnil))
-    {
-      f = sf;
-      XSETFRAME (frame, f);
-    }
-  else
-    {
-      CHECK_FRAME (frame);
-      f = XFRAME (frame);
-    }
  if (! FRAME_LIVE_P (f))
    return Qnil;
@@ -1148,19 +1138,16 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
  if (NILP (XCDR (Vframe_list)) && !EQ (force, Qnoelisp))
    error ("Attempt to delete the only frame");
+  XSETFRAME (frame, f);
  /* Does this frame have a minibuffer, and is it the surrogate
     minibuffer for any other frame?  */
-  if (FRAME_HAS_MINIBUF_P (XFRAME (frame)))
+  if (FRAME_HAS_MINIBUF_P (f))
    {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
-      for (frames = Vframe_list;
+      FOR_EACH_FRAME (frames, this)
-           CONSP (frames);
-           frames = XCDR (frames))
        {
-          Lisp_Object this;
-          this = XCAR (frames);
          if (! EQ (this, frame)
              && EQ (frame,
                     WINDOW_FRAME (XWINDOW
@@ -1353,15 +1340,13 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
     another one.  */
  if (f == last_nonminibuf_frame)
    {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
      last_nonminibuf_frame = 0;
-      for (frames = Vframe_list;
+      FOR_EACH_FRAME (frames, this)
-           CONSP (frames);
-           frames = XCDR (frames))
        {
-          f = XFRAME (XCAR (frames));
+          f = XFRAME (this);
          if (!FRAME_MINIBUF_ONLY_P (f))
            {
              last_nonminibuf_frame = f;
@@ -1374,27 +1359,13 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
     single-kboard state if we're in it for this kboard.  */
  if (kb != NULL)
    {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
      /* Some frame we found on the same kboard, or nil if there are none.  */
-      Lisp_Object frame_on_same_kboard;
+      Lisp_Object frame_on_same_kboard = Qnil;
-      frame_on_same_kboard = Qnil;
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
-        {
-          Lisp_Object this;
-          struct frame *f1;
-          this = XCAR (frames);
+      FOR_EACH_FRAME (frames, this)
-          if (!FRAMEP (this))
+        if (kb == FRAME_KBOARD (XFRAME (this)))
-            emacs_abort ();
+          frame_on_same_kboard = this;
-          f1 = XFRAME (this);
-          if (kb == FRAME_KBOARD (f1))
-            frame_on_same_kboard = this;
-        }
      if (NILP (frame_on_same_kboard))
        not_single_kboard_state (kb);
@@ -1406,27 +1377,16 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
     frames with other windows.  */
  if (kb != NULL && EQ (frame, KVAR (kb, Vdefault_minibuffer_frame)))
    {
-      Lisp_Object frames;
+      Lisp_Object frames, this;
      /* The last frame we saw with a minibuffer, minibuffer-only or not.  */
-      Lisp_Object frame_with_minibuf;
+      Lisp_Object frame_with_minibuf = Qnil;
      /* Some frame we found on the same kboard, or nil if there are none.  */
-      Lisp_Object frame_on_same_kboard;
+      Lisp_Object frame_on_same_kboard = Qnil;
-      frame_on_same_kboard = Qnil;
+      FOR_EACH_FRAME (frames, this)
-      frame_with_minibuf = Qnil;
-      for (frames = Vframe_list;
-           CONSP (frames);
-           frames = XCDR (frames))
        {
-          Lisp_Object this;
+          struct frame *f1 = XFRAME (this);
-          struct frame *f1;
-          this = XCAR (frames);
-          if (!FRAMEP (this))
-            emacs_abort ();
-          f1 = XFRAME (this);
          /* Consider only frames on the same kboard
             and only those with minibuffers.  */
@@ -1665,25 +1625,23 @@ DEFUN ("make-frame-visible", Fmake_frame_visible, Smake_frame_visible,
 If omitted, FRAME defaults to the currently selected frame.  */)
  (Lisp_Object frame)
 {
-  if (NILP (frame))
+  struct frame *f = decode_live_frame (frame);
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (FRAME_WINDOW_P (XFRAME (frame)))
+  if (FRAME_WINDOW_P (f))
    {
-      FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
+      FRAME_SAMPLE_VISIBILITY (f);
-      x_make_frame_visible (XFRAME (frame));
+      x_make_frame_visible (f);
    }
 #endif
-  make_frame_visible_1 (XFRAME (frame)->root_window);
+  make_frame_visible_1 (f->root_window);
  /* Make menu bar update for the Buffers and Frames menus.  */
  windows_or_buffers_changed++;
+  XSETFRAME (frame, f);
  return frame;
 }
@@ -1724,16 +1682,13 @@ always considered visible, whether or not they are currently being
 displayed in the terminal.  */)
  (Lisp_Object frame, Lisp_Object force)
 {
-  if (NILP (frame))
+  struct frame *f = decode_live_frame (frame);
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  if (NILP (force) && !other_visible_frames (XFRAME (frame)))
+  if (NILP (force) && !other_visible_frames (f))
    error ("Attempt to make invisible the sole visible or iconified frame");
  /* Don't allow minibuf_window to remain on a deleted frame.  */
-  if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
+  if (EQ (f->minibuffer_window, minibuf_window))
    {
      struct frame *sf = XFRAME (selected_frame);
      /* Use set_window_buffer instead of Fset_window_buffer (see
@@ -1745,8 +1700,8 @@ displayed in the terminal.  */)
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (FRAME_WINDOW_P (XFRAME (frame)))
+  if (FRAME_WINDOW_P (f))
-    x_make_frame_invisible (XFRAME (frame));
+    x_make_frame_invisible (f);
 #endif
  /* Make menu bar update for the Buffers and Frames menus.  */
@@ -1761,19 +1716,10 @@ DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
 If omitted, FRAME defaults to the currently selected frame.  */)
  (Lisp_Object frame)
 {
-  if (NILP (frame))
+  struct frame *f = decode_live_frame (frame);
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-#if 0 /* This isn't logically necessary, and it can do GC.  */
-  /* Don't let the frame remain selected.  */
-  if (EQ (frame, selected_frame))
-    Fhandle_switch_frame (next_frame (frame, Qt));
-#endif
  /* Don't allow minibuf_window to remain on an iconified frame.  */
-  if (EQ (XFRAME (frame)->minibuffer_window, minibuf_window))
+  if (EQ (f->minibuffer_window, minibuf_window))
    {
      struct frame *sf = XFRAME (selected_frame);
      /* Use set_window_buffer instead of Fset_window_buffer (see
@@ -1785,8 +1731,8 @@ If omitted, FRAME defaults to the currently selected frame.  */)
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (FRAME_WINDOW_P (XFRAME (frame)))
+  if (FRAME_WINDOW_P (f))
-      x_iconify_frame (XFRAME (frame));
+      x_iconify_frame (f);
 #endif
  /* Make menu bar update for the Buffers and Frames menus.  */
@@ -1824,20 +1770,12 @@ DEFUN ("visible-frame-list", Fvisible_frame_list, Svisible_frame_list,
       doc: /* Return a list of all frames now \"visible\" (being updated).  */)
  (void)
 {
-  Lisp_Object tail, frame;
+  Lisp_Object tail, frame, value = Qnil;
-  struct frame *f;
-  Lisp_Object value;
+  FOR_EACH_FRAME (tail, frame)
+    if (FRAME_VISIBLE_P (XFRAME (frame)))
+      value = Fcons (frame, value);
-  value = Qnil;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
-    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
-      f = XFRAME (frame);
-      if (FRAME_VISIBLE_P (f))
-        value = Fcons (frame, value);
-    }
  return value;
 }
@@ -1850,13 +1788,9 @@ If Emacs is displaying on an ordinary terminal or some other device which
 doesn't support multiple overlapping frames, this function selects FRAME.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
+  XSETFRAME (frame, f);
  if (FRAME_TERMCAP_P (f))
    /* On a text terminal select FRAME.  */
@@ -1879,14 +1813,7 @@ If Emacs is displaying on an ordinary terminal or some other device which
 doesn't support multiple overlapping frames, this function does nothing.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
    (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
@@ -1922,18 +1849,14 @@ is affected by `select-frame', while the latter is not.
 The redirection lasts until `redirect-frame-focus' is called to change it.  */)
  (Lisp_Object frame, Lisp_Object focus_frame)
 {
-  struct frame *f;
  /* Note that we don't check for a live frame here.  It's reasonable
     to redirect the focus of a frame you're about to delete, if you
     know what other frame should receive those keystrokes.  */
-  CHECK_FRAME (frame);
+  struct frame *f = decode_any_frame (frame);
  if (! NILP (focus_frame))
    CHECK_LIVE_FRAME (focus_frame);
-  f = XFRAME (frame);
  fset_focus_frame (f, focus_frame);
  if (FRAME_TERMINAL (f)->frame_rehighlight_hook)
@@ -1943,15 +1866,14 @@ The redirection lasts until `redirect-frame-focus' is called to change it.  */)
 }
-DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 1, 1, 0,
+DEFUN ("frame-focus", Fframe_focus, Sframe_focus, 0, 1, 0,
       doc: /* Return the frame to which FRAME's keystrokes are currently being sent.
-This returns nil if FRAME's focus is not redirected.
+If FRAME is omitted or nil, the selected frame is used.
+Return nil if FRAME's focus is not redirected.
 See `redirect-frame-focus'.  */)
  (Lisp_Object frame)
 {
-  CHECK_LIVE_FRAME (frame);
+  return FRAME_FOCUS_FRAME (decode_live_frame (frame));
-  return FRAME_FOCUS_FRAME (XFRAME (frame));
 }
@@ -1974,22 +1896,6 @@ get_frame_param (register struct frame *frame, Lisp_Object prop)
 }
 #endif
-/* Return the buffer-predicate of the selected frame.  */
-Lisp_Object
-frame_buffer_predicate (Lisp_Object frame)
-{
-  return XFRAME (frame)->buffer_predicate;
-}
-/* Return the buffer-list of the selected frame.  */
-static Lisp_Object
-frame_buffer_list (Lisp_Object frame)
-{
-  return XFRAME (frame)->buffer_list;
-}
 /* Discard BUFFER from the buffer-list and buried-buffer-list of each frame.  */
 void
@@ -2168,20 +2074,14 @@ DEFUN ("frame-parameters", Fframe_parameters, Sframe_parameters, 0, 1, 0,
       doc: /* Return the parameters-alist of frame FRAME.
 It is a list of elements of the form (PARM . VALUE), where PARM is a symbol.
 The meaningful PARMs depend on the kind of frame.
-If FRAME is omitted, return information on the currently selected frame.  */)
+If FRAME is omitted or nil, return information on the currently selected frame.  */)
  (Lisp_Object frame)
 {
  Lisp_Object alist;
-  FRAME_PTR f;
+  struct frame *f = decode_any_frame (frame);
  int height, width;
  struct gcpro gcpro1;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
  if (!FRAME_LIVE_P (f))
    return Qnil;
@@ -2242,9 +2142,8 @@ If FRAME is omitted, return information on the currently selected frame.  */)
                   : FRAME_MINIBUF_ONLY_P (f) ? Qonly
                   : FRAME_MINIBUF_WINDOW (f)));
  store_in_alist (&alist, Qunsplittable, (FRAME_NO_SPLIT_P (f) ? Qt : Qnil));
-  store_in_alist (&alist, Qbuffer_list, frame_buffer_list (frame));
+  store_in_alist (&alist, Qbuffer_list, f->buffer_list);
-  store_in_alist (&alist, Qburied_buffer_list,
+  store_in_alist (&alist, Qburied_buffer_list, f->buried_buffer_list);
-                  XFRAME (frame)->buried_buffer_list);
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -2269,17 +2168,12 @@ DEFUN ("frame-parameter", Fframe_parameter, Sframe_parameter, 2, 2, 0,
 If FRAME is nil, describe the currently selected frame.  */)
  (Lisp_Object frame, Lisp_Object parameter)
 {
-  struct frame *f;
+  struct frame *f = decode_any_frame (frame);
-  Lisp_Object value;
+  Lisp_Object value = Qnil;
-  if (NILP (frame))
-    frame = selected_frame;
-  else
-    CHECK_FRAME (frame);
  CHECK_SYMBOL (parameter);
-  f = XFRAME (frame);
+  XSETFRAME (frame, f);
-  value = Qnil;
  if (FRAME_LIVE_P (f))
    {
@@ -2359,14 +2253,9 @@ Note that this functionality is obsolete as of Emacs 22.2, and its
 use is not recommended.  Explicitly check for a frame-parameter instead.  */)
  (Lisp_Object frame, Lisp_Object alist)
 {
-  FRAME_PTR f;
+  struct frame *f = decode_live_frame (frame);
  register Lisp_Object tail, prop, val;
-  if (EQ (frame, Qnil))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
  if (FRAME_WINDOW_P (f))
@@ -2421,18 +2310,13 @@ use is not recommended.  Explicitly check for a frame-parameter instead.  */)
 DEFUN ("frame-char-height", Fframe_char_height, Sframe_char_height,
       0, 1, 0,
       doc: /* Height in pixels of a line in the font in frame FRAME.
-If FRAME is omitted, the selected frame is used.
+If FRAME is omitted or nil, the selected frame is used.
 For a terminal frame, the value is always 1.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
 #ifdef HAVE_WINDOW_SYSTEM
+  struct frame *f = decode_any_frame (frame);
  if (FRAME_WINDOW_P (f))
    return make_number (x_char_height (f));
  else
@@ -2444,19 +2328,14 @@ For a terminal frame, the value is always 1.  */)
 DEFUN ("frame-char-width", Fframe_char_width, Sframe_char_width,
       0, 1, 0,
       doc: /* Width in pixels of characters in the font in frame FRAME.
-If FRAME is omitted, the selected frame is used.
+If FRAME is omitted or nil, the selected frame is used.
 On a graphical screen, the width is the standard width of the default font.
 For a terminal screen, the value is always 1.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
 #ifdef HAVE_WINDOW_SYSTEM
+  struct frame *f = decode_any_frame (frame);
  if (FRAME_WINDOW_P (f))
    return make_number (x_char_width (f));
  else
@@ -2467,7 +2346,7 @@ For a terminal screen, the value is always 1.  */)
 DEFUN ("frame-pixel-height", Fframe_pixel_height,
       Sframe_pixel_height, 0, 1, 0,
       doc: /* Return a FRAME's height in pixels.
-If FRAME is omitted, the selected frame is used.  The exact value
+If FRAME is omitted or nil, the selected frame is used.  The exact value
 of the result depends on the window-system and toolkit in use:
 In the Gtk+ version of Emacs, it includes only any window (including
@@ -2482,12 +2361,7 @@ result is really in characters rather than pixels (i.e., is identical
 to `frame-height'). */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_any_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
 #ifdef HAVE_WINDOW_SYSTEM
  if (FRAME_WINDOW_P (f))
@@ -2501,15 +2375,10 @@ DEFUN ("frame-pixel-width", Fframe_pixel_width,
       Sframe_pixel_width, 0, 1, 0,
       doc: /* Return FRAME's width in pixels.
 For a terminal frame, the result really gives the width in characters.
-If FRAME is omitted, the selected frame is used.  */)
+If FRAME is omitted or nil, the selected frame is used.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_any_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
 #ifdef HAVE_WINDOW_SYSTEM
  if (FRAME_WINDOW_P (f))
@@ -2523,17 +2392,15 @@ DEFUN ("tool-bar-pixel-width", Ftool_bar_pixel_width,
       Stool_bar_pixel_width, 0, 1, 0,
       doc: /* Return width in pixels of FRAME's tool bar.
 The result is greater than zero only when the tool bar is on the left
-or right side of FRAME.  If FRAME is omitted, the selected frame is
+or right side of FRAME.  If FRAME is omitted or nil, the selected frame
-used.  */)
+is used.  */)
  (Lisp_Object frame)
 {
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
 #ifdef FRAME_TOOLBAR_WIDTH
-  if (FRAME_WINDOW_P (XFRAME (frame)))
+  struct frame *f = decode_any_frame (frame);
-    return make_number (FRAME_TOOLBAR_WIDTH (XFRAME (frame)));
+  if (FRAME_WINDOW_P (f))
+    return make_number (FRAME_TOOLBAR_WIDTH (f));
 #endif
  return make_number (0);
 }
@@ -2544,13 +2411,9 @@ Optional third arg non-nil means that redisplay should use LINES lines
 but that the idea of the actual height of the frame should not be changed.  */)
  (Lisp_Object frame, Lisp_Object lines, Lisp_Object pretend)
 {
-  register struct frame *f;
+  register struct frame *f = decode_live_frame (frame);
  CHECK_TYPE_RANGED_INTEGER (int, lines);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -2572,12 +2435,9 @@ Optional third arg non-nil means that redisplay should use COLS columns
 but that the idea of the actual width of the frame should not be changed.  */)
  (Lisp_Object frame, Lisp_Object cols, Lisp_Object pretend)
 {
-  register struct frame *f;
+  register struct frame *f = decode_live_frame (frame);
  CHECK_TYPE_RANGED_INTEGER (int, cols);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -4294,12 +4154,7 @@ Otherwise it returns nil.  FRAME omitted or nil means the
 selected frame.  This is useful when `make-pointer-invisible' is set.  */)
  (Lisp_Object frame)
 {
-  if (NILP (frame))
+  return decode_any_frame (frame)->pointer_invisible ? Qnil : Qt;
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  return (XFRAME (frame)->pointer_invisible ? Qnil : Qt);
 }
diff --git a/src/frame.h b/src/frame.h
index f8c3d99fedd..35cbc44becc 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -237,7 +237,7 @@ struct frame
 #if defined (USE_GTK) || defined (HAVE_NS)
  /* Nonzero means using a tool bar that comes from the toolkit.  */
-  int external_tool_bar;
+  unsigned external_tool_bar : 1;
 #endif
  /* Margin at the top of the frame.  Used to display the tool-bar.  */
@@ -409,10 +409,6 @@ struct frame
     show no modeline for that window.  */
  unsigned wants_modeline : 1;
-  /* Non-zero if the hardware device this frame is displaying on can
-     support scroll bars.  */
-  char can_have_scroll_bars;
  /* Non-0 means raise this frame to the top of the heap when selected.  */
  unsigned auto_raise : 1;
@@ -438,8 +434,7 @@ struct frame
  /* Nonzero means that the pointer is invisible. */
  unsigned pointer_invisible :1;
-  /* If can_have_scroll_bars is non-zero, this is non-zero if we should
+  /* Nonzero if we should actually display the scroll bars on this frame.  */
-     actually display them on this frame.  */
  enum vertical_scroll_bar_type vertical_scroll_bar_type;
  /* What kind of text cursor should we draw in the future?
@@ -767,11 +762,6 @@ typedef struct frame *FRAME_PTR;
 #define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
 #define FRAME_FOCUS_FRAME(f) f->focus_frame
-/* Nonzero if frame F supports scroll bars.
-   If this is zero, then it is impossible to enable scroll bars
-   on frame F.  */
-#define FRAME_CAN_HAVE_SCROLL_BARS(f) ((f)->can_have_scroll_bars)
 /* This frame slot says whether scroll bars are currently enabled for frame F,
   and which side they are on.  */
 #define FRAME_VERTICAL_SCROLL_BAR_TYPE(f) ((f)->vertical_scroll_bar_type)
@@ -953,6 +943,8 @@ extern Lisp_Object Qnoelisp;
 extern struct frame *last_nonminibuf_frame;
 extern void set_menu_bar_lines (struct frame *, Lisp_Object, Lisp_Object);
+extern struct frame *decode_live_frame (Lisp_Object);
+extern struct frame *decode_any_frame (Lisp_Object);
 extern struct frame *make_initial_frame (void);
 extern struct frame *make_frame (int);
 #ifdef HAVE_WINDOW_SYSTEM
diff --git a/src/fringe.c b/src/fringe.c
index d788503e91e..a126292e1ff 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1731,10 +1731,8 @@ Return nil if POS is not visible in WINDOW.  */)
  struct glyph_row *row;
  ptrdiff_t textpos;
-  if (NILP (window))
+  w = decode_any_window (window);
-    window = selected_window;
+  XSETWINDOW (window, w);
-  CHECK_WINDOW (window);
-  w = XWINDOW (window);
  if (!NILP (pos))
    {
diff --git a/src/image.c b/src/image.c
index 538ae2b7772..07db6cece1f 100644
--- a/src/image.c
+++ b/src/image.c
@@ -3731,10 +3731,10 @@ xpm_make_color_table_h (void (**put_func) (Lisp_Object,
 {
  *put_func = xpm_put_color_table_h;
  *get_func = xpm_get_color_table_h;
-  return make_hash_table (Qequal, make_number (DEFAULT_HASH_SIZE),
+  return make_hash_table (hashtest_equal, make_number (DEFAULT_HASH_SIZE),
                          make_float (DEFAULT_REHASH_SIZE),
                          make_float (DEFAULT_REHASH_THRESHOLD),
-                          Qnil, Qnil, Qnil);
+                          Qnil);
 }
 static void
diff --git a/src/indent.c b/src/indent.c
index bbc944d2518..eee96061e25 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1764,11 +1764,7 @@ visible section of the buffer, and pass LINE and COL as TOPOS.  */)
  else
    hscroll = tab_offset = 0;
-  if (NILP (window))
+  w = decode_live_window (window);
-    window = Fselected_window ();
-  else
-    CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
  if (XINT (from) < BEGV || XINT (from) > ZV)
    args_out_of_range_3 (from, make_number (BEGV), make_number (ZV));
@@ -1790,8 +1786,7 @@ visible section of the buffer, and pass LINE and COL as TOPOS.  */)
                               1))
                         : XINT (XCAR (topos))),
                        (NILP (width) ? -1 : XINT (width)),
-                        hscroll, tab_offset,
+                        hscroll, tab_offset, w);
-                        XWINDOW (window));
  XSETFASTINT (bufpos, pos->bufpos);
  XSETINT (hpos, pos->hpos);
@@ -1988,11 +1983,7 @@ whether or not it is currently displayed in some window.  */)
    }
  CHECK_NUMBER (lines);
-  if (! NILP (window))
+  w = decode_live_window (window);
-    CHECK_WINDOW (window);
-  else
-    window = selected_window;
-  w = XWINDOW (window);
  old_buffer = Qnil;
  GCPRO3 (old_buffer, old_charpos, old_bytepos);
diff --git a/src/keyboard.c b/src/keyboard.c
index 0029304ea8e..98c1cc0b78b 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3419,20 +3419,20 @@ int stop_character EXTERNALLY_VISIBLE;
 static KBOARD *
 event_to_kboard (struct input_event *event)
 {
-  Lisp_Object frame;
+  /* Not applicable for these special events.  */
-  frame = event->frame_or_window;
+  if (event->kind == SELECTION_REQUEST_EVENT
-  if (CONSP (frame))
+      || event->kind == SELECTION_CLEAR_EVENT)
-    frame = XCAR (frame);
+    return NULL;
-  else if (WINDOWP (frame))
-    frame = WINDOW_FRAME (XWINDOW (frame));
-  /* There are still some events that don't set this field.
-     For now, just ignore the problem.
-     Also ignore dead frames here.  */
-  if (!FRAMEP (frame) || !FRAME_LIVE_P (XFRAME (frame)))
-    return 0;
  else
-    return FRAME_KBOARD (XFRAME (frame));
+    {
+      Lisp_Object obj = event->frame_or_window;
+      /* There are some events that set this field to nil or string.  */
+      if (WINDOWP (obj))
+        obj = WINDOW_FRAME (XWINDOW (obj));
+      /* Also ignore dead frames here.  */
+      return ((FRAMEP (obj) && FRAME_LIVE_P (XFRAME (obj)))
+              ? FRAME_KBOARD (XFRAME (obj)) : NULL);
+    }
 }
 #ifdef subprocesses
@@ -12189,14 +12189,15 @@ mark_kboards (void)
      {
        if (event == kbd_buffer + KBD_BUFFER_SIZE)
          event = kbd_buffer;
+        /* These two special event types has no Lisp_Objects to mark.  */
        if (event->kind != SELECTION_REQUEST_EVENT
            && event->kind != SELECTION_CLEAR_EVENT)
          {
            mark_object (event->x);
            mark_object (event->y);
+            mark_object (event->frame_or_window);
+            mark_object (event->arg);
          }
-        mark_object (event->frame_or_window);
-        mark_object (event->arg);
      }
  }
 }
diff --git a/src/lisp.h b/src/lisp.h
index 7746b4e313e..c909287b7cd 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -160,11 +160,9 @@ enum Lisp_Bits
 #define GCTYPEBITS 3
        GCTYPEBITS,
-    /* 2**GCTYPEBITS.  This must also be a macro that expands to a
+    /* 2**GCTYPEBITS.  This must be a macro that expands to a literal
-       literal integer constant, for MSVC.  */
+       integer constant, for MSVC.  */
-    GCALIGNMENT =
 #define GCALIGNMENT 8
-        GCALIGNMENT,
    /* Number of bits in a Lisp_Object value, not counting the tag.  */
    VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS,
@@ -410,14 +408,11 @@ enum pvec_type
  PVEC_WINDOW_CONFIGURATION,
  PVEC_SUBR,
  PVEC_OTHER,
-  /* These last 4 are special because we OR them in fns.c:internal_equal,
+  /* These should be last, check internal_equal to see why.  */
-     so they have to use a disjoint bit pattern:
+  PVEC_COMPILED,
-     if (!(size & (PVEC_COMPILED | PVEC_CHAR_TABLE
+  PVEC_CHAR_TABLE,
-                   | PVEC_SUB_CHAR_TABLE | PVEC_FONT))) */
+  PVEC_SUB_CHAR_TABLE,
-  PVEC_COMPILED                 = 0x10,
+  PVEC_FONT /* Should be last because it's used for range checking.  */
-  PVEC_CHAR_TABLE               = 0x20,
-  PVEC_SUB_CHAR_TABLE           = 0x30,
-  PVEC_FONT                     = 0x40
 };
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
@@ -437,9 +432,18 @@ enum More_Lisp_Bits
       only the number of Lisp_Object fields (that need to be traced by GC).
       The distinction is used, e.g., by Lisp_Process, which places extra
       non-Lisp_Object fields at the end of the structure.  */
-    PSEUDOVECTOR_SIZE_BITS = 16,
+    PSEUDOVECTOR_SIZE_BITS = 12,
    PSEUDOVECTOR_SIZE_MASK = (1 << PSEUDOVECTOR_SIZE_BITS) - 1,
-    PVEC_TYPE_MASK = 0x0fff << PSEUDOVECTOR_SIZE_BITS,
+    /* To calculate the memory footprint of the pseudovector, it's useful
+       to store the size of non-Lisp area in word_size units here.  */
+    PSEUDOVECTOR_REST_BITS = 12,
+    PSEUDOVECTOR_REST_MASK = (((1 << PSEUDOVECTOR_REST_BITS) - 1)
+                              << PSEUDOVECTOR_SIZE_BITS),
+    /* Used to extract pseudovector subtype information.  */
+    PSEUDOVECTOR_AREA_BITS = PSEUDOVECTOR_SIZE_BITS + PSEUDOVECTOR_REST_BITS,
+    PVEC_TYPE_MASK = 0x3f << PSEUDOVECTOR_AREA_BITS,
    /* Number of bits to put in each character in the internal representation
       of bool vectors.  This should not vary across implementations.  */
@@ -450,9 +454,6 @@ enum More_Lisp_Bits
 For example, if tem is a Lisp_Object whose type is Lisp_Cons,
 XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
-/* Return a perfect hash of the Lisp_Object representation.  */
-#define XHASH(a) XLI (a)
 #if USE_LSB_TAG
 enum lsb_bits
@@ -505,6 +506,11 @@ static EMACS_INT const VALMASK
 #endif /* not USE_LSB_TAG */
+/* Return a (Lisp-integer sized) hash of the Lisp_Object value.  Happens to be
+   like XUINT right now, but XUINT should only be applied to objects we know
+   are integers.  */
+#define XHASH(a) XUINT (a)
 /* For integers known to be positive, XFASTINT sometimes provides
   faster retrieval and XSETFASTINT provides faster storage.
   If not, fallback on the non-accelerated path.  */
@@ -520,17 +526,12 @@ static EMACS_INT const VALMASK
 # define XUNTAG(a, type) XPNTR (a)
 #endif
-#define EQ(x, y) (XHASH (x) == XHASH (y))
+#define EQ(x, y) (XLI (x) == XLI (y))
 /* Largest and smallest representable fixnum values.  These are the C
-   values.  They are macros for use in static initializers, and
+   values.  They are macros for use in static initializers.  */
-   constants for visibility to GDB.  */
-static EMACS_INT const MOST_POSITIVE_FIXNUM =
 #define MOST_POSITIVE_FIXNUM (EMACS_INT_MAX >> INTTYPEBITS)
-        MOST_POSITIVE_FIXNUM;
-static EMACS_INT const MOST_NEGATIVE_FIXNUM =
 #define MOST_NEGATIVE_FIXNUM (-1 - MOST_POSITIVE_FIXNUM)
-        MOST_NEGATIVE_FIXNUM;
 /* Value is non-zero if I doesn't fit into a Lisp fixnum.  It is
   written this way so that it also works if I is of unsigned
@@ -615,13 +616,13 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 /* Pseudovector types.  */
-#define XSETPVECTYPE(v, code) XSETTYPED_PVECTYPE (v, header.size, code)
+#define XSETPVECTYPE(v, code)                                           \
-#define XSETTYPED_PVECTYPE(v, size_member, code) \
+  ((v)->header.size |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS))
-  ((v)->size_member |= PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_SIZE_BITS))
+#define XSETPVECTYPESIZE(v, code, lispsize, restsize)           \
-#define XSETPVECTYPESIZE(v, code, sizeval) \
  ((v)->header.size = (PSEUDOVECTOR_FLAG                        \
-                       | ((code) << PSEUDOVECTOR_SIZE_BITS)     \
+                       | ((code) << PSEUDOVECTOR_AREA_BITS)     \
-                       | (sizeval)))
+                       | ((restsize) << PSEUDOVECTOR_SIZE_BITS) \
+                       | (lispsize)))
 /* The cast to struct vectorlike_header * avoids aliasing issues.  */
 #define XSETPSEUDOVECTOR(a, b, code) \
@@ -633,16 +634,14 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code)                        \
  (XSETVECTOR (a, b),                                                   \
   eassert ((size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))               \
-            == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_SIZE_BITS))))
+            == (PSEUDOVECTOR_FLAG | (code << PSEUDOVECTOR_AREA_BITS))))
 #define XSETWINDOW_CONFIGURATION(a, b) \
  (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW_CONFIGURATION))
 #define XSETPROCESS(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_PROCESS))
 #define XSETWINDOW(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_WINDOW))
 #define XSETTERMINAL(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_TERMINAL))
-/* XSETSUBR is special since Lisp_Subr lacks struct vectorlike_header.  */
+#define XSETSUBR(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_SUBR))
-#define XSETSUBR(a, b) \
-  XSETTYPED_PSEUDOVECTOR (a, b, XSUBR (a)->size, PVEC_SUBR)
 #define XSETCOMPILED(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_COMPILED))
 #define XSETBUFFER(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_BUFFER))
 #define XSETCHAR_TABLE(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_CHAR_TABLE))
@@ -809,7 +808,7 @@ struct Lisp_String
  };
 /* Header of vector-like objects.  This documents the layout constraints on
-   vectors and pseudovectors other than struct Lisp_Subr.  It also prevents
+   vectors and pseudovectors (objects of PVEC_xxx subtype).  It also prevents
   compilers from being fooled by Emacs's type punning: the XSETPSEUDOVECTOR
   and PSEUDOVECTORP macros cast their pointers to struct vectorlike_header *,
   because when two such pointers potentially alias, a compiler won't
@@ -817,43 +816,26 @@ struct Lisp_String
   <http://debbugs.gnu.org/cgi/bugreport.cgi?bug=8546>.  */
 struct vectorlike_header
  {
-    /* This field contains various pieces of information:
+    /* The only field contains various pieces of information:
       - The MSB (ARRAY_MARK_FLAG) holds the gcmarkbit.
       - The next bit (PSEUDOVECTOR_FLAG) indicates whether this is a plain
         vector (0) or a pseudovector (1).
       - If PSEUDOVECTOR_FLAG is 0, the rest holds the size (number
         of slots) of the vector.
-       - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into
+       - If PSEUDOVECTOR_FLAG is 1, the rest is subdivided into three fields:
-         a "pvec type" tag held in PVEC_TYPE_MASK and a size held in the lowest
+         - a) pseudovector subtype held in PVEC_TYPE_MASK field;
-         PSEUDOVECTOR_SIZE_BITS.  That size normally indicates the number of
+         - b) number of Lisp_Objects slots at the beginning of the object
-         Lisp_Object slots at the beginning of the object that need to be
+           held in PSEUDOVECTOR_SIZE_MASK field.  These objects are always
-         traced by the GC, tho some types use it slightly differently.
+           traced by the GC;
-       - E.g. if the pvec type is PVEC_FREE it means this is an unallocated
+         - c) size of the rest fields held in PSEUDOVECTOR_REST_MASK and
-         vector on a free-list and PSEUDOVECTOR_SIZE_BITS indicates its size
+           measured in word_size units.  Rest fields may also include
-         in bytes.  */
+           Lisp_Objects, but these objects usually needs some special treatment
+           during GC.
+         There are some exceptions.  For PVEC_FREE, b) is always zero.  For
+         PVEC_BOOL_VECTOR and PVEC_SUBR, both b) and c) are always zero.
+         Current layout limits the pseudovectors to 63 PVEC_xxx subtypes,
+         4095 Lisp_Objects in GC-ed area and 4095 word-sized other slots.  */
    ptrdiff_t size;
-    /* When the vector is allocated from a vector block, NBYTES is used
-       if the vector is not on a free list, and VECTOR is used otherwise.
-       For large vector-like objects, BUFFER or VECTOR is used as a pointer
-       to the next vector-like object.  It is generally a buffer or a
-       Lisp_Vector alias, so for convenience it is a union instead of a
-       pointer: this way, one can write P->next.vector instead of ((struct
-       Lisp_Vector *) P->next).  */
-    union {
-      /* This is only needed for small vectors that are not free because the
-         `size' field only gives us the number of Lisp_Object slots, whereas we
-         need to know the total size, including non-Lisp_Object data.
-         FIXME: figure out a way to store this info elsewhere so we can
-         finally get rid of this extra word of overhead.  */
-      ptrdiff_t nbytes;
-      struct buffer *buffer;
-      /* FIXME: This can be removed: For large vectors, this field could be
-         placed *before* the vector itself.  And for small vectors on a free
-         list, this field could be stored in the vector's bytes, since the
-         empty vector is handled specially anyway.  */
-      struct Lisp_Vector *vector;
-    } next;
  };
 /* Regular vector is just a header plus array of Lisp_Objects.  */
@@ -1027,15 +1009,11 @@ struct Lisp_Sub_Char_Table
 /* This structure describes a built-in function.
   It is generated by the DEFUN macro only.
-   defsubr makes it into a Lisp object.
+   defsubr makes it into a Lisp object.  */
-   This type is treated in most respects as a pseudovector,
-   but since we never dynamically allocate or free them,
-   we don't need a struct vectorlike_header and its 'next' field.  */
 struct Lisp_Subr
  {
-    ptrdiff_t size;
+    struct vectorlike_header header;
    union {
      Lisp_Object (*a0) (void);
      Lisp_Object (*a1) (Lisp_Object);
@@ -1183,14 +1161,29 @@ struct Lisp_Symbol
 /* The structure of a Lisp hash table.  */
+struct hash_table_test
+{
+  /* Name of the function used to compare keys.  */
+  Lisp_Object name;
+  /* User-supplied hash function, or nil.  */
+  Lisp_Object user_hash_function;
+  /* User-supplied key comparison function, or nil.  */
+  Lisp_Object user_cmp_function;
+  /* C function to compare two keys.  */
+  bool (*cmpfn) (struct hash_table_test *t, Lisp_Object, Lisp_Object);
+  /* C function to compute hash code.  */
+  EMACS_UINT (*hashfn) (struct hash_table_test *t, Lisp_Object);
+};
 struct Lisp_Hash_Table
 {
  /* This is for Lisp; the hash table code does not refer to it.  */
  struct vectorlike_header header;
-  /* Function used to compare keys.  */
-  Lisp_Object test;
  /* Nil if table is non-weak.  Otherwise a symbol describing the
     weakness of the table.  */
  Lisp_Object weak;
@@ -1221,12 +1214,6 @@ struct Lisp_Hash_Table
     hash table size to reduce collisions.  */
  Lisp_Object index;
-  /* User-supplied hash function, or nil.  */
-  Lisp_Object user_hash_function;
-  /* User-supplied key comparison function, or nil.  */
-  Lisp_Object user_cmp_function;
  /* Only the fields above are traced normally by the GC.  The ones below
     `count' are special and are either ignored by the GC or traced in
     a special way (e.g. because of weakness).  */
@@ -1239,17 +1226,12 @@ struct Lisp_Hash_Table
     This is gc_marked specially if the table is weak.  */
  Lisp_Object key_and_value;
+  /* The comparison and hash functions.  */
+  struct hash_table_test test;
  /* Next weak hash table if this is a weak hash table.  The head
     of the list is in weak_hash_tables.  */
  struct Lisp_Hash_Table *next_weak;
-  /* C function to compare two keys.  */
-  bool (*cmpfn) (struct Lisp_Hash_Table *,
-                 Lisp_Object, EMACS_UINT,
-                 Lisp_Object, EMACS_UINT);
-  /* C function to compute hash code.  */
-  EMACS_UINT (*hashfn) (struct Lisp_Hash_Table *, Lisp_Object);
 };
@@ -1304,6 +1286,15 @@ static double const DEFAULT_REHASH_THRESHOLD = 0.8;
 static double const DEFAULT_REHASH_SIZE = 1.5;
+/* Combine two integers X and Y for hashing.  The result might not fit
+   into a Lisp integer.  */
+LISP_INLINE EMACS_UINT
+sxhash_combine (EMACS_UINT x, EMACS_UINT y)
+{
+  return (x << 4) + (x >> (BITS_PER_EMACS_INT - 4)) + y;
+}
 /* These structures are used for various misc types.  */
 struct Lisp_Misc_Any            /* Supertype of all Misc types.  */
@@ -1703,6 +1694,8 @@ typedef struct {
 #define MARKERP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Marker)
 #define SAVE_VALUEP(x) (MISCP (x) && XMISCTYPE (x) == Lisp_Misc_Save_Value)
+#define AUTOLOADP(x) (CONSP (x) && EQ (Qautoload, XCAR (x)))
 #define INTFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Int)
 #define BOOLFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Bool)
 #define OBJFWDP(x) (XFWDTYPE (x) == Lisp_Fwd_Obj)
@@ -1716,7 +1709,7 @@ typedef struct {
 #define PSEUDOVECTOR_TYPEP(v, code)                                     \
  (((v)->size & (PSEUDOVECTOR_FLAG | PVEC_TYPE_MASK))                   \
-   == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_SIZE_BITS)))
+   == (PSEUDOVECTOR_FLAG | ((code) << PSEUDOVECTOR_AREA_BITS)))
 /* True if object X, with internal type struct T *, is a pseudovector whose
   code is CODE.  */
@@ -1729,8 +1722,7 @@ typedef struct {
 #define PROCESSP(x) PSEUDOVECTORP (x, PVEC_PROCESS)
 #define WINDOWP(x) PSEUDOVECTORP (x, PVEC_WINDOW)
 #define TERMINALP(x) PSEUDOVECTORP (x, PVEC_TERMINAL)
-/* SUBRP is special since Lisp_Subr lacks struct vectorlike_header.  */
+#define SUBRP(x) PSEUDOVECTORP (x, PVEC_SUBR)
-#define SUBRP(x) TYPED_PSEUDOVECTORP (x, Lisp_Subr, PVEC_SUBR)
 #define COMPILEDP(x) PSEUDOVECTORP (x, PVEC_COMPILED)
 #define BUFFERP(x) PSEUDOVECTORP (x, PVEC_BUFFER)
 #define CHAR_TABLE_P(x) PSEUDOVECTORP (x, PVEC_CHAR_TABLE)
@@ -1791,20 +1783,6 @@ typedef struct {
 #define CHECK_WINDOW_CONFIGURATION(x) \
  CHECK_TYPE (WINDOW_CONFIGURATIONP (x), Qwindow_configuration_p, x)
-/* A window of any sort, leaf or interior, is "valid" if one of its
-   buffer, vchild, or hchild members is non-nil.  */
-#define CHECK_VALID_WINDOW(x)                           \
-  CHECK_TYPE (WINDOWP (x)                               \
-              && (!NILP (XWINDOW (x)->buffer)           \
-                  || !NILP (XWINDOW (x)->vchild)        \
-                  || !NILP (XWINDOW (x)->hchild)),      \
-              Qwindow_valid_p, x)
-/* A window is "live" if and only if it shows a buffer.  */
-#define CHECK_LIVE_WINDOW(x)                                            \
-  CHECK_TYPE (WINDOWP (x) && !NILP (XWINDOW (x)->buffer),               \
-              Qwindow_live_p, x)
 #define CHECK_PROCESS(x) \
  CHECK_TYPE (PROCESSP (x), Qprocessp, x)
@@ -1919,8 +1897,8 @@ typedef struct {
 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                          \
   static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
-   { (PVEC_SUBR << PSEUDOVECTOR_SIZE_BITS)                              \
+   { { (PVEC_SUBR << PSEUDOVECTOR_AREA_BITS)                            \
-     | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),                \
+       | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)) },            \
      { (Lisp_Object (__cdecl *)(void))fnname },                        \
       minargs, maxargs, lname, intspec, 0};                            \
   Lisp_Object fnname
@@ -1928,8 +1906,8 @@ typedef struct {
 #define DEFUN(lname, fnname, sname, minargs, maxargs, intspec, doc)     \
   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                          \
   static struct Lisp_Subr alignas (GCALIGNMENT) sname =                \
-     { PVEC_SUBR << PSEUDOVECTOR_SIZE_BITS,                             \
+     { { PVEC_SUBR << PSEUDOVECTOR_AREA_BITS },                         \
-      { .a ## maxargs = fnname },                                       \
+       { .a ## maxargs = fnname },                                      \
       minargs, maxargs, lname, intspec, 0};                            \
   Lisp_Object fnname
 #endif
@@ -2658,9 +2636,6 @@ extern Lisp_Object Qfont_spec, Qfont_entity, Qfont_object;
 EXFUN (Fbyteorder, 0) ATTRIBUTE_CONST;
-/* Defined in frame.c.  */
-extern Lisp_Object Qframep;
 /* Defined in data.c.  */
 extern Lisp_Object indirect_function (Lisp_Object);
 extern Lisp_Object find_symbol_value (Lisp_Object);
@@ -2746,15 +2721,15 @@ extern Lisp_Object larger_vector (Lisp_Object, ptrdiff_t, ptrdiff_t);
 extern void sweep_weak_hash_tables (void);
 extern Lisp_Object Qcursor_in_echo_area;
 extern Lisp_Object Qstring_lessp;
-extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq, Qeql;
+extern Lisp_Object QCsize, QCtest, QCweakness, Qequal, Qeq;
 EMACS_UINT hash_string (char const *, ptrdiff_t);
 EMACS_UINT sxhash (Lisp_Object, int);
-Lisp_Object make_hash_table (Lisp_Object, Lisp_Object, Lisp_Object,
+Lisp_Object make_hash_table (struct hash_table_test, Lisp_Object, Lisp_Object,
-                             Lisp_Object, Lisp_Object, Lisp_Object,
+                             Lisp_Object, Lisp_Object);
-                             Lisp_Object);
 ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, EMACS_UINT *);
 ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
                    EMACS_UINT);
+extern struct hash_table_test hashtest_eql, hashtest_equal;
 extern Lisp_Object substring_both (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t);
@@ -2976,7 +2951,7 @@ extern void make_byte_code (struct Lisp_Vector *);
 extern Lisp_Object Qautomatic_gc;
 extern Lisp_Object Qchar_table_extra_slots;
 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
-extern struct Lisp_Vector *allocate_pseudovector (int memlen, int lisplen, int tag);
+extern struct Lisp_Vector *allocate_pseudovector (int, int, enum pvec_type);
 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag)                            \
  ((typ*)                                                               \
   allocate_pseudovector                                                \
@@ -3328,7 +3303,6 @@ extern Lisp_Object do_switch_frame (Lisp_Object, int, int, Lisp_Object);
 #if HAVE_NS
 extern Lisp_Object get_frame_param (struct frame *, Lisp_Object);
 #endif
-extern Lisp_Object frame_buffer_predicate (Lisp_Object);
 extern void frames_discard_buffer (Lisp_Object);
 extern void syms_of_frame (void);
diff --git a/src/lisp.mk b/src/lisp.mk
index 1f459d4d5f1..8c2710110e3 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -34,9 +34,9 @@
 ## that does not have an explicit .el extension, but beware of any
 ## no-byte-compile ones.
-## Confusingly, term/internal is not in loadup, but is unconditionally
+## Confusingly, international/cp51932 and international/eucjp-ms are
-## loaded by pc-win, which is.  Ditto for international/cp51932 and
+## unconditionally loaded from language/japanese, instead of being
-## international/eucjp-ms, loaded from language/japanese.
+## loaded directly from loadup.el; FIXME.
 ## Note that this list should not include lisp files which might not
 ## be present, like site-load.el and site-init.el; this makefile
diff --git a/src/lread.c b/src/lread.c
index 94744620279..3a82e0057e2 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -3981,7 +3981,7 @@ defsubr (struct Lisp_Subr *sname)
 {
  Lisp_Object sym, tem;
  sym = intern_c_string (sname->symbol_name);
-  XSETTYPED_PVECTYPE (sname, size, PVEC_SUBR);
+  XSETPVECTYPE (sname, PVEC_SUBR);
  XSETSUBR (tem, sname);
  set_symbol_function (sym, tem);
 }
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 7cb6667c7ea..50e5e2ec4df 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -1476,8 +1476,8 @@ $(BLD)/unexw32.$(O) : \
        $(SRC)/w32.h \
        $(SRC)/w32common.h \
        $(SRC)/w32heap.h \
-        $(LISP_H) \
+        $(CONFIG_H) \
-        $(CONFIG_H)
+        $(LISP_H)
 $(BLD)/vm-limit.$(O) : \
        $(SRC)/vm-limit.c \
@@ -1565,6 +1565,7 @@ $(BLD)/w32fns.$(O) : \
        $(SRC)/w32.h \
        $(SRC)/w32common.h \
        $(SRC)/w32heap.h \
+        $(NT_INC)/unistd.h \
        $(BUFFER_H) \
        $(CCL_H) \
        $(CHARACTER_H) \
diff --git a/src/msdos.c b/src/msdos.c
index bac6b977fdf..dd05a8b2c5d 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -3305,7 +3305,7 @@ XMenuActivate (Display *foo, XMenu *menu, int *pane, int *selidx,
     Emacs will process them after we return and surprise the user.  */
  discard_mouse_events ();
  mouse_clear_clicks ();
-  if (!kbd_buffer_events_waiting (1))
+  if (!kbd_buffer_events_waiting ())
    clear_input_pending ();
  /* Allow mouse events generation by dos_rawgetc.  */
  mouse_preempted--;
@@ -3927,8 +3927,10 @@ croak (char *badfunc)
 /*
 * A few unimplemented functions that we silently ignore.
 */
-int setpgrp (void) {return 0; }
+pid_t tcgetpgrp (int fd) { return 0; }
+int setpgid (int pid, int pgid) { return 0; }
 int setpriority (int x, int y, int z) { return 0; }
+pid_t setsid (void) { return 0; }
 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 4
 ssize_t
@@ -4214,8 +4216,8 @@ init_gettimeofday (void)
 }
 #endif
-void
+static void
-emacs_abort (void)
+msdos_abort (void)
 {
  dos_ttcooked ();
  ScreenSetCursor (10, 0);
@@ -4233,6 +4235,15 @@ emacs_abort (void)
 }
 void
+msdos_fatal_signal (int sig)
+{
+  if (sig == SIGABRT)
+    msdos_abort ();
+  else
+    raise (sig);
+}
+void
 syms_of_msdos (void)
 {
  recent_doskeys = Fmake_vector (make_number (NUM_RECENT_DOSKEYS), Qnil);
diff --git a/src/nsfns.m b/src/nsfns.m
index 7a22ac547c3..e8bf696e7f5 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1175,7 +1175,6 @@ This function is an internal primitive--use `make-frame' instead.  */)
      f = make_frame (1);
  XSETFRAME (frame, f);
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
  f->terminal = dpyinfo->terminal;
diff --git a/src/nsfont.m b/src/nsfont.m
index 4f29d1d54a9..2ba38b7570e 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -46,8 +46,9 @@ Author: Adrian Robert (arobert@cogsci.ucsd.edu)
 #define NSFONT_TRACE 0
 extern Lisp_Object Qns;
-extern Lisp_Object Qnormal, Qbold, Qitalic, Qcondensed, Qexpanded;
+extern Lisp_Object Qnormal, Qbold, Qitalic;
 static Lisp_Object Qapple, Qroman, Qmedium;
+static Lisp_Object Qcondensed, Qexpanded;
 extern Lisp_Object Qappend;
 extern float ns_antialias_threshold;
 extern int ns_tmp_flags;
@@ -201,8 +202,8 @@ ns_descriptor_to_entity (NSFontDescriptor *desc,
                    make_number (100 + 100
                         * ns_attribute_fvalue (desc, NSFontSlantTrait)));*/
    FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
-                    traits & NSFontCondensedTrait ? Qcondensed :
+                    traits & NSFontCondensedTrait ? Qcondensed :
-                    traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
+                    traits & NSFontExpandedTrait ? Qexpanded : Qnormal);
 /*    FONT_SET_STYLE (font_entity, FONT_WIDTH_INDEX,
                    make_number (100 + 100
                         * ns_attribute_fvalue (desc, NSFontWidthTrait)));*/
@@ -559,7 +560,11 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
    if (isMatch)
        [fkeys removeObject: NSFontFamilyAttribute];
-    matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
+    if ([fkeys count] > 0)
+      matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
+    else
+      matchingDescs = [NSMutableArray array];
    if (NSFONT_TRACE)
        NSLog(@"Got desc %@ and found %d matching fonts from it: ", fdesc,
              [matchingDescs count]);
@@ -1507,6 +1512,8 @@ syms_of_nsfont (void)
 {
  nsfont_driver.type = Qns;
  register_font_driver (&nsfont_driver, NULL);
+  DEFSYM (Qcondensed, "condensed");
+  DEFSYM (Qexpanded, "expanded");
  DEFSYM (Qapple, "apple");
  DEFSYM (Qroman, "roman");
  DEFSYM (Qmedium, "medium");
diff --git a/src/nsterm.m b/src/nsterm.m
index 9b2e544c75b..7ba1608268b 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -100,6 +100,7 @@ static unsigned convert_ns_to_X_keysym[] =
  NSBeginFunctionKey,           0x58,
  NSSelectFunctionKey,          0x60,
  NSPrintFunctionKey,           0x61,
+  NSClearLineFunctionKey,       0x0B,
  NSExecuteFunctionKey,         0x62,
  NSInsertFunctionKey,          0x63,
  NSUndoFunctionKey,            0x65,
@@ -144,6 +145,23 @@ static unsigned convert_ns_to_X_keysym[] =
  NSNewlineCharacter,           0x0D,
  NSEnterCharacter,             0x8D,
+  0x41|NSNumericPadKeyMask,     0xAE,  /* KP_Decimal */
+  0x43|NSNumericPadKeyMask,     0xAA,  /* KP_Multiply */
+  0x45|NSNumericPadKeyMask,     0xAB,  /* KP_Add */
+  0x4B|NSNumericPadKeyMask,     0xAF,  /* KP_Divide */
+  0x4E|NSNumericPadKeyMask,     0xAD,  /* KP_Subtract */
+  0x51|NSNumericPadKeyMask,     0xBD,  /* KP_Equal */
+  0x52|NSNumericPadKeyMask,     0xB0,  /* KP_0 */
+  0x53|NSNumericPadKeyMask,     0xB1,  /* KP_1 */
+  0x54|NSNumericPadKeyMask,     0xB2,  /* KP_2 */
+  0x55|NSNumericPadKeyMask,     0xB3,  /* KP_3 */
+  0x56|NSNumericPadKeyMask,     0xB4,  /* KP_4 */
+  0x57|NSNumericPadKeyMask,     0xB5,  /* KP_5 */
+  0x58|NSNumericPadKeyMask,     0xB6,  /* KP_6 */
+  0x59|NSNumericPadKeyMask,     0xB7,  /* KP_7 */
+  0x5B|NSNumericPadKeyMask,     0xB8,  /* KP_8 */
+  0x5C|NSNumericPadKeyMask,     0xB9,  /* KP_9 */
  0x1B,                         0x1B   /* escape */
 };
@@ -4754,12 +4772,12 @@ not_in_argv (NSString *arg)
  Mouse_HLInfo *hlinfo = MOUSE_HL_INFO (emacsframe);
  int code;
  unsigned fnKeysym = 0;
-  int flags;
  static NSMutableArray *nsEvArray;
 #if !defined (NS_IMPL_COCOA) || MAC_OS_X_VERSION_MAX_ALLOWED < MAC_OS_X_VERSION_10_6
  static BOOL firstTime = YES;
 #endif
  int left_is_none;
+  unsigned int flags = [theEvent modifierFlags];
  NSTRACE (keyDown);
@@ -4810,7 +4828,10 @@ not_in_argv (NSString *arg)
      /* (Carbon way: [theEvent keyCode]) */
      /* is it a "function key"? */
-      fnKeysym = ns_convert_key (code);
+      fnKeysym = (code < 0x00ff && (flags&NSNumericPadKeyMask))
+        ? ns_convert_key ([theEvent keyCode] | NSNumericPadKeyMask)
+        : ns_convert_key (code);
      if (fnKeysym)
        {
          /* COUNTERHACK: map 'Delete' on upper-right main KB to 'Backspace',
@@ -4823,7 +4844,6 @@ not_in_argv (NSString *arg)
      /* are there modifiers? */
      emacs_event->modifiers = 0;
-      flags = [theEvent modifierFlags];
      if (flags & NSHelpKeyMask)
          emacs_event->modifiers |= hyper_modifier;
diff --git a/src/print.c b/src/print.c
index ccf0e8ed7cc..bf86be5622e 100644
--- a/src/print.c
+++ b/src/print.c
@@ -798,7 +798,7 @@ safe_debug_print (Lisp_Object arg)
  else
    fprintf (stderr, "#<%s_LISP_OBJECT 0x%08"pI"x>\r\n",
             !valid ? "INVALID" : "SOME",
-             XHASH (arg));
+             XLI (arg));
 }
@@ -1815,14 +1815,14 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
 #endif
          /* Implement a readable output, e.g.:
            #s(hash-table size 2 test equal data (k1 v1 k2 v2)) */
-          /* Always print the size. */
+          /* Always print the size.  */
          len = sprintf (buf, "#s(hash-table size %"pD"d", ASIZE (h->next));
          strout (buf, len, len, printcharfun);
-          if (!NILP (h->test))
+          if (!NILP (h->test.name))
            {
              strout (" test ", -1, -1, printcharfun);
-              print_object (h->test, printcharfun, escapeflag);
+              print_object (h->test.name, printcharfun, escapeflag);
            }
          if (!NILP (h->weak))
diff --git a/src/process.c b/src/process.c
index 77e99ead01f..43f0239d301 100644
--- a/src/process.c
+++ b/src/process.c
@@ -130,6 +130,10 @@ extern int sys_select (int, SELECT_TYPE *, SELECT_TYPE *, SELECT_TYPE *,
                       EMACS_TIME *, void *);
 #endif
+/* This is for DOS_NT ports.  FIXME: Remove this old portability cruft
+   by having DOS_NT ports implement waitpid instead of wait.  Nowadays
+   POSIXish hosts all define waitpid, WNOHANG, and WUNTRACED, as these
+   have been standard since POSIX.1-1988.  */
 #ifndef WNOHANG
 # undef waitpid
 # define waitpid(pid, status, options) wait (status)
@@ -795,9 +799,8 @@ get_process (register Lisp_Object name)
 #ifdef SIGCHLD
 /* Fdelete_process promises to immediately forget about the process, but in
   reality, Emacs needs to remember those processes until they have been
-   treated by the SIGCHLD handler; otherwise this handler would consider the
+   treated by the SIGCHLD handler and waitpid has been invoked on them;
-   process as being synchronous and say that the synchronous process is
+   otherwise they might fill up the kernel's process table.  */
-   dead.  */
 static Lisp_Object deleted_pid_list;
 #endif
@@ -1704,16 +1707,7 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
  if (inchannel > max_process_desc)
    max_process_desc = inchannel;
-  /* Until we store the proper pid, enable the SIGCHLD handler
+  /* This may signal an error. */
-     to recognize an unknown pid as standing for this process.
-     It is very important not to let this `marker' value stay
-     in the table after this function has returned; if it does
-     it might cause call-process to hang and subsequent asynchronous
-     processes to get their return values scrambled.  */
-  XPROCESS (process)->pid = -1;
-  /* This must be called after the above line because it may signal an
-     error. */
  setup_process_coding_systems (process);
  encoded_current_dir = ENCODE_FILE (current_dir);
@@ -1745,7 +1739,6 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
      /* Make the pty be the controlling terminal of the process.  */
 #ifdef HAVE_PTYS
      /* First, disconnect its current controlling terminal.  */
-#ifdef HAVE_SETSID
      /* We tried doing setsid only if pty_flag, but it caused
         process_set_signal to fail on SGI when using a pipe.  */
      setsid ();
@@ -1758,12 +1751,6 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
          ioctl (xforkin, TIOCSCTTY, 0);
 #endif
        }
-#else /* not HAVE_SETSID */
-      /* It's very important to call setpgid here and no time
-         afterwards.  Otherwise, we lose our controlling tty which
-         is set when we open the pty. */
-      setpgid (0, 0);
-#endif /* not HAVE_SETSID */
 #if defined (LDISC1)
      if (pty_flag && xforkin >= 0)
        {
@@ -1796,22 +1783,15 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
              ioctl (j, TIOCNOTTY, 0);
              emacs_close (j);
            }
-#ifndef USG
-          /* In order to get a controlling terminal on some versions
-             of BSD, it is necessary to put the process in pgrp 0
-             before it opens the terminal.  */
-          setpgid (0, 0);
-#endif
        }
 #endif /* TIOCNOTTY */
 #if !defined (DONT_REOPEN_PTY)
 /*** There is a suggestion that this ought to be a
-     conditional on TIOCSPGRP,
+     conditional on TIOCSPGRP, or !defined TIOCSCTTY.
-     or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
     Trying the latter gave the wrong results on Debian GNU/Linux 1.1;
     that system does seem to need this code, even though
-     both HAVE_SETSID and TIOCSCTTY are defined.  */
+     both TIOCSCTTY is defined.  */
        /* Now close the pty (if we had it open) and reopen it.
           This makes the pty the controlling terminal of the subprocess.  */
      if (pty_flag)
@@ -1880,6 +1860,8 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
 #endif
  XPROCESS (process)->pid = pid;
+  if (0 <= pid)
+    XPROCESS (process)->alive = 1;
  /* Stop blocking signals in the parent.  */
 #ifdef SIGCHLD
@@ -4437,7 +4419,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                  if (EMACS_TIME_LT (timer_delay, timeout))
                    {
                      timeout = timer_delay;
-                      timeout_reduced_for_timers = 1;
+                      timeout_reduced_for_timers = 1;
                    }
                }
              else
@@ -6273,9 +6255,35 @@ process has been transmitted to the serial port.  */)
  return process;
 }
-/* On receipt of a signal that a child status has changed, loop asking
+/* If the status of the process DESIRED has changed, return true and
-   about children with changed statuses until the system says there
+   set *STATUS to its exit status; otherwise, return false.
-   are no more.
+   If HAVE is nonnegative, assume that HAVE = waitpid (HAVE, STATUS, ...)
+   has already been invoked, and do not invoke waitpid again.  */
+static bool
+process_status_retrieved (pid_t desired, pid_t have, int *status)
+{
+  if (have < 0)
+    {
+      /* Invoke waitpid only with a known process ID; do not invoke
+         waitpid with a nonpositive argument.  Otherwise, Emacs might
+         reap an unwanted process by mistake.  For example, invoking
+         waitpid (-1, ...) can mess up glib by reaping glib's subprocesses,
+         so that another thread running glib won't find them.  */
+      do
+        have = waitpid (desired, status, WNOHANG | WUNTRACED);
+      while (have < 0 && errno == EINTR);
+    }
+  return have == desired;
+}
+/* If PID is nonnegative, the child process PID with wait status W has
+   changed its status; record this and return true.
+   If PID is negative, ignore W, and look for known child processes
+   of Emacs whose status have changed.  For each one found, record its new
+   status.
   All we do is change the status; we do not run sentinels or print
   notifications.  That is saved for the next time keyboard input is
@@ -6298,13 +6306,23 @@ process has been transmitted to the serial port.  */)
   ** Malloc WARNING: This should never call malloc either directly or
   indirectly; if it does, that is a bug  */
-/* Record the changed status of the child process PID with wait status W.  */
 void
 record_child_status_change (pid_t pid, int w)
 {
 #ifdef SIGCHLD
-  Lisp_Object proc;
-  struct Lisp_Process *p;
+# ifdef WNOHANG
+  /* On POSIXish hosts, record at most one child only if we already
+     know one child that has exited.  */
+  bool record_at_most_one_child = 0 <= pid;
+# else
+  /* On DOS_NT (the only porting target that lacks WNOHANG),
+     record the status of at most one child process, since the SIGCHLD
+     handler must return right away.  If any more processes want to
+     signal us, we will get another signal.  */
+  bool record_at_most_one_child = 1;
+# endif
  Lisp_Object tail;
  /* Find the process that signaled us, and record its status.  */
@@ -6312,68 +6330,69 @@ record_child_status_change (pid_t pid, int w)
  /* The process can have been deleted by Fdelete_process.  */
  for (tail = deleted_pid_list; CONSP (tail); tail = XCDR (tail))
    {
+      bool all_pids_are_fixnums
+        = (MOST_NEGATIVE_FIXNUM <= TYPE_MINIMUM (pid_t)
+           && TYPE_MAXIMUM (pid_t) <= MOST_POSITIVE_FIXNUM);
      Lisp_Object xpid = XCAR (tail);
-      if ((INTEGERP (xpid) && pid == XINT (xpid))
+      if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
-          || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
        {
-          XSETCAR (tail, Qnil);
+          pid_t deleted_pid;
-          return;
+          if (INTEGERP (xpid))
+            deleted_pid = XINT (xpid);
+          else
+            deleted_pid = XFLOAT_DATA (xpid);
+          if (process_status_retrieved (deleted_pid, pid, &w))
+            {
+              XSETCAR (tail, Qnil);
+              if (record_at_most_one_child)
+                return;
+            }
        }
    }
  /* Otherwise, if it is asynchronous, it is in Vprocess_alist.  */
-  p = 0;
  for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
    {
-      proc = XCDR (XCAR (tail));
+      Lisp_Object proc = XCDR (XCAR (tail));
-      p = XPROCESS (proc);
+      struct Lisp_Process *p = XPROCESS (proc);
-      if (EQ (p->type, Qreal) && p->pid == pid)
+      if (p->alive && process_status_retrieved (p->pid, pid, &w))
-        break;
+        {
-      p = 0;
+          /* Change the status of the process that was found.  */
-    }
+          p->tick = ++process_tick;
+          p->raw_status = w;
-  /* Look for an asynchronous process whose pid hasn't been filled
+          p->raw_status_new = 1;
-     in yet.  */
-  if (! p)
-    for (tail = Vprocess_alist; CONSP (tail); tail = XCDR (tail))
-      {
-        proc = XCDR (XCAR (tail));
-        p = XPROCESS (proc);
-        if (p->pid == -1)
-          break;
-        p = 0;
-      }
-  /* Change the status of the process that was found.  */
+          /* If process has terminated, stop waiting for its output.  */
-  if (p)
+          if (WIFSIGNALED (w) || WIFEXITED (w))
-    {
+            {
-      int clear_desc_flag = 0;
+              int clear_desc_flag = 0;
+              p->alive = 0;
+              if (p->infd >= 0)
+                clear_desc_flag = 1;
-      p->tick = ++process_tick;
+              /* clear_desc_flag avoids a compiler bug in Microsoft C.  */
-      p->raw_status = w;
+              if (clear_desc_flag)
-      p->raw_status_new = 1;
+                {
+                  FD_CLR (p->infd, &input_wait_mask);
+                  FD_CLR (p->infd, &non_keyboard_wait_mask);
+                }
+            }
-      /* If process has terminated, stop waiting for its output.  */
+          /* Tell wait_reading_process_output that it needs to wake up and
-      if ((WIFSIGNALED (w) || WIFEXITED (w))
+             look around.  */
-          && p->infd >= 0)
+          if (input_available_clear_time)
-        clear_desc_flag = 1;
+            *input_available_clear_time = make_emacs_time (0, 0);
-      /* We use clear_desc_flag to avoid a compiler bug in Microsoft C.  */
+          if (record_at_most_one_child)
-      if (clear_desc_flag)
+            return;
-        {
-          FD_CLR (p->infd, &input_wait_mask);
-          FD_CLR (p->infd, &non_keyboard_wait_mask);
        }
-      /* Tell wait_reading_process_output that it needs to wake up and
-         look around.  */
-      if (input_available_clear_time)
-        *input_available_clear_time = make_emacs_time (0, 0);
    }
-  /* There was no asynchronous process found for that pid: we have
-     a synchronous process.  */
+  if (0 <= pid)
-  else
    {
+      /* The caller successfully waited for a pid but no asynchronous
+         process was found for it, so this is a synchronous process.  */
      synch_process_alive = 0;
      /* Report the status of the synchronous process.  */
@@ -6392,38 +6411,10 @@ record_child_status_change (pid_t pid, int w)
 #ifdef SIGCHLD
-/* On some systems, the SIGCHLD handler must return right away.  If
-   any more processes want to signal us, we will get another signal.
-   Otherwise, loop around to use up all the processes that have
-   something to tell us.  */
-#if (defined WINDOWSNT \
-     || (defined USG && !defined GNU_LINUX \
-         && !(defined HPUX && defined WNOHANG)))
-enum { CAN_HANDLE_MULTIPLE_CHILDREN = 0 };
-#else
-enum { CAN_HANDLE_MULTIPLE_CHILDREN = 1 };
-#endif
 static void
 handle_child_signal (int sig)
 {
-  do
+  record_child_status_change (-1, 0);
-    {
-      pid_t pid;
-      int status;
-      do
-        pid = waitpid (-1, &status, WNOHANG | WUNTRACED);
-      while (pid < 0 && errno == EINTR);
-      /* PID == 0 means no processes found, PID == -1 means a real failure.
-         Either way, we have done all our job.  */
-      if (pid <= 0)
-        break;
-      record_child_status_change (pid, status);
-    }
-  while (CAN_HANDLE_MULTIPLE_CHILDREN);
 }
 static void
diff --git a/src/process.h b/src/process.h
index ce3d2e702cc..74d1a124060 100644
--- a/src/process.h
+++ b/src/process.h
@@ -142,6 +142,9 @@ struct Lisp_Process
    /* Flag to set coding-system of the process buffer from the
       coding_system used to decode process output.  */
    unsigned int inherit_coding_system_flag : 1;
+    /* Whether the process is alive, i.e., can be waited for.  Running
+       processes can be waited for, but exited and fake processes cannot.  */
+    unsigned int alive : 1;
    /* Record the process status in the raw form in which it comes from `wait'.
       This is to avoid consing in a signal handler.  The `raw_status_new'
       flag indicates that `raw_status' contains a new status that still
diff --git a/src/profiler.c b/src/profiler.c
index 51580710f28..3d8f7243d2f 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -35,6 +35,9 @@ saturated_add (EMACS_INT a, EMACS_INT b)
 typedef struct Lisp_Hash_Table log_t;
+static Lisp_Object Qprofiler_backtrace_equal;
+static struct hash_table_test hashtest_profiler;
 static Lisp_Object
 make_log (int heap_size, int max_stack_depth)
 {
@@ -42,10 +45,11 @@ make_log (int heap_size, int max_stack_depth)
     a special way.  This is OK as long as the object is not exposed
     to Elisp, i.e. until it is returned by *-profiler-log, after which
     it can't be used any more.  */
-  Lisp_Object log = make_hash_table (Qequal, make_number (heap_size),
+  Lisp_Object log = make_hash_table (hashtest_profiler,
+                                     make_number (heap_size),
                                     make_float (DEFAULT_REHASH_SIZE),
                                     make_float (DEFAULT_REHASH_THRESHOLD),
-                                     Qnil, Qnil, Qnil);
+                                     Qnil);
  struct Lisp_Hash_Table *h = XHASH_TABLE (log);
  /* What is special about our hash-tables is that the keys are pre-filled
@@ -238,8 +242,6 @@ handle_profiler_signal (int signal)
    cpu_gc_count = saturated_add (cpu_gc_count, 1);
  else
    {
-      Lisp_Object oquit;
-      bool saved_pending_signals;
      EMACS_INT count = 1;
 #ifdef HAVE_ITIMERSPEC
      if (profiler_timer_ok)
@@ -249,19 +251,8 @@ handle_profiler_signal (int signal)
          count += overruns;
        }
 #endif
-      /* record_backtrace uses hash functions that call Fequal, which
-         uses QUIT, which can call malloc, which can cause disaster in
-         a signal handler.  So inhibit QUIT.  */
-      oquit = Vinhibit_quit;
-      saved_pending_signals = pending_signals;
-      Vinhibit_quit = Qt;
-      pending_signals = 0;
      eassert (HASH_TABLE_P (cpu_log));
      record_backtrace (XHASH_TABLE (cpu_log), count);
-      Vinhibit_quit = oquit;
-      pending_signals = saved_pending_signals;
    }
 }
@@ -515,6 +506,66 @@ malloc_probe (size_t size)
  record_backtrace (XHASH_TABLE (memory_log), min (size, MOST_POSITIVE_FIXNUM));
 }
+DEFUN ("function-equal", Ffunction_equal, Sfunction_equal, 2, 2, 0,
+       doc: /* Return non-nil if F1 and F2 come from the same source.
+Used to determine if different closures are just different instances of
+the same lambda expression, or are really unrelated function.  */)
+     (Lisp_Object f1, Lisp_Object f2)
+{
+  bool res;
+  if (EQ (f1, f2))
+    res = true;
+  else if (COMPILEDP (f1) && COMPILEDP (f2))
+    res = EQ (AREF (f1, COMPILED_BYTECODE), AREF (f2, COMPILED_BYTECODE));
+  else if (CONSP (f1) && CONSP (f2) && CONSP (XCDR (f1)) && CONSP (XCDR (f2))
+           && EQ (Qclosure, XCAR (f1))
+           && EQ (Qclosure, XCAR (f2)))
+    res = EQ (XCDR (XCDR (f1)), XCDR (XCDR (f2)));
+  else
+    res = false;
+  return res ? Qt : Qnil;
+}
+static bool
+cmpfn_profiler (struct hash_table_test *t,
+                Lisp_Object bt1, Lisp_Object bt2)
+{
+  if (VECTORP (bt1) && VECTORP (bt2))
+    {
+      ptrdiff_t i, l = ASIZE (bt1);
+      if (l != ASIZE (bt2))
+        return false;
+      for (i = 0; i < l; i++)
+        if (NILP (Ffunction_equal (AREF (bt1, i), AREF (bt2, i))))
+          return false;
+      return true;
+    }
+  else
+    return EQ (bt1, bt2);
+}
+static EMACS_UINT
+hashfn_profiler (struct hash_table_test *ht, Lisp_Object bt)
+{
+  if (VECTORP (bt))
+    {
+      EMACS_UINT hash = 0;
+      ptrdiff_t i, l = ASIZE (bt);
+      for (i = 0; i < l; i++)
+        {
+          Lisp_Object f = AREF (bt, i);
+          EMACS_UINT hash1
+            = (COMPILEDP (f) ? XHASH (AREF (f, COMPILED_BYTECODE))
+               : (CONSP (f) && CONSP (XCDR (f)) && EQ (Qclosure, XCAR (f)))
+               ? XHASH (XCDR (XCDR (f))) : XHASH (f));
+          hash = sxhash_combine (hash, hash1);
+        }
+      return (hash & INTMASK);
+    }
+  else
+    return XHASH (bt);
+}
 void
 syms_of_profiler (void)
 {
@@ -527,6 +578,16 @@ If the log gets full, some of the least-seen call-stacks will be evicted
 to make room for new entries.  */);
  profiler_log_size = 10000;
+  DEFSYM (Qprofiler_backtrace_equal, "profiler-backtrace-equal");
+  {
+    struct hash_table_test test
+      = { Qprofiler_backtrace_equal, Qnil, Qnil,
+          cmpfn_profiler, hashfn_profiler };
+    hashtest_profiler = test;
+  }
+  defsubr (&Sfunction_equal);
 #ifdef PROFILER_CPU_SUPPORT
  profiler_cpu_running = NOT_RUNNING;
  cpu_log = Qnil;
diff --git a/src/ralloc.c b/src/ralloc.c
index 11897411930..e5bf76b0e6d 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -327,6 +327,8 @@ relinquish (void)
      if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
        {
+          heap_ptr lh_prev;
          /* This heap should have no blocs in it.  If it does, we
             cannot return it to the system.  */
          if (last_heap->first_bloc != NIL_BLOC
@@ -335,28 +337,26 @@ relinquish (void)
          /* Return the last heap, with its header, to the system.  */
          excess = (char *)last_heap->end - (char *)last_heap->start;
-          last_heap = last_heap->prev;
+          lh_prev = last_heap->prev;
-          last_heap->next = NIL_HEAP;
+          /* If the system doesn't want that much memory back, leave
+             last_heap unaltered to reflect that.  This can occur if
+             break_value is still within the original data segment.  */
+          if ((*real_morecore) (- excess) != 0)
+            {
+              last_heap = lh_prev;
+              last_heap->next = NIL_HEAP;
+            }
        }
      else
        {
          excess = (char *) last_heap->end
                        - (char *) ROUNDUP ((char *)last_heap->end - excess);
-          last_heap->end = (char *) last_heap->end - excess;
+          /* If the system doesn't want that much memory back, leave
-        }
+             the end of the last heap unchanged to reflect that.  This
+             can occur if break_value is still within the original
-      if ((*real_morecore) (- excess) == 0)
+             data segment.  */
-        {
+          if ((*real_morecore) (- excess) != 0)
-          /* If the system didn't want that much memory back, adjust
+            last_heap->end = (char *) last_heap->end - excess;
-             the end of the last heap to reflect that.  This can occur
-             if break_value is still within the original data segment.  */
-          last_heap->end = (char *) last_heap->end + excess;
-          /* Make sure that the result of the adjustment is accurate.
-             It should be, for the else clause above; the other case,
-             which returns the entire last heap to the system, seems
-             unlikely to trigger this mode of failure.  */
-          if (last_heap->end != (*real_morecore) (0))
-            emacs_abort ();
        }
    }
 }
diff --git a/src/regex.c b/src/regex.c
index 7443eff3977..1473551e6cc 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -28,7 +28,7 @@
     rather than at run-time, so that re_match can be reentrant.
 */
-/* AIX requires this to be the first thing in the file. */
+/* AIX requires this to be the first thing in the file.  */
 #if defined _AIX && !defined REGEX_MALLOC
  #pragma alloca
 #endif
diff --git a/src/sysdep.c b/src/sysdep.c
index 63eac5d9e09..aa9d0f38c3c 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -452,7 +452,7 @@ sys_suspend (void)
 #if defined (SIGTSTP) && !defined (MSDOS)
  {
-    pid_t pgrp = EMACS_GETPGRP (0);
+    pid_t pgrp = getpgrp ();
    EMACS_KILLPG (pgrp, SIGTSTP);
  }
@@ -709,7 +709,7 @@ static pid_t inherited_pgroup;
 void
 init_foreground_group (void)
 {
-  pid_t pgrp = EMACS_GETPGRP (0);
+  pid_t pgrp = getpgrp ();
  inherited_pgroup = getpid () == pgrp ? 0 : pgrp;
 }
diff --git a/src/systty.h b/src/systty.h
index b7f36c6c259..80bcaedf740 100644
--- a/src/systty.h
+++ b/src/systty.h
@@ -52,27 +52,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif /* not CDEL */
 #endif /* not _POSIX_VDISABLE */
-/* Get the number of characters queued for output.  */
-/* EMACS_OUTQSIZE(FD, int *SIZE) stores the number of characters
-   queued for output to the terminal FD in *SIZE, if FD is a tty.
-   Returns -1 if there was an error (i.e. FD is not a tty), 0
-   otherwise.  */
-#ifdef TIOCOUTQ
-#define EMACS_OUTQSIZE(fd, size) (ioctl ((fd), TIOCOUTQ, (size)))
-#endif
-/* Manipulate a terminal's current process group.  */
-/* EMACS_GETPGRP (arg) returns the process group of the process.  */
-#if defined (GETPGRP_VOID)
-#  define EMACS_GETPGRP(x) getpgrp()
-#else /* !GETPGRP_VOID */
-#  define EMACS_GETPGRP(x) getpgrp(x)
-#endif /* !GETPGRP_VOID */
 /* Manipulate a TTY's input/output processing parameters.  */
 /* struct emacs_tty is a structure used to hold the current tty
diff --git a/src/term.c b/src/term.c
index 74b02b0af27..578c701858f 100644
--- a/src/term.c
+++ b/src/term.c
@@ -133,10 +133,6 @@ enum no_color_bit
 static int max_frame_cols;
-/* Non-zero if we have dropped our controlling tty and therefore
-   should not open a frame on stdout. */
-static int no_controlling_tty;
 #ifdef HAVE_GPM
@@ -2918,36 +2914,9 @@ set_tty_hooks (struct terminal *terminal)
 static void
 dissociate_if_controlling_tty (int fd)
 {
-#ifndef DOS_NT
  pid_t pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
-  if (pgid != -1)
+  if (0 <= pgid)
-    {
+    setsid ();
-#if defined (USG5)
-      setpgrp ();
-      no_controlling_tty = 1;
-#elif defined (CYGWIN)
-      setsid ();
-      no_controlling_tty = 1;
-#else
-#ifdef TIOCNOTTY                /* Try BSD ioctls. */
-      sigset_t blocked;
-      sigemptyset (&blocked);
-      sigaddset (&blocked, SIGTTOU);
-      pthread_sigmask (SIG_BLOCK, &blocked, 0);
-      fd = emacs_open (DEV_TTY, O_RDWR, 0);
-      if (fd != -1 && ioctl (fd, TIOCNOTTY, 0) != -1)
-        {
-          no_controlling_tty = 1;
-        }
-      if (fd != -1)
-        emacs_close (fd);
-      pthread_sigmask (SIG_UNBLOCK, &blocked, 0);
-#else
-# error "Unknown system."
-#endif  /* ! TIOCNOTTY */
-#endif  /* ! USG */
-    }
-#endif  /* !DOS_NT */
 }
 /* Create a termcap display on the tty device with the given name and
@@ -3235,7 +3204,6 @@ use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
    FrameCols (tty) = FRAME_COLS (f);
    tty->specified_window = FRAME_LINES (f);
-    FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
    FRAME_VERTICAL_SCROLL_BAR_TYPE (f) = vertical_scroll_bar_none;
    terminal->char_ins_del_ok = 1;
    baud_rate = 19200;
diff --git a/src/termhooks.h b/src/termhooks.h
index bac86423a4b..d1ee7138d67 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -243,16 +243,8 @@ struct input_event
  Lisp_Object x, y;
  Time timestamp;
-  /* This is padding just to put the frame_or_window field
+  /* This field is copied into a vector while the event is in
-     past the size of struct selection_input_event.  */
+     the queue, so that garbage collections won't kill it.  */
-  int *padding[2];
-  /* This field is copied into a vector while the event is in the queue,
-     so that garbage collections won't kill it.  */
-  /* In a menu_bar_event, this is a cons cell whose car is the frame
-     and whose cdr is the Lisp object that is the event's value.  */
-  /* This field is last so that struct selection_input_event
-     does not overlap with it.  */
  Lisp_Object frame_or_window;
  /* Additional event argument.  This is used for TOOL_BAR_EVENTs and
@@ -423,14 +415,6 @@ struct terminal
  int memory_below_frame;       /* Terminal remembers lines scrolled
                                   off bottom */
-#if 0  /* These are not used anywhere. */
-  /* EMACS_INT baud_rate; */    /* Output speed in baud */
-  int min_padding_speed;        /* Speed below which no padding necessary. */
-  int dont_calculate_costs;     /* Nonzero means don't bother computing
-                                   various cost tables; we won't use them. */
-#endif
  /* Window-based redisplay interface for this device (0 for tty
     devices). */
  struct redisplay_interface *rif;
@@ -478,10 +462,7 @@ struct terminal
     Otherwise, set *bar_window to Qnil, and *x and *y to the column and
     row of the character cell the mouse is over.
-     Set *time to the time the mouse was at the returned position.
+     Set *time to the time the mouse was at the returned position.  */
-     This should clear mouse_moved until the next motion
-     event arrives.  */
  void (*mouse_position_hook) (struct frame **f, int,
                               Lisp_Object *bar_window,
                               enum scroll_bar_part *part,
@@ -489,11 +470,6 @@ struct terminal
                               Lisp_Object *y,
                               Time *);
-  /* The window system handling code should set this if the mouse has
-     moved since the last call to the mouse_position_hook.  Calling that
-     hook should clear this.  */
-  int mouse_moved;
  /* When a frame's focus redirection is changed, this hook tells the
     window system code to re-decide where to put the highlight.  Under
     X, this means that Emacs lies about where the focus is.  */
diff --git a/src/terminal.c b/src/terminal.c
index 2c0c60e7345..854ca61f19c 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -360,14 +360,7 @@ If FRAME is nil, the selected frame is used.
 The terminal device is represented by its integer identifier.  */)
  (Lisp_Object frame)
 {
-  struct terminal *t;
+  struct terminal *t = FRAME_TERMINAL (decode_live_frame (frame));
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  t = FRAME_TERMINAL (XFRAME (frame));
  if (!t)
    return Qnil;
diff --git a/src/w32fns.c b/src/w32fns.c
index 210eaf1a188..6458054013f 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -26,6 +26,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <limits.h>
 #include <errno.h>
 #include <math.h>
+#include <fcntl.h>
+#include <unistd.h>
 #include "lisp.h"
 #include "w32term.h"
@@ -262,12 +264,8 @@ have_menus_p (void)
 FRAME_PTR
 check_x_frame (Lisp_Object frame)
 {
-  FRAME_PTR f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (! FRAME_W32_P (f))
    error ("Non-W32 frame used");
  return f;
@@ -306,19 +304,14 @@ check_x_display_info (Lisp_Object frame)
 /* Return the Emacs frame-object corresponding to an w32 window.
   It could be the frame's main window or an icon window.  */
-/* This function can be called during GC, so use GC_xxx type test macros.  */
 struct frame *
 x_window_to_frame (struct w32_display_info *dpyinfo, HWND wdesc)
 {
  Lisp_Object tail, frame;
  struct frame *f;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
      f = XFRAME (frame);
      if (!FRAME_W32_P (f) || FRAME_W32_DISPLAY_INFO (f) != dpyinfo)
        continue;
@@ -2087,8 +2080,35 @@ sync_modifiers (void)
 static int
 modifier_set (int vkey)
 {
-  if (vkey == VK_CAPITAL || vkey == VK_SCROLL)
+  /* Warning: The fact that VK_NUMLOCK is not treated as the other 2
-    return (GetKeyState (vkey) & 0x1);
+     toggle keys is not an omission!  If you want to add it, you will
+     have to make changes in the default sub-case of the WM_KEYDOWN
+     switch, because if the NUMLOCK modifier is set, the code there
+     will directly convert any key that looks like an ASCII letter,
+     and also downcase those that look like upper-case ASCII.  */
+  if (vkey == VK_CAPITAL)
+    {
+      if (NILP (Vw32_enable_caps_lock))
+        return 0;
+      else
+        return (GetKeyState (vkey) & 0x1);
+    }
+  if (vkey == VK_SCROLL)
+    {
+      if (NILP (Vw32_scroll_lock_modifier)
+          /* w32-scroll-lock-modifier can be any non-nil value that is
+             not one of the modifiers, in which case it shall be ignored.  */
+          || !(   EQ (Vw32_scroll_lock_modifier, Qhyper)
+               || EQ (Vw32_scroll_lock_modifier, Qsuper)
+               || EQ (Vw32_scroll_lock_modifier, Qmeta)
+               || EQ (Vw32_scroll_lock_modifier, Qalt)
+               || EQ (Vw32_scroll_lock_modifier, Qcontrol)
+               || EQ (Vw32_scroll_lock_modifier, Qshift)))
+        return 0;
+      else
+        return (GetKeyState (vkey) & 0x1);
+    }
  if (!modifiers_recorded)
    return (GetKeyState (vkey) & 0x8000);
@@ -4286,9 +4306,6 @@ This function is an internal primitive--use `make-frame' instead.  */)
  XSETFRAME (frame, f);
-  /* Note that Windows does support scroll bars.  */
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
  /* By default, make scrollbars the system standard width. */
  FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = GetSystemMetrics (SM_CXVSCROLL);
@@ -5389,7 +5406,6 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
  Finsert (1, &text);
  set_buffer_internal_1 (old_buffer);
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
  record_unwind_protect (unwind_create_tip_frame, frame);
  /* By setting the output method, we're essentially saying that
@@ -7700,6 +7716,30 @@ globals_of_w32fns (void)
  syms_of_w32uniscribe ();
 }
+typedef USHORT (WINAPI * CaptureStackBackTrace_proc) (ULONG, ULONG, PVOID *,
+                                                      PULONG);
+#define BACKTRACE_LIMIT_MAX 62
+int
+w32_backtrace (void **buffer, int limit)
+{
+  static CaptureStackBackTrace_proc s_pfn_CaptureStackBackTrace = NULL;
+  HMODULE hm_kernel32 = NULL;
+  if (!s_pfn_CaptureStackBackTrace)
+    {
+      hm_kernel32 = LoadLibrary ("Kernel32.dll");
+      s_pfn_CaptureStackBackTrace =
+        (CaptureStackBackTrace_proc) GetProcAddress (hm_kernel32,
+                                                     "RtlCaptureStackBackTrace");
+    }
+  if (s_pfn_CaptureStackBackTrace)
+    return s_pfn_CaptureStackBackTrace (0, min (BACKTRACE_LIMIT_MAX, limit),
+                                        buffer, NULL);
+  return 0;
+}
 void
 emacs_abort (void)
 {
@@ -7707,7 +7747,10 @@ emacs_abort (void)
  button = MessageBox (NULL,
                       "A fatal error has occurred!\n\n"
                       "Would you like to attach a debugger?\n\n"
-                       "Select YES to debug, NO to abort Emacs"
+                       "Select:\n"
+                       "YES -- to debug Emacs, or\n"
+                       "NO  -- to abort Emacs and produce a backtrace\n"
+                       "       (emacs_backtrace.txt in current directory)."
 #if __GNUC__
                       "\n\n(type \"gdb -p <emacs-PID>\" and\n"
                       "\"continue\" inside GDB before clicking YES.)"
@@ -7722,7 +7765,59 @@ emacs_abort (void)
      exit (2); /* tell the compiler we will never return */
    case IDNO:
    default:
-      abort ();
+      {
-      break;
+        void *stack[BACKTRACE_LIMIT_MAX + 1];
+        int i = w32_backtrace (stack, BACKTRACE_LIMIT_MAX + 1);
+        if (i)
+          {
+#ifdef CYGWIN
+            int stderr_fd = 2;
+#else
+            HANDLE errout = GetStdHandle (STD_ERROR_HANDLE);
+            int stderr_fd = -1;
+#endif
+            int errfile_fd = -1;
+            int j;
+#ifndef CYGWIN
+            if (errout && errout != INVALID_HANDLE_VALUE)
+              stderr_fd = _open_osfhandle ((intptr_t)errout, O_APPEND | O_BINARY);
+#endif
+            if (stderr_fd >= 0)
+              write (stderr_fd, "\r\nBacktrace:\r\n", 14);
+            errfile_fd = _open ("emacs_backtrace.txt", O_RDWR | O_CREAT | O_BINARY, S_IREAD | S_IWRITE);
+            if (errfile_fd >= 0)
+              {
+                lseek (errfile_fd, 0L, SEEK_END);
+                write (errfile_fd, "\r\nBacktrace:\r\n", 14);
+              }
+            for (j = 0; j < i; j++)
+              {
+                char buf[INT_BUFSIZE_BOUND (void *)];
+                /* stack[] gives the return addresses, whereas we want
+                   the address of the call, so decrease each address
+                   by approximate size of 1 CALL instruction.  */
+                sprintf (buf, "0x%p\r\n", stack[j] - sizeof(void *));
+                if (stderr_fd >= 0)
+                  write (stderr_fd, buf, strlen (buf));
+                if (errfile_fd >= 0)
+                  write (errfile_fd, buf, strlen (buf));
+              }
+            if (i == BACKTRACE_LIMIT_MAX)
+              {
+                if (stderr_fd >= 0)
+                  write (stderr_fd, "...\r\n", 5);
+                if (errfile_fd >= 0)
+                  write (errfile_fd, "...\r\n", 5);
+              }
+            if (errfile_fd >= 0)
+              close (errfile_fd);
+          }
+        abort ();
+        break;
+      }
    }
 }
diff --git a/src/w32proc.c b/src/w32proc.c
index 73013a3b013..e074ece020d 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -230,14 +230,14 @@ sigismember (const sigset_t *set, int signo)
  return (*set & (1U << signo)) != 0;
 }
-int
+pid_t
-setpgrp (int pid, int gid)
+getpgrp (void)
 {
-  return 0;
+  return getpid ();
 }
 pid_t
-getpgrp (void)
+tcgetpgrp (int fd)
 {
  return getpid ();
 }
@@ -248,6 +248,12 @@ setpgid (pid_t pid, pid_t pgid)
  return 0;
 }
+pid_t
+setsid (void)
+{
+  return getpid ();
+}
 /* Emulations of interval timers.
   Limitations: only ITIMER_REAL and ITIMER_PROF are supported.
diff --git a/src/w32term.c b/src/w32term.c
index 3ebd849ec31..e53fa5e7756 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -3555,16 +3555,11 @@ w32_handle_tool_bar_click (struct frame *f, struct input_event *button_event)
 static struct scroll_bar *
 x_window_to_scroll_bar (Window window_id)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      Lisp_Object frame, bar, condemned;
+      Lisp_Object bar, condemned;
-      frame = XCAR (tail);
-      /* All elements of Vframe_list should be frames.  */
-      if (! FRAMEP (frame))
-        emacs_abort ();
      /* Scan this frame's scroll bar list for a scroll bar with the
         right window ID.  */
@@ -3744,7 +3739,7 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height)
  HWND hwnd;
  SCROLLINFO si;
  struct scroll_bar *bar
-    = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
+    = XSCROLL_BAR (Fmake_vector (make_number (VECSIZE (struct scroll_bar)), Qnil));
  Lisp_Object barobj;
  block_input ();
diff --git a/src/w32term.h b/src/w32term.h
index 14b3d1ffc42..98186a7d363 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -415,9 +415,8 @@ extern struct w32_output w32term_display;
 struct scroll_bar {
-  /* These fields are shared by all vectors.  */
+  /* This field is shared by all vectors.  */
-  EMACS_INT size_from_Lisp_Vector_struct;
+  struct vectorlike_header header;
-  struct Lisp_Vector *next_from_Lisp_Vector_struct;
  /* The window we're a scroll bar for.  */
  Lisp_Object window;
@@ -460,12 +459,6 @@ struct scroll_bar {
  Lisp_Object fringe_extended_p;
 };
-/* The number of elements a vector holding a struct scroll_bar needs.  */
-#define SCROLL_BAR_VEC_SIZE                                     \
-  ((sizeof (struct scroll_bar)                                  \
-    - sizeof (EMACS_INT) - sizeof (struct Lisp_Vector *))       \
-   / word_size)
 /* Turning a lisp vector value into a pointer to a struct scroll_bar.  */
 #define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec))
diff --git a/src/widget.c b/src/widget.c
index 1f472c6231c..b4f7335c652 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -650,6 +650,16 @@ EmacsFrameInitialize (Widget request, Widget new, ArgList dum1, Cardinal *dum2)
  set_frame_size (ew);
 }
+static void
+resize_cb (Widget widget,
+           XtPointer closure,
+           XEvent* event,
+           Boolean* continue_to_dispatch)
+{
+  EmacsFrame ew = (EmacsFrame) widget;
+  EmacsFrameResize (widget);
+}
 static void
 EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs)
@@ -665,6 +675,9 @@ EmacsFrameRealize (Widget widget, XtValueMask *mask, XSetWindowAttributes *attrs
  *mask |= CWEventMask;
  XtCreateWindow (widget, InputOutput, (Visual *)CopyFromParent, *mask,
                  attrs);
+  /* Some ConfigureNotify events does not end up in EmacsFrameResize so
+     make sure we get them all.  Seen with xfcwm4 for example.  */
+  XtAddRawEventHandler (widget, StructureNotifyMask, False, resize_cb, NULL);
  update_wm_hints (ew);
 }
@@ -691,15 +704,22 @@ EmacsFrameResize (Widget widget)
 {
  EmacsFrame ew = (EmacsFrame)widget;
  struct frame *f = ew->emacs_frame.frame;
+  struct x_output *x = f->output_data.x;
  int columns;
  int rows;
  pixel_to_char_size (ew, ew->core.width, ew->core.height, &columns, &rows);
-  change_frame_size (f, rows, columns, 0, 1, 0);
+  if (columns != FRAME_COLS (f)
-  update_wm_hints (ew);
+      || rows != FRAME_LINES (f)
-  update_various_frame_slots (ew);
+      || ew->core.width != FRAME_PIXEL_WIDTH (f)
+      || ew->core.height + x->menubar_height != FRAME_PIXEL_HEIGHT (f))
+    {
+      change_frame_size (f, rows, columns, 0, 1, 0);
+      update_wm_hints (ew);
+      update_various_frame_slots (ew);
-  cancel_mouse_face (f);
+      cancel_mouse_face (f);
+    }
 }
 static Boolean
diff --git a/src/window.c b/src/window.c
index dfcabda59b9..9f3474fcd53 100644
--- a/src/window.c
+++ b/src/window.c
@@ -244,7 +244,7 @@ decode_live_window (register Lisp_Object window)
  return XWINDOW (window);
 }
-static struct window *
+struct window *
 decode_any_window (register Lisp_Object window)
 {
  struct window *w;
@@ -270,6 +270,15 @@ decode_valid_window (register Lisp_Object window)
  return w;
 }
+/* Build a frequently used 4-integer (X Y W H) list.  */
+static Lisp_Object
+list4i (EMACS_INT x, EMACS_INT y, EMACS_INT w, EMACS_INT h)
+{
+  return list4 (make_number (x), make_number (y),
+                make_number (w), make_number (h));
+}
 DEFUN ("windowp", Fwindowp, Swindowp, 1, 1, 0,
       doc: /* Return t if OBJECT is a window and nil otherwise.  */)
  (Lisp_Object object)
@@ -296,7 +305,7 @@ Internal windows and deleted windows are not live.  */)
 }
 /* Frames and windows.  */
-DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 1, 1, 0,
+DEFUN ("window-frame", Fwindow_frame, Swindow_frame, 0, 1, 0,
       doc: /* Return the frame that window WINDOW is on.
 WINDOW must be a valid window and defaults to the selected one.  */)
  (Lisp_Object window)
@@ -331,10 +340,7 @@ DEFUN ("minibuffer-window", Fminibuffer_window, Sminibuffer_window, 0, 1, 0,
 If FRAME is omitted or nil, it defaults to the selected frame.  */)
  (Lisp_Object frame)
 {
-  if (NILP (frame))
+  return FRAME_MINIBUF_WINDOW (decode_live_frame (frame));
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  return FRAME_MINIBUF_WINDOW (XFRAME (frame));
 }
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
@@ -556,7 +562,7 @@ Return nil for a window with no parent (e.g. a root window).  */)
  return decode_valid_window (window)->parent;
 }
-DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 1, 1, 0,
+DEFUN ("window-top-child", Fwindow_top_child, Swindow_top_child, 0, 1, 0,
       doc: /* Return the topmost child window of window WINDOW.
 WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW is a live window (live windows have no children).
@@ -564,11 +570,10 @@ Return nil if WINDOW is an internal window whose children form a
 horizontal combination.  */)
  (Lisp_Object window)
 {
-  CHECK_WINDOW (window);
  return decode_valid_window (window)->vchild;
 }
-DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 1, 1, 0,
+DEFUN ("window-left-child", Fwindow_left_child, Swindow_left_child, 0, 1, 0,
       doc: /* Return the leftmost child window of window WINDOW.
 WINDOW must be a valid window and defaults to the selected one.
 Return nil if WINDOW is a live window (live windows have no children).
@@ -576,7 +581,6 @@ Return nil if WINDOW is an internal window whose children form a
 vertical combination.  */)
  (Lisp_Object window)
 {
-  CHECK_WINDOW (window);
  return decode_valid_window (window)->hchild;
 }
@@ -600,22 +604,27 @@ Return nil if WINDOW has no previous sibling.  */)
 DEFUN ("window-combination-limit", Fwindow_combination_limit, Swindow_combination_limit, 1, 1, 0,
       doc: /* Return combination limit of window WINDOW.
-WINDOW must be a valid window and defaults to the selected one.
 If the return value is nil, child windows of WINDOW can be recombined with
 WINDOW's siblings.  A return value of t means that child windows of
-WINDOW are never \(re-)combined with WINDOW's siblings.  */)
+WINDOW are never \(re-)combined with WINDOW's siblings.
+WINDOW must be a valid window.  The return value is meaningful for
+internal windows only.  */)
  (Lisp_Object window)
 {
-  return decode_valid_window (window)->combination_limit;
+  CHECK_VALID_WINDOW (window);
+  return XWINDOW (window)->combination_limit;
 }
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
       doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
-WINDOW must be a valid window and defaults to the selected one.
 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
 siblings.  LIMIT t means that child windows of WINDOW are never
 \(re-)combined with WINDOW's siblings.  Other values are reserved for
-future use.  */)
+future use.
+WINDOW must be a valid window.  Setting the combination limit is
+meaningful for internal windows only.  */)
  (Lisp_Object window, Lisp_Object limit)
 {
  wset_combination_limit (decode_valid_window (window), limit);
@@ -774,8 +783,7 @@ area is only partially visible, that counts as a whole line; to
 exclude partially-visible lines, use `window-text-height'.  */)
  (Lisp_Object window)
 {
-  struct window *w = decode_live_window (window);
+  return make_number (window_body_lines (decode_live_window (window)));
-  return make_number (window_body_lines (w));
 }
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
@@ -787,8 +795,7 @@ marginal areas, or scroll bars.  On a graphical display, the width is
 expressed as an integer multiple of the default character width.  */)
  (Lisp_Object window)
 {
-  struct window *w = decode_live_window (window);
+  return make_number (window_body_cols (decode_live_window (window)));
-  return make_number (window_body_cols (w));
 }
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
@@ -831,10 +838,8 @@ Note that if `automatic-hscrolling' is non-nil, you cannot scroll the
 window so that the location of point moves off-window.  */)
  (Lisp_Object window, Lisp_Object ncol)
 {
-  struct window *w = decode_live_window (window);
  CHECK_NUMBER (ncol);
-  return set_window_hscroll (w, XINT (ncol));
+  return set_window_hscroll (decode_live_window (window), XINT (ncol));
 }
 DEFUN ("window-redisplay-end-trigger", Fwindow_redisplay_end_trigger,
@@ -879,11 +884,8 @@ header line, and/or mode line.  For the edges of just the text area, use
 {
  register struct window *w = decode_valid_window (window);
-  return Fcons (make_number (WINDOW_LEFT_EDGE_COL (w)),
+  return list4i (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
-         Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
+                 WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
-         Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w)),
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w)),
-                Qnil))));
 }
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
@@ -902,11 +904,8 @@ of just the text area, use `window-inside-pixel-edges'.  */)
 {
  register struct window *w = decode_valid_window (window);
-  return Fcons (make_number (WINDOW_LEFT_EDGE_X (w)),
+  return list4i (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
-         Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
+                 WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
-         Fcons (make_number (WINDOW_RIGHT_EDGE_X (w)),
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w)),
-                Qnil))));
 }
 static void
@@ -948,13 +947,13 @@ of just the text area, use `window-inside-absolute-pixel-edges'.  */)
 {
  register struct window *w = decode_valid_window (window);
  int add_x, add_y;
  calc_absolute_offset (w, &add_x, &add_y);
-  return Fcons (make_number (WINDOW_LEFT_EDGE_X (w) + add_x),
+  return list4i (WINDOW_LEFT_EDGE_X (w) + add_x,
-         Fcons (make_number (WINDOW_TOP_EDGE_Y (w) + add_y),
+                 WINDOW_TOP_EDGE_Y (w) + add_y,
-         Fcons (make_number (WINDOW_RIGHT_EDGE_X (w) + add_x),
+                 WINDOW_RIGHT_EDGE_X (w) + add_x,
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w) + add_y),
+                 WINDOW_BOTTOM_EDGE_Y (w) + add_y);
-                Qnil))));
 }
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
@@ -973,16 +972,16 @@ display margins, fringes, header line, and/or mode line.  */)
 {
  register struct window *w = decode_live_window (window);
-  return list4 (make_number (WINDOW_BOX_LEFT_EDGE_COL (w)
+  return list4i ((WINDOW_BOX_LEFT_EDGE_COL (w)
-                             + WINDOW_LEFT_MARGIN_COLS (w)
+                  + WINDOW_LEFT_MARGIN_COLS (w)
-                             + WINDOW_LEFT_FRINGE_COLS (w)),
+                  + WINDOW_LEFT_FRINGE_COLS (w)),
-                make_number (WINDOW_TOP_EDGE_LINE (w)
+                 (WINDOW_TOP_EDGE_LINE (w)
-                             + WINDOW_HEADER_LINE_LINES (w)),
+                  + WINDOW_HEADER_LINE_LINES (w)),
-                make_number (WINDOW_BOX_RIGHT_EDGE_COL (w)
+                 (WINDOW_BOX_RIGHT_EDGE_COL (w)
-                             - WINDOW_RIGHT_MARGIN_COLS (w)
+                  - WINDOW_RIGHT_MARGIN_COLS (w)
-                             - WINDOW_RIGHT_FRINGE_COLS (w)),
+                  - WINDOW_RIGHT_FRINGE_COLS (w)),
-                make_number (WINDOW_BOTTOM_EDGE_LINE (w)
+                 (WINDOW_BOTTOM_EDGE_LINE (w)
-                             - WINDOW_MODE_LINE_LINES (w)));
+                  - WINDOW_MODE_LINE_LINES (w)));
 }
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
@@ -1000,16 +999,16 @@ display margins, fringes, header line, and/or mode line.  */)
 {
  register struct window *w = decode_live_window (window);
-  return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
+  return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
-                             + WINDOW_LEFT_MARGIN_WIDTH (w)
+                  + WINDOW_LEFT_MARGIN_WIDTH (w)
-                             + WINDOW_LEFT_FRINGE_WIDTH (w)),
+                  + WINDOW_LEFT_FRINGE_WIDTH (w)),
-                make_number (WINDOW_TOP_EDGE_Y (w)
+                 (WINDOW_TOP_EDGE_Y (w)
-                             + WINDOW_HEADER_LINE_HEIGHT (w)),
+                  + WINDOW_HEADER_LINE_HEIGHT (w)),
-                make_number (WINDOW_BOX_RIGHT_EDGE_X (w)
+                 (WINDOW_BOX_RIGHT_EDGE_X (w)
-                             - WINDOW_RIGHT_MARGIN_WIDTH (w)
+                  - WINDOW_RIGHT_MARGIN_WIDTH (w)
-                             - WINDOW_RIGHT_FRINGE_WIDTH (w)),
+                  - WINDOW_RIGHT_FRINGE_WIDTH (w)),
-                make_number (WINDOW_BOTTOM_EDGE_Y (w)
+                 (WINDOW_BOTTOM_EDGE_Y (w)
-                             - WINDOW_MODE_LINE_HEIGHT (w)));
+                  - WINDOW_MODE_LINE_HEIGHT (w)));
 }
 DEFUN ("window-inside-absolute-pixel-edges",
@@ -1029,18 +1028,19 @@ display margins, fringes, header line, and/or mode line.  */)
 {
  register struct window *w = decode_live_window (window);
  int add_x, add_y;
  calc_absolute_offset (w, &add_x, &add_y);
-  return list4 (make_number (WINDOW_BOX_LEFT_EDGE_X (w)
+  return list4i ((WINDOW_BOX_LEFT_EDGE_X (w)
-                             + WINDOW_LEFT_MARGIN_WIDTH (w)
+                  + WINDOW_LEFT_MARGIN_WIDTH (w)
-                             + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
+                  + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
-                make_number (WINDOW_TOP_EDGE_Y (w)
+                 (WINDOW_TOP_EDGE_Y (w)
-                             + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
+                  + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
-                make_number (WINDOW_BOX_RIGHT_EDGE_X (w)
+                 (WINDOW_BOX_RIGHT_EDGE_X (w)
-                             - WINDOW_RIGHT_MARGIN_WIDTH (w)
+                  - WINDOW_RIGHT_MARGIN_WIDTH (w)
-                             - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
+                  - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
-                make_number (WINDOW_BOTTOM_EDGE_Y (w)
+                 (WINDOW_BOTTOM_EDGE_Y (w)
-                             - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
+                  - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
 }
 /* Test if the character at column X, row Y is within window W.
@@ -1373,12 +1373,7 @@ The top left corner of the frame is considered to be row 0,
 column 0.  */)
  (Lisp_Object x, Lisp_Object y, Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  /* Check that arguments are integers or floats.  */
  CHECK_NUMBER_OR_FLOAT (x);
@@ -1626,8 +1621,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
    {
      Lisp_Object part = Qnil;
      if (!fully_p)
-        part = list4 (make_number (rtop), make_number (rbot),
+        part = list4i (rtop, rbot, rowh, vpos);
-                        make_number (rowh), make_number (vpos));
      in_window = Fcons (make_number (x),
                         Fcons (make_number (y), part));
    }
@@ -1693,23 +1687,19 @@ Return nil if window display is not up-to-date.  In that case, use
      if (!WINDOW_WANTS_HEADER_LINE_P (w))
        return Qnil;
      row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
-      if (!row->enabled_p)
+      return row->enabled_p ? list4i (row->height, 0, 0, 0) : Qnil;
-        return Qnil;
-      return list4 (make_number (row->height),
-                    make_number (0), make_number (0),
-                    make_number (0));
    }
  if (EQ (line, Qmode_line))
    {
      row = MATRIX_MODE_LINE_ROW (w->current_matrix);
-      if (!row->enabled_p)
+      return (row->enabled_p ?
-        return Qnil;
+              list4i (row->height,
-      return list4 (make_number (row->height),
+                      0, /* not accurate */
-                    make_number (0), /* not accurate */
+                      (WINDOW_HEADER_LINE_HEIGHT (w)
-                    make_number (WINDOW_HEADER_LINE_HEIGHT (w)
+                       + window_text_bottom_y (w)),
-                                 + window_text_bottom_y (w)),
+                      0)
-                    make_number (0));
+              : Qnil);
    }
  CHECK_NUMBER (line);
@@ -1738,10 +1728,7 @@ Return nil if window display is not up-to-date.  In that case, use
 found_row:
  crop = max (0, (row->y + row->height) - max_y);
-  return list4 (make_number (row->height + min (0, row->y) - crop),
+  return list4i (row->height + min (0, row->y) - crop, i, row->y, crop);
-                make_number (i),
-                make_number (row->y),
-                make_number (crop));
 }
 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
@@ -2146,10 +2133,10 @@ window_list (void)
 {
  if (!CONSP (Vwindow_list))
    {
-      Lisp_Object tail;
+      Lisp_Object tail, frame;
      Vwindow_list = Qnil;
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, frame)
        {
          Lisp_Object args[2];
@@ -2157,7 +2144,7 @@ window_list (void)
             new windows at the front of args[1], which means we
             have to reverse this list at the end.  */
          args[1] = Qnil;
-          foreach_window (XFRAME (XCAR (tail)), add_window_to_list, &args[1]);
+          foreach_window (XFRAME (frame), add_window_to_list, &args[1]);
          args[0] = Vwindow_list;
          args[1] = Fnreverse (args[1]);
          Vwindow_list = Fnconc (2, args);
@@ -2252,11 +2239,9 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
 static void
 decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object *all_frames)
 {
-  if (NILP (*window))
+  struct window *w = decode_live_window (*window);
-    *window = selected_window;
-  else
-    CHECK_LIVE_WINDOW (*window);
+  XSETWINDOW (*window, w);
  /* MINIBUF nil may or may not include minibuffers.  Decide if it
     does.  */
  if (NILP (*minibuf))
@@ -2272,7 +2257,7 @@ decode_next_window_args (Lisp_Object *window, Lisp_Object *minibuf, Lisp_Object
  if (NILP (*all_frames))
    *all_frames
      = (!EQ (*minibuf, Qlambda)
-         ? FRAME_MINIBUF_WINDOW (XFRAME (XWINDOW (*window)->frame))
+         ? FRAME_MINIBUF_WINDOW (XFRAME (w->frame))
         : Qnil);
  else if (EQ (*all_frames, Qvisible))
    ;
@@ -3122,12 +3107,12 @@ run_window_configuration_change_hook (struct frame *f)
 }
 DEFUN ("run-window-configuration-change-hook", Frun_window_configuration_change_hook,
-       Srun_window_configuration_change_hook, 1, 1, 0,
+       Srun_window_configuration_change_hook, 0, 1, 0,
-       doc: /* Run `window-configuration-change-hook' for FRAME.  */)
+       doc: /* Run `window-configuration-change-hook' for FRAME.
+If FRAME is omitted or nil, it defaults to the selected frame.  */)
  (Lisp_Object frame)
 {
-  CHECK_LIVE_FRAME (frame);
+  run_window_configuration_change_hook (decode_live_frame (frame));
-  run_window_configuration_change_hook (XFRAME (frame));
  return Qnil;
 }
@@ -3654,10 +3639,12 @@ window_resize_apply (struct window *w, int horflag)
 }
-DEFUN ("window-resize-apply", Fwindow_resize_apply, Swindow_resize_apply, 1, 2, 0,
+DEFUN ("window-resize-apply", Fwindow_resize_apply, Swindow_resize_apply, 0, 2, 0,
       doc: /* Apply requested size values for window-tree of FRAME.
-Optional argument HORIZONTAL omitted or nil means apply requested height
+If FRAME is omitted or nil, it defaults to the selected frame.
-values.  HORIZONTAL non-nil means apply requested width values.
+Optional argument HORIZONTAL omitted or nil means apply requested
+height values.  HORIZONTAL non-nil means apply requested width values.
 This function checks whether the requested values sum up to a valid
 window layout, recursively assigns the new sizes of all child windows
@@ -3668,17 +3655,10 @@ Note: This function does not check any of `window-fixed-size-p',
 be applied on the Elisp level.  */)
     (Lisp_Object frame, Lisp_Object horizontal)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
-  struct window *r;
+  struct window *r = XWINDOW (FRAME_ROOT_WINDOW (f));
  int horflag = !NILP (horizontal);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
-  r = XWINDOW (FRAME_ROOT_WINDOW (f));
  if (!window_resize_check (r, horflag)
      || ! EQ (r->new_total,
               (horflag ? r->total_cols : r->total_lines)))
@@ -3892,9 +3872,10 @@ set correctly.  See the code of `split-window' for how this is done.  */)
      make_parent_window (old, horflag);
      p = XWINDOW (o->parent);
-      /* Store t in the new parent's combination_limit slot to avoid
+      if (EQ (Vwindow_combination_limit, Qt))
-        that its children get merged into another window.  */
+        /* Store t in the new parent's combination_limit slot to avoid
-      wset_combination_limit (p, Qt);
+           that its children get merged into another window.  */
+        wset_combination_limit (p, Qt);
      /* These get applied below.  */
      wset_new_total (p, horflag ? o->total_cols : o->total_lines);
      wset_new_normal (p, new_normal);
@@ -6161,12 +6142,7 @@ saved by this function.  */)
  register int n_windows;
  register struct save_window_data *data;
  register int i;
-  FRAME_PTR f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
  data = ALLOCATE_PSEUDOVECTOR (struct save_window_data, frame_cols,
@@ -6319,10 +6295,9 @@ Value is a list of the form (LEFT-WIDTH RIGHT-WIDTH OUTSIDE-MARGINS).  */)
 {
  struct window *w = decode_live_window (window);
-  return Fcons (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
+  return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
-                Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
+                make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
-                       Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
+                WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w) ? Qt : Qnil);
-                               ? Qt : Qnil), Qnil)));
 }
@@ -6391,12 +6366,12 @@ value.  */)
  (Lisp_Object window)
 {
  struct window *w = decode_live_window (window);
-  return Fcons (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
+  return list4 (make_number ((WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              ? WINDOW_CONFIG_SCROLL_BAR_WIDTH (w)
                              : WINDOW_SCROLL_BAR_AREA_WIDTH (w))),
-                Fcons (make_number (WINDOW_SCROLL_BAR_COLS (w)),
+                make_number (WINDOW_SCROLL_BAR_COLS (w)),
-                       Fcons (w->vertical_scroll_bar_type,
+                w->vertical_scroll_bar_type, Qnil);
-                              Fcons (Qnil, Qnil))));
 }
diff --git a/src/window.h b/src/window.h
index 115b361194c..2a12226c0aa 100644
--- a/src/window.h
+++ b/src/window.h
@@ -970,17 +970,26 @@ struct glyph *get_phys_cursor_glyph (struct window *w);
       || !NILP (XWINDOW (WINDOW)->vchild)              \
       || !NILP (XWINDOW (WINDOW)->hchild)))
+/* A window of any sort, leaf or interior, is "valid" if one
+   of its buffer, vchild, or hchild members is non-nil.  */
+#define CHECK_VALID_WINDOW(WINDOW)                              \
+  CHECK_TYPE (WINDOW_VALID_P (WINDOW), Qwindow_valid_p, WINDOW)
 /* Value is non-zero if WINDOW is a live window.  */
 #define WINDOW_LIVE_P(WINDOW)                                   \
  (WINDOWP (WINDOW) && !NILP (XWINDOW (WINDOW)->buffer))
+/* A window is "live" if and only if it shows a buffer.  */
+#define CHECK_LIVE_WINDOW(WINDOW)                               \
+  CHECK_TYPE (WINDOW_LIVE_P (WINDOW), Qwindow_live_p, WINDOW)
 /* These used to be in lisp.h.  */
 extern Lisp_Object Qwindowp, Qwindow_live_p;
 extern Lisp_Object Vwindow_list;
 extern struct window *decode_live_window (Lisp_Object);
+extern struct window *decode_any_window (Lisp_Object);
 extern bool compare_window_configurations (Lisp_Object, Lisp_Object, bool);
 extern void mark_window_cursors_off (struct window *);
 extern int window_internal_height (struct window *);
diff --git a/src/xdisp.c b/src/xdisp.c
index b3b08edcd0a..a74628db392 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -928,6 +928,7 @@ static enum move_it_result
       move_it_in_display_line_to (struct it *, ptrdiff_t, int,
                                   enum move_operation_enum);
 void move_it_vertically_backward (struct it *, int);
+static void get_visually_first_element (struct it *);
 static void init_to_row_start (struct it *, struct window *,
                               struct glyph_row *);
 static int init_to_row_end (struct it *, struct window *,
@@ -3113,6 +3114,40 @@ init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
      eassert (STRINGP (it->string));
      it->current.string_pos = pos->string_pos;
      it->method = GET_FROM_STRING;
+      it->end_charpos = SCHARS (it->string);
+      /* Set up the bidi iterator for this overlay string.  */
+      if (it->bidi_p)
+        {
+          it->bidi_it.string.lstring = it->string;
+          it->bidi_it.string.s = NULL;
+          it->bidi_it.string.schars = SCHARS (it->string);
+          it->bidi_it.string.bufpos = it->overlay_strings_charpos;
+          it->bidi_it.string.from_disp_str = it->string_from_display_prop_p;
+          it->bidi_it.string.unibyte = !it->multibyte_p;
+          bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
+                        FRAME_WINDOW_P (it->f), &it->bidi_it);
+          /* Synchronize the state of the bidi iterator with
+             pos->string_pos.  For any string position other than
+             zero, this will be done automagically when we resume
+             iteration over the string and get_visually_first_element
+             is called.  But if string_pos is zero, and the string is
+             to be reordered for display, we need to resync manually,
+             since it could be that the iteration state recorded in
+             pos ended at string_pos of 0 moving backwards in string.  */
+          if (CHARPOS (pos->string_pos) == 0)
+            {
+              get_visually_first_element (it);
+              if (IT_STRING_CHARPOS (*it) != 0)
+                do {
+                  /* Paranoia.  */
+                  eassert (it->bidi_it.charpos < it->bidi_it.string.schars);
+                  bidi_move_to_visually_next (&it->bidi_it);
+                } while (it->bidi_it.charpos != 0);
+            }
+          eassert (IT_STRING_CHARPOS (*it) == it->bidi_it.charpos
+                   && IT_STRING_BYTEPOS (*it) == it->bidi_it.bytepos);
+        }
    }
  if (CHARPOS (pos->string_pos) >= 0)
@@ -3122,6 +3157,9 @@ init_from_display_pos (struct it *it, struct window *w, struct display_pos *pos)
         IT should already be filled with that string.  */
      it->current.string_pos = pos->string_pos;
      eassert (STRINGP (it->string));
+      if (it->bidi_p)
+        bidi_init_it (IT_STRING_CHARPOS (*it), IT_STRING_BYTEPOS (*it),
+                      FRAME_WINDOW_P (it->f), &it->bidi_it);
    }
  /* Restore position in display vector translations, control
@@ -10731,7 +10769,7 @@ clear_garbaged_frames (void)
            {
              if (f->resized_p)
                {
-                  Fredraw_frame (frame);
+                  redraw_frame (f);
                  f->force_flush_display_p = 1;
                }
              clear_current_matrices (f);
@@ -11058,17 +11096,15 @@ x_consider_frame_title (Lisp_Object frame)
      || f->explicit_name)
    {
      /* Do we have more than one visible frame on this X display?  */
-      Lisp_Object tail;
+      Lisp_Object tail, other_frame, fmt;
-      Lisp_Object fmt;
      ptrdiff_t title_start;
      char *title;
      ptrdiff_t len;
      struct it it;
      ptrdiff_t count = SPECPDL_INDEX ();
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, other_frame)
        {
-          Lisp_Object other_frame = XCAR (tail);
          struct frame *tf = XFRAME (other_frame);
          if (tf != f
@@ -11878,19 +11914,14 @@ tool_bar_lines_needed (struct frame *f, int *n_rows)
 DEFUN ("tool-bar-lines-needed", Ftool_bar_lines_needed, Stool_bar_lines_needed,
       0, 1, 0,
-       doc: /* Return the number of lines occupied by the tool bar of FRAME.  */)
+       doc: /* Return the number of lines occupied by the tool bar of FRAME.
+If FRAME is nil or omitted, use the selected frame.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_any_frame (frame);
  struct window *w;
  int nlines = 0;
-  if (NILP (frame))
-    frame = selected_frame;
-  else
-    CHECK_FRAME (frame);
-  f = XFRAME (frame);
  if (WINDOWP (f->tool_bar_window)
      && (w = XWINDOW (f->tool_bar_window),
          WINDOW_TOTAL_LINES (w) > 0))
@@ -14753,13 +14784,18 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
          if (NUMBERP (aggressive))
            {
              double float_amount = XFLOATINT (aggressive) * height;
-              amount_to_scroll = float_amount;
+              int aggressive_scroll = float_amount;
-              if (amount_to_scroll == 0 && float_amount > 0)
+              if (aggressive_scroll == 0 && float_amount > 0)
-                amount_to_scroll = 1;
+                aggressive_scroll = 1;
              /* Don't let point enter the scroll margin near top of
-                 the window.  */
+                 the window.  This could happen if the value of
-              if (amount_to_scroll > height - 2*this_scroll_margin + dy)
+                 scroll_up_aggressively is too large and there are
-                amount_to_scroll = height - 2*this_scroll_margin + dy;
+                 non-zero margins, because scroll_up_aggressively
+                 means put point that fraction of window height
+                 _from_the_bottom_margin_.  */
+              if (aggressive_scroll + 2*this_scroll_margin > height)
+                aggressive_scroll = height - 2*this_scroll_margin;
+              amount_to_scroll = dy + aggressive_scroll;
            }
        }
@@ -14819,7 +14855,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
          /* Compute the vertical distance from PT to the scroll
             margin position.  Move as far as scroll_max allows, or
             one screenful, or 10 screen lines, whichever is largest.
-             Give up if distance is greater than scroll_max.  */
+             Give up if distance is greater than scroll_max or if we
+             didn't reach the scroll margin position.  */
          SET_TEXT_POS (pos, PT, PT_BYTE);
          start_display (&it, w, pos);
          y0 = it.current_y;
@@ -14829,7 +14866,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
                      y_to_move, -1,
                      MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
          dy = it.current_y - y0;
-          if (dy > scroll_max)
+          if (dy > scroll_max
+              || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
            return SCROLLING_FAILED;
          /* Compute new window start.  */
@@ -14847,15 +14885,16 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
              if (NUMBERP (aggressive))
                {
                  double float_amount = XFLOATINT (aggressive) * height;
-                  amount_to_scroll = float_amount;
+                  int aggressive_scroll = float_amount;
-                  if (amount_to_scroll == 0 && float_amount > 0)
+                  if (aggressive_scroll == 0 && float_amount > 0)
-                    amount_to_scroll = 1;
+                    aggressive_scroll = 1;
-                  amount_to_scroll -=
-                    this_scroll_margin - dy - FRAME_LINE_HEIGHT (f);
                  /* Don't let point enter the scroll margin near
-                     bottom of the window.  */
+                     bottom of the window, if the value of
-                  if (amount_to_scroll > height - 2*this_scroll_margin + dy)
+                     scroll_down_aggressively happens to be too
-                    amount_to_scroll = height - 2*this_scroll_margin + dy;
+                     large.  */
+                  if (aggressive_scroll + 2*this_scroll_margin > height)
+                    aggressive_scroll = height - 2*this_scroll_margin;
+                  amount_to_scroll = dy + aggressive_scroll;
                }
            }
@@ -21018,10 +21057,8 @@ are the selected window and the WINDOW's buffer).  */)
  Lisp_Object str;
  int string_start = 0;
-  if (NILP (window))
+  w = decode_any_window (window);
-    window = selected_window;
+  XSETWINDOW (window, w);
-  CHECK_WINDOW (window);
-  w = XWINDOW (window);
  if (NILP (buffer))
    buffer = w->buffer;
@@ -21050,7 +21087,7 @@ are the selected window and the WINDOW's buffer).  */)
     and set that to nil so that we don't alter the outer value.  */
  record_unwind_protect (unwind_format_mode_line,
                         format_mode_line_unwind_data
-                           (XFRAME (WINDOW_FRAME (XWINDOW (window))),
+                           (XFRAME (WINDOW_FRAME (w)),
                            old_buffer, selected_window, 1));
  mode_line_proptrans_alist = Qnil;
@@ -21334,6 +21371,12 @@ decode_mode_spec (struct window *w, register int c, int field_width,
  Lisp_Object obj;
  struct frame *f = XFRAME (WINDOW_FRAME (w));
  char *decode_mode_spec_buf = f->decode_mode_spec_buffer;
+  /* We are going to use f->decode_mode_spec_buffer as the buffer to
+     produce strings from numerical values, so limit preposterously
+     large values of FIELD_WIDTH to avoid overrunning the buffer's
+     end.  The size of the buffer is enough for FRAME_MESSAGE_BUF_SIZE
+     bytes plus the terminating null.  */
+  int width = min (field_width, FRAME_MESSAGE_BUF_SIZE (f));
  struct buffer *b = current_buffer;
  obj = Qnil;
@@ -21429,7 +21472,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
        {
          ptrdiff_t col = current_column ();
          wset_column_number_displayed (w, make_number (col));
-          pint2str (decode_mode_spec_buf, field_width, col);
+          pint2str (decode_mode_spec_buf, width, col);
          return decode_mode_spec_buf;
        }
@@ -21460,14 +21503,14 @@ decode_mode_spec (struct window *w, register int c, int field_width,
    case 'i':
      {
        ptrdiff_t size = ZV - BEGV;
-        pint2str (decode_mode_spec_buf, field_width, size);
+        pint2str (decode_mode_spec_buf, width, size);
        return decode_mode_spec_buf;
      }
    case 'I':
      {
        ptrdiff_t size = ZV - BEGV;
-        pint2hrstr (decode_mode_spec_buf, field_width, size);
+        pint2hrstr (decode_mode_spec_buf, width, size);
        return decode_mode_spec_buf;
      }
@@ -21574,12 +21617,12 @@ decode_mode_spec (struct window *w, register int c, int field_width,
        line_number_displayed = 1;
        /* Make the string to show.  */
-        pint2str (decode_mode_spec_buf, field_width, topline + nlines);
+        pint2str (decode_mode_spec_buf, width, topline + nlines);
        return decode_mode_spec_buf;
    no_value:
        {
          char* p = decode_mode_spec_buf;
-          int pad = field_width - 2;
+          int pad = width - 2;
          while (pad-- > 0)
            *p++ = ' ';
          *p++ = '?';
@@ -29381,8 +29424,10 @@ start_hourglass (void)
    delay = make_emacs_time (DEFAULT_HOURGLASS_DELAY, 0);
 #ifdef HAVE_NTGUI
-  extern void w32_note_current_window (void);
+  {
-  w32_note_current_window ();
+    extern void w32_note_current_window (void);
+    w32_note_current_window ();
+  }
 #endif /* HAVE_NTGUI */
  hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
diff --git a/src/xfaces.c b/src/xfaces.c
index 221387c4b6d..daf329791c1 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -314,16 +314,10 @@ static Lisp_Object QCfontset;
 Lisp_Object Qnormal;
 Lisp_Object Qbold;
 static Lisp_Object Qline, Qwave;
-static Lisp_Object Qultra_light, Qreverse_oblique, Qreverse_italic;
 Lisp_Object Qextra_light, Qlight;
 Lisp_Object Qsemi_light, Qsemi_bold, Qextra_bold, Qultra_bold;
 Lisp_Object Qoblique;
 Lisp_Object Qitalic;
-static Lisp_Object Qultra_condensed, Qextra_condensed;
-Lisp_Object Qcondensed;
-static Lisp_Object Qsemi_condensed, Qsemi_expanded, Qextra_expanded;
-Lisp_Object Qexpanded;
-static Lisp_Object Qultra_expanded;
 static Lisp_Object Qreleased_button, Qpressed_button;
 static Lisp_Object QCstyle, QCcolor, QCline_width;
 Lisp_Object Qunspecified;       /* used in dosfns.c */
@@ -669,23 +663,6 @@ x_free_gc (struct frame *f, GC gc)
 }
 #endif  /* HAVE_NS */
-/* If FRAME is nil, return a pointer to the selected frame.
-   Otherwise, check that FRAME is a live frame, and return a pointer
-   to it.  NPARAM is the parameter number of FRAME, for
-   CHECK_LIVE_FRAME.  This is here because it's a frequent pattern in
-   Lisp function definitions.  */
-static struct frame *
-frame_or_selected_frame (Lisp_Object frame, int nparam)
-{
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  return XFRAME (frame);
-}
 /***********************************************************************
                           Frames and faces
 ***********************************************************************/
@@ -1204,15 +1181,9 @@ FRAME specifies the frame and thus the display for interpreting COLOR.
 If FRAME is nil or omitted, use the selected frame.  */)
  (Lisp_Object color, Lisp_Object frame)
 {
-  struct frame *f;
  CHECK_STRING (color);
-  if (NILP (frame))
+  return (face_color_gray_p (decode_any_frame (frame), SSDATA (color))
-    frame = selected_frame;
+          ? Qt : Qnil);
-  else
-    CHECK_FRAME (frame);
-  f = XFRAME (frame);
-  return face_color_gray_p (f, SSDATA (color)) ? Qt : Qnil;
 }
@@ -1225,17 +1196,10 @@ If FRAME is nil or omitted, use the selected frame.
 COLOR must be a valid color name.  */)
  (Lisp_Object color, Lisp_Object frame, Lisp_Object background_p)
 {
-  struct frame *f;
  CHECK_STRING (color);
-  if (NILP (frame))
+  return (face_color_supported_p (decode_any_frame (frame),
-    frame = selected_frame;
+                                  SSDATA (color), !NILP (background_p))
-  else
+          ? Qt : Qnil);
-    CHECK_FRAME (frame);
-  f = XFRAME (frame);
-  if (face_color_supported_p (f, SSDATA (color), !NILP (background_p)))
-    return Qt;
-  return Qnil;
 }
@@ -1683,9 +1647,7 @@ the WIDTH times as wide as FACE on FRAME.  */)
  /* We can't simply call check_x_frame because this function may be
     called before any frame is created.  */
-  if (NILP (frame))
+  f = decode_live_frame (frame);
-    frame = selected_frame;
-  f = frame_or_selected_frame (frame, 2);
  if (! FRAME_WINDOW_P (f))
    {
      /* Perhaps we have not yet created any frame.  */
@@ -1693,6 +1655,8 @@ the WIDTH times as wide as FACE on FRAME.  */)
      frame = Qnil;
      face = Qnil;
    }
+  else
+    XSETFRAME (frame, f);
  /* Determine the width standard for comparison with the fonts we find.  */
@@ -3679,21 +3643,12 @@ frame.  If FRAME is t, report on the defaults for face SYMBOL (for new
 frames).  If FRAME is omitted or nil, use the selected frame.  */)
  (Lisp_Object symbol, Lisp_Object keyword, Lisp_Object frame)
 {
-  Lisp_Object lface, value = Qnil;
+  struct frame *f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
+  Lisp_Object lface = lface_from_face_name (f, symbol, 1), value = Qnil;
  CHECK_SYMBOL (symbol);
  CHECK_SYMBOL (keyword);
-  if (EQ (frame, Qt))
-    lface = lface_from_face_name (NULL, symbol, 1);
-  else
-    {
-      if (NILP (frame))
-        frame = selected_frame;
-      CHECK_LIVE_FRAME (frame);
-      lface = lface_from_face_name (XFRAME (frame), symbol, 1);
-    }
  if (EQ (keyword, QCfamily))
    value = LFACE_FAMILY (lface);
  else if (EQ (keyword, QCfoundry))
@@ -3876,7 +3831,7 @@ return the font name used for CHARACTER.  */)
    }
  else
    {
-      struct frame *f = frame_or_selected_frame (frame, 1);
+      struct frame *f = decode_live_frame (frame);
      int face_id = lookup_named_face (f, face, 1);
      struct face *fface = FACE_FROM_ID (f, face_id);
@@ -3963,14 +3918,11 @@ If FRAME is omitted or nil, use the selected frame.  */)
  struct frame *f;
  Lisp_Object lface1, lface2;
-  if (EQ (frame, Qt))
+  /* Don't use check_x_frame here because this function is called
-    f = NULL;
+     before X frames exist.  At that time, if FRAME is nil,
-  else
+     selected_frame will be used which is the frame dumped with
-    /* Don't use check_x_frame here because this function is called
+     Emacs.  That frame is not an X frame.  */
-       before X frames exist.  At that time, if FRAME is nil,
+  f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
-       selected_frame will be used which is the frame dumped with
-       Emacs.  That frame is not an X frame.  */
-    f = frame_or_selected_frame (frame, 2);
  lface1 = lface_from_face_name (f, face1, 1);
  lface2 = lface_from_face_name (f, face2, 1);
@@ -3988,20 +3940,10 @@ If FRAME is t, report on the defaults for face FACE (for new frames).
 If FRAME is omitted or nil, use the selected frame.  */)
  (Lisp_Object face, Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
-  Lisp_Object lface;
+  Lisp_Object lface = lface_from_face_name (f, face, 1);
  int i;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
-  if (EQ (frame, Qt))
-    lface = lface_from_face_name (NULL, face, 1);
-  else
-    lface = lface_from_face_name (f, face, 1);
  for (i = 1; i < LFACE_VECTOR_SIZE; ++i)
    if (!UNSPECIFIEDP (AREF (lface, i)))
      break;
@@ -4016,8 +3958,7 @@ DEFUN ("frame-face-alist", Fframe_face_alist, Sframe_face_alist,
 For internal use only.  */)
  (Lisp_Object frame)
 {
-  struct frame *f = frame_or_selected_frame (frame, 0);
+  return decode_live_frame (frame)->face_alist;
-  return f->face_alist;
 }
@@ -4205,14 +4146,9 @@ or lists of the form (RED GREEN BLUE).
 If FRAME is unspecified or nil, the current frame is used.  */)
  (Lisp_Object color1, Lisp_Object color2, Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = decode_live_frame (frame);
  XColor cdef1, cdef2;
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (!(CONSP (color1) && parse_rgb_list (color1, &cdef1))
      && !(STRINGP (color1) && defined_color (f, SSDATA (color1), &cdef1, 0)))
    signal_error ("Invalid color", color1);
@@ -5076,17 +5012,14 @@ face for italic.  */)
  else
    {
      /* Find any frame on DISPLAY.  */
-      Lisp_Object fl_tail;
+      Lisp_Object tail;
      frame = Qnil;
-      for (fl_tail = Vframe_list; CONSP (fl_tail); fl_tail = XCDR (fl_tail))
+      FOR_EACH_FRAME (tail, frame)
-        {
+        if (!NILP (Fequal (Fcdr (Fassq (Qdisplay,
-          frame = XCAR (fl_tail);
+                                        XFRAME (frame)->param_alist)),
-          if (!NILP (Fequal (Fcdr (Fassq (Qdisplay,
+                           display)))
-                                          XFRAME (frame)->param_alist)),
+          break;
-                             display)))
-            break;
-        }
    }
  CHECK_LIVE_FRAME (frame);
@@ -6509,7 +6442,6 @@ syms_of_xfaces (void)
  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");
@@ -6519,16 +6451,6 @@ syms_of_xfaces (void)
  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");
diff --git a/src/xfns.c b/src/xfns.c
index d497cffe3df..1f98e9fc8c7 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -164,12 +164,8 @@ have_menus_p (void)
 FRAME_PTR
 check_x_frame (Lisp_Object frame)
 {
-  FRAME_PTR f;
+  struct frame *f = decode_live_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
  if (! FRAME_X_P (f))
    error ("Non-X frame used");
  return f;
@@ -228,13 +224,11 @@ x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
  Lisp_Object tail, frame;
  struct frame *f;
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
      f = XFRAME (frame);
      if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
        continue;
@@ -274,18 +268,16 @@ struct frame *
 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
 {
  Lisp_Object tail, frame;
-  struct frame *f, *found;
+  struct frame *f, *found = NULL;
  struct x_output *x;
-  if (wdesc == None) return NULL;
+  if (wdesc == None)
+    return NULL;
-  found = NULL;
+  FOR_EACH_FRAME (tail, frame)
-  for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
    {
-      frame = XCAR (tail);
+      if (found)
-      if (!FRAMEP (frame))
+        break;
-        continue;
      f = XFRAME (frame);
      if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
        {
@@ -329,13 +321,11 @@ x_menubar_window_to_frame (struct x_display_info *dpyinfo, XEvent *event)
  struct frame *f;
  struct x_output *x;
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
      f = XFRAME (frame);
      if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
        continue;
@@ -363,13 +353,11 @@ x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
  struct frame *f;
  struct x_output *x;
-  if (wdesc == None) return 0;
+  if (wdesc == None)
+    return NULL;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
      f = XFRAME (frame);
      if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
        continue;
@@ -3000,16 +2988,14 @@ x_default_font_parameter (struct frame *f, Lisp_Object parms)
 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
       0, 1, 0,
       doc: /* Send the size hints for frame FRAME to the window manager.
-If FRAME is nil, use the selected frame.  */)
+If FRAME is omitted or nil, use the selected frame.
+Signal error if FRAME is not an X frame.  */)
  (Lisp_Object frame)
 {
-  struct frame *f;
+  struct frame *f = check_x_frame (frame);
-  if (NILP (frame))
-    frame = selected_frame;
-  f = XFRAME (frame);
  block_input ();
-  if (FRAME_X_P (f))
+  x_wm_set_size_hint (f, 0, 0);
-    x_wm_set_size_hint (f, 0, 0);
  unblock_input ();
  return Qnil;
 }
@@ -3111,9 +3097,6 @@ This function is an internal primitive--use `make-frame' instead.  */)
  XSETFRAME (frame, f);
-  /* Note that X Windows does support scroll bars.  */
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
  f->terminal = dpyinfo->terminal;
  f->output_method = output_x_window;
@@ -4596,7 +4579,6 @@ x_create_tip_frame (struct x_display_info *dpyinfo,
  Finsert (1, &text);
  set_buffer_internal_1 (old_buffer);
-  FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
  record_unwind_protect (unwind_create_tip_frame, frame);
  f->terminal = dpyinfo->terminal;
diff --git a/src/xmenu.c b/src/xmenu.c
index 01d932cf8d8..b585df2125b 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -132,11 +132,8 @@ menubar_id_to_frame (LWLIB_ID id)
  Lisp_Object tail, frame;
  FRAME_PTR f;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      frame = XCAR (tail);
-      if (!FRAMEP (frame))
-        continue;
      f = XFRAME (frame);
      if (!FRAME_WINDOW_P (f))
        continue;
diff --git a/src/xselect.c b/src/xselect.c
index de9386bd7d9..64c64fa0c76 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1940,7 +1940,7 @@ x_handle_selection_notify (XSelectionEvent *event)
 static struct frame *
 frame_for_x_selection (Lisp_Object object)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
  struct frame *f;
  if (NILP (object))
@@ -1949,9 +1949,9 @@ frame_for_x_selection (Lisp_Object object)
      if (FRAME_X_P (f) && FRAME_LIVE_P (f))
        return f;
-      for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+      FOR_EACH_FRAME (tail, frame)
        {
-          f = XFRAME (XCAR (tail));
+          f = XFRAME (frame);
          if (FRAME_X_P (f) && FRAME_LIVE_P (f))
            return f;
        }
@@ -1959,15 +1959,14 @@ frame_for_x_selection (Lisp_Object object)
  else if (TERMINALP (object))
    {
      struct terminal *t = get_terminal (object, 1);
      if (t->type == output_x_window)
-        {
+        FOR_EACH_FRAME (tail, frame)
-          for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+          {
-            {
+            f = XFRAME (frame);
-              f = XFRAME (XCAR (tail));
+            if (FRAME_LIVE_P (f) && f->terminal == t)
-              if (FRAME_LIVE_P (f) && f->terminal == t)
+              return f;
-                return f;
+          }
-            }
-        }
    }
  else if (FRAMEP (object))
    {
diff --git a/src/xterm.c b/src/xterm.c
index f8420d13a32..463d82b4ee2 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1438,7 +1438,7 @@ static struct frame *
 x_frame_of_widget (Widget widget)
 {
  struct x_display_info *dpyinfo;
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
  struct frame *f;
  dpyinfo = x_display_info_for_display (XtDisplay (widget));
@@ -1452,15 +1452,15 @@ x_frame_of_widget (Widget widget)
  /* Look for a frame with that top-level widget.  Allocate the color
     on that frame to get the right gamma correction value.  */
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
-    if (FRAMEP (XCAR (tail))
+    {
-        && (f = XFRAME (XCAR (tail)),
+      f = XFRAME (frame);
-            (FRAME_X_P (f)
+      if (FRAME_X_P (f)
-             && f->output_data.nothing != 1
+          && f->output_data.nothing != 1
-             && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
+          && FRAME_X_DISPLAY_INFO (f) == dpyinfo
-        && f->output_data.x->widget == widget)
+          && f->output_data.x->widget == widget)
-      return f;
+        return f;
+    }
  emacs_abort ();
 }
@@ -4098,20 +4098,15 @@ XTmouse_position (FRAME_PTR *fp, int insist, Lisp_Object *bar_window,
 static struct scroll_bar *
 x_window_to_scroll_bar (Display *display, Window window_id)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
  window_id = (Window) xg_get_scroll_id_for_window (display, window_id);
 #endif /* USE_GTK  && USE_TOOLKIT_SCROLL_BARS */
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
    {
-      Lisp_Object frame, bar, condemned;
+      Lisp_Object bar, condemned;
-      frame = XCAR (tail);
-      /* All elements of Vframe_list should be frames.  */
-      if (! FRAMEP (frame))
-        emacs_abort ();
      if (! FRAME_X_P (XFRAME (frame)))
        continue;
@@ -4143,20 +4138,16 @@ x_window_to_scroll_bar (Display *display, Window window_id)
 static Widget
 x_window_to_menu_bar (Window window)
 {
-  Lisp_Object tail;
+  Lisp_Object tail, frame;
-  for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
+  FOR_EACH_FRAME (tail, frame)
-    {
+    if (FRAME_X_P (XFRAME (frame)))
-      if (FRAME_X_P (XFRAME (XCAR (tail))))
+      {
-        {
+        Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
-          Lisp_Object frame = XCAR (tail);
-          Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
-          if (menu_bar && xlwmenu_window_p (menu_bar, window))
-            return menu_bar;
-        }
-    }
+        if (menu_bar && xlwmenu_window_p (menu_bar, window))
+          return menu_bar;
+      }
  return NULL;
 }
@@ -6108,7 +6099,6 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
        SELECTION_EVENT_DISPLAY (&inev.sie) = eventp->display;
        SELECTION_EVENT_SELECTION (&inev.sie) = eventp->selection;
        SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
-        inev.ie.frame_or_window = Qnil;
      }
      break;
@@ -6128,7 +6118,6 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
          SELECTION_EVENT_TARGET (&inev.sie) = eventp->target;
          SELECTION_EVENT_PROPERTY (&inev.sie) = eventp->property;
          SELECTION_EVENT_TIME (&inev.sie) = eventp->time;
-          inev.ie.frame_or_window = Qnil;
      }
      break;
@@ -10870,10 +10859,10 @@ default is nil, which is the same as `super'.  */);
  DEFVAR_LISP ("x-keysym-table", Vx_keysym_table,
    doc: /* Hash table of character codes indexed by X keysym codes.  */);
-  Vx_keysym_table = make_hash_table (Qeql, make_number (900),
+  Vx_keysym_table = make_hash_table (hashtest_eql, make_number (900),
                                     make_float (DEFAULT_REHASH_SIZE),
                                     make_float (DEFAULT_REHASH_THRESHOLD),
-                                     Qnil, Qnil, Qnil);
+                                     Qnil);
 }
 #endif /* HAVE_X_WINDOWS */
diff --git a/src/xterm.h b/src/xterm.h
index 4bc8f9813ed..6ef3d11fe48 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -890,10 +890,8 @@ struct scroll_bar
   by this structure.  */
 /* For an event of kind SELECTION_REQUEST_EVENT,
-   this structure really describes the contents.
+   this structure really describes the contents.  */
-   **Don't make this struct longer!**
-   If it overlaps the frame_or_window field of struct input_event,
-   that will cause GC to crash.  */
 struct selection_input_event
 {
  int kind;