upstream

41 files changed, 1332 insertions, 965 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 835c550b426..37907cd555a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,384 @@
+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)
+
+2012-10-31  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix crash when using Emacs as commit editor for git (Bug#12697).
+        * callproc.c (setpgrp): Remove macro, as we now use setpgid
+        and it is configured in conf_post.h.
+        (Fcall_process): Don't invoke both setsid and setpgid; the former
+        is enough, if it exists.
+        * callproc.c (Fcall_process, child_setup):
+        * process.c (create_process): Use setpgid.
+        * conf_post.h (setpgid) [!HAVE_SETPGID]: New macro, which substitutes
+        for the real thing.
+        * dispnew.c (init_display): Initialize the foreground group
+        if we are running a tty display.
+        * emacs.c (main): Do not worry about setpgrp; init_display does it now.
+        * lisp.h (init_foreground_group): New decl.
+        * sysdep.c (inherited_pgroup): New static var.
+        (init_foreground_group, tcsetpgrp_without_stopping)
+        (narrow_foreground_group, widen_foreground_group): New functions.
+        (init_sys_modes): Narrow foreground group.
+        (reset_sys_modes): Widen foreground group.
+
+2012-10-31  Michael Albinus  <michael.albinus@gmx.de>
+
+        * dbusbind.c: Fix cut'n'waste error.  Use HAVE_DBUS_VALIDATE_INTERFACE.
+
+2012-10-31  Martin Rudalics  <rudalics@gmx.at>
+
+        * minibuf.c (read_minibuf): Restore current buffer since
+        choose_minibuf_frame calling Fset_frame_selected_window may
+        change it (Bug#12766).
+
+2012-10-30  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * frame.c (Fframe_pixel_height): Fix documentation (Bug#12733).
+
+2012-10-30  Kenichi Handa  <handa@gnu.org>
+
+        * font.c (Ffont_at): If WINDOW is specified and it is not
+        displaying the current buffer, signal an error.
+
+2012-10-29  Daniel Colascione  <dancol@dancol.org>
+
+        * cygw32.h, cygw32.c (Qutf_16le, from_unicode, to_unicode): In
+        preparation for fixing bug#12739, move these functions from
+        here...
+
+        * coding.h, coding.c: ... to here, and compile them only when
+        WINDOWSNT or CYGWIN.  Moving these functions out of cygw32 proper
+        lets us write cygw32-agnostic code for the HAVE_NTGUI case.
+
+2012-10-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (TIMER_TICKS_PER_SEC): New macro.
+        (timer_loop, getitimer, setitimer): Use it instead of
+        CLOCKS_PER_SEC, which is no longer pertinent, since we don't use
+        'clock'.
+        (w32_get_timer_time): Use 10*TIMER_TICKS_PER_SEC instead of a
+        literal 10000.
+
+2012-10-28  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (NO_APPDEFINED_DATA): New define.
+        (last_appdefined_event_data): New variable
+        (last_appdefined_event): Remove.
+        (ns_select): Initialize t from last_appdefined_event_data instead
+        of [last_appdefined_event data1].
+        (sendEvent:): Save [theEvent data1] to last_appdefined_event_data,
+        remove last_appdefined_event (Bug#12698).
+
+2012-10-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * frame.c (x_set_font): Catch internal error.
+
+2012-10-27  Eli Zaretskii  <eliz@gnu.org>
+
+        Avoid overflow in w32 implementation of interval timers.
+        When possible, for ITIMER_PROF count only times the main thread
+        actually executes.
+        * w32proc.c <struct itimer_data>: 'expire' and 'reload' are now
+        'volatile ULONGLONG' types.  All the other data which was
+        previously clock_t is now ULONGLONG.  'terminate' is 'volatile int'.
+        (GetThreadTimes_Proc): New typedef.
+        (w32_get_timer_time): New function, returns a suitable time value
+        for the timer.
+        (timer_loop): Enter critical section when accessing ULONGLONG
+        values of the itimer_data struct, as these accesses are no longer
+        atomic.  Call 'w32_get_timer_time' instead of 'clock'.
+        Remove unused variable.
+        (init_timers): Initialize s_pfn_Get_Thread_Times.
+        (start_timer_thread): Don't assign itimer->caller_thread here.
+        (getitimer): Assign itimer->caller_thread here.
+        (setitimer): Always call getitimer to get the value of ticks_now.
+        (sys_spawnve): Avoid compiler warning about format mismatch.
+
+2012-10-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_wnd_proc) <WM_MOUSEMOVE>: Don't enable tracking of
+        mouse movement events if the menu bar is active.  This avoids
+        producing a busy "hour-glass" cursor by Windows if the mouse
+        pointer is positioned over a tooltip shown for some menu item.
+
 2012-10-25  Paul Eggert  <eggert@cs.ucla.edu>
 
         Don't assume process IDs fit in int.
@@ -64,8 +445,8 @@
 
 2012-10-19  Eli Zaretskii  <eliz@gnu.org>
 
-        * puresize.h (BASE_PURESIZE): Bump the base value to 1700000.  See
-        http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00593.html
+        * puresize.h (BASE_PURESIZE): Bump the base value to 1700000.
+        See http://lists.gnu.org/archive/html/emacs-devel/2012-10/msg00593.html
         for the reasons.
 
         * alloc.c (NSTATICS): Decrease to 0x800.
@@ -523,7 +904,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
@@ -684,8 +1065,8 @@
         (ns_clear_frame_area): Remove resize handle code.
 
         * nsfns.m (ns_in_resize): Remove.
-        (x_set_icon_name, ns_set_name, ns_set_name_as_filename): Remove
-        ns_in_resize check.
+        (x_set_icon_name, ns_set_name, ns_set_name_as_filename):
+        Remove ns_in_resize check.
 
 2012-10-07  Paul Eggert  <eggert@cs.ucla.edu>
 
@@ -6006,7 +6387,7 @@
         * lisp.h (make_formatted_string): New prototype.
         * alloc.c (make_formatted_string): New function.
         * buffer.c (Fgenerate_new_buffer_name): Use it.
-        * dbus.c (syms_of_dbusbind): Likewise.
+        * dbusbind.c (syms_of_dbusbind): Likewise.
         * editfns.c (Fcurrent_time_zone): Likewise.
         * filelock.c (get_boot_time): Likewise.
         * frame.c (make_terminal_frame, set_term_frame_name)
diff --git a/src/buffer.c b/src/buffer.c
index 0b3dde27968..bb69675346a 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;
-  Lisp_Object notsogood = Qnil;
+  struct frame *f = decode_any_frame (frame);
+  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 */
@@ -6210,15 +6203,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
-  nil             don't display a cursor
-  box             display a filled box cursor
-  hollow          display a hollow box cursor
-  bar             display a vertical bar cursor with default width
-  (bar . WIDTH)   display a vertical bar cursor with width WIDTH
-  hbar            display a horizontal bar cursor with default height
+  t               use the cursor specified for the frame
+  nil             don't display a cursor
+  box             display a filled box cursor
+  hollow          display a hollow box cursor
+  bar             display a vertical bar cursor with default width
+  (bar . WIDTH)   display a vertical bar cursor with width WIDTH
+  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/callproc.c b/src/callproc.c
index b33882e54c2..c7bbe36e605 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -64,13 +64,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "nsterm.h"
 #endif
 
-#ifdef HAVE_SETPGID
-#if !defined (USG)
-#undef setpgrp
-#define setpgrp setpgid
-#endif
-#endif
-
 /* Pattern used by call-process-region to make temp files.  */
 static Lisp_Object Vtemp_file_name_pattern;
 
@@ -618,14 +611,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
       {
         if (fd[0] >= 0)
           emacs_close (fd[0]);
-#ifdef HAVE_SETSID
+
         setsid ();
-#endif
-#if defined (USG)
-        setpgrp ();
-#else
-        setpgrp (pid, pid);
-#endif /* USG */
 
         /* Emacs ignores SIGPIPE, but the child should not.  */
         signal (SIGPIPE, SIG_DFL);
@@ -1295,15 +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 (USG)
-#ifndef SETPGRP_RELEASES_CTTY
-  setpgrp ();                   /* No arguments but equivalent in this case */
-#endif
-#else /* not USG */
-  setpgrp (pid, pid);
-#endif /* not USG */
-
-  /* setpgrp_of_tty is incorrect here; it uses input_fd.  */
+  setpgid (0, 0);
   tcsetpgrp (0, pid);
 
   /* execvp does not accept an environment arg so the only way
diff --git a/src/coding.c b/src/coding.c
index 7628a9fbf2e..56202e4861d 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -343,6 +343,10 @@ Lisp_Object Qcoding_system_p, Qcoding_system_error;
 Lisp_Object Qemacs_mule, Qraw_text;
 Lisp_Object Qutf_8_emacs;
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+static Lisp_Object Qutf_16le;
+#endif
+
 /* Coding-systems are handed between Emacs Lisp programs and C internal
    routines by the following three variables.  */
 /* Coding system to be used to encode text for terminal display when
@@ -7971,6 +7975,40 @@ preferred_coding_system (void)
   return CODING_ID_NAME (id);
 }
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+
+Lisp_Object
+from_unicode (Lisp_Object str)
+{
+  CHECK_STRING (str);
+  if (!STRING_MULTIBYTE (str) &&
+      SBYTES (str) & 1)
+    {
+      str = Fsubstring (str, make_number (0), make_number (-1));
+    }
+
+  return code_convert_string_norecord (str, Qutf_16le, 0);
+}
+
+wchar_t *
+to_unicode (Lisp_Object str, Lisp_Object *buf)
+{
+  *buf = code_convert_string_norecord (str, Qutf_16le, 1);
+  /* We need to make a another copy (in addition to the one made by
+     code_convert_string_norecord) to ensure that the final string is
+     _doubly_ zero terminated --- that is, that the string is
+     terminated by two zero bytes and one utf-16le null character.
+     Because strings are already terminated with a single zero byte,
+     we just add one additional zero. */
+  str = make_uninit_string (SBYTES (*buf) + 1);
+  memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf));
+  SDATA (str) [SBYTES (*buf)] = '\0';
+  *buf = str;
+  return WCSDATA (*buf);
+}
+
+#endif /* WINDOWSNT || CYGWIN */
+
 
 #ifdef emacs
 /*** 8. Emacs Lisp library functions ***/
@@ -10284,6 +10322,11 @@ syms_of_coding (void)
   DEFSYM (Qutf_8, "utf-8");
   DEFSYM (Qutf_8_emacs, "utf-8-emacs");
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+  /* No, not utf-16-le: that one has a BOM.  */
+  DEFSYM (Qutf_16le, "utf-16le");
+#endif
+
   DEFSYM (Qutf_16, "utf-16");
   DEFSYM (Qbig, "big");
   DEFSYM (Qlittle, "little");
diff --git a/src/coding.h b/src/coding.h
index 989552bf667..192be58f083 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -701,6 +701,28 @@ extern void encode_coding_object (struct coding_system *,
                                   Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
 
+#if defined (WINDOWSNT) || defined (CYGWIN)
+
+/* These functions use Lisp string objects to store the UTF-16LE
+   strings that modern versions of Windows expect.  These strings are
+   not particularly useful to Lisp, and all Lisp strings should be
+   native Emacs multibyte.  */
+
+/* Access the wide-character string stored in a Lisp string object.  */
+#define WCSDATA(x) ((wchar_t *) SDATA (x))
+
+/* Convert the multi-byte string in STR to UTF-16LE encoded unibyte
+   string, and store it in *BUF.  BUF may safely point to STR on entry.  */
+extern wchar_t *to_unicode (Lisp_Object str, Lisp_Object *buf);
+
+/* Convert STR, a UTF-16LE encoded string embedded in a unibyte string
+   object, to a multi-byte Emacs string and return it.  This function
+   calls code_convert_string_norecord internally and has all its
+   failure modes.  STR itself is not modified.  */
+extern Lisp_Object from_unicode (Lisp_Object str);
+
+#endif /* WINDOWSNT || CYGWIN */
+
 /* Macros for backward compatibility.  */
 
 #define decode_coding_region(coding, from, to)          \
diff --git a/src/conf_post.h b/src/conf_post.h
index aa008107ba6..66390ddf103 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -110,8 +110,17 @@ 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.  */
 
+#define emacs_raise(sig) msdos_fatal_signal (sig)
+
 /* Define one of these for easier conditionals.  */
 #ifdef HAVE_X_WINDOWS
 /* We need a little extra space, see ../../lisp/loadup.el and the
diff --git a/src/cygw32.c b/src/cygw32.c
index 8f63461da2a..54f2076a891 100644
--- a/src/cygw32.c
+++ b/src/cygw32.c
@@ -22,7 +22,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "buffer.h"
 #include <unistd.h>
 #include <fcntl.h>
-static Lisp_Object Qutf_16le;
 
 static Lisp_Object
 fchdir_unwind (Lisp_Object dir_fd)
@@ -107,36 +106,6 @@ conv_filename_from_w32_unicode (const wchar_t* in, int absolute_p)
   return unbind_to (count, DECODE_FILE (converted));
 }
 
-Lisp_Object
-from_unicode (Lisp_Object str)
-{
-  CHECK_STRING (str);
-  if (!STRING_MULTIBYTE (str) &&
-      SBYTES (str) & 1)
-    {
-      str = Fsubstring (str, make_number (0), make_number (-1));
-    }
-
-  return code_convert_string_norecord (str, Qutf_16le, 0);
-}
-
-wchar_t *
-to_unicode (Lisp_Object str, Lisp_Object *buf)
-{
-  *buf = code_convert_string_norecord (str, Qutf_16le, 1);
-  /* We need to make a another copy (in addition to the one made by
-     code_convert_string_norecord) to ensure that the final string is
-     _doubly_ zero terminated --- that is, that the string is
-     terminated by two zero bytes and one utf-16le null character.
-     Because strings are already terminated with a single zero byte,
-     we just add one additional zero. */
-  str = make_uninit_string (SBYTES (*buf) + 1);
-  memcpy (SDATA (str), SDATA (*buf), SBYTES (*buf));
-  SDATA (str) [SBYTES (*buf)] = '\0';
-  *buf = str;
-  return WCSDATA (*buf);
-}
-
 DEFUN ("cygwin-convert-path-to-windows",
        Fcygwin_convert_path_to_windows, Scygwin_convert_path_to_windows,
        1, 2, 0,
@@ -162,8 +131,6 @@ DEFUN ("cygwin-convert-path-from-windows",
 void
 syms_of_cygw32 (void)
 {
-  /* No, not utf-16-le: that one has a BOM.  */
-  DEFSYM (Qutf_16le, "utf-16le");
   defsubr (&Scygwin_convert_path_from_windows);
   defsubr (&Scygwin_convert_path_to_windows);
 }
diff --git a/src/cygw32.h b/src/cygw32.h
index 78e77a9a141..51571913fd1 100644
--- a/src/cygw32.h
+++ b/src/cygw32.h
@@ -33,20 +33,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "lisp.h"
 #include "coding.h"
 
-/* *** Character conversion *** */
-
-/* Access the wide-character string stored in a Lisp string object.  */
-#define WCSDATA(x) ((wchar_t *) SDATA (x))
-
-/* Convert the multi-byte string in STR to UTF-16LE encoded unibyte
-   string, and store it in *BUF.  BUF may safely point to STR on entry.  */
-extern wchar_t *to_unicode (Lisp_Object str, Lisp_Object *buf);
-
-/* Convert STR, a UTF-16LE encoded string embedded in a unibyte string
-   object, to a multi-byte Emacs string, and return it.  */
-extern Lisp_Object from_unicode (Lisp_Object str);
-
-/* *** Misc *** */
 extern void syms_of_cygw32 (void);
 extern char * w32_strerror (int error_no);
 
diff --git a/src/dbusbind.c b/src/dbusbind.c
index 08f34f47042..80086946fc4 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -299,8 +299,8 @@ xd_symbol_to_dbus_type (Lisp_Object object)
       }                                                                 \
   } while (0)
 
-#if (HAVE_DBUS_VALIDATE_BUS_NAME || HAVE_DBUS_VALIDATE_PATH \
-     || XD_DBUS_VALIDATE_OBJECT || HAVE_DBUS_VALIDATE_MEMBER)
+#if (HAVE_DBUS_VALIDATE_BUS_NAME || HAVE_DBUS_VALIDATE_PATH             \
+     || HAVE_DBUS_VALIDATE_INTERFACE || HAVE_DBUS_VALIDATE_MEMBER)
 #define XD_DBUS_VALIDATE_OBJECT(object, func)                           \
   do {                                                                  \
     if (!NILP (object))                                                 \
diff --git a/src/dispnew.c b/src/dispnew.c
index 89cca68c127..7a0901aafd6 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -56,9 +56,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 <stdio_ext.h>
-#endif
+#include <fpending.h>
 
 #if defined (HAVE_TERM_H) && defined (GNU_LINUX)
 #include <term.h>               /* for tgetent */
@@ -3075,14 +3073,12 @@ window_to_frame_hpos (struct window *w, int hpos)
                             Redrawing Frames
  **********************************************************************/
 
-DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 1, 1, 0,
-       doc: /* Clear frame FRAME and output again what is supposed to appear on it.  */)
+DEFUN ("redraw-frame", Fredraw_frame, Sredraw_frame, 0, 1, 0,
+       doc: /* Clear frame FRAME and output again what is supposed to appear on it.
+If FRAME is omitted or nil, the selected frame is used.  */)
   (Lisp_Object frame)
 {
-  struct frame *f;
-
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
+  struct frame *f = decode_live_frame (frame);
 
   /* Ignore redraw requests, if frame has no glyphs yet.
      (Implementation note: It still has to be checked why we are
@@ -4658,24 +4654,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);
-                      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);
-                        }
-                    }
+                    fflush (display_output);
                 }
             }
 
@@ -6294,6 +6276,8 @@ init_display (void)
     struct terminal *t;
     struct frame *f = XFRAME (selected_frame);
 
+    init_foreground_group ();
+
     /* Open a display on the controlling tty. */
     t = init_tty (0, terminal_type, 1); /* Errors are fatal. */
 
@@ -6384,15 +6368,7 @@ don't show a cursor.  */)
   /* Don't change cursor state while redisplaying.  This could confuse
      output routines.  */
   if (!redisplaying_p)
-    {
-      if (NILP (window))
-        window = selected_window;
-      else
-        CHECK_WINDOW (window);
-
-      XWINDOW (window)->cursor_off_p = NILP (show);
-    }
-
+    decode_any_window (window)->cursor_off_p = NILP (show);
   return Qnil;
 }
 
@@ -6403,15 +6379,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;
-
-  if (NILP (window))
-    window = selected_window;
-  else
-    CHECK_WINDOW (window);
-
-  w = XWINDOW (window);
-  return w->cursor_off_p ? Qnil : Qt;
+  return decode_any_window (window)->cursor_off_p ? Qnil : Qt;
 }
 
 DEFUN ("last-nonminibuffer-frame", Flast_nonminibuf_frame,
diff --git a/src/emacs.c b/src/emacs.c
index 168eb35d3a3..894e4d3cb30 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"
@@ -678,6 +679,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
@@ -734,6 +751,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++;
@@ -1085,28 +1104,21 @@ 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);
 #endif /* DOS_NT */
     }
 
+#if defined (HAVE_PTHREAD) && !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC)
   if (! noninteractive)
     {
-#if defined (USG5) && defined (INTERRUPT_INPUT)
-      setpgrp ();
-#endif
-#if defined (HAVE_PTHREAD) && !defined (SYSTEM_MALLOC) && !defined (DOUG_LEA_MALLOC)
-      {
-        extern void malloc_enable_thread (void);
+      extern void malloc_enable_thread (void);
 
-        malloc_enable_thread ();
-      }
-#endif
+      malloc_enable_thread ();
     }
+#endif
 
   init_signals (dumping);
 
@@ -1878,8 +1890,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);
@@ -1909,7 +1919,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/font.c b/src/font.c
index bff2356d6ca..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))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  font_close_object (XFRAME (frame), font_object);
+  font_close_object (decode_live_frame (frame), font_object);
   return Qnil;
 }
 
@@ -4760,18 +4747,20 @@ FONT is a font-spec, font-entity, or font-object. */)
 DEFUN ("font-at", Ffont_at, Sfont_at, 1, 3, 0,
        doc: /* Return a font-object for displaying a character at POSITION.
 Optional second arg WINDOW, if non-nil, is a window displaying
-the current buffer.  It defaults to the currently selected window.  */)
+the current buffer.  It defaults to the currently selected window.
+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;
-  ptrdiff_t pos;
+  struct window *w = decode_live_window (window);
 
   if (NILP (string))
     {
+      if (XBUFFER (w->buffer) != current_buffer)
+        error ("Specified window is not displaying the current buffer.");
       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
     {
@@ -4779,14 +4768,9 @@ the current buffer.  It defaults to the currently selected window.  */)
       CHECK_STRING (string);
       if (! (0 <= XINT (position) && XINT (position) < SCHARS (string)))
         args_out_of_range (string, position);
-      pos = XINT (position);
     }
-  if (NILP (window))
-    window = selected_window;
-  CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
 
-  return font_at (-1, pos, NULL, w, string);
+  return font_at (-1, XINT (position), NULL, w, string);
 }
 
 #if 0
@@ -4850,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;
@@ -4859,10 +4843,7 @@ If the named font is not yet loaded, return nil.  */)
 
   if (! FONTP (name))
     CHECK_STRING (name);
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
+  f = decode_live_frame (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))
-    *frame = selected_frame;
-  CHECK_LIVE_FRAME (*frame);
+  XSETFRAME (*frame, f);
 
   if (EQ (name, Qt))
     return Vdefault_fontset;
   if (NILP (name))
-    {
-      id = FRAME_FONTSET (XFRAME (*frame));
-    }
+    id = FRAME_FONTSET (f);
   else
     {
       CHECK_STRING (name);
diff --git a/src/frame.c b/src/frame.c
index 6478ad1e06f..52be8be270e 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;
 
@@ -1120,23 +1135,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,9 +1152,11 @@ 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;
 
@@ -1665,25 +1671,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))
-    frame = selected_frame;
-
-  CHECK_LIVE_FRAME (frame);
+  struct frame *f = decode_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));
-      x_make_frame_visible (XFRAME (frame));
+      FRAME_SAMPLE_VISIBILITY (f);
+      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 +1728,13 @@ always considered visible, whether or not they are currently being
 displayed in the terminal.  */)
   (Lisp_Object frame, Lisp_Object force)
 {
-  if (NILP (frame))
-    frame = selected_frame;
+  struct frame *f = decode_live_frame (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 +1746,8 @@ displayed in the terminal.  */)
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
-  if (FRAME_WINDOW_P (XFRAME (frame)))
-    x_make_frame_invisible (XFRAME (frame));
+  if (FRAME_WINDOW_P (f))
+    x_make_frame_invisible (f);
 #endif
 
   /* Make menu bar update for the Buffers and Frames menus.  */
@@ -1761,19 +1762,10 @@ DEFUN ("iconify-frame", Ficonify_frame, Siconify_frame,
 If omitted, FRAME defaults to the currently selected frame.  */)
   (Lisp_Object frame)
 {
-  if (NILP (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
+  struct frame *f = decode_live_frame (frame);
 
   /* 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 +1777,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)))
-      x_iconify_frame (XFRAME (frame));
+  if (FRAME_WINDOW_P (f))
+      x_iconify_frame (f);
 #endif
 
   /* Make menu bar update for the Buffers and Frames menus.  */
@@ -1850,13 +1842,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;
-  if (NILP (frame))
-    frame = selected_frame;
+  struct frame *f = decode_live_frame (frame);
 
-  CHECK_LIVE_FRAME (frame);
-
-  f = XFRAME (frame);
+  XSETFRAME (frame, f);
 
   if (FRAME_TERMCAP_P (f))
     /* On a text terminal select FRAME.  */
@@ -1879,14 +1867,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;
-
-  if (NILP (frame))
-    frame = selected_frame;
-
-  CHECK_LIVE_FRAME (frame);
-
-  f = XFRAME (frame);
+  struct frame *f = decode_live_frame (frame);
 
   if (FRAME_TERMINAL (f)->frame_raise_lower_hook)
     (*FRAME_TERMINAL (f)->frame_raise_lower_hook) (f, 0);
@@ -1922,18 +1903,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 +1920,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 (XFRAME (frame));
+  return FRAME_FOCUS_FRAME (decode_live_frame (frame));
 }
 
 
@@ -1974,22 +1950,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 +2128,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 +2196,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, Qburied_buffer_list,
-                  XFRAME (frame)->buried_buffer_list);
+  store_in_alist (&alist, Qbuffer_list, f->buffer_list);
+  store_in_alist (&alist, Qburied_buffer_list, f->buried_buffer_list);
 
   /* I think this should be done with a hook.  */
 #ifdef HAVE_WINDOW_SYSTEM
@@ -2269,17 +2222,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;
-  Lisp_Object value;
+  struct frame *f = decode_any_frame (frame);
+  Lisp_Object value = Qnil;
 
-  if (NILP (frame))
-    frame = selected_frame;
-  else
-    CHECK_FRAME (frame);
   CHECK_SYMBOL (parameter);
 
-  f = XFRAME (frame);
-  value = Qnil;
+  XSETFRAME (frame, f);
 
   if (FRAME_LIVE_P (f))
     {
@@ -2359,14 +2307,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 +2364,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 +2382,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,30 +2400,22 @@ 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
 the minibuffer or echo area), mode line, and header line.  It does not
 include the tool bar or menu bar.
 
-With the Motif or Lucid toolkits, it also includes the tool bar (but
-not the menu bar).
-
-In a graphical version with no toolkit, it includes both the tool bar
-and menu bar.
+With other graphical versions, it also includes the tool bar and the
+menu bar.
 
 For a text terminal, it includes the menu bar.  In this case, the
 result is really in characters rather than pixels (i.e., is identical
 to `frame-height'). */)
   (Lisp_Object frame)
 {
-  struct frame *f;
-
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
+  struct frame *f = decode_any_frame (frame);
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
@@ -2504,15 +2429,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;
-
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-  f = XFRAME (frame);
+  struct frame *f = decode_any_frame (frame);
 
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
@@ -2526,17 +2446,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
-used.  */)
+or right side of FRAME.  If FRAME is omitted or nil, the selected frame
+is used.  */)
   (Lisp_Object frame)
 {
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_FRAME (frame);
-
 #ifdef FRAME_TOOLBAR_WIDTH
-  if (FRAME_WINDOW_P (XFRAME (frame)))
-    return make_number (FRAME_TOOLBAR_WIDTH (XFRAME (frame)));
+  struct frame *f = decode_any_frame (frame);
+
+  if (FRAME_WINDOW_P (f))
+    return make_number (FRAME_TOOLBAR_WIDTH (f));
 #endif
   return make_number (0);
 }
@@ -2547,13 +2465,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
@@ -2575,12 +2489,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
@@ -3242,6 +3153,9 @@ x_set_font (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
           Lisp_Object ascii_font = fontset_ascii (fontset);
           Lisp_Object spec = font_spec_from_name (ascii_font);
 
+          if (NILP (spec))
+            signal_error ("Invalid font name", ascii_font);
+
           if (! font_match_p (spec, font_object))
             fontset = -1;
         }
@@ -4294,12 +4208,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))
-    frame = selected_frame;
-
-  CHECK_FRAME (frame);
-
-  return (XFRAME (frame)->pointer_invisible ? Qnil : Qt);
+  return decode_any_frame (frame)->pointer_invisible ? Qnil : Qt;
 }
 
 
diff --git a/src/frame.h b/src/frame.h
index f8c3d99fedd..1dc3ebbaf13 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -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
-     actually display them on this frame.  */
+  /* Nonzero if we should actually display the scroll bars 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))
-    window = selected_window;
-  CHECK_WINDOW (window);
-  w = XWINDOW (window);
+  w = decode_any_window (window);
+  XSETWINDOW (window, w);
 
   if (!NILP (pos))
     {
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))
-    window = Fselected_window ();
-  else
-    CHECK_LIVE_WINDOW (window);
-  w = XWINDOW (window);
+  w = decode_live_window (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,
-                        XWINDOW (window));
+                        hscroll, tab_offset, w);
 
   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))
-    CHECK_WINDOW (window);
-  else
-    window = selected_window;
-  w = XWINDOW (window);
+  w = decode_live_window (window);
 
   old_buffer = Qnil;
   GCPRO3 (old_buffer, old_charpos, old_bytepos);
diff --git a/src/keyboard.c b/src/keyboard.c
index 2f751d0ec72..7507b29d494 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -3419,20 +3419,13 @@ int stop_character EXTERNALLY_VISIBLE;
 static KBOARD *
 event_to_kboard (struct input_event *event)
 {
-  Lisp_Object frame;
-  frame = event->frame_or_window;
-  if (CONSP (frame))
-    frame = XCAR (frame);
-  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
@@ -12193,14 +12186,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 17a9e5c1f6a..7a3b819116f 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
-       literal integer constant, for MSVC.  */
-    GCALIGNMENT =
+    /* 2**GCTYPEBITS.  This must be a macro that expands to a literal
+       integer constant, for MSVC.  */
 #define GCALIGNMENT 8
-        GCALIGNMENT,
 
     /* Number of bits in a Lisp_Object value, not counting the tag.  */
     VALBITS = BITS_PER_EMACS_INT - GCTYPEBITS,
@@ -528,14 +526,9 @@ static EMACS_INT const VALMASK
 #define EQ(x, y) (XHASH (x) == XHASH (y))
 
 /* Largest and smallest representable fixnum values.  These are the C
-   values.  They are macros for use in static initializers, and
-   constants for visibility to GDB.  */
-static EMACS_INT const MOST_POSITIVE_FIXNUM =
+   values.  They are macros for use in static initializers.  */
 #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
@@ -1796,20 +1789,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)
 
@@ -2663,9 +2642,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);
@@ -3333,7 +3309,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);
 
@@ -3479,6 +3454,7 @@ struct terminal;
 extern char *get_current_dir_name (void);
 #endif
 extern void stuff_char (char c);
+extern void init_foreground_group (void);
 extern void init_sigio (int);
 extern void sys_subshell (void);
 extern void sys_suspend (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
-## loaded by pc-win, which is.  Ditto for international/cp51932 and
-## international/eucjp-ms, loaded from language/japanese.
+## Confusingly, international/cp51932 and international/eucjp-ms are
+## unconditionally loaded from language/japanese, instead of being
+## 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/makefile.w32-in b/src/makefile.w32-in
index 5be1ccb70df..f5cab34d7dc 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -1475,8 +1475,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 \
@@ -1564,6 +1564,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/minibuf.c b/src/minibuf.c
index 2cc89e75680..dcc4af37c13 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -472,6 +472,10 @@ read_minibuf (Lisp_Object map, Lisp_Object initial, Lisp_Object prompt,
 
   /* Choose the minibuffer window and frame, and take action on them.  */
 
+  /* Prepare for restoring the current buffer since choose_minibuf_frame
+     calling Fset_frame_selected_window may change it (Bug#12766).  */
+  record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
   choose_minibuf_frame ();
 
   record_unwind_protect (choose_minibuf_frame_1, Qnil);
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
-emacs_abort (void)
+static 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/nsterm.m b/src/nsterm.m
index a4eaad47ac1..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 */
 };
 
@@ -190,7 +208,8 @@ static BOOL ns_menu_bar_is_hidden = NO;
 
 /* event loop */
 static BOOL send_appdefined = YES;
-static NSEvent *last_appdefined_event = 0;
+#define NO_APPDEFINED_DATA (-8)
+static int last_appdefined_event_data = NO_APPDEFINED_DATA;
 static NSTimer *timed_entry = 0;
 static NSTimer *scroll_repeat_entry = nil;
 static fd_set select_readfds, select_writefds;
@@ -3436,8 +3455,7 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
    -------------------------------------------------------------------------- */
 {
   int result;
-  NSEvent *ev;
-  int k, nr = 0;
+  int t, k, nr = 0;
   struct input_event event;
   char c;
 
@@ -3521,16 +3539,11 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
     }
   unblock_input ();
 
-  ev = last_appdefined_event;
+  t = last_appdefined_event_data;
 
-  if (ev)
+  if (t != NO_APPDEFINED_DATA)
     {
-      int t;
-      if ([ev type] != NSApplicationDefined)
-        emacs_abort ();
-
-      t = [ev data1];
-      last_appdefined_event = 0;
+      last_appdefined_event_data = NO_APPDEFINED_DATA;
 
       if (t == -2)
         {
@@ -4307,7 +4320,7 @@ ns_term_shutdown (int sig)
          modal loop. Just defer it until later. */
       if ([NSApp modalWindow] == nil)
         {
-          last_appdefined_event = theEvent;
+          last_appdefined_event_data = [theEvent data1];
           [self stop: self];
         }
       else
@@ -4759,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);
 
@@ -4815,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',
@@ -4828,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/process.c b/src/process.c
index 307e82819d6..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
-   process as being synchronous and say that the synchronous process is
-   dead.  */
+   treated by the SIGCHLD handler and waitpid has been invoked on them;
+   otherwise they might fill up the kernel's process table.  */
 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
-     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. */
+  /* This 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,14 +1751,6 @@ create_process (Lisp_Object process, char **new_argv, Lisp_Object current_dir)
           ioctl (xforkin, TIOCSCTTY, 0);
 #endif
         }
-#else /* not HAVE_SETSID */
-#ifdef USG
-      /* It's very important to call setpgrp here and no time
-         afterwards.  Otherwise, we lose our controlling tty which
-         is set when we open the pty. */
-      setpgrp ();
-#endif /* USG */
-#endif /* not HAVE_SETSID */
 #if defined (LDISC1)
       if (pty_flag && xforkin >= 0)
         {
@@ -1798,26 +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.  */
-#ifdef HAVE_SETPGID
-          setpgid (0, 0);
-#else
-          setpgrp (0, 0);
-#endif
-#endif
         }
 #endif /* TIOCNOTTY */
 
 #if !defined (DONT_REOPEN_PTY)
 /*** There is a suggestion that this ought to be a
-     conditional on TIOCSPGRP,
-     or !(defined (HAVE_SETSID) && defined (TIOCSCTTY)).
+     conditional on TIOCSPGRP, or !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)
@@ -1886,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
@@ -4443,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
@@ -6279,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
-   about children with changed statuses until the system says there
-   are no more.
+/* If the status of the process DESIRED has changed, return true and
+   set *STATUS to its exit status; otherwise, return false.
+   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
@@ -6304,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.  */
@@ -6318,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))
-          || (FLOATP (xpid) && pid == XFLOAT_DATA (xpid)))
+      if (all_pids_are_fixnums ? INTEGERP (xpid) : NUMBERP (xpid))
         {
-          XSETCAR (tail, Qnil);
-          return;
+          pid_t deleted_pid;
+          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));
-      p = XPROCESS (proc);
-      if (EQ (p->type, Qreal) && p->pid == pid)
-        break;
-      p = 0;
-    }
-
-  /* Look for an asynchronous process whose pid hasn't been filled
-     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;
-      }
+      Lisp_Object proc = XCDR (XCAR (tail));
+      struct Lisp_Process *p = XPROCESS (proc);
+      if (p->alive && process_status_retrieved (p->pid, pid, &w))
+        {
+          /* Change the status of the process that was found.  */
+          p->tick = ++process_tick;
+          p->raw_status = w;
+          p->raw_status_new = 1;
 
-  /* Change the status of the process that was found.  */
-  if (p)
-    {
-      int clear_desc_flag = 0;
+          /* If process has terminated, stop waiting for its output.  */
+          if (WIFSIGNALED (w) || WIFEXITED (w))
+            {
+              int clear_desc_flag = 0;
+              p->alive = 0;
+              if (p->infd >= 0)
+                clear_desc_flag = 1;
 
-      p->tick = ++process_tick;
-      p->raw_status = w;
-      p->raw_status_new = 1;
+              /* clear_desc_flag avoids a compiler bug in Microsoft C.  */
+              if (clear_desc_flag)
+                {
+                  FD_CLR (p->infd, &input_wait_mask);
+                  FD_CLR (p->infd, &non_keyboard_wait_mask);
+                }
+            }
 
-      /* If process has terminated, stop waiting for its output.  */
-      if ((WIFSIGNALED (w) || WIFEXITED (w))
-          && p->infd >= 0)
-        clear_desc_flag = 1;
+          /* 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);
 
-      /* We use clear_desc_flag to avoid a compiler bug in Microsoft C.  */
-      if (clear_desc_flag)
-        {
-          FD_CLR (p->infd, &input_wait_mask);
-          FD_CLR (p->infd, &non_keyboard_wait_mask);
+          if (record_at_most_one_child)
+            return;
         }
-
-      /* 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.  */
-  else
+
+  if (0 <= pid)
     {
+      /* 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.  */
@@ -6398,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
-    {
-      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);
+  record_child_status_change (-1, 0);
 }
 
 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/sysdep.c b/src/sysdep.c
index c7174e91612..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);
   }
 
@@ -683,6 +683,75 @@ ignore_sigio (void)
 }
 
 
+/* Saving and restoring the process group of Emacs's terminal.  */
+
+/* The process group of which Emacs was a member when it initially
+   started.
+
+   If Emacs was in its own process group (i.e. inherited_pgroup ==
+   getpid ()), then we know we're running under a shell with job
+   control (Emacs would never be run as part of a pipeline).
+   Everything is fine.
+
+   If Emacs was not in its own process group, then we know we're
+   running under a shell (or a caller) that doesn't know how to
+   separate itself from Emacs (like sh).  Emacs must be in its own
+   process group in order to receive SIGIO correctly.  In this
+   situation, we put ourselves in our own pgroup, forcibly set the
+   tty's pgroup to our pgroup, and make sure to restore and reinstate
+   the tty's pgroup just like any other terminal setting.  If
+   inherited_group was not the tty's pgroup, then we'll get a
+   SIGTTmumble when we try to change the tty's pgroup, and a CONT if
+   it goes foreground in the future, which is what should happen.  */
+
+static pid_t inherited_pgroup;
+
+void
+init_foreground_group (void)
+{
+  pid_t pgrp = getpgrp ();
+  inherited_pgroup = getpid () == pgrp ? 0 : pgrp;
+}
+
+/* Safely set a controlling terminal FD's process group to PGID.
+   If we are not in the foreground already, POSIX requires tcsetpgrp
+   to deliver a SIGTTOU signal, which would stop us.  This is an
+   annoyance, so temporarily ignore the signal.
+
+   In practice, platforms lacking SIGTTOU also lack tcsetpgrp, so
+   skip all this unless SIGTTOU is defined.  */
+static void
+tcsetpgrp_without_stopping (int fd, pid_t pgid)
+{
+#ifdef SIGTTOU
+  signal_handler_t handler;
+  block_input ();
+  handler = signal (SIGTTOU, SIG_IGN);
+  tcsetpgrp (fd, pgid);
+  signal (SIGTTOU, handler);
+  unblock_input ();
+#endif
+}
+
+/* Split off the foreground process group to Emacs alone.  When we are
+   in the foreground, but not started in our own process group,
+   redirect the tty device handle FD to point to our own process
+   group.  FD must be the file descriptor of the controlling tty.  */
+static void
+narrow_foreground_group (int fd)
+{
+  if (inherited_pgroup && setpgid (0, 0) == 0)
+    tcsetpgrp_without_stopping (fd, getpid ());
+}
+
+/* Set the tty to our original foreground group.  */
+static void
+widen_foreground_group (int fd)
+{
+  if (inherited_pgroup && setpgid (0, inherited_pgroup) == 0)
+    tcsetpgrp_without_stopping (fd, inherited_pgroup);
+}
+
 /* Getting and setting emacs_tty structures.  */
 
 /* Set *TC to the parameters associated with the terminal FD.
@@ -799,6 +868,8 @@ init_sys_modes (struct tty_display_info *tty_out)
   if (!tty_out->output)
     return;                     /* The tty is suspended. */
 
+  narrow_foreground_group (fileno (tty_out->input));
+
   if (! tty_out->old_tty)
     tty_out->old_tty = xmalloc (sizeof *tty_out->old_tty);
 
@@ -1231,6 +1302,7 @@ reset_sys_modes (struct tty_display_info *tty_out)
   dos_ttcooked ();
 #endif
 
+  widen_foreground_group (fileno (tty_out->input));
 }
 
 #ifdef HAVE_PTYS
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 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 */
+  if (0 <= pgid)
+    setsid ();
 }
 
 /* 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 0b3260f13ab..256ba26e435 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -245,16 +245,8 @@ struct input_event
   Lisp_Object x, y;
   Time timestamp;
 
-  /* This is padding just to put the frame_or_window field
-     past the size of struct selection_input_event.  */
-  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.  */
+  /* This field is copied into a vector while the event is in
+     the queue, so that garbage collections won't kill it.  */
   Lisp_Object frame_or_window;
 
   /* Additional event argument.  This is used for TOOL_BAR_EVENTs and
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;
-
-  if (NILP (frame))
-    frame = selected_frame;
-
-  CHECK_LIVE_FRAME (frame);
-
-  t = FRAME_TERMINAL (XFRAME (frame));
+  struct terminal *t = FRAME_TERMINAL (decode_live_frame (frame));
 
   if (!t)
     return Qnil;
diff --git a/src/w32fns.c b/src/w32fns.c
index 28e8ea02e05..24760054523 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;
@@ -3331,7 +3329,19 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
          versions, there is no way of telling when the mouse leaves the
          frame, so we just have to put up with help-echo and mouse
          highlighting remaining while the frame is not active.  */
-      if (track_mouse_event_fn && !track_mouse_window)
+      if (track_mouse_event_fn && !track_mouse_window
+          /* If the menu bar is active, turning on tracking of mouse
+             movement events might send these events to the tooltip
+             frame, if the user happens to move the mouse pointer over
+             the tooltip.  But since we don't process events for
+             tooltip frames, this causes Windows to present a
+             hourglass cursor, which is ugly and unexpected.  So don't
+             enable tracking mouse events in this case; they will be
+             restarted when the menu pops down.  (Confusingly, the
+             menubar_active member of f->output_data.w32, tested
+             above, is only set when a menu was popped up _not_ from
+             the frame's menu bar, but via x-popup-menu.)  */
+          && !menubar_in_use)
         {
           TRACKMOUSEEVENT tme;
           tme.cbSize = sizeof (tme);
@@ -4271,9 +4281,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);
 
@@ -5374,7 +5381,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
@@ -7685,6 +7691,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)
 {
@@ -7692,7 +7722,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.)"
@@ -7707,7 +7740,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 57b3860cb76..f35a2da537c 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -230,12 +230,30 @@ sigismember (const sigset_t *set, int signo)
   return (*set & (1U << signo)) != 0;
 }
 
+pid_t
+getpgrp (void)
+{
+  return getpid ();
+}
+
+pid_t
+tcgetpgrp (int fd)
+{
+  return getpid ();
+}
+
 int
-setpgrp (int pid, int gid)
+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.
@@ -244,28 +262,92 @@ setpgrp (int pid, int gid)
    the thread calls the appropriate signal handler when the timer
    expires, after stopping the thread which installed the timer.  */
 
-/* FIXME: clock_t counts overflow after 49 days, need to handle the
-   wrap-around.  */
 struct itimer_data {
-  clock_t expire;
-  clock_t reload;
-  int terminate;
+  volatile ULONGLONG expire;
+  volatile ULONGLONG reload;
+  volatile int terminate;
   int type;
   HANDLE caller_thread;
   HANDLE timer_thread;
 };
 
-static clock_t ticks_now;
+static ULONGLONG ticks_now;
 static struct itimer_data real_itimer, prof_itimer;
-static clock_t clocks_min;
+static ULONGLONG clocks_min;
 /* If non-zero, itimers are disabled.  Used during shutdown, when we
    delete the critical sections used by the timer threads.  */
 static int disable_itimers;
 
 static CRITICAL_SECTION crit_real, crit_prof;
 
-#define MAX_SINGLE_SLEEP 30
+/* GetThreadTimes is not available on Windows 9X and possibly also on 2K.  */
+typedef BOOL (WINAPI *GetThreadTimes_Proc) (
+  HANDLE hThread,
+  LPFILETIME lpCreationTime,
+  LPFILETIME lpExitTime,
+  LPFILETIME lpKernelTime,
+  LPFILETIME lpUserTime);
+
+static GetThreadTimes_Proc s_pfn_Get_Thread_Times;
+
+#define MAX_SINGLE_SLEEP    30
+#define TIMER_TICKS_PER_SEC 1000
+
+/* Return a suitable time value, in 1-ms units, for THREAD, a handle
+   to a thread.  If THREAD is NULL or an invalid handle, return the
+   current wall-clock time since January 1, 1601 (UTC).  Otherwise,
+   return the sum of kernel and user times used by THREAD since it was
+   created, plus its creation time.  */
+static ULONGLONG
+w32_get_timer_time (HANDLE thread)
+{
+  ULONGLONG retval;
+  int use_system_time = 1;
+  /* The functions below return times in 100-ns units.  */
+  const int tscale = 10 * TIMER_TICKS_PER_SEC;
+
+  if (thread && thread != INVALID_HANDLE_VALUE
+      && s_pfn_Get_Thread_Times != NULL)
+    {
+      FILETIME creation_ftime, exit_ftime, kernel_ftime, user_ftime;
+      ULARGE_INTEGER temp_creation, temp_kernel, temp_user;
 
+      if (s_pfn_Get_Thread_Times (thread, &creation_ftime, &exit_ftime,
+                                  &kernel_ftime, &user_ftime))
+        {
+          use_system_time = 0;
+          temp_creation.LowPart = creation_ftime.dwLowDateTime;
+          temp_creation.HighPart = creation_ftime.dwHighDateTime;
+          temp_kernel.LowPart = kernel_ftime.dwLowDateTime;
+          temp_kernel.HighPart = kernel_ftime.dwHighDateTime;
+          temp_user.LowPart = user_ftime.dwLowDateTime;
+          temp_user.HighPart = user_ftime.dwHighDateTime;
+          retval =
+            temp_creation.QuadPart / tscale + temp_kernel.QuadPart / tscale
+            + temp_user.QuadPart / tscale;
+        }
+      else
+        DebPrint (("GetThreadTimes failed with error code %lu\n",
+                   GetLastError ()));
+    }
+
+  if (use_system_time)
+    {
+      FILETIME current_ftime;
+      ULARGE_INTEGER temp;
+
+      GetSystemTimeAsFileTime (&current_ftime);
+
+      temp.LowPart = current_ftime.dwLowDateTime;
+      temp.HighPart = current_ftime.dwHighDateTime;
+
+      retval = temp.QuadPart / tscale;
+    }
+
+  return retval;
+}
+
+/* Thread function for a timer thread.  */
 static DWORD WINAPI
 timer_loop (LPVOID arg)
 {
@@ -273,14 +355,14 @@ timer_loop (LPVOID arg)
   int which = itimer->type;
   int sig = (which == ITIMER_REAL) ? SIGALRM : SIGPROF;
   CRITICAL_SECTION *crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
-  const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / CLOCKS_PER_SEC;
-  int new_count = 0;
+  const DWORD max_sleep = MAX_SINGLE_SLEEP * 1000 / TIMER_TICKS_PER_SEC;
+  HANDLE hth = (which == ITIMER_REAL) ? NULL : itimer->caller_thread;
 
   while (1)
     {
       DWORD sleep_time;
       signal_handler handler;
-      clock_t now, expire, reload;
+      ULONGLONG now, expire, reload;
 
       /* Load new values if requested by setitimer.  */
       EnterCriticalSection (crit);
@@ -290,15 +372,14 @@ timer_loop (LPVOID arg)
       if (itimer->terminate)
         return 0;
 
-      if (itimer->expire == 0)
+      if (expire == 0)
         {
           /* We are idle.  */
           Sleep (max_sleep);
           continue;
         }
 
-      expire = itimer->expire;
-      if (expire > (now = clock ()))
+      if (expire > (now = w32_get_timer_time (hth)))
         sleep_time = expire - now;
       else
         sleep_time = 0;
@@ -309,24 +390,30 @@ timer_loop (LPVOID arg)
           if (itimer->terminate)
             return 0;
           Sleep (max_sleep);
+          EnterCriticalSection (crit);
           expire = itimer->expire;
-          sleep_time = (expire > (now = clock ())) ? expire - now : 0;
+          LeaveCriticalSection (crit);
+          sleep_time =
+            (expire > (now = w32_get_timer_time (hth))) ? expire - now : 0;
         }
       if (itimer->terminate)
         return 0;
       if (sleep_time > 0)
         {
-          Sleep (sleep_time * 1000 / CLOCKS_PER_SEC);
+          Sleep (sleep_time * 1000 / TIMER_TICKS_PER_SEC);
           /* Always sleep past the expiration time, to make sure we
              never call the handler _before_ the expiration time,
              always slightly after it.  Sleep(5) makes sure we don't
-             hog the CPU by calling 'clock' with high frequency, and
-             also let other threads work.  */
-          while (clock () < expire)
+             hog the CPU by calling 'w32_get_timer_time' with high
+             frequency, and also let other threads work.  */
+          while (w32_get_timer_time (hth) < expire)
             Sleep (5);
         }
 
-      if (itimer->expire == 0)
+      EnterCriticalSection (crit);
+      expire = itimer->expire;
+      LeaveCriticalSection (crit);
+      if (expire == 0)
         continue;
 
       /* Time's up.  */
@@ -353,19 +440,21 @@ timer_loop (LPVOID arg)
           ResumeThread (itimer->caller_thread);
         }
 
-      if (itimer->expire == 0)
-        continue;
-
       /* Update expiration time and loop.  */
       EnterCriticalSection (crit);
       expire = itimer->expire;
+      if (expire == 0)
+        {
+          LeaveCriticalSection (crit);
+          continue;
+        }
       reload = itimer->reload;
       if (reload > 0)
         {
-          now = clock ();
+          now = w32_get_timer_time (hth);
           if (expire <= now)
             {
-              clock_t lag = now - expire;
+              ULONGLONG lag = now - expire;
 
               /* If we missed some opportunities (presumably while
                  sleeping or while the signal handler ran), skip
@@ -448,6 +537,15 @@ term_timers (void)
 void
 init_timers (void)
 {
+  /* GetThreadTimes is not available on all versions of Windows, so
+     need to probe for its availability dynamically, and call it
+     through a pointer.  */
+  s_pfn_Get_Thread_Times = NULL; /* in case dumped Emacs comes with a value */
+  if (os_subtype != OS_9X)
+    s_pfn_Get_Thread_Times =
+      (GetThreadTimes_Proc)GetProcAddress (GetModuleHandle ("kernel32.dll"),
+                                           "GetThreadTimes");
+
   /* Make sure we start with zeroed out itimer structures, since
      dumping may have left there traces of threads long dead.  */
   memset (&real_itimer, 0, sizeof real_itimer);
@@ -473,14 +571,6 @@ start_timer_thread (int which)
     return 0;
 
   /* Start a new thread.  */
-  if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
-                        GetCurrentProcess (), &itimer->caller_thread, 0,
-                        FALSE, DUPLICATE_SAME_ACCESS))
-    {
-      errno = ESRCH;
-      return -1;
-    }
-
   itimer->terminate = 0;
   itimer->type = which;
   /* Request that no more than 64KB of stack be reserved for this
@@ -512,17 +602,16 @@ start_timer_thread (int which)
 int
 getitimer (int which, struct itimerval *value)
 {
-  volatile clock_t *t_expire;
-  volatile clock_t *t_reload;
-  clock_t expire, reload;
+  volatile ULONGLONG *t_expire;
+  volatile ULONGLONG *t_reload;
+  ULONGLONG expire, reload;
   __int64 usecs;
   CRITICAL_SECTION *crit;
+  struct itimer_data *itimer;
 
   if (disable_itimers)
     return -1;
 
-  ticks_now = clock ();
-
   if (!value)
     {
       errno = EFAULT;
@@ -535,8 +624,22 @@ getitimer (int which, struct itimerval *value)
       return -1;
     }
 
-  t_expire = (which == ITIMER_REAL) ? &real_itimer.expire: &prof_itimer.expire;
-  t_reload = (which == ITIMER_REAL) ? &real_itimer.reload: &prof_itimer.reload;
+  itimer = (which == ITIMER_REAL) ? &real_itimer : &prof_itimer;
+
+  if (!DuplicateHandle (GetCurrentProcess (), GetCurrentThread (),
+                        GetCurrentProcess (), &itimer->caller_thread, 0,
+                        FALSE, DUPLICATE_SAME_ACCESS))
+    {
+      errno = ESRCH;
+      return -1;
+    }
+
+  ticks_now = w32_get_timer_time ((which == ITIMER_REAL)
+                                  ? NULL
+                                  : itimer->caller_thread);
+
+  t_expire = &itimer->expire;
+  t_reload = &itimer->reload;
   crit = (which == ITIMER_REAL) ? &crit_real : &crit_prof;
 
   EnterCriticalSection (crit);
@@ -547,11 +650,13 @@ getitimer (int which, struct itimerval *value)
   if (expire)
     expire -= ticks_now;
 
-  value->it_value.tv_sec    = expire / CLOCKS_PER_SEC;
-  usecs = (expire % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+  value->it_value.tv_sec    = expire / TIMER_TICKS_PER_SEC;
+  usecs =
+    (expire % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
   value->it_value.tv_usec   = usecs;
-  value->it_interval.tv_sec = reload / CLOCKS_PER_SEC;
-  usecs = (reload % CLOCKS_PER_SEC) * (__int64)1000000 / CLOCKS_PER_SEC;
+  value->it_interval.tv_sec = reload / TIMER_TICKS_PER_SEC;
+  usecs =
+    (reload % TIMER_TICKS_PER_SEC) * (__int64)1000000 / TIMER_TICKS_PER_SEC;
   value->it_interval.tv_usec= usecs;
 
   return 0;
@@ -560,10 +665,11 @@ getitimer (int which, struct itimerval *value)
 int
 setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
 {
-  volatile clock_t *t_expire, *t_reload;
-  clock_t expire, reload, expire_old, reload_old;
+  volatile ULONGLONG *t_expire, *t_reload;
+  ULONGLONG expire, reload, expire_old, reload_old;
   __int64 usecs;
   CRITICAL_SECTION *crit;
+  struct itimerval tem, *ptem;
 
   if (disable_itimers)
     return -1;
@@ -573,26 +679,21 @@ setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
      time we are called, measure the clock tick resolution.  */
   if (!clocks_min)
     {
-      clock_t t1, t2;
+      ULONGLONG t1, t2;
 
-      for (t1 = clock (); (t2 = clock ()) == t1; )
+      for (t1 = w32_get_timer_time (NULL);
+           (t2 = w32_get_timer_time (NULL)) == t1; )
         ;
       clocks_min = t2 - t1;
     }
 
   if (ovalue)
-    {
-      if (getitimer (which, ovalue)) /* also sets ticks_now */
-        return -1;                   /* errno already set */
-    }
+    ptem = ovalue;
   else
-    ticks_now = clock ();
+    ptem = &tem;
 
-  if (which != ITIMER_REAL && which != ITIMER_PROF)
-    {
-      errno = EINVAL;
-      return -1;
-    }
+  if (getitimer (which, ptem)) /* also sets ticks_now */
+    return -1;                 /* errno already set */
 
   t_expire =
     (which == ITIMER_REAL) ? &real_itimer.expire : &prof_itimer.expire;
@@ -612,26 +713,26 @@ setitimer(int which, struct itimerval *value, struct itimerval *ovalue)
       return 0;
     }
 
-  reload = value->it_interval.tv_sec * CLOCKS_PER_SEC;
+  reload = value->it_interval.tv_sec * TIMER_TICKS_PER_SEC;
 
   usecs = value->it_interval.tv_usec;
   if (value->it_interval.tv_sec == 0
-      && usecs && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+      && usecs && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
     reload = clocks_min;
   else
     {
-      usecs *= CLOCKS_PER_SEC;
+      usecs *= TIMER_TICKS_PER_SEC;
       reload += usecs / 1000000;
     }
 
-  expire = value->it_value.tv_sec * CLOCKS_PER_SEC;
+  expire = value->it_value.tv_sec * TIMER_TICKS_PER_SEC;
   usecs = value->it_value.tv_usec;
   if (value->it_value.tv_sec == 0
-      && usecs * CLOCKS_PER_SEC < clocks_min * 1000000)
+      && usecs * TIMER_TICKS_PER_SEC < clocks_min * 1000000)
     expire = clocks_min;
   else
     {
-      usecs *= CLOCKS_PER_SEC;
+      usecs *= TIMER_TICKS_PER_SEC;
       expire += usecs / 1000000;
     }
 
@@ -1577,7 +1678,7 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
       numenv++;
     }
   /* extra env vars... */
-  sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%d",
+  sprintf (ppid_env_var_buffer, "EM_PARENT_PROCESS_ID=%lu",
            GetCurrentProcessId ());
   arglen += strlen (ppid_env_var_buffer) + 1;
   numenv++;
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);
-  update_wm_hints (ew);
-  update_various_frame_slots (ew);
+  if (columns != FRAME_COLS (f)
+      || rows != FRAME_LINES (f)
+      || 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 c34e0d9300e..514119abef5 100644
--- a/src/window.c
+++ b/src/window.c
@@ -245,7 +245,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;
@@ -271,6 +271,15 @@ decode_valid_window (register Lisp_Object window)
   return w;
 }
 
+/* Build a frequently used 4-integer (X Y W H) list.  */
+
+static Lisp_Object
+quad (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)
@@ -297,7 +306,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)
@@ -332,10 +341,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))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  return FRAME_MINIBUF_WINDOW (XFRAME (frame));
+  return FRAME_MINIBUF_WINDOW (decode_live_frame (frame));
 }
 
 DEFUN ("window-minibuffer-p", Fwindow_minibuffer_p,
@@ -557,7 +563,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).
@@ -565,11 +571,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).
@@ -577,7 +582,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;
 }
 
@@ -601,13 +605,16 @@ 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,
@@ -775,8 +782,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 (w));
+  return make_number (window_body_lines (decode_live_window (window)));
 }
 
 DEFUN ("window-body-width", Fwindow_body_width, Swindow_body_width, 0, 1, 0,
@@ -788,8 +794,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 (w));
+  return make_number (window_body_cols (decode_live_window (window)));
 }
 
 DEFUN ("window-hscroll", Fwindow_hscroll, Swindow_hscroll, 0, 1, 0,
@@ -832,10 +837,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,
@@ -880,11 +883,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)),
-         Fcons (make_number (WINDOW_TOP_EDGE_LINE (w)),
-         Fcons (make_number (WINDOW_RIGHT_EDGE_COL (w)),
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_LINE (w)),
-                Qnil))));
+  return quad (WINDOW_LEFT_EDGE_COL (w), WINDOW_TOP_EDGE_LINE (w),
+               WINDOW_RIGHT_EDGE_COL (w), WINDOW_BOTTOM_EDGE_LINE (w));
 }
 
 DEFUN ("window-pixel-edges", Fwindow_pixel_edges, Swindow_pixel_edges, 0, 1, 0,
@@ -903,11 +903,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)),
-         Fcons (make_number (WINDOW_TOP_EDGE_Y (w)),
-         Fcons (make_number (WINDOW_RIGHT_EDGE_X (w)),
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w)),
-                Qnil))));
+  return quad (WINDOW_LEFT_EDGE_X (w), WINDOW_TOP_EDGE_Y (w),
+               WINDOW_RIGHT_EDGE_X (w), WINDOW_BOTTOM_EDGE_Y (w));
 }
 
 static void
@@ -949,13 +946,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),
-         Fcons (make_number (WINDOW_TOP_EDGE_Y (w) + add_y),
-         Fcons (make_number (WINDOW_RIGHT_EDGE_X (w) + add_x),
-         Fcons (make_number (WINDOW_BOTTOM_EDGE_Y (w) + add_y),
-                Qnil))));
+  return quad (WINDOW_LEFT_EDGE_X (w) + add_x,
+               WINDOW_TOP_EDGE_Y (w) + add_y,
+               WINDOW_RIGHT_EDGE_X (w) + add_x,
+               WINDOW_BOTTOM_EDGE_Y (w) + add_y);
 }
 
 DEFUN ("window-inside-edges", Fwindow_inside_edges, Swindow_inside_edges, 0, 1, 0,
@@ -974,16 +971,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)
-                             + WINDOW_LEFT_MARGIN_COLS (w)
-                             + WINDOW_LEFT_FRINGE_COLS (w)),
-                make_number (WINDOW_TOP_EDGE_LINE (w)
-                             + WINDOW_HEADER_LINE_LINES (w)),
-                make_number (WINDOW_BOX_RIGHT_EDGE_COL (w)
-                             - WINDOW_RIGHT_MARGIN_COLS (w)
-                             - WINDOW_RIGHT_FRINGE_COLS (w)),
-                make_number (WINDOW_BOTTOM_EDGE_LINE (w)
-                             - WINDOW_MODE_LINE_LINES (w)));
+  return quad (WINDOW_BOX_LEFT_EDGE_COL (w)
+               + WINDOW_LEFT_MARGIN_COLS (w)
+               + WINDOW_LEFT_FRINGE_COLS (w),
+               WINDOW_TOP_EDGE_LINE (w)
+               + WINDOW_HEADER_LINE_LINES (w),
+               WINDOW_BOX_RIGHT_EDGE_COL (w)
+               - WINDOW_RIGHT_MARGIN_COLS (w)
+               - WINDOW_RIGHT_FRINGE_COLS (w),
+               WINDOW_BOTTOM_EDGE_LINE (w)
+               - WINDOW_MODE_LINE_LINES (w));
 }
 
 DEFUN ("window-inside-pixel-edges", Fwindow_inside_pixel_edges, Swindow_inside_pixel_edges, 0, 1, 0,
@@ -1001,16 +998,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)
-                             + WINDOW_LEFT_MARGIN_WIDTH (w)
-                             + WINDOW_LEFT_FRINGE_WIDTH (w)),
-                make_number (WINDOW_TOP_EDGE_Y (w)
-                             + WINDOW_HEADER_LINE_HEIGHT (w)),
-                make_number (WINDOW_BOX_RIGHT_EDGE_X (w)
-                             - WINDOW_RIGHT_MARGIN_WIDTH (w)
-                             - WINDOW_RIGHT_FRINGE_WIDTH (w)),
-                make_number (WINDOW_BOTTOM_EDGE_Y (w)
-                             - WINDOW_MODE_LINE_HEIGHT (w)));
+  return quad (WINDOW_BOX_LEFT_EDGE_X (w)
+               + WINDOW_LEFT_MARGIN_WIDTH (w)
+               + WINDOW_LEFT_FRINGE_WIDTH (w),
+               WINDOW_TOP_EDGE_Y (w)
+               + WINDOW_HEADER_LINE_HEIGHT (w),
+               WINDOW_BOX_RIGHT_EDGE_X (w)
+               - WINDOW_RIGHT_MARGIN_WIDTH (w)
+               - WINDOW_RIGHT_FRINGE_WIDTH (w),
+               WINDOW_BOTTOM_EDGE_Y (w)
+               - WINDOW_MODE_LINE_HEIGHT (w));
 }
 
 DEFUN ("window-inside-absolute-pixel-edges",
@@ -1030,18 +1027,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)
-                             + WINDOW_LEFT_MARGIN_WIDTH (w)
-                             + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x),
-                make_number (WINDOW_TOP_EDGE_Y (w)
-                             + WINDOW_HEADER_LINE_HEIGHT (w) + add_y),
-                make_number (WINDOW_BOX_RIGHT_EDGE_X (w)
-                             - WINDOW_RIGHT_MARGIN_WIDTH (w)
-                             - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x),
-                make_number (WINDOW_BOTTOM_EDGE_Y (w)
-                             - WINDOW_MODE_LINE_HEIGHT (w) + add_y));
+  return quad (WINDOW_BOX_LEFT_EDGE_X (w)
+               + WINDOW_LEFT_MARGIN_WIDTH (w)
+               + WINDOW_LEFT_FRINGE_WIDTH (w) + add_x,
+               WINDOW_TOP_EDGE_Y (w)
+               + WINDOW_HEADER_LINE_HEIGHT (w) + add_y,
+               WINDOW_BOX_RIGHT_EDGE_X (w)
+               - WINDOW_RIGHT_MARGIN_WIDTH (w)
+               - WINDOW_RIGHT_FRINGE_WIDTH (w) + add_x,
+               WINDOW_BOTTOM_EDGE_Y (w)
+               - WINDOW_MODE_LINE_HEIGHT (w) + add_y);
 }
 
 /* Test if the character at column X, row Y is within window W.
@@ -1374,12 +1372,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;
-
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
+  struct frame *f = decode_live_frame (frame);
 
   /* Check that arguments are integers or floats.  */
   CHECK_NUMBER_OR_FLOAT (x);
@@ -1627,8 +1620,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),
-                        make_number (rowh), make_number (vpos));
+        part = quad (rtop, rbot, rowh, vpos);
       in_window = Fcons (make_number (x),
                          Fcons (make_number (y), part));
     }
@@ -1694,23 +1686,18 @@ 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 Qnil;
-      return list4 (make_number (row->height),
-                    make_number (0), make_number (0),
-                    make_number (0));
+      return row->enabled_p ? quad (row->height, 0, 0, 0) : Qnil;
     }
 
   if (EQ (line, Qmode_line))
     {
       row = MATRIX_MODE_LINE_ROW (w->current_matrix);
-      if (!row->enabled_p)
-        return Qnil;
-      return list4 (make_number (row->height),
-                    make_number (0), /* not accurate */
-                    make_number (WINDOW_HEADER_LINE_HEIGHT (w)
-                                 + window_text_bottom_y (w)),
-                    make_number (0));
+      return (row->enabled_p ?
+              quad (row->height,
+                    0, /* not accurate */
+                    WINDOW_HEADER_LINE_HEIGHT (w)
+                    + window_text_bottom_y (w), 0)
+              : Qnil);
     }
 
   CHECK_NUMBER (line);
@@ -1739,10 +1726,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),
-                make_number (i),
-                make_number (row->y),
-                make_number (crop));
+  return quad (row->height + min (0, row->y) - crop, i, row->y, crop);
 }
 
 DEFUN ("window-dedicated-p", Fwindow_dedicated_p, Swindow_dedicated_p,
@@ -2253,11 +2237,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))
-    *window = selected_window;
-  else
-    CHECK_LIVE_WINDOW (*window);
+  struct window *w = decode_live_window (*window);
 
+  XSETWINDOW (*window, w);
   /* MINIBUF nil may or may not include minibuffers.  Decide if it
      does.  */
   if (NILP (*minibuf))
@@ -2273,7 +2255,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))
     ;
@@ -3123,12 +3105,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,
-       doc: /* Run `window-configuration-change-hook' for FRAME.  */)
+       Srun_window_configuration_change_hook, 0, 1, 0,
+       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 (XFRAME (frame));
+  run_window_configuration_change_hook (decode_live_frame (frame));
   return Qnil;
 }
 
@@ -3655,10 +3637,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
-values.  HORIZONTAL non-nil means apply requested width values.
+If FRAME is omitted or nil, it defaults to the selected frame.
+
+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
@@ -3669,17 +3653,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 window *r;
+  struct frame *f = decode_live_frame (frame);
+  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)))
@@ -6165,12 +6142,7 @@ saved by this function.  */)
   register int n_windows;
   register struct save_window_data *data;
   register int i;
-  FRAME_PTR f;
-
-  if (NILP (frame))
-    frame = selected_frame;
-  CHECK_LIVE_FRAME (frame);
-  f = XFRAME (frame);
+  struct frame *f = decode_live_frame (frame);
 
   n_windows = count_windows (XWINDOW (FRAME_ROOT_WINDOW (f)));
   data = ALLOCATE_PSEUDOVECTOR (struct save_window_data, frame_cols,
@@ -6323,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)),
-                Fcons (make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
-                       Fcons ((WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w)
-                               ? Qt : Qnil), Qnil)));
+  return list3 (make_number (WINDOW_LEFT_FRINGE_WIDTH (w)),
+                make_number (WINDOW_RIGHT_FRINGE_WIDTH (w)),
+                WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w) ? Qt : Qnil);
 }
 
 
@@ -6395,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)),
-                       Fcons (w->vertical_scroll_bar_type,
-                              Fcons (Qnil, Qnil))));
+                make_number (WINDOW_SCROLL_BAR_COLS (w)),
+                w->vertical_scroll_bar_type, 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 109aca9051c..a98572bde72 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -933,6 +933,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 *,
@@ -3118,6 +3119,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)
@@ -3127,6 +3162,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
@@ -11932,19 +11970,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))
@@ -21123,10 +21156,8 @@ are the selected window and the WINDOW's buffer).  */)
   Lisp_Object str;
   int string_start = 0;
 
-  if (NILP (window))
-    window = selected_window;
-  CHECK_WINDOW (window);
-  w = XWINDOW (window);
+  w = decode_any_window (window);
+  XSETWINDOW (window, w);
 
   if (NILP (buffer))
     buffer = w->buffer;
@@ -21155,7 +21186,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;
 
diff --git a/src/xfaces.c b/src/xfaces.c
index 221387c4b6d..41c618612ac 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -669,23 +669,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 +1187,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))
-    frame = selected_frame;
-  else
-    CHECK_FRAME (frame);
-  f = XFRAME (frame);
-  return face_color_gray_p (f, SSDATA (color)) ? Qt : Qnil;
+  return (face_color_gray_p (decode_any_frame (frame), SSDATA (color))
+          ? Qt : Qnil);
 }
 
 
@@ -1225,17 +1202,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))
-    frame = selected_frame;
-  else
-    CHECK_FRAME (frame);
-  f = XFRAME (frame);
-  if (face_color_supported_p (f, SSDATA (color), !NILP (background_p)))
-    return Qt;
-  return Qnil;
+  return (face_color_supported_p (decode_any_frame (frame),
+                                  SSDATA (color), !NILP (background_p))
+          ? Qt : Qnil);
 }
 
 
@@ -1683,9 +1653,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))
-    frame = selected_frame;
-  f = frame_or_selected_frame (frame, 2);
+  f = decode_live_frame (frame);
   if (! FRAME_WINDOW_P (f))
     {
       /* Perhaps we have not yet created any frame.  */
@@ -1693,6 +1661,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 +3649,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 +3837,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 +3924,11 @@ If FRAME is omitted or nil, use the selected frame.  */)
   struct frame *f;
   Lisp_Object lface1, lface2;
 
-  if (EQ (frame, Qt))
-    f = NULL;
-  else
-    /* Don't use check_x_frame here because this function is called
-       before X frames exist.  At that time, if FRAME is nil,
-       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);
+  /* Don't use check_x_frame here because this function is called
+     before X frames exist.  At that time, if FRAME is nil,
+     selected_frame will be used which is the frame dumped with
+     Emacs.  That frame is not an X frame.  */
+  f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
 
   lface1 = lface_from_face_name (f, face1, 1);
   lface2 = lface_from_face_name (f, face2, 1);
@@ -3988,20 +3946,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;
-  Lisp_Object lface;
+  struct frame *f = EQ (frame, Qt) ? NULL : decode_live_frame (frame);
+  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 +3964,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 f->face_alist;
+  return decode_live_frame (frame)->face_alist;
 }
 
 
@@ -4205,14 +4152,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);
diff --git a/src/xfns.c b/src/xfns.c
index d497cffe3df..9c99902b93d 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;
@@ -3111,9 +3107,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 +4589,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/xterm.c b/src/xterm.c
index a52a113ccda..a36b008c105 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -3457,7 +3457,7 @@ x_focus_changed (int type, int state, struct x_display_info *dpyinfo, struct fra
 
           /* Don't stop displaying the initial startup message
              for a switch-frame event we don't need.  */
-          /* When run as a deamon, Vterminal_frame is always NIL.  */
+          /* When run as a daemon, Vterminal_frame is always NIL.  */
           if ((NILP (Vterminal_frame) || EQ (Fdaemonp(), Qt))
               && CONSP (Vframe_list)
               && !NILP (XCDR (Vframe_list)))
@@ -6117,7 +6117,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;
 
@@ -6137,7 +6136,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;