Merge from trunk; up to 2013-02-18T01:30:27Z!monnier@iro.umontreal.ca.

199 files changed, 8174 insertions, 4063 deletions

diff --git a/src/.gdbinit b/src/.gdbinit
index e1ee81e66b5..4215ffa312b 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -1,4 +1,4 @@
-# Copyright (C) 1992-1998, 2000-2012  Free Software Foundation, Inc.
+# Copyright (C) 1992-1998, 2000-2013 Free Software Foundation, Inc.
 #
 # This file is part of GNU Emacs.
 #
@@ -13,9 +13,7 @@
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Emacs; see the file COPYING.  If not, write to the
-# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-# Boston, MA 02110-1301, USA.
+# along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
 
 # Force loading of symbols, enough to give us VALBITS etc.
 set $dummy = main + 8
@@ -360,7 +358,6 @@ end
 
 define pwinx
   set $w = $arg0
-  xgetint $w->sequence_number
   if ($w->mini_p != Qnil)
     printf "Mini "
   end
diff --git a/src/ChangeLog b/src/ChangeLog
index 222be9575b8..e945e221593 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,1749 @@
+2013-02-17  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (x_draw_vertical_border): For a window that is neither
+        the leftmost nor the rightmost, redraw both the left and the right
+        vertical borders.  (Bug#13723)
+
+2013-02-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xml.c (init_libxml2_functions):
+        * sound.c (sound_warning):
+        * sheap.c (report_sheap_usage):
+        * process.c (wait_reading_process_output):
+        * msdos.c (XMenuActivate):
+        * macros.c (Fstart_kbd_macro, Fend_kbd_macro):
+        * keyboard.c (top_level_1):
+        * editfns.c (Fmessage, Fmessage_box):
+        * callint.c (Fcall_interactively):
+        * fns.c (Fyes_or_no_p): Prefer `message1' over `message'.
+
+2013-02-17  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (syms_of_xterm): Move scroll-bar-adjust-thumb-portion ...
+        * frame.c (syms_of_frame): ... to here.
+
+2013-02-16  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (sys_chown): Remove unused function.
+
+        * w32term.c <input_signal_count>: Declare 'volatile'
+        unconditionally.  (Bug#9066)
+
+        * w32.c (set_errno): Reset h_errno and don't set it to any other
+        value.  Set errno instead.
+        (check_errno): Reset h_errno.
+        (sys_socket, socket_to_fd, sys_bind, sys_connect)
+        (sys_gethostname, sys_getservbyname, sys_getpeername)
+        (sys_shutdown, sys_setsockopt, sys_listen, sys_getsockname)
+        (sys_accept, sys_recvfrom, sys_sendto, fcntl, sys_read): Don't set
+        h_errno.
+        (sys_gethostbyname): Set h_errno only errors detected.
+
+2013-02-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * process.c (h_errno) [!HAVE_H_ERRNO]: Remove unused decl.
+
+2013-02-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * keyboard.c (read_char): Fix calculation of auto-save time out
+        when auto-save-timeout is less than 4.  (Bug#13720)
+
+        * w32proc.c (new_child): Free up to 2 slots of dead processes at a
+        time.  Improve diagnostics in DebPrint.  (Bug#13546)
+
+        * w32.c (sys_socket, sys_bind, sys_connect, sys_gethostname)
+        (sys_gethostbyname, sys_getservbyname, sys_getpeername)
+        (sys_shutdown, sys_setsockopt, sys_listen, sys_getsockname)
+        (sys_accept, sys_recvfrom, sys_sendto, fcntl): In case of failure,
+        make sure errno is set to an appropriate value.  (Bug#13546)
+        (socket_to_fd): Add assertion against indexing fd_info[] with a
+        value that is out of bounds.
+        (sys_accept): If fd is negative, do not set up the child_process
+        structure for reading.
+
+2013-02-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * composite.c (fill_gstring_header): Remove useless prototype.
+        Break long line.
+        * lisp.h (message_dolog, compile_pattern): Adjust prototype.
+        * print.c (PRINTDECLARE, print_object):
+        * search.c (compile_pattern, fast_looking_at, search_buffer):
+        (simple_search, boyer_moore, Freplace_match):
+        * xdisp.c (c_string_pos, number_of_chars, message_dolog):
+        (get_overlay_arrow_glyph_row, display_mode_element):
+        (decode_mode_spec_coding, message3):
+        * xfaces.c (face_at_string_position): Use bool for booleans.
+        Adjust comments.
+
+2013-02-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix AIX port (Bug#13650).
+        * lisp.h (XPNTR) [!USE_LSB_TAG && DATA_SEG_BITS]:
+        Fix bug introduced in 2012-07-27 change.  DATA_SEG_BITS, if set,
+        was #undeffed earlier, so it cannot be used as a macro here.
+        Use the constant and not the macro.
+
+2013-02-15  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32proc.c (new_child): If no vacant slots are found in
+        child_procs[], make another pass looking for slots whose process
+        has exited or died.  (Bug#13546)
+
+        * w32.c (sys_pipe): When failing due to file descriptors above
+        MAXDESC, set errno to EMFILE.
+        (_sys_read_ahead): Update cp->status when failing to read serial
+        communications input, so that the status doesn't stay at
+        STATUS_READ_IN_PROGRESS.  (Bug#13546)
+
+2013-02-14  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (tb_size_cb): New function.
+        (xg_create_tool_bar): Connect size-allocate to tb_size_cb (Bug#13512).
+
+2013-02-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (active_maps): Fcurrent_active_maps expects a position, not
+        an event.
+
+2013-02-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (syms_of_keyboard): Further tweaks of docstring.
+
+2013-02-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.c (font_range): Add pos_byte argument.  Adjust comment
+        and break long line.
+        * font.h (font_range): Adjust prototype.
+        * composite.c (autocmp_chars): Pass byte position to font_range.
+        Break long line.  Remove useless prototype and format comment.
+
+2013-02-13  Glenn Morris  <rgm@gnu.org>
+
+        * keyboard.c (input-decode-map, key-translation-map): Doc fixes.
+
+2013-02-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Improve AIX port some more (Bug#13650).
+        With this, it should be as good as it was in 23.3, though it's
+        still pretty bad: the dumped emacs does not run.  See Mark Fleishman in
+        http://lists.gnu.org/archive/html/help-gnu-emacs/2011-04/msg00287.html
+        * unexaix.c (start_of_text): Remove.
+        (_data, _text): Declare as char[], not int, as AIX manual suggests.
+        (bias, lnnoptr, text_scnptr, data_scnptr, load_scnptr)
+        (orig_load_scnptr, orig_data_scnptr):
+        Now off_t, not long, since they are file offsets.
+        (make_hdr): Use _data, not start_of_data ().
+        This is the key part of the fix.
+        (make_hdr, unrelocate_symbols): Use off_t for file offsets.
+        (unrelocate_symbols): Cast pointers to intptr_t, not to ulong.
+
+        * pre-crt0.c (data_start): Initialize to 1.
+        This ports to compilers that optimize the external declaration
+        'int x = 0;' as if it were 'int x;' to shrink the executable.
+
+        Improve AIX port (Bug#13650).
+        This doesn't fix the bug, but it makes progress: Emacs builds now.
+        * unexaix.c: Include inttypes.h, stdarg.h.
+        (report_error, report_error_1): Mark as _Noreturn.
+        (report_error): Don't report the wrong errno.
+        (report_error_1): Now varargs.  All callers changed.
+        (make_hdr): Use uintptr_t, not unsigned, when converting pointers
+        to unsigned.  Don't use ADDR_CORRECT, as it no longer exists.
+        (write_ptr): Use %p to print address rather than %lx and a cast
+        to unsigned long.  Grow buffer a bit, to be safer.
+
+2013-02-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * bidi.c (bidi_resolve_neutral): After finding the next
+        non-neutral character, accept NEUTRAL_ON type as well, because
+        directional control characters, such as LRE and RLE, have their
+        type converted to that by bidi_resolve_weak.  This avoids aborts
+        when LRE/RLE follows a run of neutrals.
+        (bidi_move_to_visually_next): Assert that return value of
+        bidi_peek_at_next_level is non-negative.  Negative values will
+        cause an infloop.
+
+2013-02-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor getenv-related fixes.
+        * callproc.c (Fcall_process_region) [!DOS_NT]:
+        Avoid unnecessary duplicate call to getenv.
+        * callproc.c (init_callproc):
+        * dispnew.c (init_display):
+        * sysdep.c (sys_subshell):
+        Omit unnecessary cast of getenv or egetenv.
+
+2013-02-13  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in ($(BLD)/filelock.$(O), $(BLD)/sysdep.$(O)):
+        Update dependencies.
+
+2013-02-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (redisplay_internal): Don't set w->region_showing to the
+        marker's position.
+        (display_line): Set w->region_showing to the value of
+        it->region_beg_charpos, not to -1.  This fixes redisplay
+        optimization when cursor is moved up after M->.  (Bug#13623)
+        (Bug#13626)
+        (try_scrolling): Scroll text up more if point is too close to ZV
+        and inside the scroll margin.  This makes sure point is moved
+        outside the scroll margin in these cases.
+
+        * window.h (struct window): region_showing can no longer be
+        negative.
+
+2013-02-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Tune by using memchr and memrchr.
+        * doc.c (Fsnarf_documentation):
+        * fileio.c (Fsubstitute_in_file_name):
+        * search.c (find_newline, scan_newline):
+        * xdisp.c (pos_visible_p, display_count_lines):
+        Use memchr and memrchr rather than scanning byte-by-byte.
+        * search.c (find_newline): Rename from scan_buffer.
+        Omit first arg TARGET, as it's always '\n'.  All callers changed.
+
+        Clean up read_key_sequence a tiny bit more.
+        * keyboard.c (read_char_x_menu_prompt) [HAVE_MENUS]:
+        (read_key_sequence): Remove unused locals.
+
+2013-02-11  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Clean up read_key_sequence a bit; reread active keymaps after first event.
+        * keyboard.c (read_char, read_char_x_menu_prompt)
+        (read_char_minibuf_menu_prompt):
+        Replace nmaps+maps with a single `map' arg.
+        (follow_key): Operate on a single map.
+        (active_maps): New function.
+        (test_undefined): Also return true for nil bindings.
+        (read_key_sequence): Use active_maps to replace the arrays of keymaps with
+        a single (composed) keymap.  Remember `first_event' to choose the right
+        set of active keymaps.  Recompute the set of keymaps after receiving
+        the first event.  Remove GOBBLE_FIRST_EVENT.
+        (syms_of_keyboard): Remove inhibit_local_menu_bar_menus.
+        * keyboard.h (read_char): Update declaration.
+        * lread.c (read_filtered_event): Adjust call to read_char.
+
+2013-02-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (move_it_vertically_backward, move_it_by_lines):
+        Don't use the limitation on backwards movement when lines are truncated
+        in the window.  (Bug#13675)
+
+2013-02-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * marker.c (set_marker_internal): If desired position is passed
+        as a marker, avoid call to buf_charpos_to_bytepos.
+        * window.c (Fset_window_point): Omit redundant type checking.
+        (Fset_window_start): Likewise.  Format comment.
+        (window_scroll_pixel_based): Use set_marker_restricted_both
+        with character and byte positions obtained from an iterator.
+        (Fset_window_configuration): Use set_marker_restricted_both.
+        * xdisp.c (message_dolog): Likewise.
+
+2013-02-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (move_it_vertically_backward, move_it_by_lines):
+        When text lines are longer than window's screen lines, don't move back
+        too far.  This speeds up some redisplay operations.  (Bug#13675)
+
+2013-02-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * syntax.c (scan_sexps_forward): Fix byte position calculation
+        Bug#13664 (a.k.a Bug#13667) introduced with 2013-02-08 change.
+
+2013-02-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Fexpand_file_name): Omit confusing pointer comparison
+        that was not needed.
+
+2013-02-09  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Minor hashing refactoring.
+        * fns.c (SXHASH_REDUCE): Move to lisp.h.
+        (sxhash_float): Return EMACS_UINT, for consistency with the other
+        hash functions.
+        * lisp.h (INTMASK): Now a macro, since SXHASH_REDUCE is now a
+        non-static inline function and therefore can't use static vars.
+        (SXHASH_REDUCE): Move here from fns.c, and make it inline.
+        * profiler.c (hashfn_profiler): Use SXHASH_REDUCE, to be consistent
+        with the other hash functions.
+
+2013-02-09  Eli Zaretskii  <eliz@gnu.org>
+
+        * callproc.c (Fcall_process_region) [WINDOWSNT]: Make sure the
+        XXXXXX part of the temporary file pattern is not downcased even
+        when w32-downcase-file-names is non-nil.  (Bug#13661)
+
+        * xdisp.c (decode_mode_spec): Remove handling of %t.
+
+        * msdos.c (careadlinkatcwd): Remove.
+
+2013-02-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lread.c (skip_dyn_bytes): New function (bug#12598).
+        (read1): Use it.  Use getc instead of READCHAR to read bytes.
+        (load_each_byte): Remove.  Update users.
+
+2013-02-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * search.c (scan_buffer): Calculate end byte position just once.
+        (scan_newline): Do not recalculate start_byte.
+        (search_command): Use eassert.
+        * syntax.c (struct lisp_parse_state): New member location_byte.
+        (scan_sexps_forward): Record from_byte and avoid redundant
+        character to byte position calculation ...
+        (Fparse_partial_sexp): ... here.  Break too long line.
+
+2013-02-08  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (make_uninit_vector): New function.
+        * alloc.c (Fvector, Fmake_byte_code):
+        * ccl.c (Fregister_ccl_program):
+        * charset.c (Fdefine_charset_internal, define_charset_internal):
+        * coding.c (make_subsidiaries, Fdefine_coding_system_internal):
+        * composite.c (syms_of_composite):
+        * font.c (Fquery_font, Ffont_info, syms_of_font):
+        * fontset.c (FONT_DEF_NEW, Fset_fontset_font):
+        * ftfont.c (ftfont_shape_by_flt):
+        * indent.c (recompute_width_table):
+        * nsselect.m (clean_local_selection_data):
+        * syntax.c (init_syntax_once):
+        * w32unsubscribe.c (uniscribe_shape):
+        * window.c (Fcurrent_window_configuration):
+        * xfaces.c (Fx_family_fonts):
+        * xselect.c (selection_data_to_lisp_data): Use it.
+
+2013-02-07  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * coding.c (Fdefine_coding_system_internal): Use AREF where
+        argument is known to be a vector.
+        * fns.c (Flocale_info): Likewise for ASET.
+        * xselect.c (selection_data_to_lisp_data): Likewise for ASET.
+        * w32fns.c (w32_parse_hot_key): Likewise for ASIZE and AREF.
+
+2013-02-05  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsmenu.m (update_frame_tool_bar): Check for negative tool bar
+        height.
+
+        * nsterm.h (HAVE_NATIVE_FS): Define if OSX => 10.7.
+        (EmacsView): Add fs_is_native, fsIsNative, isFullscreen and
+        updateCollectionBehaviour.
+
+        * nsterm.m (NEW_STYLE_FS): Remove.
+        (ns_last_use_native_fullscreen): New variable.
+        (x_make_frame_visible): Replace NEW_STYLE_FS with isFullscreen.
+        (x_set_window_size): Do not take title bar and tool bar into account
+        if isFullscreen returns YES.
+        (ns_fullscreen_hook): Replace NEW_STYLE_FS with isFullscreen.
+        (check_native_fs): New function.
+        (ns_select, ns_read_socket): Call check_native_fs if HAVE_NATIVE_FS.
+        (ns_term_init): Remove NEW_STYLE_FS.
+        (updateFrameSize:, windowWillResize:toSize:): Only adjust for title bar
+        and tool bar if isFullscreen returns NO.
+        (windowDidResize:): Replace NEW_STYLE_FS with fsIsNative.
+        (initFrameFromEmacs:): Initialize fs_is_native.  Replace NEW_STYLE_FS
+        with HAVE_NATIVE_FS.
+        (window:willUseFullScreenPresentationOptions:): New method.
+        (windowDidEnterFullScreen:): Replace NEW_STYLE_FS with fsIsNative.
+        Hide toolbar if not enabled (Bug#13444).
+        (windowDidExitFullScreen:): Call updateCollectionBehaviour.
+        Restore tool bar if enabled, hide it otherwise (Bug#13444).
+        (fsIsNative, isFullscreen, updateCollectionBehaviour): New methods.
+        (toggleFullScreen:): If fs_is_native, call toggleFullScreen on
+        window.  Do no set FRAME_EXTERNAL_TOOL_BAR (f) to 0.
+        Check FRAME_EXTERNAL_TOOL_BAR (f) before restoring
+        FRAME_TOOLBAR_HEIGHT (f).  Call updateFrameSize when going non-fs.
+        (syms_of_nsterm): Add ns-use-native-fullscreen.
+
+2013-02-04  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Qchoose_write_coding_system): Now static.
+
+2013-02-04  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (window_buffer_changed): region_showing can be negative,
+        which still means region is being displayed.
+        (redisplay_internal): Resurrect code that forced redisplay of the
+        whole window when showing region and the mark has changed.
+        Record the new mark position to allow redisplay optimizations.
+        (display_line): If it->region_beg_charpos is non-zero, set the
+        window's region_showing member to -1.  (Bug#13623)  (Bug#13626)
+
+        * window.h (struct window) <region_showing>: Declare ptrdiff_t,
+        not bitfield of 1 bit.
+
+2013-02-03  Daniel Colascione  <dancol@dancol.org>
+
+        * emacs.c: Use execvp, not execv, when DAEMON_MUST_EXEC, so that
+        daemon mode works on cygw32 when Emacs is installed and not just
+        during development.
+
+2013-02-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid file time stamp bug on MS-Windows (Bug#13149).
+        * fileio.c (Fwrite_region): Don't use the heuristic on empty files,
+        as FAT32 doesn't update time stamps when truncating them.
+        Also, check that a file time stamp is not a multiple of 100 ns;
+        this should catch all instances of the problem on MS-Windows,
+        as its native file system resolution is 100 ns or worse, and
+        checking for a non-multiple of 100 ns should impose only a small
+        overhead on systems with ns resolution.
+
+2013-02-02  Eli Zaretskii  <eliz@gnu.org>
+
+        Avoid encoding file names on MS-Windows when they need to be run
+        through dostounix_filename.
+        * w32.c (normalize_filename): Accept an additional argument
+        MULTIBYTE; if non-zero, traverse the file name by bytes and don't
+        downcase it even if w32-downcase-file-names is non-nil.
+        (dostounix_filename): Accept an additional argument MULTIBYTE and
+        pass it to normalize_filename.
+        (emacs_root_dir): Adjust.
+
+        * msdos.h (dostounix_filename): Adjust prototype.
+
+        * w32.h (dostounix_filename): Adjust prototype.
+
+        * msdos.c (dostounix_filename): Accept an additional argument and
+        ignore it.
+        (init_environment): Adjust callers of dostounix_filename.
+
+        * fileio.c (Ffile_name_directory, file_name_as_directory)
+        (directory_file_name, Fexpand_file_name)
+        (Fsubstitute_in_file_name): [DOS_NT] Adjust call to
+        dostounix_filename.
+        [WINDOWSNT]: Downcase file names if w32-downcase-file-names is
+        non-nil.
+        (Fsubstitute_in_file_name): [DOS_NT] Don't downcase environment
+        variables, as egetenv is case-insensitive for DOS_NT.
+
+        * dired.c (file_name_completion): Don't call Fdirectory_file_name
+        with an encoded file name.
+
+        * w32proc.c (Fw32_short_file_name, Fw32_long_file_name):
+        Adjust calls to dostounix_filename.
+
+        * w32fns.c (Fx_file_dialog): Adjust call to dostounix_filename.
+
+        * unexw32.c (unexec): Adjust call to dostounix_filename.
+
+        * termcap.c (tgetent) [MSDOS]: Adjust call to dostounix_filename.
+
+        * emacs.c (decode_env_path) [DOS_NT]: Adjust call to
+        dostounix_filename.
+
+        * callproc.c (Fcall_process) [MSDOS]: Adjust call to
+        dostounix_filename.
+
+        * callproc.c (Fcall_process): Make sure program name in PATH and
+        new_argv[0] is encoded, if needed.  Otherwise, un-encoded string
+        is passed to exec/spawnve, which fails unless the file-name
+        encoding is UTF-8.
+
+        * w32proc.c (sys_spawnve): Make sure escape_char is initialized,
+        even if w32-quote-process-args is nil.
+
+2013-02-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix timestamp bug when write-region appends nothing (Bug#13149).
+        * fileio.c (Fwrite_region): When neither O_EXCL nor O_TRUNC is used,
+        the file's time stamp doesn't change if Emacs happens to write nothing
+        to the file, and on a buggy file system this could cause Emacs to
+        incorrectly infer that the file system doesn't have the bug.
+        Avoid this problem by inhibiting the inference in this case.
+
+2013-02-01  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Convert base_line_number, base_line_pos
+        and column_number_displayed members from Lisp_Object to ptrdiff_t.
+        Convert region_showing member from Lisp_Object to bitfield.
+        Remove sequence_number member.  Adjust comments.
+        * window.c (sequence_number): Remove.
+        (make_window): Initialize column_number_displayed.
+        * print.c (print_object): Follow the printed representation of
+        frames and print window pointer to distinguish between windows.
+        (adjust_window_count): Invalidate base_line_pos.  Adjust comment.
+        * xdisp.c (wset_base_line_number, wset_base_line_pos)
+        (wset_column_number_displayed, wset_region_showing): Remove.
+        (window_buffer_changed, mode_line_update_needed, redisplay_internal)
+        (try_scrolling, try_cursor_movement, redisplay_window)
+        (try_window_reusing_current_matrix, try_window_id, display_line)
+        (display_mode_lines, decode_mode_spec): Adjust users.
+        * .gdbinit (pwinx): Do not print sequence_number.
+
+2013-02-01  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Use fdopendir, fstatat and readlinkat, for efficiency (Bug#13539).
+        * conf_post.h (GNULIB_SUPPORT_ONLY_AT_FDCWD): Remove.
+        * dired.c: Include <fcntl.h>.
+        (open_directory): New function, which uses open and fdopendir
+        rather than opendir.  DOS_NT platforms still use opendir, though.
+        (directory_files_internal, file_name_completion): Use it.
+        (file_attributes): New function, with most of the old Ffile_attributes.
+        (directory_files_internal, Ffile_attributes): Use it.
+        (file_attributes, file_name_completion_stat): First arg is now fd,
+        not dir name.  All uses changed.  Use fstatat rather than lstat +
+        stat.
+        (file_attributes): Use emacs_readlinkat rather than Ffile_symlink_p.
+        * fileio.c: Include <allocator.h>, <careadlinkat.h>.
+        (emacs_readlinkat): New function, with much of the old
+        Ffile_symlink_p, but with an fd argument for speed.
+        It uses readlinkat rather than careadlinkatcwd, so that it
+        need not assume the working directory.
+        (Ffile_symlink_p): Use it.
+        * filelock.c (current_lock_owner): Use emacs_readlinkat
+        rather than emacs_readlink.
+        * lisp.h (emacs_readlinkat): New decl.
+        (READLINK_BUFSIZE, emacs_readlink): Remove.
+        * sysdep.c: Do not include <allocator.h>, <careadlinkat.h>.
+        (emacs_norealloc_allocator, emacs_readlink): Remove.
+        This stuff is moved to fileio.c.
+        * w32.c (fstatat, readlinkat): New functions.
+        (careadlinkat): Don't check that fd == AT_FDCWD.
+        (careadlinkatcwd): Remove; no longer needed.
+
+2013-01-31  Glenn Morris  <rgm@gnu.org>
+
+        * fileio.c (choose_write_coding_system): Make it callable from Lisp.
+        (Fwrite_region): Update for new choose_write_coding_system args.
+        Move the last piece of choose_write_coding_system here.  (Bug#13522)
+        (syms_of_fileio): Add choose-write-coding-system.
+
+2013-01-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (sys_open): Zero out the flags for the new file descriptor.
+        (sys_close): Zero out the flags for the file descriptor before
+        closing it.  (Bug#13546)
+
+        * w32.c (parse_root, get_volume_info, readdir, read_unc_volume)
+        (logon_network_drive, stat_worker, symlink, chase_symlinks):
+        Use CharNextExA and CharPrevExA to iterate over file names encoded in
+        DBCS.  (Bug#13553)
+
+        * w32.c (w32_get_long_filename, init_environment, readlink):
+        Support file names encoded in DBCS codepages.
+        (readlink): Use the current file-name-coding-system, not the ANSI
+        codepage, to decode and handle targets of symlinks.
+
+2013-01-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (opendir): Now accepts a 'const char *'.
+
+2013-01-28  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Remove obsolete redisplay code.  See the discussion at
+        http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00576.html.
+        * dispnew.c (preemption_period, preemption_next_check): Remove.
+        (Vredisplay_preemption_period): Likewise.
+        (update_frame, update_single_window, update_window, update_frame_1):
+        Adjust users.  Always assume that PERIODIC_PREEMPTION_CHECKING is not
+        used, following the 2012-06-22 change.
+
+2013-01-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32notify.c (Fw32notify_add_watch): Doc fix.  (Bug#13540)
+
+2013-01-25  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * font.c (num_fonts): Remove the leftover from old
+        debugging code.  Adjust comment style here and there.
+        * insdel.c (insert_1): Remove.
+        * lisp.h (insert_1): Remove prototype.
+        * xdisp.c (message_dolog): Adjust users to call insert_1_both.
+
+2013-01-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (max_filename_mbslen): New function.
+        (normalize_filename, readdir): Use it to detect locales where ANSI
+        encoding of file names uses a double-byte character set (DBCS).
+        If a DBCS encoding is used, advance by characters using
+        CharNextExA, instead of incrementing a 'char *' pointer.
+        Use _mbslwr instead of _strlwr.  (Bug#13515)
+
+        * w32heap.c (allocate_heap) [!_WIN64]: Decrease the initial
+        request of memory reservation to 1.7GB.  (Bug#13065)
+
+2013-01-25  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * coding.c (detect_coding_iso_2022): Move back mis-reordered code
+        at check_extra_latin label.  (Bug#13505)
+
+2013-01-24  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * nsfont.m (ns_escape_name, ns_unescape_name, ns_registry_to_script):
+        Avoid redundant calls to strlen.
+
+2013-01-24  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Drop async_visible and async_iconified fields of struct frame.
+        This is possible because async input is gone; for details, see
+        http://lists.gnu.org/archive/html/emacs-devel/2012-12/msg00734.html.
+        * frame.h (struct frame): Remove async_visible and async_iconified
+        members, convert garbaged to unsigned bitfield.  Adjust comments.
+        (FRAME_SAMPLE_VISIBILITY): Remove.  Adjust all users.
+        (SET_FRAME_VISIBLE, SET_FRAME_ICONIFIED): New macros.
+        * frame.c, gtkutil.c, term.c, w32fns.c, window.c, xdisp.c:
+        Consistently use SET_FRAME_VISIBLE, SET_FRAME_ICONIFIED,
+        FRAME_VISIBLE_P and FRAME_ICONIFIED_P macros where appropriate.
+        * w32term.c: Ditto.
+        (w32_read_socket): Save iconified state to generate DEICONIFY_EVENT
+        properly.  Likewise for obscured.
+        * xterm.c: Ditto.
+        (handle_one_xevent): Save visible state to generate ICONIFY_EVENT
+        properly.
+        * nsterm.m: Ditto.
+        (windowDidDeminiaturize): Generate DEICONIFY_EVENT.
+
+2013-01-24  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * insdel.c (prepare_to_modify_buffer): Revert last change as suggested
+        in http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00555.html.
+
+2013-01-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (message2, message2_nolog): Remove functions.
+        (message3, message3_nolog): Extract nbytes and multibyteness directly
+        from the string.  Change all callers.
+        (message3_nolog): Don't set message_enable_multibyte since set_message
+        will reset it anyway.
+        (message1, message1_nolog): Use message3.
+        (vmessage): Use a stack allocated buffer rather than f->message_buf.
+        (with_echo_area_buffer): Remove last two arguments.  Update all callers.
+        (set_message): Drop all but the second arg, which has to be a string.
+        (set_message_1): Simplify now that we know that a1 is NULL and the
+        second arg is a string.
+        * frame.h (struct frame): Remove `message_buf' field.
+        Use glyphs_initialized_p instead.
+        (FRAME_MESSAGE_BUF): Remove macro.
+        * w16select.c (Fw16_set_clipboard_data): Prefer message3 to message2.
+        * lisp.h (message2, message2_nolog): Remove declarations.
+        (message3, message3_nolog): Update declarations.
+        * keyboard.c (read_char_minibuf_menu_text)
+        (read_char_minibuf_menu_width): Remove vars.
+        (read_char_minibuf_menu_prompt): Rewrite the menu's construction so as
+        to correctly handle multibyte strings.
+        * frame.c (delete_frame): Don't free message_buf any more.
+        * editfns.c (message_text, message_length): Remove vars.
+        (Fmessage_box): Don't copy the Lisp string's bytes any longer.
+        * fileio.c (auto_save_error): Use message3 instead of message2.
+        * dispnew.c (adjust_frame_message_buffer): Remove function.
+
+2013-01-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (w32fullscreen_hook): Account correctly for the screen
+        real estate used for the tool bar and the menu bar.
+
+2013-01-23  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * insdel.c (prepare_to_modify_buffer): Force redisplay if
+        hidden buffer is prepared to modification (Bug#13164).
+
+2013-01-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * window.h (struct window): Change window_end_valid member from
+        Lisp_Object to a bitfield.  Adjust comments.
+        (wset_window_end_valid): Remove.
+        * window.c (adjust_window_count): Clear window_end_valid.
+        (Fwindow_end): Adjust user.  Remove ancient #if 0 code.
+        (Fwindow_line_height, set_window_buffer, Frecenter)
+        (Fsplit_window_internal, Fdelete_other_windows_internal)
+        (Fset_window_fringes, Fset_window_scroll_bars): Adjust users.
+        * dispnew.c (adjust_glyph_matrix, clear_window_matrices): Likewise.
+        * xdisp.c (check_window_end, reconsider_clip_changes)
+        (redisplay_internal, mark_window_display_accurate_1, redisplay_window)
+        (try_window, try_window_reusing_current_matrix, note_mouse_highlight)
+        (find_first_unchanged_at_end_row, try_window_id): Likewise.
+
+2013-01-22  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xdisp.c (mark_window_display_accurate): Simplify the loop
+        assuming that the only one of vchild, hchild or buffer window
+        slots is non-nil.  Call mark_window_display_accurate_1 for
+        the leaf windows only.
+        (mark_window_display_accurate_1): Always assume leaf window.
+        Adjust comment.
+
+2013-01-22  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * emacs.c (Qkill_emacs_hook): Now static.
+
+        * fileio.c (Finsert_file_contents): Simplify.
+        Remove unnecessary assignments and tests.
+
+2013-01-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (acl_set_file): Don't test for errors unless
+        set_file_security returns FALSE.  Avoids spurious errors when
+        saving files.
+
+2013-01-21  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * fileio.c (Finsert_file_contents): Revert code introduced at
+        2013-01-18 in favor of the simpler and generally better fix.
+        Save stack space by removing 'buffer' and reusing 'read_buf'
+        where appropriate.
+
+2013-01-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * lisp.h (eabs): Define unconditionally (Bug#13419).
+        The old "#if !defined (eabs)" was an unnecessary revenant of back
+        when this macro was called "abs".  Document 'eabs' better.
+
+2013-01-19  Glenn Morris  <rgm@gnu.org>
+
+        * fns.c (Frandom): Doc fix.
+
+2013-01-19  Eli Zaretskii  <eliz@gnu.org>
+
+        * editfns.c (get_pos_property): Use SAFE_ALLOCA_LISP, to avoid
+        segfault when there are lots of overlays.
+
+        * buffer.c (sort_overlays): Use SAFE_NALLOCA, to avoid segfault
+        when there are lots of overlays.
+        See http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00421.html
+        for the details and a way to reproduce.
+
+2013-01-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c: Use O_APPEND to append.
+        This corresponds better to the natural interpretation of "append",
+        and avoids the need to open the output file twice, or to invoke
+        lseek when APPEND is neither nil nor a number.
+        This relies on POSIX 1003.1-1988 or later, which is OK nowadays.
+        (Fwrite_region): Simplify.  Use O_APPEND instead of opening the
+        file possibly twice, and lseeking to its end; this avoids the
+        need to lseek on non-regular files.  Do not use O_EXCL and O_TRUNC
+        at the same time: the combination is never needed and apparently
+        it doesn't work with DOS_NT.
+
+        Fix size bug on DOS_NT introduced by CIFS workaround (Bug#13149).
+        * fileio.c (Fwrite_region): Use O_BINARY in checking code, too.
+
+        Allow floating-point file offsets.
+        Problem reported by Vitalie Spinu in
+        <http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00411.html>.
+        * fileio.c (emacs_lseek): Remove.
+        (file_offset): New function.
+        (Finsert_file_contents, Fwrite_region): Use it.
+
+2013-01-19  Chong Yidong  <cyd@gnu.org>
+
+        * emacs.c (Fkill_emacs): Set waiting_for_input to 0 to avoid
+        aborting on Fsignal (Bug#13289).
+
+2013-01-19  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (acl_set_file): Treat ERROR_ACCESS_DENIED from
+        set_file_security as failure due to insufficient privileges.
+        Reported by Fabrice Popineau <fabrice.popineau@supelec.fr>.
+        (fstat): Return owner and group like 'stat' and 'lstat' do.
+
+2013-01-19  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Work around bug in CIFS and vboxsf file systems (Bug#13149).
+        The bug was observed on Ubuntu operating inside a virtual machine,
+        editing files mounted via CIFS or vboxsf from the MS Windows 7 host.
+        The workaround introduces a race condition on non-buggy hosts,
+        but it's an unlikely race and anyway there's a nearly identical
+        nearby race that can't be fixed.
+        * fileio.c (valid_timestamp_file_system, timestamp_file_system):
+        New static vars.
+        (Fwrite_region): Test for file system time stamp bug.
+        (init_fileio): New function.
+        * lisp.h (init_fileio): Declare it.
+        * emacs.c (main): Call it.
+
+        * fileio.c (Finsert_file_contents): Simplify new diagnostic
+        and make it more consistent with other stat-failure diagnostics.
+
+2013-01-18  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix crash when inserting data from non-regular files.
+        See http://lists.gnu.org/archive/html/emacs-devel/2013-01/msg00406.html
+        for the error description produced by valgrind.
+        * fileio.c (read_non_regular): Rename to read_contents.
+        Free Lisp_Save_Value object used to pass parameters.
+        (read_non_regular_quit): Rename to read_contents_quit.
+        (Finsert_file_contents): Redesign internal file reading loop to adjust
+        gap and end positions after each read and so help make_gap to work
+        properly.  Do not signal an I/O error too early and so do not leave
+        not yet decoded characters in a buffer, which was the reason of
+        redisplay crash.  Use list2 to build return value.  Adjust comments.
+
+2013-01-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Close a race when statting and reading files (Bug#13149).
+        * fileio.c (Finsert_file_contents): Use open+fstat, not stat+open.
+        This avoids a race if the file is renamed between stat and open.
+        This race is not the problem originally noted in Bug#13149;
+        see <http://bugs.gnu.org/13149#73> and later messages in the thread.
+
+2013-01-17  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (toplevel): Add comment about using Lisp_Save_Value
+        objects, related functions and macros.
+        (make_save_value): Adjust prototype.
+        (make_save_pointer): New prototype.
+        (SAFE_NALLOCA): Fix indentation.  Use make_save_pointer.
+        (SAFE_ALLOCA_LISP): Adjust make_save_value usage.
+        * alloc.c (format_save_value): Rename to make_save_value.
+        (make_save_pointer): New function.
+        (record_xmalloc): Use make_save_pointer.
+        * dired.c, editfns.c, fileio.c, font.c, gtkutil.c, lread.c:
+        * nsmenu.m, nsterm.m, xfns.c, xmenu.c, xselect.c, keymap.c:
+        Change users of make_save_value to make_save_pointer.
+        Likewise for format_save_value and make_save_value.
+
+2013-01-17  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.h (NARROWED, BUF_NARROWED): Drop unused macros.
+        (DECODE_POSITION, BUFFER_CHECK_INDIRECTION): Fix indentation.
+        * buffer.c (toplevel, syms_of_buffer): Drop old commented-out
+        debugging stubs.
+
+2013-01-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * alloc.c (free_save_value): Now static.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * keymap.c (map_keymap_internal): Use format_save_value.
+        (map_keymap_char_table_item): Adjust accordingly.
+        * fileio.c (non_regular_fd, non_regular_inserted)
+        (non_regular_nbytes): Remove.
+        (Finsert_file_contents): Convert trytry to ptrdiff_t.
+        Use format_save_value to pass parameters to read_non_regular.
+        (read_non_regular): Use XSAVE_ macros to extract parameters.
+        Adjust comment.
+        * xmenu.c (xmenu_show) [!USE_X_TOOLKIT && !USE_GTK]: Use
+        format_save_value.
+        (pop_down_menu) [!USE_X_TOOLKIT && !USE_GTK]: Adjust user.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (XSAVE_POINTER, XSAVE_INTEGER): Change to allow
+        extraction from any Lisp_Save_Value slot.  Add type checking.
+        * alloc.c, dired.c, editfns.c, fileio.c, ftfont.c, gtkutil.c:
+        * keymap.c, lread.c, nsterm.h, nsmenu.c, xfns.c, xmenu.c:
+        * xselect.c: All users changed.
+
+2013-01-15  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Some convenient bits to deal with Lisp_Save_Values.
+        * lisp.h (XSAVE_OBJECT): New macro to extract saved objects.
+        (allocate_misc): Remove prototype.
+        (format_save_value): New prototype.
+        * alloc.c (allocate_misc): Revert back to static.
+        (format_save_value): New function to build Lisp_Save_Value
+        object with the specified internal structure.
+        (make_save_value): Reimplement using format_save_value.
+        * editfns.c (save_excursion_save): Use format_save_value.
+        (save_excursion_restore): Use XSAVE_OBJECT.
+
+2013-01-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid needless casts with XSAVE_POINTER.
+        * alloc.c (mark_object) [GC_MARK_STACK]:
+        * dired.c (directory_files_internal_unwind):
+        * fileio.c (do_auto_save_unwind):
+        * gtkutil.c (pop_down_dialog):
+        * keymap.c (map_keymap_char_table_item):
+        * lread.c (load_unwind):
+        * nsmenu.m (pop_down_menu):
+        * print.c (print_object) [GC_MARK_STACK]:
+        * xfns.c (clean_up_file_dialog):
+        * xmenu.c (cleanup_widget_value_tree):
+        Omit casts between XSAVE_POINTER and a pointer type.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix compilation with GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE.
+        * eval.c (eval_sub): Protect `form' from being GCed before its
+        car and cdr becomes protected with the backtrace entry.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Make Lisp_Save_Value more versatile storage for up to four objects.
+        * lisp.h (toplevel): Enumeration to describe types of saved objects.
+        (struct Lisp_Save_Value): New layout.  Adjust comments.
+        (XSAVE_POINTER): New macro.
+        (XSAVE_INTEGER): Likewise.
+        (allocate_misc): Add prototype.
+        (free_misc): Likewise.
+        * alloc.c (allocate_misc): Now global.
+        (free_misc): Likewise.  Adjust comment.
+        (make_save_value): Use new Lisp_Save_Value layout.  Adjust comment.
+        (free_save_value): Likewise.
+        (mark_object): Likewise.
+        * editfns.c (save_excursion_save): Pack everything within
+        Lisp_Save_Value and so avoid xmalloc.
+        (save_excursion_restore): Adjust to match new layout.  Use free_misc
+        because we do not allocate extra memory any more.  Add eassert.
+        * print.c (print_object): New code to print Lisp_Save_Value.  Do not
+        rely on valid_lisp_object_p if !GC_MARK_STACK.  Adjust comments.
+        * dired.c, fileio.c, font.c, ftfont.c, gtkutil.c, keymap.c,
+        * lread.c, nsmenu.m, nsterm.h, xfns.c, xmenu.c, xselect.c:
+        Use XSAVE_POINTER and XSAVE_INTEGER where appropriate.
+
+2013-01-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfont.m (LCD_SMOOTHING_MARGIN): New define.
+        (nsfont_draw): Remove disabling of LCD smoothing.
+        (ns_glyph_metrics): Add LCD_SMOOTHING_MARGIN to bearings to fix
+        Bug#11484 with LCD smoothing on.
+
+2013-01-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix SIGDANGER handlers, for AIX (Bug#13408).
+        * sysdep.c.c (handle_danger_signal, deliver_danger_signal) [SIGDANGER]:
+        Move handlers here from emacs.c; they were out of place.
+
+2013-01-11  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * xterm.c (syms_of_xterm): Adjust documentation for
+        scroll-bar-adjust-thumb-portion.
+
+2012-12-31  Adam Sjøgren  <asjo@koldfront.dk>  (tiny change)
+
+        * xterm.c (scroll-bar-adjust-thumb-portion): New variable to
+        determine whether scroll bar thumb size should be adjusted or
+        not. Use variable for MOTIF.
+
+        * gtkutil.c (scroll-bar-adjust-thumb-portion): Use variable for
+        GTK.
+
+2013-01-13  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (keyDown:): Set processingCompose to NO if an emacs key
+        event is generated.
+        (doCommandBySelector:): Set processingCompose to NO.
+
+        * nsfont.m (ns_findfonts): Add block/unblock_input calls.
+        Remove check for fkeys count > zero, block/unblock fixes the real bug.
+        (nsfont_list_family): Add block/unblock_input calls.
+        (nsfont_open): Move block_input earlier.  Add unblock_input before early
+        return.
+        (nsfont_draw): Add block/unblock_input calls.
+
+2013-01-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * indent.c (Fvertical_motion): Remove now-incorrect GCPROs
+        for old_charpos and old_bytepos.
+
+2013-01-12  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix bug with set-time-zone-rule and LOCALTIME_CACHE (Bug#13415).
+        * editfns.c (set_time_zone_rule) [LOCALTIME_CACHE]:
+        Clear tzvalbuf_in_environ if this workaround is in effect.
+        Problem and fix reported by Kazuhiro Ito.
+
+2013-01-11  Aaron S. Hawley  <Aaron.Hawley@vtinfo.com>
+
+        * insdel.c (Fcombine_after_change_execute, syms_of_insdel):
+        Fix ambiguous doc string cross-reference(s).
+
+        * keyboard.c (Fcommand_execute, syms_of_keyboard): Fix ambiguous
+         doc string cross-reference(s).
+
+        * window.c (Fwindow_point, syms_of_window): Fix ambiguous doc
+         string cross-reference(s).
+
+2013-01-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid unnecessary byte position calculation for the gap movement.
+        Since all users of move_gap do CHAR_TO_BYTE for other purposes
+        anyway, all of them should use move_gap_both instead.
+        * lisp.h (move_gap): Remove prototype.
+        * insdel.c (move_gap): Remove.
+        (move_gap_both): Add eassert.
+        * editfns.c (Ftranspose_regions): Tweak to use move_gap_both.
+        * xml.c (parse_region): Likewise.
+
+2013-01-11  Paul Eggert  <eggert@cs.ucla.edu>
+
+        emacsclient -t should not suspend Emacs server (Bug#13387)
+        * lisp.h, sysdep.c (block_tty_out_signal, unblock_tty_out_signal):
+        New functions.
+        * term.c (init_tty): Use them instead of rolling our own code.
+        * sysdep.c (tcsetpgrp_without_stopping): Likewise.  Here, this
+        switches from 'signal' to 'pthread_sigmask', which is safer in
+        multithreaded applications.
+        * term.c (Fresume_tty): Don't bother dissociating if O_IGNORE_CTTY,
+        which has already arranged for that.
+        (dissociate_if_controlling_tty): If setsid fails, fall back on TIOCNOTTY.
+        This is the main part of the bug fix.
+
+2013-01-10  Rainer Orth  <ro@CeBiTec.Uni-Bielefeld.DE>  (tiny change)
+
+        * gtkutil.c (xg_initialize): Add ifdef HAVE_FREETYPE around
+        x_last_font_name (Bug#13403).
+
+2013-01-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Omit buffer_slot_type_mismatch and use generic predicates to enforce
+        the type of per-buffer values where appropriate.
+        * lisp.h (struct Lisp_Buffer_Objfwd): Rename slottype member to
+        predicate, which is how it's really used now.  Adjust comment.
+        * buffer.h (buffer_slot_type_mismatch): Remove prototype.
+        * buffer.c (buffer_slot_type_mismatch): Remove.
+        (DEFVAR_PER_BUFFER, defvar_per_buffer): Rename type argument to
+        predicate.  Adjust comment.
+        (syms_of_buffer): Use Qsymbolp for major-mode.  Use Qintegerp for
+        fill-column, left-margin, tab-width, buffer-saved-size,
+        left-margin-width, right-margin-width, left-fringe-width,
+        right-fringe-width, scroll-bar-width and buffer-display-count.
+        Use Qstringp for default-directory, buffer-file-name,
+        buffer-file-truename and buffer-auto-save-file-name.  Use Qfloatp for
+        scroll-up-aggressively and scroll-down-aggressively.  Use Qnumberp for
+        line-spacing.
+        * data.c (store_symval_forwarding): Adjust to call the predicate.
+
+2013-01-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * w32.c (get_name_and_id, acl_set_file):
+        * w32term.c (w32fullscreen_hook): Remove unused local variables.
+
+2013-01-09  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (make_gap_1): New prototype.
+        * buffer.h (GAP_BYTES_DFL, GAP_BYTES_MIN): New macros for the special
+        gap size values.
+        * editfns.c (Fbuffer_size): Rename from Fbufsize to fit the common
+        naming convention.
+        (syms_of_editfns): Adjust defsubr.  Drop commented-out obsolete code.
+        * insdel.c (make_gap_larger): Use GAP_BYTES_DFL.  Adjust comment.
+        (make_gap_smaller): Use GAP_BYTES_MIN.  Adjust comment.
+        (make_gap_1): New function to adjust the gap of any buffer.
+        * coding.c (coding_alloc_by_making_gap): Use it.
+        * buffer.c (compact_buffer): Likewise.  Use BUF_Z_BYTE, BUF_GAP_SIZE,
+        GAP_BYTES_DFL and GAP_BYTES_MIN.  Adjust comment.
+
+2013-01-08  Juri Linkov  <juri@jurta.org>
+
+        * xfaces.c (tty_supports_face_attributes_p): Return 0 for the case
+        of (supports :underline (:style wave)).  (Bug#13000)
+
+2013-01-08  Aaron S. Hawley  <aaron.s.hawley@gmail.com>
+
+        * undo.c (Fprimitive_undo): Move to simple.el.
+        (syms_of_undo): Remove declarations for Sprimitive_undo.
+
+2013-01-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (echo_add_key): Rename from echo_add_char.
+
+2013-01-06  Chong Yidong  <cyd@gnu.org>
+
+        * keyboard.c (echo_add_char): New function, factored out from
+        echo_char.  Don't add a space if the previous echo string was
+        empty (Bug#13255).
+        (echo_char): Use it.
+        (read_key_sequence): When echoing mock input, ensure that the
+        trailing dash is properly added.
+
+2013-01-05  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (dump_glyph): Align glyph data better.  Use "pD" instead
+        of a non-portable "t" to print ptrdiff_t values.  Allow up to 9
+        digits for buffer positions, before misalignment starts.
+        Display "0" for integer "object" field.
+        (dump_glyph_row): Adapt the header line to changes in dump_glyph.
+        Display the newline glyph more unambiguously.
+
+2013-01-04  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * nsterm.m (ns_draw_underwave):
+        * w32term.c (w32_draw_underwave):
+        * xterm.c (x_draw_underwave): Make underwave look more triangular
+        and also degrade gracefully for small fonts.  (Bug#13000)
+
+        * nsterm.m (ns_draw_text_decoration):
+        * w32term.c (x_draw_glyph_string):
+        * xterm.c (x_draw_glyph_string): Don't use previous underline
+        thickness and position if previous underline type is underwave.
+
+2013-01-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * fileio.c (Ffile_acl): Undocument return format.
+
+2013-01-02  Glenn Morris  <rgm@gnu.org>
+
+        * keymap.c (Fkey_description): Doc fix.  (Bug#13323)
+
+2013-01-02  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Simplify via eabs.
+        * dired.c (file_name_completion):
+        * doc.c (get_doc_string):
+        * floatfns.c (round2):
+        * font.c (font_score, font_delete_unmatched):
+        * fringe.c (compute_fringe_widths):
+        * lread.c (read_list):
+        * minibuf.c (Ftry_completion):
+        * term.c (tty_ins_del_lines):
+        * xterm.c (x_draw_image_foreground, x_draw_image_foreground_1):
+        Use eabs (x) rather than open-coding it as (x < 0 ? -x : x).
+
+2012-12-31  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (unsetenv): Set up the string passed to _putenv
+        correctly.
+        See http://lists.gnu.org/archive/html/emacs-devel/2012-12/msg00863.html
+        for the bug this caused.
+
+2012-12-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * coding.c (Qmac): Now static.
+
+2012-12-30  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (TOOLBAR_TOP_WIDGET): New macro.
+        (xg_pack_tool_bar): Use TOOLBAR_TOP_WIDGET, condition out use of
+        handlebox_widget.  Set toolbar_in_hbox to false/true, set
+        toolbar_is_packed to true.
+        (xg_update_tool_bar_sizes): Use widget returned by TOOLBAR_TOP_WIDGET.
+        (update_frame_tool_bar): Check toolbar_is_packed for packing.
+        Show all on TOOLBAR_TOP_WIDGET.
+        (free_frame_tool_bar): Check toolbar_is_packed.  Use widget returned
+        by TOOLBAR_TOP_WIDGET.
+        (xg_change_toolbar_position): Use widget returned by TOOLBAR_TOP_WIDGET.
+        Check toolbar_is_packed.
+        (xg_have_tear_offs, tearoff_remove, tearoff_activate): Condition on
+        HAVE_GTK_TEAROFF_MENU_ITEM_NEW.
+        (xg_have_tear_offs): When ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW, return
+        false.
+        (create_menus): Create tearoff only if HAVE_GTK_TEAROFF_MENU_ITEM_NEW.
+        (xg_update_menubar): Update title only if
+        HAVE_GTK_TEAROFF_MENU_ITEM_NEW.
+        (xg_update_submenu): Skip tearoff only if
+        HAVE_GTK_TEAROFF_MENU_ITEM_NEW.
+        (xg_initialize): Initialize xg_detached_menus only if
+        HAVE_GTK_TEAROFF_MENU_ITEM_NEW.
+
+        * xterm.h (struct x_output): Surround handlebox_widget with
+        #ifdef HAVE_GTK_HANDLE_BOX_NEW.  toolbar_is_packed is new,
+        toolbar_in_hbox is bool.
+
+2012-12-30  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * src/Makefile.in (TEMACS_LDFLAGS2): Remove.
+        (LIBS_GNUSTEP): Define.
+        (LIBES): Add $(LIBS_GNUSTEP).
+        (temacs$(EXEEXT)): Use $(LDFLAGS) instead of $(TEMACS_LDFLAGS2).
+
+2012-12-30  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (set_cursor_from_row): Don't confuse a truncation or
+        continuation glyph on a TTY with an indication of an empty line.
+        (Bug#13277)
+
+2012-12-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (Fset_file_selinux_context, Fset_file_acl): Return t if
+        file's SELinux context or ACLs successfully set, nil otherwise.
+        (Bug#13298)
+        (Fcopy_file) [WINDOWSNT]: Improve diagnostics when CopyFile fails.
+
+        * w32proc.c (reader_thread): Avoid passing NULL handles to
+        SetEvent and WaitForSingleObject.
+
+2012-12-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port EXTERNALLY_VISIBLE to Clang 3.2.
+        * conf_post.h (__has_attribute): New macro.
+        (EXTERNALLY_VISIBLE): Use it.  This ports to Clang 3.2.
+
+2012-12-27  Glenn Morris  <rgm@gnu.org>
+
+        * cygw32.c (Fcygwin_convert_file_name_to_windows)
+        (Fcygwin_convert_file_name_from_windows): Doc fixes.
+
+2012-12-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (file_name_as_directory, directory_file_name):
+        Accept an additional argument MULTIBYTE to indicate whether the input C
+        came from a multibyte or a unibyte Lisp string; all callers
+        adjusted.  Don't assume the input string is always multibyte.
+        (Bug#13262)
+        (Ffile_name_directory) [DOS_NT]: Handle unibyte strings correctly:
+        don't ENCODE_FILE them, and return a unibyte string if the input
+        was unibyte.
+        (Fexpand_file_name): Don't mix unibyte with multibyte strings, and
+        don't assume the input strings will always be multibyte.  If the
+        input strings are multibyte, decode strings obtained from C
+        library functions.
+
+2012-12-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * lisp.h (toplevel): Add two notices to the comment about
+        defining a new Lisp data type.
+        * print.c (print_object): If Lisp_Save_Value object's pointer
+        is the address of a memory area containing Lisp_Objects, try
+        to print them.
+        * alloc.c (valid_lisp_object_p): Adjust comment.
+
+2012-12-26  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * keyboard.c (record_asynch_buffer_change): Initialize an event
+        only if it's really needed.
+        * frame.h (enum output_method): Remove output_mac member since
+        it's a leftover from the deleted code.
+        * frame.c (Fframep): Adjust user here ...
+        * terminal.c (Fterminal_live_p): ... and here.
+        * coding.c (Qmac): Now here because it's only used to denote
+        end-of-line encoding type.
+        (syms_of_coding): DEFSYM it.
+        * frame.h (Qmac): Remove duplicated declaration.
+
+2012-12-26  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * window.c (select_window_1): Now static, since it's used only here.
+
+2012-12-25  Eli Zaretskii  <eliz@gnu.org>
+
+        * window.c (window_body_cols): Subtract display margins from the
+        window body width on TTYs as well.  See
+        http://lists.gnu.org/archive/html/help-gnu-emacs/2012-12/msg00317.html
+        for the original report.
+
+2012-12-25  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * xdisp.c (redisplay_window): Remove inner local variable
+        because the outer shadowed one has the same meaning.
+        * xterm.h (struct x_output): Remove toolbar_detached member since it's
+        set but never used.
+        * gtkutil.c (xg_tool_bar_detach_callback, xg_tool_bar_attach_callback)
+        (xg_create_tool_bar): Adjust users.
+
+2012-12-24  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.h (BUF_COMPACT): New macro to follow the common style.
+        * buffer.c (Fget_buffer_create): Use it to set compact field of
+        struct buffer_text to avoid accessing an uninitialized value
+        when compact_buffer is called for the first time.
+        (compact_buffer): Use convenient BUF_COMPACT and BUF_MODIFF.
+        (Fset_buffer_modified_p): Use buffer_window_count to check
+        whether the buffer is displayed in some window.
+        * xdisp.c (message_dolog): Likewise.
+
+2012-12-23  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (acl_set_file): If setting the file security descriptor
+        fails, and the new DACL is identical to the existing one, silently
+        return success.  This fixes problems for users backing up their
+        own files without having the necessary privileges for setting
+        security descriptors.
+
+        * w32proc.c (reader_thread): Do not index fd_info[] with negative
+        values.
+        (reader_thread): Exit when cp->status becomes STATUS_READ_ERROR
+        after WaitForSingleObject returns normally.  This expedites reader
+        thread shutdown when delete_child triggers it.
+        (reap_subprocess): More accurate commentary for why we call
+        delete_child only when cp->fd is negative.
+
+        * w32.c (sys_close): Do not call delete_child on a subprocess
+        whose handle is not yet closed.  Instead, set its file descriptor
+        to a negative value, so that reap_subprocess will call
+        delete_child on that subprocess when its SIGCHLD arrives.
+        This avoids closing handles used for communications between sys_select
+        and reader_thread, which doesn't give sys_select a chance to
+        notice that the process exited and invoke the SIGCHLD handler for
+        it.
+
+2012-12-23  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsfns.m (Fns_do_applescript): Run event loop until script has
+        been executed (Bug#12969).
+        (ns_run_ascript): Chech as_script for nil, set to nil after
+        executing script.
+
+2012-12-22  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fselect_window): Reword doc-string (Bug#13248).
+
+2012-12-22  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (w32fullscreen_hook): New function.
+        (w32_create_terminal): Plug it into the terminal's fullscreen_hook.
+
+2012-12-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * fileio.c (Finsert_file_contents): Doc fix.
+
+        * w32proc.c (new_child, delete_child, find_child_pid): For a
+        subprocess, consider its slot being in use as long as its process
+        handle (procinfo.hProcess) is not NULL.  This avoids reusing the
+        slot when a new process is started immediately after killing
+        another one, without waiting enough time for the first process to
+        be reaped and resources allocated for it be orderly freed.
+        (Bug#13086)
+        Suggested by Fabrice Popineau <fabrice.popineau@supelec.fr>.
+
+2012-12-21  Chong Yidong  <cyd@gnu.org>
+
+        * buffer.c (Fset_buffer_major_mode): Doc fix (Bug#13231).
+
+        * fns.c (Fcompare_strings): Doc fix (Bug#13081).
+
+2012-12-21  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (get_name_and_id): Always pass NULL as the first argument
+        of lookup_account_sid.  Avoids crashes with UNC file names that
+        refer to DFS domains, not to specific machine names.  (Bug#12621)
+        Remove now unused argument FNAME; all callers changed.
+        (get_file_owner_and_group): Remove now unused argument FNAME; all
+        callers changed.
+
+2012-12-21  Chong Yidong  <cyd@gnu.org>
+
+        * editfns.c (Finsert_char): Since read-char-by-name now signals an
+        error for invalid chars, don't check for a nil return value.
+
+2012-12-20  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Avoid calls to CHAR_TO_BYTE if byte position is known.
+        * editfns.c (make_buffer_string_both): Use move_gap_both.
+        (Fbuffer_string): Use make_buffer_string_both.
+        * marker.c (buf_charpos_to_bytepos): Convert to eassert.
+        Adjust comment.
+        (buf_bytepos_to_charpos): Likewise.
+        (charpos_to_bytepos): Remove.
+        * fileio.c (Finsert_file_contents): Use move_gap_both.
+        * search.c (Freplace_match): Likewise.
+        * process.c (process_send_region): Likewise.  Use convenient
+        names for byte positions.
+        * lisp.h (charpos_to_bytepos): Remove prototype.
+        * indent.c (scan_for_column): Use CHAR_TO_BYTE.
+        * insdel.c (move_gap): Likewise.
+
+2012-12-20  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * xdisp.c (redisplay_internal): Remove now-unused local.
+
+2012-12-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (select_frame_for_redisplay, ensure_selected_frame): Remove.
+        (redisplay_internal): Don't bother selecting the frame to get the
+        proper value of frame-local variables (bug#13225).
+
+2012-12-20  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * textprop.c (set_text_properties_1): Do not allow NULL interval.
+        Rename 4th argument since it may be buffer or string.  Adjust comment.
+        * intervals.c (graft_intervals_info_buffer): Find an interval here.
+
+2012-12-19  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * coding.c (Fdetect_coding_region): Do not check start and end with
+        CHECK_NUMBER_COERCE_MARKER since validate_region does that itself.
+        (code_convert_region): Likewise.
+
+2012-12-18  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (acl_get_file, acl_set_file): Run the file name through
+        map_w32_filename, and resolve any symlinks in the file name, like
+        Posix platforms do.
+        (acl_set_file): Call revert_to_self, if any privileges were
+        enabled.
+
+2012-12-17  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in ($(BLD)/editfns.$(O), $(BLD)/fileio.$(O))
+        ($(BLD)/w32.$(O)): Update dependencies.
+
+2012-12-17  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (select_frame_for_redisplay): Use select_window_1 to
+        propagate redisplay's scrolling (if any) to the right window.
+        (redisplay_internal): Use ensure_selected_frame.
+        (display_mode_lines): Complete last fix.
+        * window.c (select_window_1): New func, extracted from select_window.
+        (select_window): Use it.
+        * window.h (select_window_1): Declare.
+
+2012-12-17  Eli Zaretskii  <eliz@gnu.org>
+
+        Emulate Posix ACL APIs on MS-Windows.
+        * w32.c: Include sddl.h and sys/acl.h.
+        (SDDL_REVISION_1): Define if not already defined.
+        (g_b_init_get_security_descriptor_dacl)
+        (g_b_init_convert_sd_to_sddl, g_b_init_convert_sddl_to_sd)
+        (g_b_init_is_valid_security_descriptor)
+        (g_b_init_set_file_security): New static flags.
+        (globals_of_w32): Initialize them to zero.
+        (SetFileSecurity_Name): New string constant.
+        (SetFileSecurity_Proc, GetSecurityDescriptorDacl_Proc)
+        (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)
+        (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)
+        (IsValidSecurityDescriptor_Proc): New typedefs.
+        (get_file_security, get_security_descriptor_owner)
+        (get_security_descriptor_group): Set errno to ENOTSUP.
+        (set_file_security, get_security_descriptor_dacl)
+        (is_valid_security_descriptor, convert_sd_to_sddl)
+        (convert_sddl_to_sd, acl_valid, acl_to_text, acl_from_text)
+        (acl_free, acl_get_file, acl_set_file): New functions.
+
+        * fileio.c (Fcopy_file) [WINDOWSNT]: Support copying ACLs.
+
+2012-12-17  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Don't reraise SIGCHLD, as that can now lose (Bug#13192).
+        With the 2012-12-03 fix for Bug#12980 in place, an old workaround
+        for some of that bug's symptoms can now cause Emacs to abort.
+        Remove the workaround.
+        * process.c (wait_reading_process_output): Don't reraise SIGCHLD.
+        The bug that caused SIGCHLD to get lost has been fixed, and the
+        workaround for it can now cause Emacs to abort.
+
+2012-12-16  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * sysdep.c (emacs_abort): Bump backtrace size to 40.
+        Companion to the 2012-09-30 patch.  Suggested by Eli Zaretskii in
+        <http://lists.gnu.org/archive/html/emacs-devel/2012-09/msg00796.html>.
+
+2012-12-16  Romain Francoise  <romain@orebokech.com>
+
+        * fileio.c (Ffile_acl, Fset_file_acl): New functions.
+        (Fcopy_file): Change last arg to `preserve_extended_attributes'
+        and copy ACL entries of file in addition to SELinux context if set.
+        (syms_of_fileio): Add `file-acl' and `set-file-acl'.
+
+        * Makefile.in (LIBACL_LIBS): New macro.
+        (LIBES): Use it.
+
+2012-12-15  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (internal_delete_file): Use bool for boolean.
+
+2012-12-15  Eli Zaretskii  <eliz@gnu.org>
+
+        Fix bug #13079 on MS-Windows with temp files not being deleted.
+        * w32.h (_child_process): New members input_file and
+        pending_deletion.
+        (register_child): First argument is now pid_t.
+        (record_infile, record_pending_deletion): New prototypes.
+
+        * w32proc.c (new_child): Initialize input_file and
+        pending_deletion members of the child.
+        (delete_child): Delete the child's temporary input file, if any,
+        that is pending deletion.
+        (register_child): First argument is now pid_t.
+        (record_infile, record_pending_deletion): New functions.
+        (reap_subprocess): Fix a typo in DebPrint string.
+        (sys_spawnve, sys_kill): Use pid_t for PID arguments.
+
+        * fileio.c (internal_delete_file): Return an int again: non-zero
+        if delete-file succeeds, zero otherwise.
+
+        * lisp.h (internal_delete_file): Adjust prototype.
+
+        * callproc.c (Fcall_process): Don't overwrite infile with result
+        of DECODE_FILE.
+        [WINDOWSNT] If BUFFER is an integer, i.e. we are launching an
+        asynchronous subprocess, record the name of the input file name,
+        if any.
+        (delete_temp_file) [WINDOWSNT]: If internal_delete_file fails to
+        delete the file, record it as pending deletion when the subprocess
+        exits.
+
+2012-12-14  Eli Zaretskii  <eliz@gnu.org>
+
+        * editfns.c [HAVE_PWD_H]: Include grp.h.
+
+        * makefile.w32-in ($(BLD)/editfns.$(O)): Add $(NT_INC)/grp.h.
+
+2012-12-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix permissions bugs with setgid directories etc. (Bug#13125)
+        * dired.c (Ffile_attributes): Return t as the 9th attribute,
+        to mark it as a placeholder.  The old value was often wrong.
+        The only user of this attribute has been changed to use
+        file-ownership-preserved-p instead, with its new group arg.
+        * editfns.c (Fgroup_gid, Fgroup_real_gid): New functions.
+
+2012-12-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (select_frame_for_redisplay, display_mode_lines):
+        Keep selected_window and selected_frame in sync.
+
+2012-12-14  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32.c (stat_worker): If w32_stat_get_owner_group is zero, do not
+        try to get accurate owner and group information from NT file
+        security APIs.  This is to make most callers of 'stat' and
+        'lstat', which don't need that information, much faster.
+
+        * dired.c (Ffile_attributes) [WINDOWSNT]:
+        Set w32_stat_get_owner_group to a non-zero value, to request accurate
+        owner and group information from 'lstat'.
+
+2012-12-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Finsert_file_contents): Don't put tail into head area,
+        as that confuses set-auto-coding, so insist on the head-read
+        returning the full 1024 bytes.  Let lseek compute the tail offset;
+        less work for us.  Do not ignore I/O errors when reading the tail.
+
+        * xdisp.c: Minor style fixes.
+        (init_iterator): Hoist assignment out of if-expression.
+        (markpos_of_region): Callers now test for sign, not for -1.
+
+2012-12-13  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Minor redisplay optimization when the region length is zero.
+        * xdisp.c (markpos_of_region): New function.
+        (init_iterator): Do not highlight the region of zero length.
+        (redisplay_window): Check whether the region is of non-zero length.
+        (try_cursor_movement): Allow if the region length is zero.
+        (try_window_reusing_current_matrix, try_window_id): Likewise.
+
+2012-12-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * search.c (search_buffer): Check the inverse translations of each
+        character in pattern when the buffer being searched is unibyte.
+        (Bug#13084)
+
+2012-12-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Fvisited_file_modtime): Return (-1 ...) for nonexistent
+        files, fixing a regression from 24.2.
+        (Fverify_visited_file_modtime): Don't read uninitialized st.st_size.
+
+2012-12-13  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Fcopy_file): Make fstat failure as serious as open failure.
+        fstat shouldn't fail, and if it does fail copy-file should not proceed.
+        Remove unnecessary S_ISLNK test, as (contra the comments) this
+        function can't copy symlinks.  Improve quality of error message
+        when attempting to copy files that are neither regular files nor
+        directories.
+
+2012-12-12  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * dispnew.c (set_window_cursor_after_update): Use clip_to_bounds.
+        * gtkutil.c (xg_set_toolkit_scroll_bar_thumb):
+        * window.c (Frecenter):
+        * xdisp.c (resize_mini_window, hscroll_window_tree, draw_glyphs):
+        * xterm.c (x_set_toolkit_scroll_bar_thumb): Likewise.
+
+2012-12-12  Daniel Colascione  <dancol@dancol.org>
+
+        * unexcw.c (fixup_executable): Use posix_fallocate to ensure that
+        the dumped Emacs is not a sparse file, greatly improving Cygwin
+        "make bootstrap" performance.
+
+2012-12-11  Michael Albinus  <michael.albinus@gmx.de>
+
+        * inotify.c (inotify_callback): Generate an Emacs event for every
+        incoming inotify event.
+
+2012-12-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (handle_face_prop): Fix logic of computing
+        it->start_of_box_run_p.
+        (append_space_for_newline): If the glyph row is R2L, reset the
+        iterator's end_of_box_run_p flag before prepending the space glyph.
+        (extend_face_to_end_of_line): If the glyph row is R2L, reset the
+        iterator's start_of_box_run_p flag before prepending the stretch.
+        (append_glyph, produce_image_glyph, append_composite_glyph)
+        (append_stretch_glyph, append_glyphless_glyph): Reverse the
+        left_box_line_p and right_box_line_p flags of the glyph for R2L
+        glyph rows.  (Bug#13011)
+
+2012-12-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        * buffer.c (Fset_buffer_multibyte): Do not force redisplay
+        if changed buffer is not shown in a window.
+        * insdel.c (prepare_to_modify_buffer): Likewise.
+        * window.c (replace_buffer_in_windows_safely): Do nothing
+        if buffer is not shown in a window.
+        (Fforce_window_update): Likewise if string or buffer argument
+        is passed.
+
+2012-12-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * inotify.c (Finotify_add_watch): Rename decoded_file_name to
+        encoded_file_name, which is what it is.
+
+2012-12-11  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Consistently use marker_position and marker_byte_position.
+        * fringe.c (Ffringe_bitmaps_at_pos):
+        * indent.c (Fvertical_motion):
+        * insdel.c (prepare_to_modify_buffer):
+        * keyboard.c (make_lispy_position):
+        * window.c (Fwindow_end, Fpos_visible_in_window_p, unshow_buffer)
+        (window_scroll_pixel_based, displayed_window_lines)
+        (Fset_window_configuration):
+        * xdisp.c (message_dolog, with_echo_area_buffer_unwind_data)
+        (mark_window_display_accurate_1, redisplay_window, decode_mode_spec):
+        Replace direct access to marker fields with calls
+        to marker_position and/or marker_byte_position.
+
+2012-12-11  Juanma Barranquero  <lekktu@gmail.com>
+
+        * makefile.w32-in (SIG2STR_H): New macro.
+        (SYSWAIT_H, $(BLD)/emacs.$(O), $(BLD)/process.$(O))
+        ($(BLD)/w32notify.$(O)): Update dependencies.
+
+2012-12-10  Daniel Colascione  <dancol@dancol.org>
+
+        * w32term.c, keyboard.c: Fix build break in cygw32 by omitting
+        Windows file notification functionality unless WINDOWSNT.
+
+        * w32gui.h (hprevinst, lpCmdLine, nCmdShow): Remove unused
+        declarations.
+
+        * w32fns.c (cache_system_info): Initialize the global hinst
+        variable here so various initialization calls DTRT.
+
+        * unexw32.c (hprevinst, lpCmdLine, nCmdShow): Remove unused variables.
+        (hinst): Remove unneeded extern declaration.
+        (_start): Remove initialization of above variables; remove
+        initialization of hinst, as cache_system_info now does that.
+
+        * emacs.c (main): Call cache_system_info early in startup; we
+        previously weren't calling it in Cygwin builds.
+
+        * Makefile.in (ntsource, WINDRES, W32_RES, W#@_RES_LINK):
+        Teach the autoconf build system how to compile a Windows resource file
+        and link it to Emacs.
+
+2012-12-10  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Per-buffer window counters.
+        * buffer.h (struct buffer): New member window_count.
+        (buffer_window_count): New function.
+        * buffer.c (Fget_buffer_create, Fmake_indirect_buffer):
+        Initialize window_count.
+        (Fkill_buffer): Verify window_count for the buffer being killed.
+        (modify_overlay): Do not force redisplay if buffer is not shown
+        in any window.
+        (init_buffer_once): Initialize window_count for buffer_defaults
+        and buffer_local_symbols.
+        * window.h (buffer_shared): Remove declaration.
+        (wset_buffer): Convert from inline ...
+        * window.c (wset_buffer): ... to an ordinary function.
+        (adjust_window_count): New function.
+        (make_parent_window): Use it.
+        * xdisp.c (buffer_shared): Remove.
+        (redisplay_internal, redisplay_window): Adjust users.
+        (buffer_shared_and_changed): Use per-buffer window counter.
+
+2012-12-10  Eli Zaretskii  <eliz@gnu.org>
+
+        Support for filesystem notifications on MS-Windows.
+        * w32proc.c (sys_select): If drain_message_queue returns non-zero,
+        and this is a TTY frame, signal the caller that keyboard input is
+        available.
+
+        * w32xfns.c (drain_message_queue): Now returns an int: an
+        indication whether any WM_EMACS_FILENOTIFY messages were found in
+        the queue.
+
+        * w32inevt.c (handle_file_notifications): New function.
+        (w32_console_read_socket): Call it to process file notifications.
+
+        * w32console.c (initialize_w32_display): Record the main thread ID
+        in dwMainThreadId.
+
+        * deps.mk (inotify.o): New dependency list.
+
+        * Makefile.in (SOME_MACHINE_OBJECTS): Add w32notify.o.
+
+        * w32term.h (WM_EMACS_FILENOTIFY): New custom message.
+        (WM_EMACS_END): Bump value by 1.
+        (notification_buffer_in_use, file_notifications)
+        (notifications_size, notifications_desc): Declare.
+        (w32_get_watch_object, lispy_file_action, globals_of_w32notify):
+        Add prototypes.
+
+        * w32term.c (lispy_file_action, queue_notifications): New functions.
+        (syms_of_w32term) <Qadded, Qremoved, Qmodified, Qrenamed_from>
+        <Qrenamed_to>: New symbols.
+        (w32_read_socket): Handle the WM_EMACS_FILENOTIFY message.
+
+        * w32notify.c: New file, implements file event notifications for
+        MS-Windows.
+
+        * w32fns.c (w32_wnd_proc): Handle the WM_EMACS_FILENOTIFY message
+        by posting it to the w32_read_socket queue.
+
+        * termhooks.h (enum event_kind) [HAVE_NTGUI]: Support FILE_NOTIFY_EVENT.
+
+        * makefile.w32-in (OBJ2): Add $(BLD)/w32notify.$(O).
+        (GLOBAL_SOURCES): Add w32notify.c
+        ($(BLD)/w32notify.$(O)): New set of dependencies.
+
+        * lisp.h (syms_of_w32notify) [WINDOWSNT]: Add prototype.
+
+        * keyboard.c (kbd_buffer_get_event) [WINDOWSNT]:
+        Handle FILE_NOTIFY_EVENT.
+        (syms_of_keyboard) [HAVE_NTGUI] <Qfile_notify>: New symbol.
+        (keys_of_keyboard) [WINDOWSNT]: Bind file-notify to
+        w32notify-handle-event by default.
+
+        * emacs.c (main) [WINDOWSNT]: Call globals_of_w32notify and
+        syms_of_w32notify.
+
+2012-12-10  Rüdiger Sonderfeld  <ruediger@c-plusplus.de>
+
+        Support for filesystem notifications on GNU/Linux via inotify.
+        * termhooks.h (enum event_kind) [HAVE_INOTIFY]: Add FILE_NOTIFY_EVENT.
+
+        * lisp.h (syms_of_inotify) [HAVE_INOTIFY]: Add prototype.
+
+        * keyboard.c (Qfile_inotify) [HAVE_INOTIFY]: New variable.
+        (syms_of_keyboard): DEFSYM it.
+        (kbd_buffer_get_event) [HAVE_INOTIFY]: Generate FILE_NOTIFY_EVENT.
+        (make_lispy_event): Support FILE_NOTIFY_EVENT by generating
+        Qfile_inotify events.
+        (keys_of_keyboard) [HAVE_INOTIFY]: Bind file-inotify events in
+        special-event-map to inotify-handle-event.
+
+        * emacs.c (main) [HAVE_INOTIFY]: Call syms_of_inotify.
+
+        * Makefile.in (base_obj): Add inotify.o.
+
+        * inotify.c: New file.
+
+2012-12-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (fd_handler:): FD_ZERO fds (Bug#13103).
+
+2012-12-10  Fabrice Popineau  <fabrice.popineau@gmail.com>
+
+        * w32fns.c (cache_system_info): Cast sysinfo_cache.dwPageSize to
+        DWORD_PTR, for compatibility with 64-bit builds.
+
+        * w32.c (_PROCESS_MEMORY_COUNTERS_EX):
+        (GetProcessWorkingSetSize_Proc, get_process_working_set_size)
+        (system_process_attributes): Use SIZE_T rather than DWORD, for
+        compatibility with 64-bit builds.
+
+2012-12-10  Christopher Schmidt  <christopher@ch.ristopher.com>
+
+        * lread.c (Vload_source_file_function): Doc fix (Bug#11647).
+
+2012-12-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * indent.c (Fvertical_motion): If a display string will be
+        displayed on the left or the right margin, don't consider it as a
+        factor in cursor positioning.  (Bug#13108)
+
+2012-12-10  Martin Rudalics  <rudalics@gmx.at>
+
+        * editfns.c (Fcompare_buffer_substrings): Reword doc-string.
+
+2012-12-10  Paul Eggert  <eggert@cs.ucla.edu>
+
+        * fileio.c (Fsubstitute_in_file_name): Use ptrdiff_t, not int,
+        for string length.
+
 2012-12-08  Eli Zaretskii  <eliz@gnu.org>
 
         * w32.c (unsetenv): Return 0 if the input string is too long.
@@ -264,9 +2010,9 @@
 2012-12-03  Fabrice Popineau  <fabrice.popineau@gmail.com>
 
         * w32fns.c: Remove prototype of atof.
-        (syspage_mask): Declared DWORD_PTR, for compatibility with 64-bit
+        (syspage_mask): Make it DWORD_PTR, for compatibility with 64-bit
         builds.
-        (file_dialog_callback): Declared UINT_PTR.
+        (file_dialog_callback): Make it UINT_PTR.
 
         * w32common.h (syspage_mask): Declare DWORD_PTR, for compatibility
         with 64-bit builds.
@@ -409,8 +2155,8 @@
         (set_frame_menubar): Adjust user.
         * w32term.h (struct x_output): Drop outdated #if 0 code.
         (struct w32_output): Use bitfields for explicit_parent,
-        asked_for_visible and menubar_active members.  Drop
-        unused pending_menu_activation member.
+        asked_for_visible and menubar_active members.
+        Drop unused pending_menu_activation member.
         * xterm.h (struct x_output): Drop outdated #if 0 code.
         Use bitfields for explicit_parent, asked_for_visible,
         has_been_visible and net_wm_state_hidden_seen members.
@@ -503,8 +2249,8 @@
         * fileio.c (Fsubstitute_in_file_name, Ffile_name_directory)
         (Fexpand_file_name) [DOS_NT]: Pass encoded file name to
         dostounix_filename.  Prevents crashes down the road, because
-        dostounix_filename assumes it gets a unibyte string.  Reported by
-        Michel de Ruiter <michel@sentient.nl>, see
+        dostounix_filename assumes it gets a unibyte string.
+        Reported by Michel de Ruiter <michel@sentient.nl>, see
         http://lists.gnu.org/archive/html/help-emacs-windows/2012-11/msg00017.html
 
 2012-11-20  Stefan Monnier  <monnier@iro.umontreal.ca>
@@ -942,7 +2688,7 @@
         * image.c (xpm_make_color_table_h): Fix compiler error because
         make_hash_table changed.
 
-2012-11-08  Thomas Kappler <tkappler@gmail.com> (tiny change)
+2012-11-08  Thomas Kappler  <tkappler@gmail.com>  (tiny change)
 
         * nsfont.m (ns_findfonts): Handle empty matchingDescs (Bug#11541).
 
@@ -1499,7 +3245,7 @@
 
 2012-10-19  Stefan Monnier  <monnier@iro.umontreal.ca>
 
-        * fns.c (Fnreverse): Include the problem element when signalling an
+        * fns.c (Fnreverse): Include the problem element when signaling an
         error (bug#12677).
 
 2012-10-18  Jan Djärv  <jan.h.d@swipnet.se>
@@ -10390,7 +12136,7 @@
 2012-05-09  Michael Albinus  <michael.albinus@gmx.de>
 
         * dbusbind.c (xd_registered_buses): New internal Lisp object.
-        Rename all occurences of Vdbus_registered_buses to xd_registered_buses.
+        Rename all occurrences of Vdbus_registered_buses to xd_registered_buses.
         (syms_of_dbusbind): Remove declaration of Vdbus_registered_buses.
         Initialize xd_registered_buses.
 
@@ -20634,7 +22380,7 @@ See ChangeLog.11 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 2011-2012 Free Software Foundation, Inc.
+  Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.1 b/src/ChangeLog.1
index 5265d6fdf59..0d926760017 100644
--- a/src/ChangeLog.1
+++ b/src/ChangeLog.1
@@ -3521,7 +3521,7 @@
         * minibuf.c: Don't allow entry to minibuffer
         while minibuffer is selected.
 
-    Copyright (C) 1985-1986, 2001-2012 Free Software Foundation, Inc.
+    Copyright (C) 1985-1986, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.10 b/src/ChangeLog.10
index 6eda101c815..c878c48a4f4 100644
--- a/src/ChangeLog.10
+++ b/src/ChangeLog.10
@@ -27912,7 +27912,7 @@ See ChangeLog.9 for earlier changes.
 ;; add-log-time-zone-rule: t
 ;; End:
 
-    Copyright (C) 2001-2012 Free Software Foundation, Inc.
+    Copyright (C) 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.11 b/src/ChangeLog.11
index 1f444b9292c..1195a8f9592 100644
--- a/src/ChangeLog.11
+++ b/src/ChangeLog.11
@@ -31383,7 +31383,7 @@ See ChangeLog.10 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 2007-2012  Free Software Foundation, Inc.
+  Copyright (C) 2007-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.2 b/src/ChangeLog.2
index 0806106836e..64e793c763c 100644
--- a/src/ChangeLog.2
+++ b/src/ChangeLog.2
@@ -4771,7 +4771,7 @@
 
 See ChangeLog.1 for earlier changes.
 
-    Copyright (C) 1986-1988, 2001-2012  Free Software Foundation, Inc.
+    Copyright (C) 1986-1988, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.3 b/src/ChangeLog.3
index 4f6e02ff8d3..2f798e1f0bc 100644
--- a/src/ChangeLog.3
+++ b/src/ChangeLog.3
@@ -16507,7 +16507,7 @@ See ChangeLog.2 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 1993, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.4 b/src/ChangeLog.4
index d7ef7d8779a..54ce63556ea 100644
--- a/src/ChangeLog.4
+++ b/src/ChangeLog.4
@@ -6906,7 +6906,7 @@ See ChangeLog.3 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 1993-1994, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1993-1994, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.5 b/src/ChangeLog.5
index c6dfde7496b..6fefabc5cd0 100644
--- a/src/ChangeLog.5
+++ b/src/ChangeLog.5
@@ -7148,7 +7148,7 @@ See ChangeLog.4 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 1994-1995, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1994-1995, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.6 b/src/ChangeLog.6
index 64f8b3a8314..77aadf4cf10 100644
--- a/src/ChangeLog.6
+++ b/src/ChangeLog.6
@@ -5354,7 +5354,7 @@
 
 See ChangeLog.5 for earlier changes.
 
-  Copyright (C) 1995-1996, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1995-1996, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.7 b/src/ChangeLog.7
index ce240ab2928..bb12627b698 100644
--- a/src/ChangeLog.7
+++ b/src/ChangeLog.7
@@ -11091,7 +11091,7 @@ See ChangeLog.6 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 1997-1998, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1997-1998, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.8 b/src/ChangeLog.8
index e68966b16a2..e89e6b006b7 100644
--- a/src/ChangeLog.8
+++ b/src/ChangeLog.8
@@ -13979,7 +13979,7 @@
 
 See ChangeLog.7 for earlier changes.
 
-  Copyright (C) 1999, 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 1999, 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/ChangeLog.9 b/src/ChangeLog.9
index d6d772c5f95..b451b78944f 100644
--- a/src/ChangeLog.9
+++ b/src/ChangeLog.9
@@ -13294,7 +13294,7 @@ See ChangeLog.8 for earlier changes.
 ;; coding: utf-8
 ;; End:
 
-  Copyright (C) 2001-2012  Free Software Foundation, Inc.
+  Copyright (C) 2001-2013 Free Software Foundation, Inc.
 
   This file is part of GNU Emacs.
 
diff --git a/src/Makefile.in b/src/Makefile.in
index d034ad04796..6ee03177861 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -1,7 +1,7 @@
 # src/Makefile for GNU Emacs.
 
-# Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2012
-#   Free Software Foundation, Inc.
+# Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2013 Free Software
+# Foundation, Inc.
 
 # This file is part of GNU Emacs.
 
@@ -28,9 +28,11 @@ SHELL = /bin/sh
 # Here are the things that we expect ../configure to edit.
 # We use $(srcdir) explicitly in dependencies so as not to depend on VPATH.
 srcdir = @srcdir@
+ntsource = $(srcdir)/../nt
 abs_builddir = @abs_builddir@
 VPATH = $(srcdir)
 CC = @CC@
+WINDRES = @WINDRES@
 CFLAGS = @CFLAGS@
 CPPFLAGS = @CPPFLAGS@
 LDFLAGS = @LDFLAGS@
@@ -109,9 +111,6 @@ LD_SWITCH_SYSTEM_TEMACS=@LD_SWITCH_SYSTEM_TEMACS@
 ## Flags to pass to ld only for temacs.
 TEMACS_LDFLAGS = $(LD_SWITCH_SYSTEM) $(LD_SWITCH_SYSTEM_TEMACS)
 
-## $LDFLAGS or empty if NS_IMPL_GNUSTEP (for some reason).
-TEMACS_LDFLAGS2 = @TEMACS_LDFLAGS2@
-
 ## If available, the full path to the paxctl program.
 ## On grsecurity/PaX systems, unexec will fail due to a gap between
 ## the bss section and the heap.  This can be prevented by disabling
@@ -228,6 +227,9 @@ LIBX_OTHER=@LIBX_OTHER@
 ## configure, which should set it to nil in non-X builds.
 LIBX_BASE=$(LIBXMENU) $(LD_SWITCH_X_SITE)
 
+## Only used for GNUstep
+LIBS_GNUSTEP=@LIBS_GNUSTEP@
+
 LIBSOUND= @LIBSOUND@
 CFLAGS_SOUND= @CFLAGS_SOUND@
 
@@ -267,6 +269,13 @@ W32_OBJ=@W32_OBJ@
 ## --lwinspool if HAVE_W32, else empty.
 W32_LIBS=@W32_LIBS@
 
+## emacs.res if HAVE_W32
+W32_RES=@W32_RES@
+## If HAVE_W32, compiler arguments for including
+## the resource file in the binary.
+## XXX -Wl,-b -Wl,pe-i386 -Wl,emacs.res
+W32_RES_LINK=@W32_RES_LINK@
+
 ## Empty if !HAVE_X_WINDOWS
 ## xfont.o ftfont.o xftfont.o ftxfont.o if HAVE_XFT
 ## xfont.o ftfont.o ftxfont.o if HAVE_FREETYPE
@@ -283,6 +292,8 @@ LIBSELINUX_LIBS = @LIBSELINUX_LIBS@
 LIBGNUTLS_LIBS = @LIBGNUTLS_LIBS@
 LIBGNUTLS_CFLAGS = @LIBGNUTLS_CFLAGS@
 
+LIBACL_LIBS = @LIBACL_LIBS@
+
 LIB_PTHREAD_SIGMASK = @LIB_PTHREAD_SIGMASK@
 
 INTERVALS_H = dispextern.h intervals.h composite.h
@@ -329,7 +340,6 @@ ALL_OBJC_CFLAGS=$(ALL_CFLAGS) $(GNU_OBJC_CFLAGS)
         @$(MKDEPDIR)
         $(CC) -c $(CPPFLAGS) $(ALL_OBJC_CFLAGS) $<
 
-
 ## lastfile must follow all files whose initialized data areas should
 ## be dumped as pure by dump-emacs.
 base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
@@ -344,7 +354,7 @@ base_obj = dispnew.o frame.o scroll.o xdisp.o menu.o $(XMENU_OBJ) window.o \
         syntax.o $(UNEXEC_OBJ) bytecode.o \
         process.o gnutls.o callproc.o \
         region-cache.o sound.o atimer.o \
-        doprnt.o intervals.o textprop.o composite.o xml.o \
+        doprnt.o intervals.o textprop.o composite.o xml.o inotify.o \
         profiler.o \
         $(MSDOS_OBJ) $(MSDOS_X_OBJ) $(NS_OBJ) $(CYGWIN_OBJ) $(FONT_OBJ) \
         $(W32_OBJ) $(WINDOW_SYSTEM_OBJ)
@@ -358,7 +368,7 @@ SOME_MACHINE_OBJECTS = dosfns.o msdos.o \
   xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o fringe.o image.o \
   fontset.o dbusbind.o cygw32.o \
   nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o \
-  w32.o w32console.o w32fns.o w32heap.o w32inevt.o \
+  w32.o w32console.o w32fns.o w32heap.o w32inevt.o w32notify.o \
   w32menu.o w32proc.o w32reg.o w32select.o w32term.o w32xfns.o \
   w16select.o widget.o xfont.o ftfont.o xftfont.o ftxfont.o gtkutil.o \
   xsettings.o xgselect.o termcap.o
@@ -390,7 +400,7 @@ otherobj= $(TERMCAP_OBJ) $(PRE_ALLOC_OBJ) $(GMALLOC_OBJ) $(RALLOC_OBJ) \
 ## Note that SunOS needs -lm to come before -lc; otherwise, you get
 ## duplicated symbols.  If the standard libraries were compiled
 ## with GCC, we might need LIB_GCC again after them.
-LIBES = $(LIBS) $(W32_LIBS) $(LIBX_BASE) $(LIBIMAGE) \
+LIBES = $(LIBS) $(W32_LIBS) $(LIBS_GNUSTEP) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBX_OTHER) $(LIBSOUND) \
    $(RSVG_LIBS) $(IMAGEMAGICK_LIBS) $(LIB_CLOCK_GETTIME) \
    $(LIB_EACCESS) $(LIB_TIMER_TIME) $(DBUS_LIBS) \
@@ -398,7 +408,7 @@ LIBES = $(LIBS) $(W32_LIBS) $(LIBX_BASE) $(LIBIMAGE) \
    $(LIBXML2_LIBS) $(LIBGPM) $(LIBRESOLV) $(LIBS_SYSTEM) \
    $(LIBS_TERMCAP) $(GETLOADAVG_LIBS) $(SETTINGS_LIBS) $(LIBSELINUX_LIBS) \
    $(FREETYPE_LIBS) $(FONTCONFIG_LIBS) $(LIBOTF_LIBS) $(M17N_FLT_LIBS) \
-   $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
+   $(LIBACL_LIBS) $(LIBGNUTLS_LIBS) $(LIB_PTHREAD) $(LIB_PTHREAD_SIGMASK) \
    $(LIB_GCC) $(LIB_MATH) $(LIB_STANDARD) $(LIB_GCC)
 
 all: emacs$(EXEEXT) $(OTHER_FILES)
@@ -463,9 +473,11 @@ $(obj) $(otherobj): globals.h
 $(lib)/libgnu.a: $(config_h)
         cd $(lib) && $(MAKE) libgnu.a
 
-temacs$(EXEEXT): $(START_FILES) stamp-oldxmenu $(obj) $(otherobj) $(lib)/libgnu.a
-        $(CC) $(LD_FIRSTFLAG) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(TEMACS_LDFLAGS2) \
-          -o temacs $(START_FILES) $(obj) $(otherobj) $(lib)/libgnu.a $(LIBES)
+temacs$(EXEEXT): $(START_FILES) stamp-oldxmenu $(obj) $(otherobj) \
+                 $(lib)/libgnu.a $(W32_RES)
+        $(CC) $(LD_FIRSTFLAG) $(ALL_CFLAGS) $(TEMACS_LDFLAGS) $(LDFLAGS) \
+          -o temacs $(START_FILES) $(obj) $(otherobj) $(lib)/libgnu.a $(LIBES) \
+          $(W32_RES_LINK)
         test "$(CANNOT_DUMP)" = "yes" || \
           test "X$(PAXCTL)" = X || $(PAXCTL) -r temacs$(EXEEXT)
 
@@ -506,11 +518,14 @@ $(OLDXMENU): $(OLDXMENU_TARGET)
 
 doc.o: buildobj.h
 
+emacs.res: $(ntsource)/emacs.rc \
+           $(ntsource)/icons/emacs.ico \
+           $(ntsource)/emacs-x86.manifest
+        $(WINDRES) -O COFF -o $@ $(ntsource)/emacs.rc
 
 ns-app: emacs$(EXEEXT)
         cd ../nextstep && $(MAKE) $(MFLAGS) all
 
-
 .PHONY: mostlyclean clean bootstrap-clean distclean maintainer-clean
 .PHONY: versionclean extraclean frc
 
diff --git a/src/README b/src/README
index 558710627a7..0508137cbea 100644
--- a/src/README
+++ b/src/README
@@ -1,4 +1,4 @@
-Copyright (C) 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 2001-2013 Free Software Foundation, Inc.
 See the end of the file for license conditions.
 
 
diff --git a/src/alloc.c b/src/alloc.c
index 5a3ba465d81..80086433e65 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1,7 +1,7 @@
 /* Storage allocation and gc for GNU Emacs Lisp interpreter.
 
-Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -26,7 +26,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <limits.h>             /* For CHAR_BIT.  */
 
 #ifdef ENABLE_CHECKING
-#include <signal.h>             /* For SIGABRT. */
+#include <signal.h>             /* For SIGABRT.  */
 #endif
 
 #ifdef HAVE_PTHREAD
@@ -209,6 +209,7 @@ Lisp_Object Qchar_table_extra_slots;
 
 static Lisp_Object Qpost_gc_hook;
 
+static void free_save_value (Lisp_Object);
 static void mark_terminals (void);
 static void gc_sweep (void);
 static Lisp_Object make_pure_vector (ptrdiff_t);
@@ -219,7 +220,6 @@ static void refill_memory_reserve (void);
 #endif
 static void compact_small_strings (void);
 static void free_large_strings (void);
-static void free_misc (Lisp_Object);
 extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE;
 
 /* When scanning the C stack for live Lisp objects, Emacs keeps track of
@@ -845,7 +845,7 @@ void *
 record_xmalloc (size_t size)
 {
   void *p = xmalloc (size);
-  record_unwind_protect (safe_alloca_unwind, make_save_value (p, 0));
+  record_unwind_protect (safe_alloca_unwind, make_save_pointer (p));
   return p;
 }
 
@@ -1684,7 +1684,7 @@ allocate_string_data (struct Lisp_String *s,
       b = lisp_malloc (size + GC_STRING_EXTRA, MEM_TYPE_NON_LISP);
 
 #ifdef DOUG_LEA_MALLOC
-      /* Back to a reasonable maximum of mmap'ed areas. */
+      /* Back to a reasonable maximum of mmap'ed areas.  */
       mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
 
@@ -1901,7 +1901,7 @@ compact_small_strings (void)
 
 #ifdef GC_CHECK_STRING_BYTES
           /* Check that the string size recorded in the string is the
-             same as the one recorded in the sdata structure. */
+             same as the one recorded in the sdata structure.  */
           if (s && string_bytes (s) != SDATA_NBYTES (from))
             emacs_abort ();
 #endif /* GC_CHECK_STRING_BYTES */
@@ -3105,13 +3105,10 @@ Any number of arguments, even zero arguments, are allowed.
 usage: (vector &rest OBJECTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  register Lisp_Object val = make_uninit_vector (nargs);
+  register struct Lisp_Vector *p = XVECTOR (val);
 
-  XSETFASTINT (len, nargs);
-  val = Fmake_vector (len, Qnil);
-  p = XVECTOR (val);
   for (i = 0; i < nargs; i++)
     p->contents[i] = args[i];
   return val;
@@ -3149,9 +3146,9 @@ stack before executing the byte-code.
 usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INTERACTIVE-SPEC &rest ELEMENTS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  register Lisp_Object len, val;
   ptrdiff_t i;
-  register struct Lisp_Vector *p;
+  register Lisp_Object val = make_uninit_vector (nargs);
+  register struct Lisp_Vector *p = XVECTOR (val);
 
   /* We used to purecopy everything here, if purify-flag was set.  This worked
      OK for Emacs-23, but with Emacs-24's lexical binding code, it can be
@@ -3161,10 +3158,6 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
      just wasteful and other times plainly wrong (e.g. those free vars may want
      to be setcar'd).  */
 
-  XSETFASTINT (len, nargs);
-  val = Fmake_vector (len, Qnil);
-
-  p = XVECTOR (val);
   for (i = 0; i < nargs; i++)
     p->contents[i] = args[i];
   make_byte_code (p);
@@ -3339,9 +3332,9 @@ allocate_misc (enum Lisp_Misc_Type type)
   return val;
 }
 
-/* Free a Lisp_Misc object */
+/* Free a Lisp_Misc object.  */
 
-static void
+void
 free_misc (Lisp_Object misc)
 {
   XMISCTYPE (misc) = Lisp_Misc_Free;
@@ -3351,34 +3344,81 @@ free_misc (Lisp_Object misc)
   total_free_markers++;
 }
 
-/* Return a Lisp_Misc_Save_Value object containing POINTER and
-   INTEGER.  This is used to package C values to call record_unwind_protect.
-   The unwind function can get the C values back using XSAVE_VALUE.  */
+/* Return a Lisp_Save_Value object with the data saved according to
+   FMT.  Format specifiers are `i' for an integer, `p' for a pointer
+   and `o' for Lisp_Object.  Up to 4 objects can be specified.  */
 
 Lisp_Object
-make_save_value (void *pointer, ptrdiff_t integer)
+make_save_value (const char *fmt, ...)
 {
-  register Lisp_Object val;
-  register struct Lisp_Save_Value *p;
+  va_list ap;
+  int len = strlen (fmt);
+  Lisp_Object val = allocate_misc (Lisp_Misc_Save_Value);
+  struct Lisp_Save_Value *p = XSAVE_VALUE (val);
+
+  eassert (0 < len && len < 5);
+  va_start (ap, fmt);
+
+#define INITX(index)                                           \
+  do {                                                         \
+    if (len <= index)                                          \
+      p->type ## index = SAVE_UNUSED;                          \
+    else                                                       \
+      {                                                        \
+        if (fmt[index] == 'i')                                 \
+         {                                                     \
+           p->type ## index = SAVE_INTEGER;                    \
+           p->data[index].integer = va_arg (ap, ptrdiff_t);    \
+         }                                                     \
+       else if (fmt[index] == 'p')                             \
+         {                                                     \
+           p->type ## index = SAVE_POINTER;                    \
+           p->data[index].pointer = va_arg (ap, void *);       \
+         }                                                     \
+       else if (fmt[index] == 'o')                             \
+         {                                                     \
+           p->type ## index = SAVE_OBJECT;                     \
+           p->data[index].object = va_arg (ap, Lisp_Object);   \
+         }                                                     \
+       else                                                    \
+         emacs_abort ();                                       \
+      }                                                        \
+  } while (0)
+
+  INITX (0);
+  INITX (1);
+  INITX (2);
+  INITX (3);
 
-  val = allocate_misc (Lisp_Misc_Save_Value);
-  p = XSAVE_VALUE (val);
-  p->pointer = pointer;
-  p->integer = integer;
-  p->dogc = 0;
+#undef INITX
+
+  va_end (ap);
+  p->area = 0;
   return val;
 }
 
-/* Free a Lisp_Misc_Save_Value object.  */
+/* The most common task it to save just one C pointer.  */
 
-void
-free_save_value (Lisp_Object save)
+Lisp_Object
+make_save_pointer (void *pointer)
 {
-  register struct Lisp_Save_Value *p = XSAVE_VALUE (save);
+  Lisp_Object val = allocate_misc (Lisp_Misc_Save_Value);
+  struct Lisp_Save_Value *p = XSAVE_VALUE (val);
 
-  p->dogc = 0;
-  xfree (p->pointer);
-  p->pointer = NULL;
+  p->area = 0;
+  p->type0 = SAVE_POINTER;
+  p->data[0].pointer = pointer;
+  p->type1 = p->type2 = p->type3 = SAVE_UNUSED;
+  return val;
+}
+
+/* Free a Lisp_Save_Value object.  Do not use this function
+   if SAVE contains pointer other than returned by xmalloc.  */
+
+static void
+free_save_value (Lisp_Object save)
+{
+  xfree (XSAVE_POINTER (save, 0));
   free_misc (save);
 }
 
@@ -4446,11 +4486,6 @@ mark_memory (void *start, void *end)
       }
 }
 
-/* setjmp will work with GCC unless NON_SAVING_SETJMP is defined in
-   the GCC system configuration.  In gcc 3.2, the only systems for
-   which this is so are i386-sco5 non-ELF, i386-sysv3 (maybe included
-   by others?) and ns32k-pc532-min.  */
-
 #if !defined GC_SAVE_REGISTERS_ON_STACK && !defined GC_SETJMP_WORKS
 
 static bool setjmp_tested_p;
@@ -4721,12 +4756,12 @@ valid_pointer_p (void *p)
 #endif
 }
 
-/* Return 2 if OBJ is a killed or special buffer object.
-   Return 1 if OBJ is a valid lisp object.
-   Return 0 if OBJ is NOT a valid lisp object.
-   Return -1 if we cannot validate OBJ.
-   This function can be quite slow,
-   so it should only be used in code for manual debugging.  */
+/* Return 2 if OBJ is a killed or special buffer object, 1 if OBJ is a
+   valid lisp object, 0 if OBJ is NOT a valid lisp object, or -1 if we
+   cannot validate OBJ.  This function can be quite slow, so its primary
+   use is the manual debugging.  The only exception is print_object, where
+   we use it to check whether the memory referenced by the pointer of
+   Lisp_Save_Value object contains valid objects.  */
 
 int
 valid_lisp_object_p (Lisp_Object obj)
@@ -5940,20 +5975,33 @@ mark_object (Lisp_Object arg)
 
         case Lisp_Misc_Save_Value:
           XMISCANY (obj)->gcmarkbit = 1;
-#if GC_MARK_STACK
           {
             register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
-            /* If DOGC is set, POINTER is the address of a memory
-               area containing INTEGER potential Lisp_Objects.  */
-            if (ptr->dogc)
+            /* If `area' is nonzero, `data[0].pointer' is the address
+               of a memory area containing `data[1].integer' potential
+               Lisp_Objects.  */
+#if GC_MARK_STACK
+            if (ptr->area)
               {
-                Lisp_Object *p = (Lisp_Object *) ptr->pointer;
+                Lisp_Object *p = ptr->data[0].pointer;
                 ptrdiff_t nelt;
-                for (nelt = ptr->integer; nelt > 0; nelt--, p++)
+                for (nelt = ptr->data[1].integer; nelt > 0; nelt--, p++)
                   mark_maybe_object (*p);
               }
+            else
+#endif /* GC_MARK_STACK */
+              {
+                /* Find Lisp_Objects in `data[N]' slots and mark them.  */
+                if (ptr->type0 == SAVE_OBJECT)
+                  mark_object (ptr->data[0].object);
+                if (ptr->type1 == SAVE_OBJECT)
+                  mark_object (ptr->data[1].object);
+                if (ptr->type2 == SAVE_OBJECT)
+                  mark_object (ptr->data[2].object);
+                if (ptr->type3 == SAVE_OBJECT)
+                  mark_object (ptr->data[3].object);
+              }
           }
-#endif
           break;
 
         case Lisp_Misc_Overlay:
@@ -6509,7 +6557,7 @@ die (const char *msg, const char *file, int line)
 }
 #endif
 
-/* Initialization */
+/* Initialization.  */
 
 void
 init_alloc_once (void)
@@ -6524,9 +6572,9 @@ init_alloc_once (void)
 #endif
 
 #ifdef DOUG_LEA_MALLOC
-  mallopt (M_TRIM_THRESHOLD, 128*1024); /* trim threshold */
-  mallopt (M_MMAP_THRESHOLD, 64*1024); /* mmap threshold */
-  mallopt (M_MMAP_MAX, MMAP_MAX_AREAS); /* max. number of mmap'ed areas */
+  mallopt (M_TRIM_THRESHOLD, 128 * 1024); /* Trim threshold.  */
+  mallopt (M_MMAP_THRESHOLD, 64 * 1024);  /* Mmap threshold.  */
+  mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);   /* Max. number of mmap'ed areas.  */
 #endif
   init_strings ();
   init_vectors ();
diff --git a/src/atimer.c b/src/atimer.c
index 5752192be76..73c7aa5686b 100644
--- a/src/atimer.c
+++ b/src/atimer.c
@@ -1,5 +1,5 @@
 /* Asynchronous timers.
-   Copyright (C) 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/atimer.h b/src/atimer.h
index 6d441d71641..2a92f1bebea 100644
--- a/src/atimer.h
+++ b/src/atimer.h
@@ -1,5 +1,5 @@
 /* Asynchronous timers.
-   Copyright (C) 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/bidi.c b/src/bidi.c
index 6f3d749ef22..db2e48a2ca7 100644
--- a/src/bidi.c
+++ b/src/bidi.c
@@ -1,6 +1,6 @@
 /* Low-level bidirectional buffer/string-scanning functions for GNU Emacs.
-   Copyright (C) 2000-2001, 2004-2005, 2009-2012
-   Free Software Foundation, Inc.
+   Copyright (C) 2000-2001, 2004-2005, 2009-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1973,6 +1973,7 @@ bidi_resolve_neutral (struct bidi_it *bidi_it)
                 next_type = STRONG_R;
                 break;
               case WEAK_BN:
+              case NEUTRAL_ON:  /* W6/Retaining */
                 if (!bidi_explicit_dir_char (bidi_it->ch))
                   emacs_abort (); /* can't happen: BNs are skipped */
                 /* FALLTHROUGH */
@@ -2391,6 +2392,10 @@ bidi_move_to_visually_next (struct bidi_it *bidi_it)
       next_level = bidi_peek_at_next_level (bidi_it);
       while (next_level != expected_next_level)
         {
+          /* If next_level is -1, it means we have an unresolved level
+             in the cache, which at this point should not happen.  If
+             it does, we will infloop.  */
+          eassert (next_level >= 0);
           expected_next_level += incr;
           level_to_search += incr;
           bidi_find_other_level_edge (bidi_it, level_to_search, !ascending);
diff --git a/src/blockinput.h b/src/blockinput.h
index 70822e29be7..192c813073d 100644
--- a/src/blockinput.h
+++ b/src/blockinput.h
@@ -1,5 +1,5 @@
 /* blockinput.h - interface to blocking complicated interrupt-driven input.
-   Copyright (C) 1989, 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1989, 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/buffer.c b/src/buffer.c
index 6e2191dc22f..aa3fcf8c234 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1,6 +1,7 @@
 /* Buffer manipulation primitives for GNU Emacs.
 
-Copyright (C) 1985-1989, 1993-1995, 1997-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -371,9 +372,6 @@ bset_zv_marker (struct buffer *b, Lisp_Object val)
   b->INTERNAL_FIELD (zv_marker) = val;
 }
 
-/* For debugging; temporary.  See set_buffer_internal.  */
-/* Lisp_Object Qlisp_mode, Vcheck_symbol; */
-
 void
 nsberror (Lisp_Object spec)
 {
@@ -547,6 +545,8 @@ even if it is dead.  The return value is never nil.  */)
   b->base_buffer = NULL;
   /* No one shares the text with us now.  */
   b->indirections = 0;
+  /* No one shows us now.  */
+  b->window_count = 0;
 
   BUF_GAP_SIZE (b) = 20;
   block_input ();
@@ -573,6 +573,7 @@ even if it is dead.  The return value is never nil.  */)
   BUF_CHARS_MODIFF (b) = 1;
   BUF_OVERLAY_MODIFF (b) = 1;
   BUF_SAVE_MODIFF (b) = 1;
+  BUF_COMPACT (b) = 1;
   set_buffer_intervals (b, NULL);
   BUF_UNCHANGED_MODIFIED (b) = 1;
   BUF_OVERLAY_UNCHANGED_MODIFIED (b) = 1;
@@ -794,6 +795,8 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
   b->indirections = -1;
   /* Notify base buffer that we share the text now.  */
   b->base_buffer->indirections++;
+  /* Always -1 for an indirect buffer.  */
+  b->window_count = -1;
 
   b->pt = b->base_buffer->pt;
   b->begv = b->base_buffer->begv;
@@ -1336,7 +1339,7 @@ DEFUN ("set-buffer-modified-p", Fset_buffer_modified_p, Sset_buffer_modified_p,
 A non-nil FLAG means mark the buffer modified.  */)
   (Lisp_Object flag)
 {
-  Lisp_Object fn, buffer, window;
+  Lisp_Object fn;
 
 #ifdef CLASH_DETECTION
   /* If buffer becoming modified, lock the file.
@@ -1389,9 +1392,7 @@ A non-nil FLAG means mark the buffer modified.  */)
      Ideally, I think there should be another mechanism for fontifying
      buffers without "modifying" buffers, or redisplay should be
      smarter about updating the `*' in mode lines.  --gerd  */
-  XSETBUFFER (buffer, current_buffer);
-  window = Fget_buffer_window (buffer, Qt);
-  if (WINDOWP (window))
+  if (buffer_window_count (current_buffer))
     {
       ++update_mode_lines;
       current_buffer->prevent_redisplay_optimizations_p = 1;
@@ -1665,7 +1666,7 @@ compact_buffer (struct buffer *buffer)
      which aren't changed since last compaction.  */
   if (BUFFER_LIVE_P (buffer)
       && (buffer->base_buffer == NULL)
-      && (buffer->text->compact != buffer->text->modiff))
+      && (BUF_COMPACT (buffer) != BUF_MODIFF (buffer)))
     {
       /* If a buffer's undo list is Qt, that means that undo is
          turned off in that buffer.  Calling truncate_undo_list on
@@ -1678,19 +1679,15 @@ compact_buffer (struct buffer *buffer)
       if (!buffer->text->inhibit_shrinking)
         {
           /* If a buffer's gap size is more than 10% of the buffer
-             size, or larger than 2000 bytes, then shrink it
-             accordingly.  Keep a minimum size of 20 bytes.  */
-          int size = min (2000, max (20, (buffer->text->z_byte / 10)));
-
-          if (buffer->text->gap_size > size)
-            {
-              struct buffer *save_current = current_buffer;
-              current_buffer = buffer;
-              make_gap (-(buffer->text->gap_size - size));
-              current_buffer = save_current;
-            }
+             size, or larger than GAP_BYTES_DFL bytes, then shrink it
+             accordingly.  Keep a minimum size of GAP_BYTES_MIN bytes.  */
+          ptrdiff_t size = clip_to_bounds (GAP_BYTES_MIN,
+                                           BUF_Z_BYTE (buffer) / 10,
+                                           GAP_BYTES_DFL);
+          if (BUF_GAP_SIZE (buffer) > size)
+            make_gap_1 (buffer, -(BUF_GAP_SIZE (buffer) - size));
         }
-      buffer->text->compact = buffer->text->modiff;
+      BUF_COMPACT (buffer) = BUF_MODIFF (buffer);
     }
 }
 
@@ -1929,10 +1926,16 @@ cleaning up all windows currently displaying the buffer to be killed. */)
       eassert (b->indirections == -1);
       b->base_buffer->indirections--;
       eassert (b->base_buffer->indirections >= 0);
+      /* Make sure that we wasn't confused.  */
+      eassert (b->window_count == -1);
     }
   else
-    /* No one shares our buffer text, can free it.  */
-    free_buffer_text (b);
+    {
+      /* Make sure that no one shows us.  */
+      eassert (b->window_count == 0);
+      /* No one shares our buffer text, can free it.  */
+      free_buffer_text (b);
+    }
 
   if (b->newline_cache)
     {
@@ -2039,7 +2042,7 @@ DEFUN ("bury-buffer-internal", Fbury_buffer_internal, Sbury_buffer_internal,
 DEFUN ("set-buffer-major-mode", Fset_buffer_major_mode, Sset_buffer_major_mode, 1, 1, 0,
        doc: /* Set an appropriate major mode for BUFFER.
 For the *scratch* buffer, use `initial-major-mode', otherwise choose a mode
-according to `default-major-mode'.
+according to the default value of `major-mode'.
 Use this function before selecting the buffer, since it may need to inspect
 the current buffer's major mode.  */)
   (Lisp_Object buffer)
@@ -2681,10 +2684,11 @@ current buffer is cleared.  */)
 
   UNGCPRO;
 
-  /* Changing the multibyteness of a buffer means that all windows
-     showing that buffer must be updated thoroughly.  */
   current_buffer->prevent_redisplay_optimizations_p = 1;
-  ++windows_or_buffers_changed;
+
+  /* If buffer is shown in a window, let redisplay consider other windows.  */
+  if (buffer_window_count (current_buffer))
+    ++windows_or_buffers_changed;
 
   /* Copy this buffer's new multibyte status
      into all of its indirect buffers.  */
@@ -3147,7 +3151,10 @@ ptrdiff_t
 sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
 {
   ptrdiff_t i, j;
-  struct sortvec *sortvec = alloca (noverlays * sizeof *sortvec);
+  USE_SAFE_ALLOCA;
+  struct sortvec *sortvec;
+
+  SAFE_NALLOCA (sortvec, 1, noverlays);
 
   /* Put the valid and relevant overlays into sortvec.  */
 
@@ -3193,6 +3200,8 @@ sort_overlays (Lisp_Object *overlay_vec, ptrdiff_t noverlays, struct window *w)
 
   for (i = 0; i < noverlays; i++)
     overlay_vec[i] = sortvec[i].overlay;
+
+  SAFE_FREE ();
   return (noverlays);
 }
 
@@ -3880,17 +3889,17 @@ modify_overlay (struct buffer *buf, ptrdiff_t start, ptrdiff_t end)
 
   BUF_COMPUTE_UNCHANGED (buf, start, end);
 
-  /* If this is a buffer not in the selected window,
-     we must do other windows.  */
-  if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
-    windows_or_buffers_changed = 1;
-  /* If multiple windows show this buffer, we must do other windows.  */
-  else if (buffer_shared > 1)
-    windows_or_buffers_changed = 1;
-  /* If we modify an overlay at the end of the buffer, we cannot
-     be sure that window end is still valid.  */
-  else if (end >= ZV && start <= ZV)
-    windows_or_buffers_changed = 1;
+  /* If BUF is visible, consider updating the display if ...  */
+  if (buffer_window_count (buf) > 0)
+    {
+      /* ... it's visible in other window than selected,  */
+      if (buf != XBUFFER (XWINDOW (selected_window)->buffer))
+        windows_or_buffers_changed = 1;
+      /* ... or if we modify an overlay at the end of the buffer
+         and so we cannot be sure that window end is still valid.  */
+      else if (end >= ZV && start <= ZV)
+        windows_or_buffers_changed = 1;
+    }
 
   ++BUF_OVERLAY_MODIFF (buf);
 }
@@ -4569,27 +4578,7 @@ evaporate_overlays (ptrdiff_t pos)
   for (; CONSP (hit_list); hit_list = XCDR (hit_list))
     Fdelete_overlay (XCAR (hit_list));
 }
-
-/* Somebody has tried to store a value with an unacceptable type
-   in the slot with offset OFFSET.  */
-
-void
-buffer_slot_type_mismatch (Lisp_Object newval, int type)
-{
-  Lisp_Object predicate;
-
-  switch (type)
-    {
-    case_Lisp_Int:    predicate = Qintegerp; break;
-    case Lisp_String: predicate = Qstringp;  break;
-    case Lisp_Symbol: predicate = Qsymbolp;  break;
-    default: emacs_abort ();
-    }
-
-  wrong_type_argument (predicate, newval);
-}
 
-
 /***********************************************************************
                          Allocation with mmap
  ***********************************************************************/
@@ -5125,6 +5114,9 @@ init_buffer_once (void)
   /* No one will share the text with these buffers, but let's play it safe.  */
   buffer_defaults.indirections = 0;
   buffer_local_symbols.indirections = 0;
+  /* Likewise no one will display them.  */
+  buffer_defaults.window_count = 0;
+  buffer_local_symbols.window_count = 0;
   set_buffer_intervals (&buffer_defaults, NULL);
   set_buffer_intervals (&buffer_local_symbols, NULL);
   /* This is not strictly necessary, but let's make them initialized.  */
@@ -5360,25 +5352,23 @@ init_buffer (void)
   free (pwd);
 }
 
-/* Similar to defvar_lisp but define a variable whose value is the Lisp
-   Object stored in the current buffer.  address is the address of the slot
-   in the buffer that is current now. */
-
-/* TYPE is nil for a general Lisp variable.
-   An integer specifies a type; then only Lisp values
-   with that type code are allowed (except that nil is allowed too).
-   LNAME is the Lisp-level variable name.
-   VNAME is the name of the buffer slot.
-   DOC is a dummy where you write the doc string as a comment.  */
-#define DEFVAR_PER_BUFFER(lname, vname, type, doc)                      \
-  do {                                                                  \
-    static struct Lisp_Buffer_Objfwd bo_fwd;                            \
-    defvar_per_buffer (&bo_fwd, lname, vname, type);                    \
+/* Similar to defvar_lisp but define a variable whose value is the
+   Lisp_Object stored in the current buffer.  LNAME is the Lisp-level
+   variable name.  VNAME is the name of the buffer slot.  PREDICATE
+   is nil for a general Lisp variable.  If PREDICATE is non-nil, then
+   only Lisp values that satisfies the PREDICATE are allowed (except
+   that nil is allowed too).  DOC is a dummy where you write the doc
+   string as a comment.  */
+
+#define DEFVAR_PER_BUFFER(lname, vname, predicate, doc)         \
+  do {                                                          \
+    static struct Lisp_Buffer_Objfwd bo_fwd;                    \
+    defvar_per_buffer (&bo_fwd, lname, vname, predicate);       \
   } while (0)
 
 static void
 defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
-                   Lisp_Object *address, Lisp_Object type)
+                   Lisp_Object *address, Lisp_Object predicate)
 {
   struct Lisp_Symbol *sym;
   int offset;
@@ -5388,7 +5378,7 @@ defvar_per_buffer (struct Lisp_Buffer_Objfwd *bo_fwd, const char *namestring,
 
   bo_fwd->type = Lisp_Fwd_Buffer_Obj;
   bo_fwd->offset = offset;
-  bo_fwd->slottype = type;
+  bo_fwd->predicate = predicate;
   sym->declared_special = 1;
   sym->redirect = SYMBOL_FORWARDED;
   {
@@ -5651,7 +5641,7 @@ Decimal digits after the % specify field width to which to pad.  */);
                           doc: /* Value of `major-mode' for new buffers.  */);
 
   DEFVAR_PER_BUFFER ("major-mode", &BVAR (current_buffer, major_mode),
-                     make_number (Lisp_Symbol),
+                     Qsymbolp,
                      doc: /* Symbol for current buffer's major mode.
 The default value (normally `fundamental-mode') affects new buffers.
 A value of nil means to use the current buffer's major mode, provided
@@ -5682,17 +5672,17 @@ Use the command `abbrev-mode' to change this variable.  */);
                      doc: /* Non-nil if searches and matches should ignore case.  */);
 
   DEFVAR_PER_BUFFER ("fill-column", &BVAR (current_buffer, fill_column),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      doc: /* Column beyond which automatic line-wrapping should happen.
 Interactively, you can set the buffer local value using \\[set-fill-column].  */);
 
   DEFVAR_PER_BUFFER ("left-margin", &BVAR (current_buffer, left_margin),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      doc: /* Column for the default `indent-line-function' to indent to.
 Linefeed indents to this column in Fundamental mode.  */);
 
   DEFVAR_PER_BUFFER ("tab-width", &BVAR (current_buffer, tab_width),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      doc: /* Distance between tab stops (for display of tab characters), in columns.
 This should be an integer greater than zero.  */);
 
@@ -5777,7 +5767,7 @@ visual lines rather than logical lines.  See the documentation of
 `visual-line-mode'.  */);
 
   DEFVAR_PER_BUFFER ("default-directory", &BVAR (current_buffer, directory),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of default directory of current buffer.  Should end with slash.
 To interactively change the default directory, use command `cd'.  */);
 
@@ -5790,18 +5780,18 @@ NOTE: This variable is not a hook;
 its value may not be a list of functions.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-name", &BVAR (current_buffer, filename),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of file visited in current buffer, or nil if not visiting a file.  */);
 
   DEFVAR_PER_BUFFER ("buffer-file-truename", &BVAR (current_buffer, file_truename),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Abbreviated truename of file visited in current buffer, or nil if none.
 The truename of a file is calculated by `file-truename'
 and then abbreviated with `abbreviate-file-name'.  */);
 
   DEFVAR_PER_BUFFER ("buffer-auto-save-file-name",
                      &BVAR (current_buffer, auto_save_file_name),
-                     make_number (Lisp_String),
+                     Qstringp,
                      doc: /* Name of file for auto-saving current buffer.
 If it is nil, that means don't auto-save this buffer.  */);
 
@@ -5813,7 +5803,7 @@ If it is nil, that means don't auto-save this buffer.  */);
 Backing up is done before the first time the file is saved.  */);
 
   DEFVAR_PER_BUFFER ("buffer-saved-size", &BVAR (current_buffer, save_length),
-                     make_number (Lisp_Int0),
+                     Qintegerp,
                      doc: /* Length of current buffer when last read in, saved or auto-saved.
 0 initially.
 -1 means auto-saving turned off until next real save.
@@ -5883,23 +5873,23 @@ In addition, a char-table has six extra slots to control the display of:
 See also the functions `display-table-slot' and `set-display-table-slot'.  */);
 
   DEFVAR_PER_BUFFER ("left-margin-width", &BVAR (current_buffer, left_margin_cols),
-                     Qnil,
+                     Qintegerp,
                      doc: /* Width of left marginal area for display of a buffer.
 A value of nil means no marginal area.  */);
 
   DEFVAR_PER_BUFFER ("right-margin-width", &BVAR (current_buffer, right_margin_cols),
-                     Qnil,
+                     Qintegerp,
                      doc: /* Width of right marginal area for display of a buffer.
 A value of nil means no marginal area.  */);
 
   DEFVAR_PER_BUFFER ("left-fringe-width", &BVAR (current_buffer, left_fringe_width),
-                     Qnil,
+                     Qintegerp,
                      doc: /* Width of this buffer's left fringe (in pixels).
 A value of 0 means no left fringe is shown in this buffer's window.
 A value of nil means to use the left fringe width from the window's frame.  */);
 
   DEFVAR_PER_BUFFER ("right-fringe-width", &BVAR (current_buffer, right_fringe_width),
-                     Qnil,
+                     Qintegerp,
                      doc: /* Width of this buffer's right fringe (in pixels).
 A value of 0 means no right fringe is shown in this buffer's window.
 A value of nil means to use the right fringe width from the window's frame.  */);
@@ -5910,7 +5900,7 @@ A value of nil means to use the right fringe width from the window's frame.  */)
 A value of nil means to display fringes between margins and buffer text.  */);
 
   DEFVAR_PER_BUFFER ("scroll-bar-width", &BVAR (current_buffer, scroll_bar_width),
-                     Qnil,
+                     Qintegerp,
                      doc: /* Width of this buffer's scroll bars in pixels.
 A value of nil means to use the scroll bar width from the window's frame.  */);
 
@@ -5990,7 +5980,7 @@ BITMAP is the corresponding fringe bitmap shown for the logical
 cursor type.  */);
 
   DEFVAR_PER_BUFFER ("scroll-up-aggressively",
-                     &BVAR (current_buffer, scroll_up_aggressively), Qnil,
+                     &BVAR (current_buffer, scroll_up_aggressively), Qfloatp,
                      doc: /* How far to scroll windows upward.
 If you move point off the bottom, the window scrolls automatically.
 This variable controls how far it scrolls.  The value nil, the default,
@@ -6003,7 +5993,7 @@ window scrolls by a full window height.  Meaningful values are
 between 0.0 and 1.0, inclusive.  */);
 
   DEFVAR_PER_BUFFER ("scroll-down-aggressively",
-                     &BVAR (current_buffer, scroll_down_aggressively), Qnil,
+                     &BVAR (current_buffer, scroll_down_aggressively), Qfloatp,
                      doc: /* How far to scroll windows downward.
 If you move point off the top, the window scrolls automatically.
 This variable controls how far it scrolls.  The value nil, the default,
@@ -6015,10 +6005,6 @@ simple case that you moved off with C-b means scrolling just one line.
 window scrolls by a full window height.  Meaningful values are
 between 0.0 and 1.0, inclusive.  */);
 
-/*DEFVAR_LISP ("debug-check-symbol", &Vcheck_symbol,
-    "Don't ask.");
-*/
-
   DEFVAR_LISP ("before-change-functions", Vbefore_change_functions,
                doc: /* List of functions to call before each text change.
 Two arguments are passed to each function: the positions of
@@ -6157,7 +6143,7 @@ then characters with property value PROP are invisible,
 and they have an ellipsis as well if ELLIPSIS is non-nil.  */);
 
   DEFVAR_PER_BUFFER ("buffer-display-count",
-                     &BVAR (current_buffer, display_count), Qnil,
+                     &BVAR (current_buffer, display_count), Qintegerp,
                      doc: /* A number incremented each time this buffer is displayed in a window.
 The function `set-window-buffer' increments it.  */);
 
@@ -6216,7 +6202,7 @@ cursor's appearance is instead controlled by the variable
 `cursor-in-non-selected-windows'.  */);
 
   DEFVAR_PER_BUFFER ("line-spacing",
-                     &BVAR (current_buffer, extra_line_spacing), Qnil,
+                     &BVAR (current_buffer, extra_line_spacing), Qnumberp,
                      doc: /* Additional space to put between lines when displaying a buffer.
 The space is measured in pixels, and put below lines on graphic displays,
 see `display-graphic-p'.
diff --git a/src/buffer.h b/src/buffer.h
index 1129840bd47..276cca32e48 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -1,7 +1,7 @@
 /* Header file for the buffer manipulation primitives.
 
-Copyright (C) 1985-1986, 1993-1995, 1997-2012
-                 Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -82,9 +82,6 @@ INLINE_HEADER_BEGIN
 /* Size of gap.  */
 #define GAP_SIZE (current_buffer->text->gap_size)
 
-/* Is the current buffer narrowed?  */
-#define NARROWED        ((BEGV != BEG) || (ZV != Z))
-
 /* Modification count.  */
 #define MODIFF (current_buffer->text->modiff)
 
@@ -173,10 +170,6 @@ INLINE_HEADER_BEGIN
 /* Size of gap.  */
 #define BUF_GAP_SIZE(buf) ((buf)->text->gap_size)
 
-/* Is this buffer narrowed?  */
-#define BUF_NARROWED(buf) ((BUF_BEGV (buf) != BUF_BEG (buf)) \
-                           || (BUF_ZV (buf) != BUF_Z (buf)))
-
 /* Modification count.  */
 #define BUF_MODIFF(buf) ((buf)->text->modiff)
 
@@ -193,6 +186,9 @@ INLINE_HEADER_BEGIN
 /* FIXME: should we move this into ->text->auto_save_modiff?  */
 #define BUF_AUTOSAVE_MODIFF(buf) ((buf)->auto_save_modified)
 
+/* Compaction count.  */
+#define BUF_COMPACT(buf) ((buf)->text->compact)
+
 /* Marker chain of buffer.  */
 #define BUF_MARKERS(buf) ((buf)->text->markers)
 
@@ -291,24 +287,24 @@ extern void enlarge_buffer_text (struct buffer *, ptrdiff_t);
 /* Access a Lisp position value in POS,
    and store the charpos in CHARPOS and the bytepos in BYTEPOS.  */
 
-#define DECODE_POSITION(charpos, bytepos, pos)                  \
-do                                                              \
-  {                                                             \
-    Lisp_Object __pos = (pos);                                  \
-    if (NUMBERP (__pos))                                        \
-      {                                                         \
-        charpos = __pos;                                        \
-        bytepos = buf_charpos_to_bytepos (current_buffer, __pos);  \
-      }                                                         \
-    else if (MARKERP (__pos))                                   \
-      {                                                         \
-        charpos = marker_position (__pos);                      \
-        bytepos = marker_byte_position (__pos);                 \
-      }                                                         \
-    else                                                        \
-      wrong_type_argument (Qinteger_or_marker_p, __pos);        \
-  }                                                             \
-while (0)
+#define DECODE_POSITION(charpos, bytepos, pos)                          \
+  do                                                                    \
+    {                                                                   \
+      Lisp_Object __pos = (pos);                                        \
+      if (NUMBERP (__pos))                                              \
+        {                                                               \
+          charpos = __pos;                                              \
+          bytepos = buf_charpos_to_bytepos (current_buffer, __pos);     \
+        }                                                               \
+      else if (MARKERP (__pos))                                         \
+        {                                                               \
+          charpos = marker_position (__pos);                            \
+          bytepos = marker_byte_position (__pos);                       \
+        }                                                               \
+      else                                                              \
+        wrong_type_argument (Qinteger_or_marker_p, __pos);              \
+    }                                                                   \
+  while (0)
 
 /* Maximum number of bytes in a buffer.
    A buffer cannot contain more bytes than a 1-origin fixnum can represent,
@@ -317,6 +313,16 @@ while (0)
 #define BUF_BYTES_MAX \
   (ptrdiff_t) min (MOST_POSITIVE_FIXNUM - 1, min (SIZE_MAX, PTRDIFF_MAX))
 
+/* Maximum gap size after compact_buffer, in bytes.  Also
+   used in make_gap_larger to get some extra reserved space.  */
+
+#define GAP_BYTES_DFL 2000
+
+/* Minimum gap size after compact_buffer, in bytes.  Also
+   used in make_gap_smaller to avoid too small gap size.  */
+
+#define GAP_BYTES_MIN 20
+
 /* Return the address of byte position N in current buffer.  */
 
 #define BYTE_POS_ADDR(n) \
@@ -770,11 +776,15 @@ struct buffer
      In an ordinary buffer, it is 0.  */
   struct buffer *base_buffer;
 
-  /* In an indirect buffer, this is -1. In an ordinary buffer,
+  /* In an indirect buffer, this is -1.  In an ordinary buffer,
      it's the number of indirect buffers that share our text;
      zero means that we're the only owner of this text.  */
   int indirections;
 
+  /* Number of windows showing this buffer.  Always -1 for
+     an indirect buffer since it counts as its base buffer.  */
+  int window_count;
+
   /* A non-zero value in slot IDX means that per-buffer variable
      with index IDX has a local value in this buffer.  The index IDX
      for a buffer-local variable is stored in that variable's slot
@@ -992,15 +1002,15 @@ bset_width_table (struct buffer *b, Lisp_Object val)
 #define BUFFER_CHECK_INDIRECTION(b)                     \
   do {                                                  \
     if (BUFFER_LIVE_P (b))                              \
-    {                                                   \
-      if (b->base_buffer)                               \
-        {                                               \
-          eassert (b->indirections == -1);              \
-          eassert (b->base_buffer->indirections > 0);   \
-        }                                               \
-      else                                              \
-        eassert (b->indirections >= 0);                 \
-    }                                                   \
+      {                                                 \
+        if (b->base_buffer)                             \
+          {                                             \
+            eassert (b->indirections == -1);            \
+            eassert (b->base_buffer->indirections > 0); \
+          }                                             \
+        else                                            \
+          eassert (b->indirections >= 0);               \
+      }                                                 \
   } while (0)
 
 /* Chain of all buffers, including killed ones.  */
@@ -1061,7 +1071,6 @@ extern void set_buffer_internal_1 (struct buffer *);
 extern void set_buffer_temp (struct buffer *);
 extern Lisp_Object buffer_local_value_1 (Lisp_Object, Lisp_Object);
 extern void record_buffer (Lisp_Object);
-extern _Noreturn void buffer_slot_type_mismatch (Lisp_Object, int);
 extern void fix_overlays_before (struct buffer *, ptrdiff_t, ptrdiff_t);
 extern void mmap_set_vars (bool);
 
@@ -1173,7 +1182,18 @@ BUF_FETCH_MULTIBYTE_CHAR (struct buffer *buf, ptrdiff_t pos)
        + pos + BUF_BEG_ADDR (buf) - BEG_BYTE);
   return STRING_CHAR (p);
 }
-
+
+/* Return number of windows showing B.  */
+
+BUFFER_INLINE int
+buffer_window_count (struct buffer *b)
+{
+  if (b->base_buffer)
+    b = b->base_buffer;
+  eassert (b->window_count >= 0);
+  return b->window_count;
+}
+
 /* Overlays */
 
 /* Return the marker that stands for where OV starts in the buffer.  */
diff --git a/src/bytecode.c b/src/bytecode.c
index 4c5ac151de1..bd8abe85e04 100644
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -1,5 +1,6 @@
 /* Execution of byte code produced by bytecomp.el.
-   Copyright (C) 1985-1988, 1993, 2000-2012 Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993, 2000-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/callint.c b/src/callint.c
index c4c087e83d7..3e295a3b26b 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -1,6 +1,6 @@
 /* Call a Lisp function interactively.
-   Copyright (C) 1985-1986, 1993-1995, 1997, 2000-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1993-1995, 1997, 2000-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -497,47 +497,47 @@ invoke it.  If KEYS is omitted or nil, the return value of
 
       switch (*tem)
         {
-        case 'a':               /* Symbol defined as a function */
+        case 'a':               /* Symbol defined as a function.  */
           visargs[i] = Fcompleting_read (callint_message,
                                          Vobarray, Qfboundp, Qt,
                                          Qnil, Qnil, Qnil, Qnil);
-          /* Passing args[i] directly stimulates compiler bug */
+          /* Passing args[i] directly stimulates compiler bug.  */
           teml = visargs[i];
           args[i] = Fintern (teml, Qnil);
           break;
 
-        case 'b':               /* Name of existing buffer */
+        case 'b':               /* Name of existing buffer.  */
           args[i] = Fcurrent_buffer ();
           if (EQ (selected_window, minibuf_window))
             args[i] = Fother_buffer (args[i], Qnil, Qnil);
           args[i] = Fread_buffer (callint_message, args[i], Qt);
           break;
 
-        case 'B':               /* Name of buffer, possibly nonexistent */
+        case 'B':               /* Name of buffer, possibly nonexistent.  */
           args[i] = Fread_buffer (callint_message,
                                   Fother_buffer (Fcurrent_buffer (), Qnil, Qnil),
                                   Qnil);
           break;
 
-        case 'c':               /* Character */
+        case 'c':               /* Character.  */
           /* Prompt in `minibuffer-prompt' face.  */
           Fput_text_property (make_number (0),
                               make_number (SCHARS (callint_message)),
                               Qface, Qminibuffer_prompt, callint_message);
           args[i] = Fread_char (callint_message, Qnil, Qnil);
           message1_nolog ((char *) 0);
-          /* Passing args[i] directly stimulates compiler bug */
+          /* Passing args[i] directly stimulates compiler bug.  */
           teml = args[i];
           /* See bug#8479.  */
           if (! CHARACTERP (teml)) error ("Non-character input-event");
           visargs[i] = Fchar_to_string (teml);
           break;
 
-        case 'C':               /* Command: symbol with interactive function */
+        case 'C':             /* Command: symbol with interactive function.  */
           visargs[i] = Fcompleting_read (callint_message,
                                          Vobarray, Qcommandp,
                                          Qt, Qnil, Qnil, Qnil, Qnil);
-          /* Passing args[i] directly stimulates compiler bug */
+          /* Passing args[i] directly stimulates compiler bug.  */
           teml = visargs[i];
           args[i] = Fintern (teml, Qnil);
           break;
@@ -549,33 +549,33 @@ invoke it.  If KEYS is omitted or nil, the return value of
           varies[i] = 1;
           break;
 
-        case 'D':               /* Directory name. */
+        case 'D':               /* Directory name.  */
           args[i] = Fread_file_name (callint_message, Qnil,
                                      BVAR (current_buffer, directory), Qlambda, Qnil,
                                      Qfile_directory_p);
           break;
 
-        case 'f':               /* Existing file name. */
+        case 'f':               /* Existing file name.  */
           args[i] = Fread_file_name (callint_message,
                                      Qnil, Qnil, Qlambda, Qnil, Qnil);
           break;
 
-        case 'F':               /* Possibly nonexistent file name. */
+        case 'F':               /* Possibly nonexistent file name.  */
           args[i] = Fread_file_name (callint_message,
                                      Qnil, Qnil, Qnil, Qnil, Qnil);
           break;
 
         case 'G':               /* Possibly nonexistent file name,
-                                   default to directory alone. */
+                                   default to directory alone.  */
           args[i] = Fread_file_name (callint_message,
                                      Qnil, Qnil, Qnil, empty_unibyte_string, Qnil);
           break;
 
-        case 'i':               /* Ignore an argument -- Does not do I/O */
+        case 'i':               /* Ignore an argument -- Does not do I/O.  */
           varies[i] = -1;
           break;
 
-        case 'k':               /* Key sequence. */
+        case 'k':               /* Key sequence.  */
           {
             ptrdiff_t speccount1 = SPECPDL_INDEX ();
             specbind (Qcursor_in_echo_area, Qt);
@@ -607,7 +607,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
           }
           break;
 
-        case 'K':               /* Key sequence to be defined. */
+        case 'K':               /* Key sequence to be defined.  */
           {
             ptrdiff_t speccount1 = SPECPDL_INDEX ();
             specbind (Qcursor_in_echo_area, Qt);
@@ -639,7 +639,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
           }
           break;
 
-        case 'U':               /* Up event from last k or K */
+        case 'U':               /* Up event from last k or K.  */
           if (!NILP (up_event))
             {
               args[i] = Fmake_vector (make_number (1), up_event);
@@ -679,7 +679,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
                                   Qnil, Qnil, Qnil, Qt);
           break;
 
-        case 'N':               /* Prefix arg as number, else number from minibuffer */
+        case 'N':     /* Prefix arg as number, else number from minibuffer.  */
           if (!NILP (prefix_arg))
             goto have_prefix_arg;
         case 'n':               /* Read number from minibuffer.  */
@@ -690,7 +690,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
                 Lisp_Object str;
                 if (! first)
                   {
-                    message ("Please enter a number.");
+                    message1 ("Please enter a number.");
                     sit_for (make_number (1), 0, 0);
                   }
                 first = 0;
@@ -714,14 +714,14 @@ invoke it.  If KEYS is omitted or nil, the return value of
           varies[i] = -1;
           break;
 
-        case 'p':               /* Prefix arg converted to number.  No I/O. */
+        case 'p':               /* Prefix arg converted to number.  No I/O.  */
         have_prefix_arg:
           args[i] = Fprefix_numeric_value (prefix_arg);
           /* visargs[i] = Qnil; */
           varies[i] = -1;
           break;
 
-        case 'r':               /* Region, point and mark as 2 args. */
+        case 'r':               /* Region, point and mark as 2 args.  */
           check_mark (1);
           set_marker_both (point_marker, Qnil, PT, PT_BYTE);
           /* visargs[i+1] = Qnil; */
@@ -742,29 +742,29 @@ invoke it.  If KEYS is omitted or nil, the return value of
         case 'S':               /* Any symbol.  */
           visargs[i] = Fread_string (callint_message,
                                      Qnil, Qnil, Qnil, Qnil);
-          /* Passing args[i] directly stimulates compiler bug */
+          /* Passing args[i] directly stimulates compiler bug.  */
           teml = visargs[i];
           args[i] = Fintern (teml, Qnil);
           break;
 
         case 'v':               /* Variable name: symbol that is
-                                   custom-variable-p. */
+                                   custom-variable-p.  */
           args[i] = Fread_variable (callint_message, Qnil);
           visargs[i] = last_minibuf_string;
           break;
 
-        case 'x':               /* Lisp expression read but not evaluated */
+        case 'x':               /* Lisp expression read but not evaluated.  */
           args[i] = Fread_minibuffer (callint_message, Qnil);
           visargs[i] = last_minibuf_string;
           break;
 
-        case 'X':               /* Lisp expression read and evaluated */
+        case 'X':               /* Lisp expression read and evaluated.  */
           args[i] = Feval_minibuffer (callint_message, Qnil);
           visargs[i] = last_minibuf_string;
           break;
 
         case 'Z':               /* Coding-system symbol, or ignore the
-                                   argument if no prefix */
+                                   argument if no prefix.  */
           if (NILP (prefix_arg))
             {
               args[i] = Qnil;
@@ -778,7 +778,7 @@ invoke it.  If KEYS is omitted or nil, the return value of
             }
           break;
 
-        case 'z':               /* Coding-system symbol or nil */
+        case 'z':               /* Coding-system symbol or nil.  */
           args[i] = Fread_coding_system (callint_message, Qnil);
           visargs[i] = last_minibuf_string;
           break;
diff --git a/src/callproc.c b/src/callproc.c
index 70e349d0d3a..9132c0dd976 100644
--- a/src/callproc.c
+++ b/src/callproc.c
@@ -402,10 +402,8 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
   filefd = emacs_open (SSDATA (infile), O_RDONLY, 0);
   if (filefd < 0)
-    {
-      infile = DECODE_FILE (infile);
-      report_file_error ("Opening process input file", Fcons (infile, Qnil));
-    }
+    report_file_error ("Opening process input file",
+                       Fcons (DECODE_FILE (infile), Qnil));
 
   if (STRINGP (output_file))
     {
@@ -447,28 +445,34 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
     path = Fsubstring (path, make_number (2), Qnil);
 
   new_argv = SAFE_ALLOCA ((nargs > 4 ? nargs - 2 : 2) * sizeof *new_argv);
-  if (nargs > 4)
-    {
-      ptrdiff_t i;
-      struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
 
-      GCPRO5 (infile, buffer, current_dir, path, error_file);
-      argument_coding.dst_multibyte = 0;
-      for (i = 4; i < nargs; i++)
-        {
-          argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
-          if (CODING_REQUIRE_ENCODING (&argument_coding))
-            /* We must encode this argument.  */
-            args[i] = encode_coding_string (&argument_coding, args[i], 1);
-        }
-      UNGCPRO;
-      for (i = 4; i < nargs; i++)
-        new_argv[i - 3] = SSDATA (args[i]);
-      new_argv[i - 3] = 0;
-    }
-  else
-    new_argv[1] = 0;
-  new_argv[0] = SSDATA (path);
+  {
+    struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+
+    GCPRO5 (infile, buffer, current_dir, path, error_file);
+    if (nargs > 4)
+      {
+        ptrdiff_t i;
+
+        argument_coding.dst_multibyte = 0;
+        for (i = 4; i < nargs; i++)
+          {
+            argument_coding.src_multibyte = STRING_MULTIBYTE (args[i]);
+            if (CODING_REQUIRE_ENCODING (&argument_coding))
+              /* We must encode this argument.  */
+              args[i] = encode_coding_string (&argument_coding, args[i], 1);
+          }
+        for (i = 4; i < nargs; i++)
+          new_argv[i - 3] = SSDATA (args[i]);
+        new_argv[i - 3] = 0;
+      }
+    else
+      new_argv[1] = 0;
+    if (STRING_MULTIBYTE (path))
+      path = ENCODE_FILE (path);
+    new_argv[0] = SSDATA (path);
+    UNGCPRO;
+  }
 
 #ifdef MSDOS /* MW, July 1993 */
 
@@ -483,7 +487,7 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
           tempfile = alloca (20);
           *tempfile = '\0';
         }
-      dostounix_filename (tempfile);
+      dostounix_filename (tempfile, 0);
       if (*tempfile == '\0' || tempfile[strlen (tempfile) - 1] != '/')
         strcat (tempfile, "/");
       strcat (tempfile, "detmp.XXX");
@@ -612,6 +616,15 @@ usage: (call-process PROGRAM &optional INFILE BUFFER DISPLAY &rest ARGS)  */)
 
 #ifdef WINDOWSNT
     pid = child_setup (filefd, fd1, fd_error, new_argv, 0, current_dir);
+    /* We need to record the input file of this child, for when we are
+       called from call-process-region to create an async subprocess.
+       That's because call-process-region's unwind procedure will
+       attempt to delete the temporary input file, which will fail
+       because that file is still in use.  Recording it with the child
+       will allow us to delete the file when the subprocess exits.
+       The second part of this is in delete_temp_file, q.v.  */
+    if (pid > 0 && INTEGERP (buffer) && nargs >= 2 && !NILP (args[1]))
+      record_infile (pid, xstrdup (SSDATA (infile)));
 #else  /* not WINDOWSNT */
 
     /* vfork, and prevent local vars from being clobbered by the vfork.  */
@@ -924,7 +937,21 @@ delete_temp_file (Lisp_Object name)
   /* Suppress jka-compr handling, etc.  */
   ptrdiff_t count = SPECPDL_INDEX ();
   specbind (intern ("file-name-handler-alist"), Qnil);
+#ifdef WINDOWSNT
+  /* If this is called when the subprocess didn't exit yet, the
+     attempt to delete its input file will fail.  In that case, we
+     schedule the file for deletion when the subprocess exits.  This
+     is the 2nd part of handling this situation; see the call to
+     record_infile in call-process above, for the first part.  */
+  if (!internal_delete_file (name))
+    {
+      Lisp_Object encoded_file = ENCODE_FILE (name);
+
+      record_pending_deletion (SSDATA (encoded_file));
+    }
+#else
   internal_delete_file (name);
+#endif
   unbind_to (count, Qnil);
   return Qnil;
 }
@@ -970,13 +997,11 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
     tmpdir = Vtemporary_file_directory;
   else
     {
+      char *outf;
 #ifndef DOS_NT
-      if (getenv ("TMPDIR"))
-        tmpdir = build_string (getenv ("TMPDIR"));
-      else
-        tmpdir = build_string ("/tmp/");
+      outf = getenv ("TMPDIR");
+      tmpdir = build_string (outf ? outf : "/tmp/");
 #else /* DOS_NT */
-      char *outf;
       if ((outf = egetenv ("TMPDIR"))
           || (outf = egetenv ("TMP"))
           || (outf = egetenv ("TEMP")))
@@ -989,8 +1014,26 @@ usage: (call-process-region START END PROGRAM &optional DELETE BUFFER DISPLAY &r
   {
     USE_SAFE_ALLOCA;
     Lisp_Object pattern = Fexpand_file_name (Vtemp_file_name_pattern, tmpdir);
-    Lisp_Object encoded_tem = ENCODE_FILE (pattern);
-    char *tempfile = SAFE_ALLOCA (SBYTES (encoded_tem) + 1);
+    Lisp_Object encoded_tem;
+    char *tempfile;
+
+#ifdef WINDOWSNT
+    /* Cannot use the result of Fexpand_file_name, because it
+       downcases the XXXXXX part of the pattern, and mktemp then
+       doesn't recognize it.  */
+    if (!NILP (Vw32_downcase_file_names))
+      {
+        Lisp_Object dirname = Ffile_name_directory (pattern);
+
+        if (NILP (dirname))
+          pattern = Vtemp_file_name_pattern;
+        else
+          pattern = concat2 (dirname, Vtemp_file_name_pattern);
+      }
+#endif
+
+    encoded_tem = ENCODE_FILE (pattern);
+    tempfile = SAFE_ALLOCA (SBYTES (encoded_tem) + 1);
     memcpy (tempfile, SDATA (encoded_tem), SBYTES (encoded_tem) + 1);
     coding_systems = Qt;
 
@@ -1274,7 +1317,7 @@ child_setup (int in, int out, int err, char **new_argv, bool set_pgrp,
 #ifdef WINDOWSNT
   prepare_standard_handles (in, out, err, handles);
   set_process_dir (SDATA (current_dir));
-  /* Spawn the child.  (See ntproc.c:Spawnve).  */
+  /* Spawn the child.  (See w32proc.c:sys_spawnve).  */
   cpid = spawnve (_P_NOWAIT, new_argv[0], new_argv, env);
   reset_standard_handles (in, out, err, handles);
   if (cpid == -1)
@@ -1610,7 +1653,7 @@ init_callproc (void)
   if (! file_accessible_directory_p (SSDATA (tempdir)))
     dir_warning ("arch-independent data dir", Vdata_directory);
 
-  sh = (char *) getenv ("SHELL");
+  sh = getenv ("SHELL");
   Vshell_file_name = build_string (sh ? sh : "/bin/sh");
 
 #ifdef DOS_NT
diff --git a/src/casefiddle.c b/src/casefiddle.c
index d9c6a078973..7f5b99752fa 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -1,6 +1,7 @@
 /* GNU Emacs case conversion functions.
 
-Copyright (C) 1985, 1994, 1997-1999, 2001-2012 Free Software Foundation, Inc.
+Copyright (C) 1985, 1994, 1997-1999, 2001-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/casetab.c b/src/casetab.c
index a84bc9202d0..76f72b26db3 100644
--- a/src/casetab.c
+++ b/src/casetab.c
@@ -1,5 +1,5 @@
 /* GNU Emacs routines to deal with case tables.
-   Copyright (C) 1993-1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 2001-2013 Free Software Foundation, Inc.
 
 Author: Howard Gayle
 
diff --git a/src/category.c b/src/category.c
index 31cc90bca68..30ffbd0890f 100644
--- a/src/category.c
+++ b/src/category.c
@@ -1,6 +1,6 @@
 /* GNU Emacs routines to deal with category tables.
 
-Copyright (C) 1998, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1998, 2001-2013 Free Software Foundation, Inc.
 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   2005, 2006, 2007, 2008, 2009, 2010, 2011
   National Institute of Advanced Industrial Science and Technology (AIST)
diff --git a/src/ccl.c b/src/ccl.c
index 34cc1c98eea..7f77e1d22fa 100644
--- a/src/ccl.c
+++ b/src/ccl.c
@@ -1,5 +1,5 @@
 /* CCL (Code Conversion Language) interpreter.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
@@ -2228,9 +2228,8 @@ Return index number of the registered CCL program.  */)
     Vccl_program_table = larger_vector (Vccl_program_table, 1, -1);
 
   {
-    Lisp_Object elt;
+    Lisp_Object elt = make_uninit_vector (4);
 
-    elt = Fmake_vector (make_number (4), Qnil);
     ASET (elt, 0, name);
     ASET (elt, 1, ccl_prog);
     ASET (elt, 2, resolved);
diff --git a/src/character.c b/src/character.c
index 5808d48a235..b2caaa290af 100644
--- a/src/character.c
+++ b/src/character.c
@@ -1,6 +1,6 @@
 /* Basic character support.
 
-Copyright (C) 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 2001-2013 Free Software Foundation, Inc.
 Copyright (C) 1995, 1997, 1998, 2001 Electrotechnical Laboratory, JAPAN.
   Licensed to the Free Software Foundation.
 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
diff --git a/src/charset.c b/src/charset.c
index 43be0e9c780..fdb8eebde8b 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -1,5 +1,5 @@
 /* Basic character set support.
-   Copyright (C) 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
@@ -1053,7 +1053,7 @@ usage: (define-charset-internal ...)  */)
       CHECK_NATNUM (parent_max_code);
       parent_code_offset = Fnth (make_number (3), val);
       CHECK_NUMBER (parent_code_offset);
-      val = Fmake_vector (make_number (4), Qnil);
+      val = make_uninit_vector (4);
       ASET (val, 0, make_number (parent_charset->id));
       ASET (val, 1, parent_min_code);
       ASET (val, 2, parent_max_code);
@@ -1259,7 +1259,7 @@ define_charset_internal (Lisp_Object name,
 
   args[charset_arg_name] = name;
   args[charset_arg_dimension] = make_number (dimension);
-  val = Fmake_vector (make_number (8), make_number (0));
+  val = make_uninit_vector (8);
   for (i = 0; i < 8; i++)
     ASET (val, i, make_number (code_space[i]));
   args[charset_arg_code_space] = val;
diff --git a/src/charset.h b/src/charset.h
index b5fa36290c8..d9a5662e520 100644
--- a/src/charset.h
+++ b/src/charset.h
@@ -1,5 +1,5 @@
 /* Header for charset handler.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
diff --git a/src/cm.c b/src/cm.c
index eda6430bafa..3a5f927eda3 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -1,5 +1,5 @@
 /* Cursor motion subroutines for GNU Emacs.
-   Copyright (C) 1985, 1995, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1995, 2001-2013 Free Software Foundation, Inc.
     based primarily on public domain code written by Chris Torek
 
 This file is part of GNU Emacs.
@@ -28,8 +28,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "termchar.h"
 #include "tparam.h"
 
-#define BIG     9999            /* 9999 good on VAXen.  For 16 bit machines
-                                   use about 2000.... */
+#define BIG     9999            /* Good on 32-bit hosts.  */
 
 int cost;               /* sums up costs */
 
diff --git a/src/cm.h b/src/cm.h
index e3e2b71dba6..6d49dda9419 100644
--- a/src/cm.h
+++ b/src/cm.h
@@ -1,5 +1,5 @@
 /* Cursor motion calculation definitions for GNU Emacs
-   Copyright (C) 1985, 1989, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1989, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/cmds.c b/src/cmds.c
index 453a4b67e57..3ebad50184a 100644
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -1,6 +1,6 @@
 /* Simple built-in editing commands.
 
-Copyright (C) 1985, 1993-1998, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1985, 1993-1998, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/coding.c b/src/coding.c
index 56202e4861d..868fb7df0ea 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -1,5 +1,5 @@
 /* Coding system handler (conversion, detection, etc).
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
@@ -302,6 +302,7 @@ Lisp_Object Vcoding_system_hash_table;
 static Lisp_Object Qcoding_system, Qeol_type;
 static Lisp_Object Qcoding_aliases;
 Lisp_Object Qunix, Qdos;
+static Lisp_Object Qmac;
 Lisp_Object Qbuffer_file_coding_system;
 static Lisp_Object Qpost_read_conversion, Qpre_write_conversion;
 static Lisp_Object Qdefault_char;
@@ -1048,14 +1049,7 @@ coding_alloc_by_making_gap (struct coding_system *coding,
       GPT -= gap_head_used, GPT_BYTE -= gap_head_used;
     }
   else
-    {
-      Lisp_Object this_buffer;
-
-      this_buffer = Fcurrent_buffer ();
-      set_buffer_internal (XBUFFER (coding->dst_object));
-      make_gap (bytes);
-      set_buffer_internal (XBUFFER (this_buffer));
-    }
+    make_gap_1 (XBUFFER (coding->dst_object), bytes);
 }
 
 
@@ -3063,20 +3057,7 @@ detect_coding_iso_2022 (struct coding_system *coding,
             }
           if (single_shifting)
             break;
-        check_extra_latin:
-          if (! VECTORP (Vlatin_extra_code_table)
-              || NILP (AREF (Vlatin_extra_code_table, c)))
-            {
-              rejected = CATEGORY_MASK_ISO;
-              break;
-            }
-          if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
-              & CODING_ISO_FLAG_LATIN_EXTRA)
-            found |= CATEGORY_MASK_ISO_8_1;
-          else
-            rejected |= CATEGORY_MASK_ISO_8_1;
-          rejected |= CATEGORY_MASK_ISO_8_2;
-          break;
+          goto check_extra_latin;
 
         default:
           if (c < 0)
@@ -3127,6 +3108,20 @@ detect_coding_iso_2022 (struct coding_system *coding,
                 }
               break;
             }
+        check_extra_latin:
+          if (! VECTORP (Vlatin_extra_code_table)
+              || NILP (AREF (Vlatin_extra_code_table, c)))
+            {
+              rejected = CATEGORY_MASK_ISO;
+              break;
+            }
+          if (CODING_ISO_FLAGS (&coding_categories[coding_category_iso_8_1])
+              & CODING_ISO_FLAG_LATIN_EXTRA)
+            found |= CATEGORY_MASK_ISO_8_1;
+          else
+            rejected |= CATEGORY_MASK_ISO_8_1;
+          rejected |= CATEGORY_MASK_ISO_8_2;
+          break;
         }
     }
   detect_info->rejected |= CATEGORY_MASK_ISO;
@@ -8426,9 +8421,6 @@ highest priority.  */)
   ptrdiff_t from, to;
   ptrdiff_t from_byte, to_byte;
 
-  CHECK_NUMBER_COERCE_MARKER (start);
-  CHECK_NUMBER_COERCE_MARKER (end);
-
   validate_region (&start, &end);
   from = XINT (start), to = XINT (end);
   from_byte = CHAR_TO_BYTE (from);
@@ -8872,8 +8864,6 @@ code_convert_region (Lisp_Object start, Lisp_Object end,
   ptrdiff_t from, from_byte, to, to_byte;
   Lisp_Object src_object;
 
-  CHECK_NUMBER_COERCE_MARKER (start);
-  CHECK_NUMBER_COERCE_MARKER (end);
   if (NILP (coding_system))
     coding_system = Qno_conversion;
   else
@@ -9493,7 +9483,7 @@ make_subsidiaries (Lisp_Object base)
   int i;
 
   memcpy (buf, SDATA (SYMBOL_NAME (base)), base_name_len);
-  subsidiaries = Fmake_vector (make_number (3), Qnil);
+  subsidiaries = make_uninit_vector (3);
   for (i = 0; i < 3; i++)
     {
       strcpy (buf + base_name_len, suffixes[i]);
@@ -9793,7 +9783,7 @@ usage: (define-coding-system-internal ...)  */)
       CHECK_VECTOR (initial);
       for (i = 0; i < 4; i++)
         {
-          val = Faref (initial, make_number (i));
+          val = AREF (initial, i);
           if (! NILP (val))
             {
               struct charset *charset;
@@ -9998,7 +9988,8 @@ usage: (define-coding-system-internal ...)  */)
           this_name = AREF (eol_type, i);
           this_aliases = Fcons (this_name, Qnil);
           this_eol_type = (i == 0 ? Qunix : i == 1 ? Qdos : Qmac);
-          this_spec = Fmake_vector (make_number (3), attrs);
+          this_spec = make_uninit_vector (3);
+          ASET (this_spec, 0, attrs);
           ASET (this_spec, 1, this_aliases);
           ASET (this_spec, 2, this_eol_type);
           Fputhash (this_name, this_spec, Vcoding_system_hash_table);
@@ -10011,7 +10002,8 @@ usage: (define-coding-system-internal ...)  */)
         }
     }
 
-  spec_vec = Fmake_vector (make_number (3), attrs);
+  spec_vec = make_uninit_vector (3);
+  ASET (spec_vec, 0, attrs);
   ASET (spec_vec, 1, aliases);
   ASET (spec_vec, 2, eol_type);
 
@@ -10308,6 +10300,7 @@ syms_of_coding (void)
   DEFSYM (Qeol_type, "eol-type");
   DEFSYM (Qunix, "unix");
   DEFSYM (Qdos, "dos");
+  DEFSYM (Qmac, "mac");
 
   DEFSYM (Qbuffer_file_coding_system, "buffer-file-coding-system");
   DEFSYM (Qpost_read_conversion, "post-read-conversion");
@@ -10719,7 +10712,7 @@ reading if you suppress escape sequence detection.
 
 The other way to read escape sequences in a file without decoding is
 to explicitly specify some coding system that doesn't use ISO-2022
-escape sequence (e.g `latin-1') on reading by \\[universal-coding-system-argument].  */);
+escape sequence (e.g., `latin-1') on reading by \\[universal-coding-system-argument].  */);
   inhibit_iso_escape_detection = 0;
 
   DEFVAR_BOOL ("inhibit-null-byte-detection",
diff --git a/src/coding.h b/src/coding.h
index 192be58f083..eb95fa13ddb 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -1,5 +1,5 @@
 /* Header for coding system handler.
-   Copyright (C) 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
@@ -767,7 +767,7 @@ extern Lisp_Object Qcoding_system_p;
 extern Lisp_Object Qraw_text, Qemacs_mule, Qno_conversion, Qundecided;
 extern Lisp_Object Qbuffer_file_coding_system;
 
-extern Lisp_Object Qunix, Qdos, Qmac;
+extern Lisp_Object Qunix, Qdos;
 
 extern Lisp_Object Qtranslation_table;
 extern Lisp_Object Qtranslation_table_id;
diff --git a/src/commands.h b/src/commands.h
index 510fce0e182..35c2c05fe72 100644
--- a/src/commands.h
+++ b/src/commands.h
@@ -1,5 +1,5 @@
 /* Definitions needed by most editing commands.
-   Copyright (C) 1985, 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/composite.c b/src/composite.c
index bcde0a4c9e6..2da98cfc36c 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -1,5 +1,5 @@
 /* Composite sequence support.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H14PRO021
@@ -642,13 +642,7 @@ compose_text (ptrdiff_t start, ptrdiff_t end, Lisp_Object components,
                        Qcomposition, prop, string);
 }
 
-
-static Lisp_Object autocmp_chars (Lisp_Object, ptrdiff_t, ptrdiff_t,
-                                  ptrdiff_t, struct window *,
-                                  struct face *, Lisp_Object);
-
-
-/* Lisp glyph-string handlers */
+/* Lisp glyph-string handlers.  */
 
 /* Hash table for automatic composition.  The key is a header of a
    lgstring (Lispy glyph-string), and the value is a body of a
@@ -704,10 +698,6 @@ composition_gstring_from_id (ptrdiff_t id)
   return HASH_VALUE (h, id);
 }
 
-static Lisp_Object fill_gstring_header (Lisp_Object, Lisp_Object,
-                                        Lisp_Object, Lisp_Object,
-                                        Lisp_Object);
-
 bool
 composition_gstring_p (Lisp_Object gstring)
 {
@@ -797,7 +787,8 @@ static Lisp_Object gstring_work;
 static Lisp_Object gstring_work_headers;
 
 static Lisp_Object
-fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end, Lisp_Object font_object, Lisp_Object string)
+fill_gstring_header (Lisp_Object header, Lisp_Object start, Lisp_Object end,
+                     Lisp_Object font_object, Lisp_Object string)
 {
   ptrdiff_t from, to, from_byte;
   ptrdiff_t len, i;
@@ -905,7 +896,9 @@ fill_gstring_body (Lisp_Object gstring)
    object.  Otherwise return nil.  */
 
 static Lisp_Object
-autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t limit, struct window *win, struct face *face, Lisp_Object string)
+autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos,
+               ptrdiff_t limit, struct window *win, struct face *face,
+               Lisp_Object string)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
   FRAME_PTR f = XFRAME (win->frame);
@@ -935,7 +928,7 @@ autocmp_chars (Lisp_Object rule, ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t
 #ifdef HAVE_WINDOW_SYSTEM
   if (FRAME_WINDOW_P (f))
     {
-      font_object = font_range (charpos, &to, win, face, string);
+      font_object = font_range (charpos, bytepos, &to, win, face, string);
       if (! FONT_OBJECT_P (font_object)
           || (! NILP (re)
               && to < limit
@@ -1958,7 +1951,7 @@ syms_of_composite (void)
   }
 
   staticpro (&gstring_work_headers);
-  gstring_work_headers = Fmake_vector (make_number (8), Qnil);
+  gstring_work_headers = make_uninit_vector (8);
   for (i = 0; i < 8; i++)
     ASET (gstring_work_headers, i, Fmake_vector (make_number (i + 2), Qnil));
   staticpro (&gstring_work);
diff --git a/src/composite.h b/src/composite.h
index 9462b932c66..603291044bc 100644
--- a/src/composite.h
+++ b/src/composite.h
@@ -1,5 +1,5 @@
 /* Header for composite sequence handler.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H14PRO021
diff --git a/src/conf_post.h b/src/conf_post.h
index b1997e79081..6c9747a436c 100644
--- a/src/conf_post.h
+++ b/src/conf_post.h
@@ -1,7 +1,7 @@
 /* conf_post.h --- configure.ac includes this via AH_BOTTOM
 
-Copyright (C) 1988, 1993-1994, 1999-2002, 2004-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1988, 1993-1994, 1999-2002, 2004-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -40,6 +40,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 #endif
 
+#ifndef __has_attribute
+# define __has_attribute(a) 0 /* non-clang */
+#endif
+
 /* This silences a few compilation warnings on FreeBSD.  */
 #ifdef BSD_SYSTEM_AHB
 #undef BSD_SYSTEM_AHB
@@ -178,10 +182,6 @@ extern void _DebPrint (const char *fmt, ...);
 #endif
 #endif
 
-/* Tell gnulib to omit support for openat-related functions having a
-   first argument other than AT_FDCWD.  */
-#define GNULIB_SUPPORT_ONLY_AT_FDCWD
-
 #include <string.h>
 #include <stdlib.h>
 
@@ -191,7 +191,9 @@ extern void _DebPrint (const char *fmt, ...);
 #define NO_INLINE
 #endif
 
-#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1))
+#if (__clang__                                                          \
+     ? __has_attribute (externally_visible)                             \
+     : (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 1)))
 #define EXTERNALLY_VISIBLE __attribute__((externally_visible))
 #else
 #define EXTERNALLY_VISIBLE
diff --git a/src/cygw32.c b/src/cygw32.c
index d9777d5e22e..a7dbdaed615 100644
--- a/src/cygw32.c
+++ b/src/cygw32.c
@@ -1,5 +1,5 @@
 /* Cygwin support routines.
-   Copyright (C) 2011-2012  Free Software Foundation, Inc.
+   Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -110,23 +110,25 @@ DEFUN ("cygwin-convert-file-name-to-windows",
        Fcygwin_convert_file_name_to_windows,
        Scygwin_convert_file_name_to_windows,
        1, 2, 0,
-       doc: /* Convert PATH to a Windows path.  If ABSOLUTE-P is
-non-nil, return an absolute path.*/)
-  (Lisp_Object path, Lisp_Object absolute_p)
+       doc: /* Convert a Cygwin file name FILE to a Windows-style file name.
+If ABSOLUTE-P is non-nil, return an absolute file name.
+For the reverse operation, see `cygwin-convert-file-name-from-windows'.  */)
+  (Lisp_Object file, Lisp_Object absolute_p)
 {
   return from_unicode (
-    conv_filename_to_w32_unicode (path, EQ (absolute_p, Qnil) ? 0 : 1));
+    conv_filename_to_w32_unicode (file, EQ (absolute_p, Qnil) ? 0 : 1));
 }
 
 DEFUN ("cygwin-convert-file-name-from-windows",
        Fcygwin_convert_file_name_from_windows,
        Scygwin_convert_file_name_from_windows,
        1, 2, 0,
-       doc: /* Convert a Windows path to a Cygwin path.  If ABSOLUTE-P
-is non-nil, return an absolute path.*/)
-  (Lisp_Object path, Lisp_Object absolute_p)
+       doc: /* Convert a Windows-style file name FILE to a Cygwin file name.
+If ABSOLUTE-P is non-nil, return an absolute file name.
+For the reverse operation, see `cygwin-convert-file-name-to-windows'.  */)
+  (Lisp_Object file, Lisp_Object absolute_p)
 {
-  return conv_filename_from_w32_unicode (to_unicode (path, &path),
+  return conv_filename_from_w32_unicode (to_unicode (file, &file),
                                          EQ (absolute_p, Qnil) ? 0 : 1);
 }
 
diff --git a/src/cygw32.h b/src/cygw32.h
index 51571913fd1..5c7066f26d1 100644
--- a/src/cygw32.h
+++ b/src/cygw32.h
@@ -1,5 +1,5 @@
 /* Header for Cygwin support routines.
-   Copyright (C) 2011-2012  Free Software Foundation, Inc.
+   Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/data.c b/src/data.c
index a72fa3e2b5f..6622088b648 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1,6 +1,6 @@
 /* Primitive operations on Lisp data types for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -583,7 +583,7 @@ DEFUN ("symbol-function", Fsymbol_function, Ssymbol_function, 1, 1, 0,
   (register Lisp_Object symbol)
 {
   CHECK_SYMBOL (symbol);
-    return XSYMBOL (symbol)->function;
+  return XSYMBOL (symbol)->function;
 }
 
 DEFUN ("symbol-plist", Fsymbol_plist, Ssymbol_plist, 1, 1, 0,
@@ -914,13 +914,11 @@ store_symval_forwarding (union Lisp_Fwd *valcontents, register Lisp_Object newva
     case Lisp_Fwd_Buffer_Obj:
       {
         int offset = XBUFFER_OBJFWD (valcontents)->offset;
-        Lisp_Object type = XBUFFER_OBJFWD (valcontents)->slottype;
+        Lisp_Object predicate = XBUFFER_OBJFWD (valcontents)->predicate;
 
-        if (!(NILP (type) || NILP (newval)
-              || (XINT (type) == Lisp_Int0
-                  ? INTEGERP (newval)
-                  : XTYPE (newval) == XINT (type))))
-          buffer_slot_type_mismatch (newval, XINT (type));
+        if (!NILP (predicate) && !NILP (newval)
+            && NILP (call1 (predicate, newval)))
+          wrong_type_argument (predicate, newval);
 
         if (buf == NULL)
           buf = current_buffer;
diff --git a/src/dbusbind.c b/src/dbusbind.c
index da8bbb1e5d7..863f7634eb5 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -1,5 +1,5 @@
 /* Elisp bindings for D-Bus.
-   Copyright (C) 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2007-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/deps.mk b/src/deps.mk
index c7316a24dad..47185c9262c 100644
--- a/src/deps.mk
+++ b/src/deps.mk
@@ -1,7 +1,7 @@
 ### deps.mk --- src/Makefile fragment for GNU Emacs
 
-## Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2012
-##   Free Software Foundation, Inc.
+## Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2013 Free Software
+## Foundation, Inc.
 
 ## This file is part of GNU Emacs.
 
@@ -128,6 +128,7 @@ image.o: image.c frame.h window.h dispextern.h blockinput.h atimer.h \
 indent.o: indent.c frame.h window.h indent.h buffer.h lisp.h $(config_h) \
    termchar.h termopts.h disptab.h region-cache.h character.h category.h \
    keyboard.h systime.h coding.h $(INTERVALS_H) globals.h
+inotify.o: inotify.c lisp.h coding.h process.h keyboard.h frame.h termhooks.h
 insdel.o: insdel.c window.h buffer.h $(INTERVALS_H) blockinput.h character.h \
    atimer.h systime.h region-cache.h lisp.h globals.h $(config_h)
 keyboard.o: keyboard.c termchar.h termhooks.h termopts.h buffer.h character.h \
diff --git a/src/dired.c b/src/dired.c
index bdb71c46364..0e37568f211 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -1,5 +1,6 @@
 /* Lisp functions for making directory listings.
-   Copyright (C) 1985-1986, 1993-1994, 1999-2012 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1993-1994, 1999-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -29,6 +30,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <grp.h>
 
 #include <errno.h>
+#include <fcntl.h>
 #include <unistd.h>
 
 #include <dirent.h>
@@ -53,6 +55,7 @@ static Lisp_Object Qfile_attributes;
 static Lisp_Object Qfile_attributes_lessp;
 
 static ptrdiff_t scmp (const char *, const char *, ptrdiff_t);
+static Lisp_Object file_attributes (int, char const *, Lisp_Object);
 
 /* Return the number of bytes in DP's name.  */
 static ptrdiff_t
@@ -65,6 +68,44 @@ dirent_namelen (struct dirent *dp)
 #endif
 }
 
+static DIR *
+open_directory (char const *name, int *fdp)
+{
+  DIR *d;
+  int fd, opendir_errno;
+
+  block_input ();
+
+#ifdef DOS_NT
+  /* Directories cannot be opened.  The emulation assumes that any
+     file descriptor other than AT_FDCWD corresponds to the most
+     recently opened directory.  This hack is good enough for Emacs.  */
+  fd = 0;
+  d = opendir (name);
+  opendir_errno = errno;
+#else
+  fd = emacs_open (name, O_RDONLY | O_DIRECTORY, 0);
+  if (fd < 0)
+    {
+      opendir_errno = errno;
+      d = 0;
+    }
+  else
+    {
+      d = fdopendir (fd);
+      opendir_errno = errno;
+      if (! d)
+        close (fd);
+    }
+#endif
+
+  unblock_input ();
+
+  *fdp = fd;
+  errno = opendir_errno;
+  return d;
+}
+
 #ifdef WINDOWSNT
 Lisp_Object
 directory_files_internal_w32_unwind (Lisp_Object arg)
@@ -77,7 +118,7 @@ directory_files_internal_w32_unwind (Lisp_Object arg)
 static Lisp_Object
 directory_files_internal_unwind (Lisp_Object dh)
 {
-  DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
+  DIR *d = XSAVE_POINTER (dh, 0);
   block_input ();
   closedir (d);
   unblock_input ();
@@ -95,6 +136,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
                           Lisp_Object id_format)
 {
   DIR *d;
+  int fd;
   ptrdiff_t directory_nbytes;
   Lisp_Object list, dirfilename, encoded_directory;
   struct re_pattern_buffer *bufp = NULL;
@@ -141,9 +183,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
   /* Now *bufp is the compiled form of MATCH; don't call anything
      which might compile a new regexp until we're done with the loop!  */
 
-  block_input ();
-  d = opendir (SSDATA (dirfilename));
-  unblock_input ();
+  d = open_directory (SSDATA (dirfilename), &fd);
   if (d == NULL)
     report_file_error ("Opening directory", Fcons (directory, Qnil));
 
@@ -151,7 +191,7 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
      file-attributes on filenames, both of which can throw, so we must
      do a proper unwind-protect.  */
   record_unwind_protect (directory_files_internal_unwind,
-                         make_save_value (d, 0));
+                         make_save_pointer (d));
 
 #ifdef WINDOWSNT
   if (attrs)
@@ -258,20 +298,9 @@ directory_files_internal (Lisp_Object directory, Lisp_Object full,
 
           if (attrs)
             {
-              /* Construct an expanded filename for the directory entry.
-                 Use the decoded names for input to Ffile_attributes.  */
-              Lisp_Object decoded_fullname, fileattrs;
-              struct gcpro gcpro1, gcpro2;
-
-              decoded_fullname = fileattrs = Qnil;
-              GCPRO2 (decoded_fullname, fileattrs);
-
-              /* Both Fexpand_file_name and Ffile_attributes can GC.  */
-              decoded_fullname = Fexpand_file_name (name, directory);
-              fileattrs = Ffile_attributes (decoded_fullname, id_format);
-
+              Lisp_Object fileattrs
+                = file_attributes (fd, dp->d_name, id_format);
               list = Fcons (Fcons (finalname, fileattrs), list);
-              UNGCPRO;
             }
           else
             list = Fcons (finalname, list);
@@ -412,8 +441,7 @@ These are all file names in directory DIRECTORY which begin with FILE.  */)
   return file_name_completion (file, directory, 1, Qnil);
 }
 
-static int file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
-                                      struct stat *st_addr);
+static int file_name_completion_stat (int, struct dirent *, struct stat *);
 static Lisp_Object Qdefault_directory;
 
 static Lisp_Object
@@ -421,6 +449,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                       Lisp_Object predicate)
 {
   DIR *d;
+  int fd;
   ptrdiff_t bestmatchsize = 0;
   int matchcount = 0;
   /* If ALL_FLAG is 1, BESTMATCH is the list of all matches, decoded.
@@ -455,16 +484,14 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
      on the encoded file name.  */
   encoded_file = STRING_MULTIBYTE (file) ? ENCODE_FILE (file) : file;
 
-  encoded_dir = ENCODE_FILE (dirname);
+  encoded_dir = ENCODE_FILE (Fdirectory_file_name (dirname));
 
-  block_input ();
-  d = opendir (SSDATA (Fdirectory_file_name (encoded_dir)));
-  unblock_input ();
+  d = open_directory (SSDATA (encoded_dir), &fd);
   if (!d)
     report_file_error ("Opening directory", Fcons (dirname, Qnil));
 
   record_unwind_protect (directory_files_internal_unwind,
-                         make_save_value (d, 0));
+                         make_save_pointer (d));
 
   /* Loop reading blocks */
   /* (att3b compiler bug requires do a null comparison this way) */
@@ -494,7 +521,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                         SCHARS (encoded_file)))
         continue;
 
-      if (file_name_completion_stat (encoded_dir, dp, &st) < 0)
+      if (file_name_completion_stat (fd, dp, &st) < 0)
         continue;
 
       directoryp = S_ISDIR (st.st_mode) != 0;
@@ -671,10 +698,7 @@ file_name_completion (Lisp_Object file, Lisp_Object dirname, bool all_flag,
                                 name, zero,
                                 make_number (compare),
                                 completion_ignore_case ? Qt : Qnil);
-          ptrdiff_t matchsize
-            = (EQ (cmp, Qt)     ? compare
-               : XINT (cmp) < 0 ? - XINT (cmp) - 1
-               :                  XINT (cmp) - 1);
+          ptrdiff_t matchsize = EQ (cmp, Qt) ? compare : eabs (XINT (cmp)) - 1;
 
           if (completion_ignore_case)
             {
@@ -774,14 +798,9 @@ scmp (const char *s1, const char *s2, ptrdiff_t len)
 }
 
 static int
-file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
-                           struct stat *st_addr)
+file_name_completion_stat (int fd, struct dirent *dp, struct stat *st_addr)
 {
-  ptrdiff_t len = dirent_namelen (dp);
-  ptrdiff_t pos = SCHARS (dirname);
   int value;
-  USE_SAFE_ALLOCA;
-  char *fullname = SAFE_ALLOCA (len + pos + 2);
 
 #ifdef MSDOS
   /* Some fields of struct stat are *very* expensive to compute on MS-DOS,
@@ -794,23 +813,15 @@ file_name_completion_stat (Lisp_Object dirname, struct dirent *dp,
   _djstat_flags = _STAT_INODE | _STAT_EXEC_MAGIC | _STAT_DIRSIZE;
 #endif /* MSDOS */
 
-  memcpy (fullname, SDATA (dirname), pos);
-  if (!IS_DIRECTORY_SEP (fullname[pos - 1]))
-    fullname[pos++] = DIRECTORY_SEP;
-
-  memcpy (fullname + pos, dp->d_name, len);
-  fullname[pos + len] = 0;
-
   /* We want to return success if a link points to a nonexistent file,
      but we want to return the status for what the link points to,
      in case it is a directory.  */
-  value = lstat (fullname, st_addr);
+  value = fstatat (fd, dp->d_name, st_addr, AT_SYMLINK_NOFOLLOW);
   if (value == 0 && S_ISLNK (st_addr->st_mode))
-    stat (fullname, st_addr);
+    fstatat (fd, dp->d_name, st_addr, 0);
 #ifdef MSDOS
   _djstat_flags = save_djstat_flags;
 #endif /* MSDOS */
-  SAFE_FREE ();
   return value;
 }
 
@@ -869,7 +880,7 @@ Elements of the attribute list are:
  7. Size in bytes.
   This is a floating point number if the size is too large for an integer.
  8. File modes, as a string of ten letters or dashes as in ls -l.
- 9. t if file's gid would change if file were deleted and recreated.
+ 9. An unspecified value, present only for backward compatibility.
 10. inode number.  If it is larger than what an Emacs integer can hold,
   this is of the form (HIGH . LOW): first the high bits, then the low 16 bits.
   If even HIGH is too large for an Emacs integer, this is instead of the form
@@ -888,21 +899,8 @@ On some FAT-based filesystems, only the date of last access is recorded,
 so last access time will always be midnight of that day.  */)
   (Lisp_Object filename, Lisp_Object id_format)
 {
-  Lisp_Object values[12];
   Lisp_Object encoded;
-  struct stat s;
-#ifdef BSD4_2
-  Lisp_Object dirname;
-  struct stat sdir;
-#endif /* BSD4_2 */
-
-  /* An array to hold the mode string generated by filemodestring,
-     including its terminating space and null byte.  */
-  char modes[sizeof "-rwxr-xr-x "];
-
   Lisp_Object handler;
-  struct gcpro gcpro1;
-  char *uname = NULL, *gname = NULL;
 
   filename = Fexpand_file_name (filename, Qnil);
 
@@ -918,14 +916,41 @@ so last access time will always be midnight of that day.  */)
         return call3 (handler, Qfile_attributes, filename, id_format);
     }
 
-  GCPRO1 (filename);
   encoded = ENCODE_FILE (filename);
-  UNGCPRO;
+  return file_attributes (AT_FDCWD, SSDATA (encoded), id_format);
+}
+
+static Lisp_Object
+file_attributes (int fd, char const *name, Lisp_Object id_format)
+{
+  Lisp_Object values[12];
+  struct stat s;
+  int lstat_result;
+
+  /* An array to hold the mode string generated by filemodestring,
+     including its terminating space and null byte.  */
+  char modes[sizeof "-rwxr-xr-x "];
+
+  char *uname = NULL, *gname = NULL;
+
+#ifdef WINDOWSNT
+  /* We usually don't request accurate owner and group info, because
+     it can be very expensive on Windows to get that, and most callers
+     of 'lstat' don't need that.  But here we do want that information
+     to be accurate.  */
+  w32_stat_get_owner_group = 1;
+#endif
+
+  lstat_result = fstatat (fd, name, &s, AT_SYMLINK_NOFOLLOW);
+
+#ifdef WINDOWSNT
+  w32_stat_get_owner_group = 0;
+#endif
 
-  if (lstat (SSDATA (encoded), &s) < 0)
+  if (lstat_result < 0)
     return Qnil;
 
-  values[0] = (S_ISLNK (s.st_mode) ? Ffile_symlink_p (filename)
+  values[0] = (S_ISLNK (s.st_mode) ? emacs_readlinkat (fd, name)
                : S_ISDIR (s.st_mode) ? Qt : Qnil);
   values[1] = make_number (s.st_nlink);
 
@@ -959,17 +984,7 @@ so last access time will always be midnight of that day.  */)
 
   filemodestring (&s, modes);
   values[8] = make_string (modes, 10);
-#ifdef BSD4_2 /* file gid will be dir gid */
-  dirname = Ffile_name_directory (filename);
-  if (! NILP (dirname))
-    encoded = ENCODE_FILE (dirname);
-  if (! NILP (dirname) && stat (SDATA (encoded), &sdir) == 0)
-    values[9] = (sdir.st_gid != s.st_gid) ? Qt : Qnil;
-  else                                  /* if we can't tell, assume worst */
-    values[9] = Qt;
-#else                                   /* file gid will be egid */
-  values[9] = (s.st_gid != getegid ()) ? Qt : Qnil;
-#endif  /* not BSD4_2 */
+  values[9] = Qt;
   values[10] = INTEGER_TO_CONS (s.st_ino);
   values[11] = INTEGER_TO_CONS (s.st_dev);
 
diff --git a/src/dispextern.h b/src/dispextern.h
index aa40f019fbe..46878745c07 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -1,6 +1,6 @@
 /* Interface definitions for display code.
 
-Copyright (C) 1985, 1993-1994, 1997-2012  Free Software Foundation, Inc.
+Copyright (C) 1985, 1993-1994, 1997-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -317,13 +317,18 @@ struct glyph
      Lisp string, this is a position in that string.  If it is a
      buffer, this is a position in that buffer.  A value of -1
      together with a null object means glyph is a truncation glyph at
-     the start of a row.  */
+     the start of a row.  Right truncation and continuation glyphs at
+     the right edge of a row have their position set to the next
+     buffer position that is not shown on this row.  Glyphs inserted
+     by redisplay, such as the empty space after the end of a line on
+     TTYs, or the overlay-arrow on a TTY, have this set to -1.  */
   ptrdiff_t charpos;
 
-  /* Lisp object source of this glyph.  Currently either a buffer or
-     a string, if the glyph was produced from characters which came from
+  /* Lisp object source of this glyph.  Currently either a buffer or a
+     string, if the glyph was produced from characters which came from
      a buffer or a string; or 0 if the glyph was inserted by redisplay
-     for its own purposes such as padding.  */
+     for its own purposes, such as padding or truncation/continuation
+     glyphs, or the overlay-arrow glyphs on TTYs.  */
   Lisp_Object object;
 
   /* Width in pixels.  */
diff --git a/src/dispnew.c b/src/dispnew.c
index 675c06c22e9..f9fed7de406 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1,6 +1,7 @@
 /* Updating of data structures for redisplay.
 
-Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -86,7 +87,6 @@ static void build_frame_matrix_from_window_tree (struct glyph_matrix *,
                                                  struct window *);
 static void build_frame_matrix_from_leaf_window (struct glyph_matrix *,
                                                  struct window *);
-static void adjust_frame_message_buffer (struct frame *);
 static void adjust_decode_mode_spec_buffer (struct frame *);
 static void fill_up_glyph_row_with_spaces (struct glyph_row *);
 static void clear_window_matrices (struct window *, bool);
@@ -107,12 +107,6 @@ static void set_window_cursor_after_update (struct window *);
 static void adjust_frame_glyphs_for_window_redisplay (struct frame *);
 static void adjust_frame_glyphs_for_frame_redisplay (struct frame *);
 
-
-/* Redisplay preemption timers.  */
-
-static EMACS_TIME preemption_period;
-static EMACS_TIME preemption_next_check;
-
 /* True upon entry to redisplay means do not assume anything about
    current contents of actual terminal frame; clear and redraw it.  */
 
@@ -606,7 +600,7 @@ adjust_glyph_matrix (struct window *w, struct glyph_matrix *matrix, int x, int y
                  are invalidated below.  */
               if (INTEGERP (w->window_end_vpos)
                   && XFASTINT (w->window_end_vpos) >= i)
-                wset_window_end_valid (w, Qnil);
+                w->window_end_valid = 0;
 
               while (i < matrix->nrows)
                 matrix->rows[i++].enabled_p = 0;
@@ -861,7 +855,7 @@ clear_window_matrices (struct window *w, bool desired_p)
           else
             {
               clear_glyph_matrix (w->current_matrix);
-              wset_window_end_valid (w, Qnil);
+              w->window_end_valid = 0;
             }
         }
 
@@ -1856,9 +1850,7 @@ adjust_frame_glyphs (struct frame *f)
   else
     adjust_frame_glyphs_for_frame_redisplay (f);
 
-  /* Don't forget the message buffer and the buffer for
-     decode_mode_spec.  */
-  adjust_frame_message_buffer (f);
+  /* Don't forget the buffer for decode_mode_spec.  */
   adjust_decode_mode_spec_buffer (f);
 
   f->glyphs_initialized_p = 1;
@@ -2158,23 +2150,6 @@ adjust_frame_glyphs_for_window_redisplay (struct frame *f)
 }
 
 
-/* Adjust/ allocate message buffer of frame F.
-
-   Note that the message buffer is never freed.  Since I could not
-   find a free in 19.34, I assume that freeing it would be
-   problematic in some way and don't do it either.
-
-   (Implementation note: It should be checked if we can free it
-   eventually without causing trouble).  */
-
-static void
-adjust_frame_message_buffer (struct frame *f)
-{
-  FRAME_MESSAGE_BUF (f) = xrealloc (FRAME_MESSAGE_BUF (f),
-                                    FRAME_MESSAGE_BUF_SIZE (f) + 1);
-}
-
-
 /* Re-allocate buffer for decode_mode_spec on frame F.  */
 
 static void
@@ -3099,21 +3074,10 @@ update_frame (struct frame *f, bool force_p, bool inhibit_hairy_id_p)
 
   if (redisplay_dont_pause)
     force_p = 1;
-  else if (NILP (Vredisplay_preemption_period))
-    force_p = 1;
-  else if (!force_p && NUMBERP (Vredisplay_preemption_period))
+  else if (!force_p && detect_input_pending_ignore_squeezables ())
     {
-      double p = XFLOATINT (Vredisplay_preemption_period);
-
-      if (detect_input_pending_ignore_squeezables ())
-        {
-          paused_p = 1;
-          goto do_pause;
-        }
-
-      preemption_period = EMACS_TIME_FROM_DOUBLE (p);
-      preemption_next_check = add_emacs_time (current_emacs_time (),
-                                              preemption_period);
+      paused_p = 1;
+      goto do_pause;
     }
 
   if (FRAME_WINDOW_P (f))
@@ -3251,15 +3215,6 @@ update_single_window (struct window *w, bool force_p)
 
       if (redisplay_dont_pause)
         force_p = 1;
-      else if (NILP (Vredisplay_preemption_period))
-        force_p = 1;
-      else if (!force_p && NUMBERP (Vredisplay_preemption_period))
-        {
-          double p = XFLOATINT (Vredisplay_preemption_period);
-          preemption_period = EMACS_TIME_FROM_DOUBLE (p);
-          preemption_next_check = add_emacs_time (current_emacs_time (),
-                                                  preemption_period);
-        }
 
       /* Update W.  */
       update_begin (f);
@@ -3413,9 +3368,7 @@ update_window (struct window *w, bool force_p)
 {
   struct glyph_matrix *desired_matrix = w->desired_matrix;
   bool paused_p;
-#if !PERIODIC_PREEMPTION_CHECKING
   int preempt_count = baud_rate / 2400 + 1;
-#endif
   struct redisplay_interface *rif = FRAME_RIF (XFRAME (WINDOW_FRAME (w)));
 #ifdef GLYPH_DEBUG
   /* Check that W's frame doesn't have glyph matrices.  */
@@ -3423,10 +3376,8 @@ update_window (struct window *w, bool force_p)
 #endif
 
   /* Check pending input the first time so that we can quickly return.  */
-#if !PERIODIC_PREEMPTION_CHECKING
   if (!force_p)
     detect_input_pending_ignore_squeezables ();
-#endif
 
   /* If forced to complete the update, or if no input is pending, do
      the update.  */
@@ -3437,9 +3388,7 @@ update_window (struct window *w, bool force_p)
       struct glyph_row *header_line_row;
       int yb;
       bool changed_p = 0, mouse_face_overwritten_p = 0;
-#if ! PERIODIC_PREEMPTION_CHECKING
       int n_updated = 0;
-#endif
 
       rif->update_window_begin_hook (w);
       yb = window_text_bottom_y (w);
@@ -3503,22 +3452,8 @@ update_window (struct window *w, bool force_p)
                detect_input_pending.  If it's done too often,
                scrolling large windows with repeated scroll-up
                commands will too quickly pause redisplay.  */
-#if PERIODIC_PREEMPTION_CHECKING
-            if (!force_p)
-              {
-                EMACS_TIME tm = current_emacs_time ();
-                if (EMACS_TIME_LT (preemption_next_check, tm))
-                  {
-                    preemption_next_check = add_emacs_time (tm,
-                                                            preemption_period);
-                    if (detect_input_pending_ignore_squeezables ())
-                      break;
-                  }
-              }
-#else
             if (!force_p && ++n_updated % preempt_count == 0)
               detect_input_pending_ignore_squeezables ();
-#endif
             changed_p |= update_window_line (w, vpos,
                                              &mouse_face_overwritten_p);
 
@@ -4016,11 +3951,10 @@ set_window_cursor_after_update (struct window *w)
       vpos = w->cursor.vpos;
     }
 
-  /* Window cursor can be out of sync for horizontally split windows.  */
-  hpos = max (-1, hpos); /* -1 is for when cursor is on the left fringe */
-  hpos = min (w->current_matrix->matrix_w - 1, hpos);
-  vpos = max (0, vpos);
-  vpos = min (w->current_matrix->nrows - 1, vpos);
+  /* Window cursor can be out of sync for horizontally split windows.
+     Horizontal position is -1 when cursor is on the left fringe.   */
+  hpos = clip_to_bounds (-1, hpos, w->current_matrix->matrix_w - 1);
+  vpos = clip_to_bounds (0, vpos, w->current_matrix->nrows - 1);
   rif->cursor_to (vpos, hpos, cy, cx);
 }
 
@@ -4551,13 +4485,11 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
   if (preempt_count <= 0)
     preempt_count = 1;
 
-#if !PERIODIC_PREEMPTION_CHECKING
   if (!force_p && detect_input_pending_ignore_squeezables ())
     {
       pause_p = 1;
       goto do_pause;
     }
-#endif
 
   /* If we cannot insert/delete lines, it's no use trying it.  */
   if (!FRAME_LINE_INS_DEL_OK (f))
@@ -4598,21 +4530,8 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
                 }
             }
 
-#if PERIODIC_PREEMPTION_CHECKING
-          if (!force_p)
-            {
-              EMACS_TIME tm = current_emacs_time ();
-              if (EMACS_TIME_LT (preemption_next_check, tm))
-                {
-                  preemption_next_check = add_emacs_time (tm, preemption_period);
-                  if (detect_input_pending_ignore_squeezables ())
-                    break;
-                }
-            }
-#else
           if (!force_p && (i - 1) % preempt_count == 0)
             detect_input_pending_ignore_squeezables ();
-#endif
 
           update_frame_line (f, i);
         }
@@ -4718,9 +4637,7 @@ update_frame_1 (struct frame *f, bool force_p, bool inhibit_id_p)
         }
     }
 
-#if !PERIODIC_PREEMPTION_CHECKING
  do_pause:
-#endif
 
   clear_desired_matrices (f);
   return pause_p;
@@ -6097,7 +6014,6 @@ init_display (void)
 
   inverse_video = 0;
   cursor_in_echo_area = 0;
-  terminal_type = (char *) 0;
 
   /* Now is the time to initialize this; it's used by init_sys_modes
      during startup.  */
@@ -6192,8 +6108,7 @@ init_display (void)
 #ifdef WINDOWSNT
   terminal_type = "w32console";
 #else
-  /* Look at the TERM variable.  */
-  terminal_type = (char *) getenv ("TERM");
+  terminal_type = getenv ("TERM");
 #endif
   if (!terminal_type)
     {
@@ -6430,15 +6345,6 @@ See `buffer-display-table' for more information.  */);
                doc: /* Non-nil means display update isn't paused when input is detected.  */);
   redisplay_dont_pause = 1;
 
-#if PERIODIC_PREEMPTION_CHECKING
-  DEFVAR_LISP ("redisplay-preemption-period", Vredisplay_preemption_period,
-               doc: /* Period in seconds between checking for input during redisplay.
-This has an effect only if `redisplay-dont-pause' is nil; in that
-case, arriving input preempts redisplay until the input is processed.
-If the value is nil, redisplay is never preempted.  */);
-  Vredisplay_preemption_period = make_float (0.10);
-#endif
-
 #ifdef CANNOT_DUMP
   if (noninteractive)
 #endif
diff --git a/src/disptab.h b/src/disptab.h
index 2e041707eea..e02bab04bbc 100644
--- a/src/disptab.h
+++ b/src/disptab.h
@@ -1,5 +1,5 @@
 /* Things for GLYPHS and glyph tables.
-   Copyright (C) 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/doc.c b/src/doc.c
index 76008295add..7234fb38bf9 100644
--- a/src/doc.c
+++ b/src/doc.c
@@ -1,6 +1,7 @@
 /* Record indices of function doc strings stored in a file.
 
-Copyright (C) 1985-1986, 1993-1995, 1997-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -83,24 +84,23 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
   ptrdiff_t minsize;
   int offset;
   EMACS_INT position;
-  Lisp_Object file, tem;
+  Lisp_Object file, tem, pos;
   USE_SAFE_ALLOCA;
 
   if (INTEGERP (filepos))
     {
       file = Vdoc_file_name;
-      position = XINT (filepos);
+      pos = filepos;
     }
   else if (CONSP (filepos))
     {
       file = XCAR (filepos);
-      position = XINT (XCDR (filepos));
+      pos = XCDR (filepos);
     }
   else
     return Qnil;
 
-  if (position < 0)
-    position = - position;
+  position = eabs (XINT (pos));
 
   if (!STRINGP (Vdoc_directory))
     return Qnil;
@@ -176,9 +176,9 @@ get_doc_string (Lisp_Object filepos, bool unibyte, bool definition)
       if (space_left <= 0)
         {
           ptrdiff_t in_buffer = p - get_doc_string_buffer;
-          get_doc_string_buffer =
-            xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size,
-                     16 * 1024, -1, 1);
+          get_doc_string_buffer
+            = xpalloc (get_doc_string_buffer, &get_doc_string_buffer_size,
+                       16 * 1024, -1, 1);
           p = get_doc_string_buffer + in_buffer;
           space_left = (get_doc_string_buffer_size - 1
                         - (p - get_doc_string_buffer));
@@ -279,10 +279,10 @@ Invalid data in documentation file -- %c followed by code %03o",
   else
     {
       /* The data determines whether the string is multibyte.  */
-      ptrdiff_t nchars =
-        multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
-                                  + offset),
-                                 to - (get_doc_string_buffer + offset));
+      ptrdiff_t nchars
+        = multibyte_chars_in_text (((unsigned char *) get_doc_string_buffer
+                                    + offset),
+                                   to - (get_doc_string_buffer + offset));
       return make_string_from_bytes (get_doc_string_buffer + offset,
                                      nchars,
                                      to - (get_doc_string_buffer + offset));
@@ -630,11 +630,10 @@ the same file name is found in the `doc-directory'.  */)
         break;
 
       buf[filled] = 0;
-      p = buf;
       end = buf + (filled < 512 ? filled : filled - 128);
-      while (p != end && *p != '\037') p++;
+      p = memchr (buf, '\037', end - buf);
       /* p points to ^_Ffunctionname\n or ^_Vvarname\n or ^_Sfilename\n.  */
-      if (p != end)
+      if (p)
         {
           end = strchr (p, '\n');
 
diff --git a/src/doprnt.c b/src/doprnt.c
index 8cab219aafa..471e35c7b43 100644
--- a/src/doprnt.c
+++ b/src/doprnt.c
@@ -1,7 +1,7 @@
 /* Output like sprintf to a buffer of specified size.
    Also takes args differently: pass one pointer to the end
    of the format string in addition to the format string itself.
-   Copyright (C) 1985, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -38,7 +38,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
      could include embedded null characters.
 
    . It signals an error if the length of the formatted string is about to
-     overflow MOST_POSITIVE_FIXNUM, to avoid producing strings longer than what
+     overflow ptrdiff_t or size_t, to avoid producing strings longer than what
      Emacs can handle.
 
    OTOH, this function supports only a small subset of the standard C formatted
diff --git a/src/dosfns.c b/src/dosfns.c
index ce1ec4a4f93..37d3998b5ee 100644
--- a/src/dosfns.c
+++ b/src/dosfns.c
@@ -1,6 +1,7 @@
 /* MS-DOS specific Lisp utilities.  Coded by Manabu Higashida, 1991.
    Major changes May-July 1993 Morten Welinder (only 10% original code left)
-   Copyright (C) 1991, 1993, 1996-1998, 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 1991, 1993, 1996-1998, 2001-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/dosfns.h b/src/dosfns.h
index 9747c364d71..0bf0ae1f19b 100644
--- a/src/dosfns.h
+++ b/src/dosfns.h
@@ -2,8 +2,8 @@
    Coded by Manabu Higashida, 1991.
    Modified by Morten Welinder, 1993-1994.
 
-Copyright (C) 1991, 1994-1995, 1997, 1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1991, 1994-1995, 1997, 1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/editfns.c b/src/editfns.c
index 7d179c8566a..bee0bcc158d 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -1,6 +1,6 @@
 /* Lisp functions pertaining to editing.
 
-Copyright (C) 1985-1987, 1989, 1993-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1987, 1989, 1993-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -24,6 +24,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #ifdef HAVE_PWD_H
 #include <pwd.h>
+#include <grp.h>
 #endif
 
 #include <unistd.h>
@@ -385,6 +386,7 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
       ptrdiff_t noverlays;
       Lisp_Object *overlay_vec, tem;
       struct buffer *obuf = current_buffer;
+      USE_SAFE_ALLOCA;
 
       set_buffer_temp (XBUFFER (object));
 
@@ -397,7 +399,7 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
          make enough space for all, and try again.  */
       if (noverlays > 40)
         {
-          overlay_vec = alloca (noverlays * sizeof *overlay_vec);
+          SAFE_ALLOCA_LISP (overlay_vec, noverlays);
           noverlays = overlays_around (posn, overlay_vec, noverlays);
         }
       noverlays = sort_overlays (overlay_vec, noverlays, NULL);
@@ -420,10 +422,12 @@ get_pos_property (Lisp_Object position, register Lisp_Object prop, Lisp_Object o
                 ; /* The overlay will not cover a char inserted at point.  */
               else
                 {
+                  SAFE_FREE ();
                   return tem;
                 }
             }
         }
+      SAFE_FREE ();
 
       { /* Now check the text properties.  */
         int stickiness = text_property_stickiness (prop, position, object);
@@ -731,9 +735,8 @@ Field boundaries are not noticed if `inhibit-field-text-motion' is non-nil.  */)
               /* This is the ONLY_IN_LINE case, check that NEW_POS and
                  FIELD_BOUND are on the same line by seeing whether
                  there's an intervening newline or not.  */
-              || (scan_buffer ('\n',
-                               XFASTINT (new_pos), XFASTINT (field_bound),
-                               fwd ? -1 : 1, &shortage, 1),
+              || (find_newline (XFASTINT (new_pos), XFASTINT (field_bound),
+                                fwd ? -1 : 1, &shortage, 1),
                   shortage != 0)))
         /* Constrain NEW_POS to FIELD_BOUND.  */
         new_pos = field_bound;
@@ -832,21 +835,17 @@ This function does not move point.  */)
 Lisp_Object
 save_excursion_save (void)
 {
-  Lisp_Object save, *data = xmalloc (word_size * 4);
-
-  data[0] = Fpoint_marker ();
-  /* Do not copy the mark if it points to nowhere.  */
-  data[1] = (XMARKER (BVAR (current_buffer, mark))->buffer
-             ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
-             : Qnil);
-  /* Selected window if current buffer is shown in it, nil otherwise.  */
-  data[2] = ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
-             ? selected_window : Qnil);
-  data[3] = BVAR (current_buffer, mark_active);
-
-  save = make_save_value (data, 4);
-  XSAVE_VALUE (save)->dogc = 1;
-  return save;
+  return make_save_value
+    ("oooo",
+     Fpoint_marker (),
+     /* Do not copy the mark if it points to nowhere.  */
+     (XMARKER (BVAR (current_buffer, mark))->buffer
+      ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
+      : Qnil),
+     /* Selected window if current buffer is shown in it, nil otherwise.  */
+     ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+      ? selected_window : Qnil),
+     BVAR (current_buffer, mark_active));
 }
 
 /* Restore saved buffer before leaving `save-excursion' special form.  */
@@ -854,10 +853,10 @@ save_excursion_save (void)
 Lisp_Object
 save_excursion_restore (Lisp_Object info)
 {
-  Lisp_Object tem, tem1, omark, nmark, *data = XSAVE_VALUE (info)->pointer;
+  Lisp_Object tem, tem1, omark, nmark;
   struct gcpro gcpro1, gcpro2, gcpro3;
 
-  tem = Fmarker_buffer (data[0]);
+  tem = Fmarker_buffer (XSAVE_OBJECT (info, 0));
   /* If we're unwinding to top level, saved buffer may be deleted.  This
      means that all of its markers are unchained and so tem is nil.  */
   if (NILP (tem))
@@ -869,12 +868,12 @@ save_excursion_restore (Lisp_Object info)
   Fset_buffer (tem);
 
   /* Point marker.  */
-  tem = data[0];
+  tem = XSAVE_OBJECT (info, 0);
   Fgoto_char (tem);
   unchain_marker (XMARKER (tem));
 
   /* Mark marker.  */
-  tem = data[1];
+  tem = XSAVE_OBJECT (info, 1);
   omark = Fmarker_position (BVAR (current_buffer, mark));
   if (NILP (tem))
     unchain_marker (XMARKER (BVAR (current_buffer, mark)));
@@ -886,7 +885,7 @@ save_excursion_restore (Lisp_Object info)
     }
 
   /* Mark active.  */
-  tem = data[3];
+  tem = XSAVE_OBJECT (info, 3);
   tem1 = BVAR (current_buffer, mark_active);
   bset_mark_active (current_buffer, tem);
 
@@ -910,7 +909,7 @@ save_excursion_restore (Lisp_Object info)
   /* If buffer was visible in a window, and a different window was
      selected, and the old selected window is still showing this
      buffer, restore point in that window.  */
-  tem = data[2];
+  tem = XSAVE_OBJECT (info, 2);
   if (WINDOWP (tem)
       && !EQ (tem, selected_window)
       && (tem1 = XWINDOW (tem)->buffer,
@@ -924,7 +923,7 @@ save_excursion_restore (Lisp_Object info)
 
  out:
 
-  free_save_value (info);
+  free_misc (info);
   return Qnil;
 }
 
@@ -967,7 +966,7 @@ usage: (save-current-buffer &rest BODY)  */)
   return unbind_to (count, Fprogn (args));
 }
 
-DEFUN ("buffer-size", Fbufsize, Sbufsize, 0, 1, 0,
+DEFUN ("buffer-size", Fbuffer_size, Sbuffer_size, 0, 1, 0,
        doc: /* Return the number of characters in the current buffer.
 If BUFFER, return the number of characters in that buffer instead.  */)
   (Lisp_Object buffer)
@@ -1272,6 +1271,24 @@ Value is an integer or a float, depending on the value.  */)
   return make_fixnum_or_float (uid);
 }
 
+DEFUN ("group-gid", Fgroup_gid, Sgroup_gid, 0, 0, 0,
+       doc: /* Return the effective gid of Emacs.
+Value is an integer or a float, depending on the value.  */)
+  (void)
+{
+  gid_t egid = getegid ();
+  return make_fixnum_or_float (egid);
+}
+
+DEFUN ("group-real-gid", Fgroup_real_gid, Sgroup_real_gid, 0, 0, 0,
+       doc: /* Return the real gid of Emacs.
+Value is an integer or a float, depending on the value.  */)
+  (void)
+{
+  gid_t gid = getgid ();
+  return make_fixnum_or_float (gid);
+}
+
 DEFUN ("user-full-name", Fuser_full_name, Suser_full_name, 0, 1, 0,
        doc: /* Return the full name of the user logged in, as a string.
 If the full name corresponding to Emacs's userid is not known,
@@ -2169,6 +2186,7 @@ set_time_zone_rule (const char *tzstring)
       xputenv (set_time_zone_rule_tz[1]);
     }
   tzset ();
+  tzvalbuf_in_environ = 0;
 #endif
 
   if (!tzstring)
@@ -2342,10 +2360,9 @@ usage: (insert-before-markers-and-inherit &rest ARGS)  */)
 }
 
 DEFUN ("insert-char", Finsert_char, Sinsert_char, 1, 3,
-       "(list (or (read-char-by-name \"Insert character (Unicode name or hex): \")\
-          (error \"You did not specify a valid character\"))\
-      (prefix-numeric-value current-prefix-arg)\
-      t))",
+       "(list (read-char-by-name \"Insert character (Unicode name or hex): \")\
+              (prefix-numeric-value current-prefix-arg)\
+              t))",
        doc: /* Insert COUNT copies of CHARACTER.
 Interactively, prompt for CHARACTER.  You can specify CHARACTER in one
 of these ways:
@@ -2482,7 +2499,7 @@ make_buffer_string_both (ptrdiff_t start, ptrdiff_t start_byte,
   Lisp_Object result, tem, tem1;
 
   if (start < GPT && GPT < end)
-    move_gap (start);
+    move_gap_both (start, start_byte);
 
   if (! NILP (BVAR (current_buffer, enable_multibyte_characters)))
     result = make_uninit_multibyte_string (end - start, end_byte - start_byte);
@@ -2580,7 +2597,7 @@ If narrowing is in effect, this function returns only the visible part
 of the buffer.  */)
   (void)
 {
-  return make_buffer_string (BEGV, ZV, 1);
+  return make_buffer_string_both (BEGV, BEGV_BYTE, ZV, ZV_BYTE, 1);
 }
 
 DEFUN ("insert-buffer-substring", Finsert_buffer_substring, Sinsert_buffer_substring,
@@ -2635,10 +2652,10 @@ They default to the values of (point-min) and (point-max) in BUFFER.  */)
 DEFUN ("compare-buffer-substrings", Fcompare_buffer_substrings, Scompare_buffer_substrings,
        6, 6, 0,
        doc: /* Compare two substrings of two buffers; return result as number.
-the value is -N if first string is less after N-1 chars,
-+N if first string is greater after N-1 chars, or 0 if strings match.
-Each substring is represented as three arguments: BUFFER, START and END.
-That makes six args in all, three for each substring.
+Return -N if first string is less after N-1 chars, +N if first string is
+greater after N-1 chars, or 0 if strings match.  Each substring is
+represented as three arguments: BUFFER, START and END.  That makes six
+args in all, three for each substring.
 
 The value of `case-fold-search' in the current buffer
 determines whether case is significant or ignored.  */)
@@ -3411,12 +3428,6 @@ usage: (save-restriction &rest BODY)  */)
   return unbind_to (count, val);
 }
 
-/* Buffer for the most recent text displayed by Fmessage_box.  */
-static char *message_text;
-
-/* Allocated length of that buffer.  */
-static ptrdiff_t message_length;
-
 DEFUN ("message", Fmessage, Smessage, 1, MANY, 0,
        doc: /* Display a message at the bottom of the screen.
 The message also goes into the `*Messages*' buffer, if `message-log-max'
@@ -3440,14 +3451,14 @@ usage: (message FORMAT-STRING &rest ARGS)  */)
       || (STRINGP (args[0])
           && SBYTES (args[0]) == 0))
     {
-      message (0);
+      message1 (0);
       return args[0];
     }
   else
     {
       register Lisp_Object val;
       val = Fformat (nargs, args);
-      message3 (val, SBYTES (val), STRING_MULTIBYTE (val));
+      message3 (val);
       return val;
     }
 }
@@ -3466,13 +3477,12 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
 {
   if (NILP (args[0]))
     {
-      message (0);
+      message1 (0);
       return Qnil;
     }
   else
     {
-      register Lisp_Object val;
-      val = Fformat (nargs, args);
+      Lisp_Object val = Fformat (nargs, args);
 #ifdef HAVE_MENUS
       /* The MS-DOS frames support popup menus even though they are
          not FRAME_WINDOW_P.  */
@@ -3489,16 +3499,7 @@ usage: (message-box FORMAT-STRING &rest ARGS)  */)
         return val;
       }
 #endif /* HAVE_MENUS */
-      /* Copy the data so that it won't move when we GC.  */
-      if (SBYTES (val) > message_length)
-        {
-          ptrdiff_t new_length = SBYTES (val) + 80;
-          message_text = xrealloc (message_text, new_length);
-          message_length = new_length;
-        }
-      memcpy (message_text, SDATA (val), SBYTES (val));
-      message2 (message_text, SBYTES (val),
-                STRING_MULTIBYTE (val));
+      message3 (val);
       return val;
     }
 }
@@ -4234,12 +4235,12 @@ usage: (format STRING &rest OBJECTS)  */)
           {
             buf = xmalloc (bufsize);
             sa_must_free = 1;
-            buf_save_value = make_save_value (buf, 0);
+            buf_save_value = make_save_pointer (buf);
             record_unwind_protect (safe_alloca_unwind, buf_save_value);
             memcpy (buf, initial_buffer, used);
           }
         else
-          XSAVE_VALUE (buf_save_value)->pointer = buf = xrealloc (buf, bufsize);
+          XSAVE_POINTER (buf_save_value, 0) = buf = xrealloc (buf, bufsize);
 
         p = buf + used;
       }
@@ -4504,7 +4505,7 @@ Transposing beyond buffer boundaries is an error.  */)
   (Lisp_Object startr1, Lisp_Object endr1, Lisp_Object startr2, Lisp_Object endr2, Lisp_Object leave_markers)
 {
   register ptrdiff_t start1, end1, start2, end2;
-  ptrdiff_t start1_byte, start2_byte, len1_byte, len2_byte;
+  ptrdiff_t start1_byte, start2_byte, len1_byte, len2_byte, end2_byte;
   ptrdiff_t gap, len1, len_mid, len2;
   unsigned char *start1_addr, *start2_addr, *temp;
 
@@ -4565,20 +4566,22 @@ Transposing beyond buffer boundaries is an error.  */)
      the gap the minimum distance to get it out of the way, and then
      deal with an unbroken array.  */
 
+  start1_byte = CHAR_TO_BYTE (start1);
+  end2_byte = CHAR_TO_BYTE (end2);
+
   /* Make sure the gap won't interfere, by moving it out of the text
      we will operate on.  */
   if (start1 < gap && gap < end2)
     {
       if (gap - start1 < end2 - gap)
-        move_gap (start1);
+        move_gap_both (start1, start1_byte);
       else
-        move_gap (end2);
+        move_gap_both (end2, end2_byte);
     }
 
-  start1_byte = CHAR_TO_BYTE (start1);
   start2_byte = CHAR_TO_BYTE (start2);
   len1_byte = CHAR_TO_BYTE (end1) - start1_byte;
-  len2_byte = CHAR_TO_BYTE (end2) - start2_byte;
+  len2_byte = end2_byte - start2_byte;
 
 #ifdef BYTE_COMBINING_DEBUG
   if (end1 == start2)
@@ -4865,12 +4868,10 @@ functions if all the text being accessed has this property.  */);
   defsubr (&Sline_beginning_position);
   defsubr (&Sline_end_position);
 
-/*  defsubr (&Smark); */
-/*  defsubr (&Sset_mark); */
   defsubr (&Ssave_excursion);
   defsubr (&Ssave_current_buffer);
 
-  defsubr (&Sbufsize);
+  defsubr (&Sbuffer_size);
   defsubr (&Spoint_max);
   defsubr (&Spoint_min);
   defsubr (&Spoint_min_marker);
@@ -4899,6 +4900,8 @@ functions if all the text being accessed has this property.  */);
   defsubr (&Suser_real_login_name);
   defsubr (&Suser_uid);
   defsubr (&Suser_real_uid);
+  defsubr (&Sgroup_gid);
+  defsubr (&Sgroup_real_gid);
   defsubr (&Suser_full_name);
   defsubr (&Semacs_pid);
   defsubr (&Scurrent_time);
diff --git a/src/emacs-icon.h b/src/emacs-icon.h
index 590d874ca82..8869f6d7d76 100644
--- a/src/emacs-icon.h
+++ b/src/emacs-icon.h
@@ -1,7 +1,7 @@
 /* XPM */
 /* Emacs icon
 
-Copyright (C) 2008-2012  Free Software Foundation, Inc.
+Copyright (C) 2008-2013 Free Software Foundation, Inc.
 
 Author:  Kentaro Ohkouchi <nanasess@fsm.ne.jp>
 
diff --git a/src/emacs.c b/src/emacs.c
index fbaf0355000..c494dff8cac 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -1,7 +1,7 @@
 /* Fully extensible Emacs, running on Unix, intended for GNU.
 
-Copyright (C) 1985-1987, 1993-1995, 1997-1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1987, 1993-1995, 1997-1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -41,6 +41,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #if defined WINDOWSNT || defined HAVE_NTGUI
 #include "w32select.h"
 #include "w32font.h"
+#include "w32common.h"
 #endif
 
 #if defined HAVE_NTGUI && defined CYGWIN
@@ -133,6 +134,7 @@ Lisp_Object Qfile_name_handler_alist;
 Lisp_Object Qrisky_local_variable;
 
 Lisp_Object Qkill_emacs;
+static Lisp_Object Qkill_emacs_hook;
 
 /* If true, Emacs should not attempt to use a window-specific code,
    but instead should use the virtual terminal under which it was started.  */
@@ -343,25 +345,6 @@ terminate_due_to_signal (int sig, int backtrace_limit)
   /* This shouldn't be executed, but it prevents a warning.  */
   exit (1);
 }
-
-#ifdef SIGDANGER
-
-/* Handler for SIGDANGER.  */
-static void
-handle_danger_signal (int sig)
-{
-  malloc_warning ("Operating system warns that virtual memory is running low.\n");
-
-  /* It might be unsafe to call do_auto_save now.  */
-  force_auto_save_soon ();
-}
-
-static void
-deliver_danger_signal (int sig)
-{
-  deliver_process_signal (sig, handle_danger_signal);
-}
-#endif
 
 /* Code for dealing with Lisp access to the Unix command line.  */
 
@@ -733,6 +716,13 @@ main (int argc, char **argv)
     }
 #endif
 
+#if defined WINDOWSNT || defined HAVE_NTGUI
+  /* Set global variables used to detect Windows version.  Do this as
+     early as possible.  (unexw32.c calls this function as well, but
+     the additional call here is harmless.) */
+  cache_system_info ();
+#endif
+
 #ifdef RUN_TIME_REMAP
   if (initialized)
     run_time_remap (argv[0]);
@@ -1069,7 +1059,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
             argv[skip_args] = fdStr;
 
-            execv (argv[0], argv);
+            execvp (argv[0], argv);
             fprintf (stderr, "emacs daemon: exec failed: %d\n", errno);
             exit (1);
           }
@@ -1287,6 +1277,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
 
 #ifdef WINDOWSNT
   globals_of_w32 ();
+  globals_of_w32notify ();
   /* Initialize environment from registry settings.  */
   init_environment (argv);
   init_ntproc (dumping); /* must precede init_editfns.  */
@@ -1327,6 +1318,7 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
     }
 
   init_callproc ();     /* Must follow init_cmdargs but not init_sys_modes.  */
+  init_fileio ();
   init_lread ();
 #ifdef WINDOWSNT
   /* Check to see if Emacs has been installed correctly.  */
@@ -1442,12 +1434,17 @@ Using an Emacs configured with --with-x-toolkit=lucid does not have this problem
       syms_of_gnutls ();
 #endif
 
+#ifdef HAVE_INOTIFY
+      syms_of_inotify ();
+#endif /* HAVE_INOTIFY */
+
 #ifdef HAVE_DBUS
       syms_of_dbusbind ();
 #endif /* HAVE_DBUS */
 
 #ifdef WINDOWSNT
       syms_of_ntterm ();
+      syms_of_w32notify ();
 #endif /* WINDOWSNT */
 
       syms_of_profiler ();
@@ -1845,7 +1842,6 @@ all of which are called before Emacs is actually killed.  */)
   (Lisp_Object arg)
 {
   struct gcpro gcpro1;
-  Lisp_Object hook;
   int exit_code;
 
   GCPRO1 (arg);
@@ -1853,9 +1849,10 @@ all of which are called before Emacs is actually killed.  */)
   if (feof (stdin))
     arg = Qt;
 
-  hook = intern ("kill-emacs-hook");
-  Frun_hooks (1, &hook);
-
+  /* Fsignal calls emacs_abort () if it sees that waiting_for_input is
+     set.  */
+  waiting_for_input = 0;
+  Frun_hooks (1, &Qkill_emacs_hook);
   UNGCPRO;
 
 #ifdef HAVE_X_WINDOWS
@@ -2155,7 +2152,7 @@ decode_env_path (const char *evarname, const char *defalt)
     {
       char *path_copy = alloca (strlen (path) + 1);
       strcpy (path_copy, path);
-      dostounix_filename (path_copy);
+      dostounix_filename (path_copy, 0);
       path = path_copy;
     }
 #endif
@@ -2267,6 +2264,7 @@ syms_of_emacs (void)
   DEFSYM (Qfile_name_handler_alist, "file-name-handler-alist");
   DEFSYM (Qrisky_local_variable, "risky-local-variable");
   DEFSYM (Qkill_emacs, "kill-emacs");
+  DEFSYM (Qkill_emacs_hook, "kill-emacs-hook");
 
 #ifndef CANNOT_DUMP
   defsubr (&Sdump_emacs);
diff --git a/src/emacsgtkfixed.c b/src/emacsgtkfixed.c
index d10185072cc..6a8c751e306 100644
--- a/src/emacsgtkfixed.c
+++ b/src/emacsgtkfixed.c
@@ -1,7 +1,7 @@
 /* A Gtk Widget that inherits GtkFixed, but can be shrunk.
 This file is only use when compiling with Gtk+ 3.
 
-Copyright (C) 2011-2012  Free Software Foundation, Inc.
+Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/emacsgtkfixed.h b/src/emacsgtkfixed.h
index 3fa294aa41e..d987797a934 100644
--- a/src/emacsgtkfixed.h
+++ b/src/emacsgtkfixed.h
@@ -1,7 +1,7 @@
 /* A Gtk Widget that inherits GtkFixed, but can be shrunk.
 This file is only use when compiling with Gtk+ 3.
 
-Copyright (C) 2011-2012  Free Software Foundation, Inc.
+Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/epaths.in b/src/epaths.in
index 705fe3aab1b..0cf8cc9ce5b 100644
--- a/src/epaths.in
+++ b/src/epaths.in
@@ -1,7 +1,7 @@
 /* Hey Emacs, this is -*- C -*- code!  */
 /*
-Copyright (C) 1993, 1995, 1997, 1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1993, 1995, 1997, 1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/eval.c b/src/eval.c
index 34b20f6fc8e..030bf14bcea 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1,5 +1,6 @@
 /* Evaluator for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985-1987, 1993-1995, 1999-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993-1995, 1999-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1930,7 +1931,10 @@ eval_sub (Lisp_Object form)
     return form;
 
   QUIT;
+
+  GCPRO1 (form);
   maybe_gc ();
+  UNGCPRO;
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
diff --git a/src/fileio.c b/src/fileio.c
index de3b84ba95d..89ad3396464 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -1,6 +1,6 @@
 /* File IO for GNU Emacs.
 
-Copyright (C) 1985-1988, 1993-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -36,6 +36,10 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <selinux/context.h>
 #endif
 
+#ifdef HAVE_POSIX_ACL
+#include <sys/acl.h>
+#endif
+
 #include <c-ctype.h>
 
 #include "lisp.h"
@@ -78,6 +82,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 
 #include "systime.h"
+#include <allocator.h>
+#include <careadlinkat.h>
 #include <stat-time.h>
 
 #ifdef HPUX
@@ -99,6 +105,11 @@ static mode_t auto_save_mode_bits;
 /* Set by auto_save_1 if an error occurred during the last auto-save.  */
 static bool auto_save_error_occurred;
 
+/* If VALID_TIMESTAMP_FILE_SYSTEM, then TIMESTAMP_FILE_SYSTEM is the device
+   number of a file system where time stamps were observed to to work.  */
+static bool valid_timestamp_file_system;
+static dev_t timestamp_file_system;
+
 /* The symbol bound to coding-system-for-read when
    insert-file-contents is called for recovering a file.  This is not
    an actual coding system name, but just an indicator to tell
@@ -122,9 +133,6 @@ static Lisp_Object Qwrite_region_annotate_functions;
    is added here.  */
 static Lisp_Object Vwrite_region_annotation_buffers;
 
-#ifdef HAVE_FSYNC
-#endif
-
 static Lisp_Object Qdelete_by_moving_to_trash;
 
 /* Lisp function for moving files to trash.  */
@@ -236,8 +244,11 @@ static Lisp_Object Qset_file_modes;
 static Lisp_Object Qset_file_times;
 static Lisp_Object Qfile_selinux_context;
 static Lisp_Object Qset_file_selinux_context;
+static Lisp_Object Qfile_acl;
+static Lisp_Object Qset_file_acl;
 static Lisp_Object Qfile_newer_than_file_p;
 Lisp_Object Qinsert_file_contents;
+static Lisp_Object Qchoose_write_coding_system;
 Lisp_Object Qwrite_region;
 static Lisp_Object Qverify_visited_file_modtime;
 static Lisp_Object Qset_visited_file_modtime;
@@ -369,16 +380,35 @@ Given a Unix syntax file name, returns a string ending in slash.  */)
 
       if (getdefdir (c_toupper (*beg) - 'A' + 1, r))
         {
-          if (!IS_DIRECTORY_SEP (res[strlen (res) - 1]))
+          size_t l = strlen (res);
+
+          if (l > 3 || !IS_DIRECTORY_SEP (res[l - 1]))
             strcat (res, "/");
           beg = res;
           p = beg + strlen (beg);
+          dostounix_filename (beg, 0);
+          tem_fn = make_specified_string (beg, -1, p - beg,
+                                          STRING_MULTIBYTE (filename));
         }
+      else
+        tem_fn = make_specified_string (beg - 2, -1, p - beg + 2,
+                                        STRING_MULTIBYTE (filename));
+    }
+  else if (STRING_MULTIBYTE (filename))
+    {
+      tem_fn = make_specified_string (beg, -1, p - beg, 1);
+      dostounix_filename (SSDATA (tem_fn), 1);
+#ifdef WINDOWSNT
+      if (!NILP (Vw32_downcase_file_names))
+        tem_fn = Fdowncase (tem_fn);
+#endif
+    }
+  else
+    {
+      dostounix_filename (beg, 0);
+      tem_fn = make_specified_string (beg, -1, p - beg, 0);
     }
-  tem_fn = ENCODE_FILE (make_specified_string (beg, -1, p - beg,
-                                               STRING_MULTIBYTE (filename)));
-  dostounix_filename (SSDATA (tem_fn));
-  return DECODE_FILE (tem_fn);
+  return tem_fn;
 #else  /* DOS_NT */
   return make_specified_string (beg, -1, p - beg, STRING_MULTIBYTE (filename));
 #endif  /* DOS_NT */
@@ -453,12 +483,14 @@ get a current directory to run processes in.  */)
   return Ffile_name_directory (filename);
 }
 
-/* Convert from file name SRC of length SRCLEN to directory name
-   in DST.  On UNIX, just make sure there is a terminating /.
-   Return the length of DST in bytes.  */
+/* Convert from file name SRC of length SRCLEN to directory name in
+   DST.  MULTIBYTE non-zero means the file name in SRC is a multibyte
+   string.  On UNIX, just make sure there is a terminating /.  Return
+   the length of DST in bytes.  */
 
 static ptrdiff_t
-file_name_as_directory (char *dst, const char *src, ptrdiff_t srclen)
+file_name_as_directory (char *dst, const char *src, ptrdiff_t srclen,
+                        bool multibyte)
 {
   if (srclen == 0)
     {
@@ -477,14 +509,7 @@ file_name_as_directory (char *dst, const char *src, ptrdiff_t srclen)
       srclen++;
     }
 #ifdef DOS_NT
-  {
-    Lisp_Object tem_fn = make_specified_string (dst, -1, srclen, 1);
-
-    tem_fn = ENCODE_FILE (tem_fn);
-    dostounix_filename (SSDATA (tem_fn));
-    tem_fn = DECODE_FILE (tem_fn);
-    memcpy (dst, SSDATA (tem_fn), (srclen = SBYTES (tem_fn)) + 1);
-  }
+  dostounix_filename (dst, multibyte);
 #endif
   return srclen;
 }
@@ -519,17 +544,23 @@ For a Unix-syntax file name, just appends a slash.  */)
       error ("Invalid handler in `file-name-handler-alist'");
     }
 
+#ifdef WINDOWSNT
+  if (!NILP (Vw32_downcase_file_names))
+    file = Fdowncase (file);
+#endif
   buf = alloca (SBYTES (file) + 10);
-  length = file_name_as_directory (buf, SSDATA (file), SBYTES (file));
+  length = file_name_as_directory (buf, SSDATA (file), SBYTES (file),
+                                   STRING_MULTIBYTE (file));
   return make_specified_string (buf, -1, length, STRING_MULTIBYTE (file));
 }
 
-/* Convert from directory name SRC of length SRCLEN to
-   file name in DST.  On UNIX, just make sure there isn't
-   a terminating /.  Return the length of DST in bytes.  */
+/* Convert from directory name SRC of length SRCLEN to file name in
+   DST.  MULTIBYTE non-zero means the file name in SRC is a multibyte
+   string.  On UNIX, just make sure there isn't a terminating /.
+   Return the length of DST in bytes.  */
 
 static ptrdiff_t
-directory_file_name (char *dst, char *src, ptrdiff_t srclen)
+directory_file_name (char *dst, char *src, ptrdiff_t srclen, bool multibyte)
 {
   /* Process as Unix format: just remove any final slash.
      But leave "/" unchanged; do not change it to "".  */
@@ -545,14 +576,7 @@ directory_file_name (char *dst, char *src, ptrdiff_t srclen)
       srclen--;
     }
 #ifdef DOS_NT
-  {
-    Lisp_Object tem_fn = make_specified_string (dst, -1, srclen, 1);
-
-    tem_fn = ENCODE_FILE (tem_fn);
-    dostounix_filename (SSDATA (tem_fn));
-    tem_fn = DECODE_FILE (tem_fn);
-    memcpy (dst, SSDATA (tem_fn), (srclen = SBYTES (tem_fn)) + 1);
-  }
+  dostounix_filename (dst, multibyte);
 #endif
   return srclen;
 }
@@ -587,8 +611,13 @@ In Unix-syntax, this function just removes the final slash.  */)
       error ("Invalid handler in `file-name-handler-alist'");
     }
 
+#ifdef WINDOWSNT
+  if (!NILP (Vw32_downcase_file_names))
+    directory = Fdowncase (directory);
+#endif
   buf = alloca (SBYTES (directory) + 20);
-  length = directory_file_name (buf, SSDATA (directory), SBYTES (directory));
+  length = directory_file_name (buf, SSDATA (directory), SBYTES (directory),
+                                STRING_MULTIBYTE (directory));
   return make_specified_string (buf, -1, length, STRING_MULTIBYTE (directory));
 }
 
@@ -886,6 +915,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
         }
     }
 
+#ifdef WINDOWSNT
+  if (!NILP (Vw32_downcase_file_names))
+    default_directory = Fdowncase (default_directory);
+#endif
+
   /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below.  */
   nm = alloca (SBYTES (name) + 1);
   memcpy (nm, SSDATA (name), SBYTES (name) + 1);
@@ -969,18 +1003,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #ifdef DOS_NT
           /* Make sure directories are all separated with /, but
              avoid allocation of a new string when not required. */
-          if (multibyte)
-            {
-              Lisp_Object tem_name = make_specified_string (nm, -1, strlen (nm),
-                                                            multibyte);
-
-              tem_name = ENCODE_FILE (tem_name);
-              dostounix_filename (SSDATA (tem_name));
-              tem_name = DECODE_FILE (tem_name);
-              memcpy (nm, SSDATA (tem_name), SBYTES (tem_name) + 1);
-            }
-          else
-            dostounix_filename (nm);
+          dostounix_filename (nm, multibyte);
 #ifdef WINDOWSNT
           if (IS_DIRECTORY_SEP (nm[1]))
             {
@@ -998,6 +1021,10 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
               temp[0] = DRIVE_LETTER (drive);
               name = concat2 (build_string (temp), name);
             }
+#ifdef WINDOWSNT
+          if (!NILP (Vw32_downcase_file_names))
+            name = Fdowncase (name);
+#endif
           return name;
 #else /* not DOS_NT */
           if (strcmp (nm, SSDATA (name)) == 0)
@@ -1038,7 +1065,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           /* `egetenv' may return a unibyte string, which will bite us since
              we expect the directory to be multibyte.  */
           tem = build_string (newdir);
-          if (!STRING_MULTIBYTE (tem))
+          if (multibyte && !STRING_MULTIBYTE (tem))
             {
               hdir = DECODE_FILE (tem);
               newdir = SSDATA (hdir);
@@ -1060,7 +1087,18 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           unblock_input ();
           if (pw)
             {
+              Lisp_Object tem;
+
               newdir = pw->pw_dir;
+              /* `getpwnam' may return a unibyte string, which will
+                 bite us since we expect the directory to be
+                 multibyte.  */
+              tem = build_string (newdir);
+              if (multibyte && !STRING_MULTIBYTE (tem))
+                {
+                  hdir = DECODE_FILE (tem);
+                  newdir = SSDATA (hdir);
+                }
               nm = p;
 #ifdef DOS_NT
               collapse_newdir = 0;
@@ -1084,6 +1122,13 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           adir = alloca (MAXPATHLEN + 1);
           if (!getdefdir (c_toupper (drive) - 'A' + 1, adir))
             adir = NULL;
+          else if (multibyte)
+            {
+              Lisp_Object tem = build_string (adir);
+
+              tem = DECODE_FILE (tem);
+              memcpy (adir, SSDATA (tem), SBYTES (tem) + 1);
+            }
         }
       if (!adir)
         {
@@ -1142,6 +1187,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
              indirectly by prepending newdir to nm if necessary, and using
              cwd (or the wd of newdir's drive) as the new newdir.  */
           char *adir;
+
           if (IS_DRIVE (newdir[0]) && IS_DEVICE_SEP (newdir[1]))
             {
               drive = (unsigned char) newdir[0];
@@ -1151,7 +1197,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
             {
               ptrdiff_t newlen = strlen (newdir);
               char *tmp = alloca (newlen + strlen (nm) + 2);
-              file_name_as_directory (tmp, newdir, newlen);
+              file_name_as_directory (tmp, newdir, newlen, multibyte);
               strcat (tmp, nm);
               nm = tmp;
             }
@@ -1159,10 +1205,17 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
           if (drive)
             {
               if (!getdefdir (c_toupper (drive) - 'A' + 1, adir))
-                newdir = "/";
+                strcpy (adir, "/");
             }
           else
             getcwd (adir, MAXPATHLEN + 1);
+          if (multibyte)
+            {
+              Lisp_Object tem = build_string (adir);
+
+              tem = DECODE_FILE (tem);
+              memcpy (adir, SSDATA (tem), SBYTES (tem) + 1);
+            }
           newdir = adir;
         }
 
@@ -1249,7 +1302,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
             strcpy (target, newdir);
         }
       else
-        file_name_as_directory (target, newdir, length);
+        file_name_as_directory (target, newdir, length, multibyte);
     }
 
   strcat (target, nm);
@@ -1292,8 +1345,8 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #ifdef WINDOWSNT
             char *prev_o = o;
 #endif
-            while (o != target && (--o) && !IS_DIRECTORY_SEP (*o))
-              ;
+            while (o != target && (--o, !IS_DIRECTORY_SEP (*o)))
+              continue;
 #ifdef WINDOWSNT
             /* Don't go below server level in UNC filenames.  */
             if (o == target + 1 && IS_DIRECTORY_SEP (*o)
@@ -1335,9 +1388,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
         target[1] = ':';
       }
     result = make_specified_string (target, -1, o - target, multibyte);
-    result = ENCODE_FILE (result);
-    dostounix_filename (SSDATA (result));
-    result = DECODE_FILE (result);
+    dostounix_filename (SSDATA (result), multibyte);
+#ifdef WINDOWSNT
+    if (!NILP (Vw32_downcase_file_names))
+      result = Fdowncase (result);
+#endif
 #else  /* !DOS_NT */
     result = make_specified_string (target, -1, o - target, multibyte);
 #endif /* !DOS_NT */
@@ -1590,7 +1645,7 @@ those `/' is discarded.  */)
 {
   char *nm, *s, *p, *o, *x, *endp;
   char *target = NULL;
-  int total = 0;
+  ptrdiff_t total = 0;
   bool substituted = 0;
   bool multibyte;
   char *xnm;
@@ -1619,18 +1674,8 @@ those `/' is discarded.  */)
   memcpy (nm, SDATA (filename), SBYTES (filename) + 1);
 
 #ifdef DOS_NT
-  {
-    Lisp_Object encoded_filename = ENCODE_FILE (filename);
-    Lisp_Object tem_fn;
-
-    dostounix_filename (SDATA (encoded_filename));
-    tem_fn = DECODE_FILE (encoded_filename);
-    nm = alloca (SBYTES (tem_fn) + 1);
-    memcpy (nm, SDATA (tem_fn), SBYTES (tem_fn) + 1);
-    substituted = (memcmp (nm, SDATA (filename), SBYTES (filename)) != 0);
-    if (substituted)
-      filename = tem_fn;
-  }
+  dostounix_filename (nm, multibyte);
+  substituted = (memcmp (nm, SDATA (filename), SBYTES (filename)) != 0);
 #endif
   endp = nm + SBYTES (filename);
 
@@ -1665,8 +1710,9 @@ those `/' is discarded.  */)
         else if (*p == '{')
           {
             o = ++p;
-            while (p != endp && *p != '}') p++;
-            if (*p != '}') goto missingclose;
+            p = memchr (p, '}', endp - p);
+            if (! p)
+              goto missingclose;
             s = p;
           }
         else
@@ -1704,7 +1750,13 @@ those `/' is discarded.  */)
       }
 
   if (!substituted)
-    return filename;
+    {
+#ifdef WINDOWSNT
+      if (!NILP (Vw32_downcase_file_names))
+        filename = Fdowncase (filename);
+#endif
+      return filename;
+    }
 
   /* If substitution required, recopy the string and do it.  */
   /* Make space in stack frame for the new copy.  */
@@ -1728,8 +1780,9 @@ those `/' is discarded.  */)
         else if (*p == '{')
           {
             o = ++p;
-            while (p != endp && *p != '}') p++;
-            if (*p != '}') goto missingclose;
+            p = memchr (p, '}', endp - p);
+            if (! p)
+              goto missingclose;
             s = p++;
           }
         else
@@ -1743,9 +1796,6 @@ those `/' is discarded.  */)
         target = alloca (s - o + 1);
         memcpy (target, o, s - o);
         target[s - o] = 0;
-#ifdef DOS_NT
-        strupr (target); /* $home == $HOME etc.  */
-#endif /* DOS_NT */
 
         /* Get variable value.  */
         o = egetenv (target);
@@ -1782,6 +1832,16 @@ those `/' is discarded.  */)
        need to quote some $ to $$ first.  */
     xnm = p;
 
+#ifdef WINDOWSNT
+  if (!NILP (Vw32_downcase_file_names))
+    {
+      Lisp_Object xname = make_specified_string (xnm, -1, x - xnm, multibyte);
+
+      xname = Fdowncase (xname);
+      return xname;
+    }
+  else
+#endif
   return make_specified_string (xnm, -1, x - xnm, multibyte);
 
  badsubst:
@@ -1895,9 +1955,10 @@ A prefix arg makes KEEP-TIME non-nil.
 If PRESERVE-UID-GID is non-nil, we try to transfer the
 uid and gid of FILE to NEWNAME.
 
-If PRESERVE-SELINUX-CONTEXT is non-nil and SELinux is enabled
-on the system, we copy the SELinux context of FILE to NEWNAME.  */)
-  (Lisp_Object file, Lisp_Object newname, Lisp_Object ok_if_already_exists, Lisp_Object keep_time, Lisp_Object preserve_uid_gid, Lisp_Object preserve_selinux_context)
+If PRESERVE-EXTENDED-ATTRIBUTES is non-nil, we try to copy additional
+attributes of FILE to NEWNAME, such as its SELinux context and ACL
+entries (depending on how Emacs was built).  */)
+  (Lisp_Object file, Lisp_Object newname, Lisp_Object ok_if_already_exists, Lisp_Object keep_time, Lisp_Object preserve_uid_gid, Lisp_Object preserve_extended_attributes)
 {
   int ifd, ofd;
   int n;
@@ -1906,12 +1967,14 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
   Lisp_Object handler;
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
   ptrdiff_t count = SPECPDL_INDEX ();
-  bool input_file_statable_p;
   Lisp_Object encoded_file, encoded_newname;
 #if HAVE_LIBSELINUX
   security_context_t con;
   int conlength = 0;
 #endif
+#ifdef HAVE_POSIX_ACL
+  acl_t acl = NULL;
+#endif
 
   encoded_file = encoded_newname = Qnil;
   GCPRO4 (file, newname, encoded_file, encoded_newname);
@@ -1934,7 +1997,7 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
   if (!NILP (handler))
     RETURN_UNGCPRO (call7 (handler, Qcopy_file, file, newname,
                            ok_if_already_exists, keep_time, preserve_uid_gid,
-                           preserve_selinux_context));
+                           preserve_extended_attributes));
 
   encoded_file = ENCODE_FILE (file);
   encoded_newname = ENCODE_FILE (newname);
@@ -1947,10 +2010,26 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
     out_st.st_mode = 0;
 
 #ifdef WINDOWSNT
+  if (!NILP (preserve_extended_attributes))
+    {
+#ifdef HAVE_POSIX_ACL
+      acl = acl_get_file (SDATA (encoded_file), ACL_TYPE_ACCESS);
+      if (acl == NULL && errno != ENOTSUP)
+        report_file_error ("Getting ACL", Fcons (file, Qnil));
+#endif
+    }
   if (!CopyFile (SDATA (encoded_file),
                  SDATA (encoded_newname),
                  FALSE))
-    report_file_error ("Copying file", Fcons (file, Fcons (newname, Qnil)));
+    {
+      /* CopyFile doesn't set errno when it fails.  By far the most
+         "popular" reason is that the target is read-only.  */
+      if (GetLastError () == 5)
+        errno = EACCES;
+      else
+        errno = EPERM;
+      report_file_error ("Copying file", Fcons (file, Fcons (newname, Qnil)));
+    }
   /* CopyFile retains the timestamp by default.  */
   else if (NILP (keep_time))
     {
@@ -1974,6 +2053,17 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
       /* Restore original attributes.  */
       SetFileAttributes (filename, attributes);
     }
+#ifdef HAVE_POSIX_ACL
+  if (acl != NULL)
+    {
+      bool fail =
+        acl_set_file (SDATA (encoded_newname), ACL_TYPE_ACCESS, acl) != 0;
+      if (fail && errno != ENOTSUP)
+        report_file_error ("Setting ACL", Fcons (newname, Qnil));
+
+      acl_free (acl);
+    }
+#endif
 #else /* not WINDOWSNT */
   immediate_quit = 1;
   ifd = emacs_open (SSDATA (encoded_file), O_RDONLY, 0);
@@ -1984,19 +2074,27 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
 
   record_unwind_protect (close_file_unwind, make_number (ifd));
 
-  /* We can only copy regular files and symbolic links.  Other files are not
-     copyable by us. */
-  input_file_statable_p = (fstat (ifd, &st) >= 0);
+  if (fstat (ifd, &st) != 0)
+    report_file_error ("Input file status", Fcons (file, Qnil));
 
-#if HAVE_LIBSELINUX
-  if (!NILP (preserve_selinux_context) && is_selinux_enabled ())
+  if (!NILP (preserve_extended_attributes))
     {
-      conlength = fgetfilecon (ifd, &con);
-      if (conlength == -1)
-        report_file_error ("Doing fgetfilecon", Fcons (file, Qnil));
-    }
+#if HAVE_LIBSELINUX
+      if (is_selinux_enabled ())
+        {
+          conlength = fgetfilecon (ifd, &con);
+          if (conlength == -1)
+            report_file_error ("Doing fgetfilecon", Fcons (file, Qnil));
+        }
 #endif
 
+#ifdef HAVE_POSIX_ACL
+      acl = acl_get_fd (ifd);
+      if (acl == NULL && errno != ENOTSUP)
+        report_file_error ("Getting ACL", Fcons (file, Qnil));
+#endif
+    }
+
   if (out_st.st_mode != 0
       && st.st_dev == out_st.st_dev && st.st_ino == out_st.st_ino)
     {
@@ -2005,14 +2103,12 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
                          Fcons (file, Fcons (newname, Qnil)));
     }
 
-  if (input_file_statable_p)
+  /* We can copy only regular files.  */
+  if (!S_ISREG (st.st_mode))
     {
-      if (!(S_ISREG (st.st_mode)) && !(S_ISLNK (st.st_mode)))
-        {
-          /* Get a better looking error message. */
-          errno = EISDIR;
-          report_file_error ("Non-regular file", Fcons (file, Qnil));
-        }
+      /* Get a better looking error message. */
+      errno = S_ISDIR (st.st_mode) ? EISDIR : EINVAL;
+      report_file_error ("Non-regular file", Fcons (file, Qnil));
     }
 
 #ifdef MSDOS
@@ -2023,13 +2119,8 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
                     S_IREAD | S_IWRITE);
 #else  /* not MSDOS */
   {
-    mode_t new_mask = 0666;
-    if (input_file_statable_p)
-      {
-        if (!NILP (preserve_uid_gid))
-          new_mask = 0600;
-        new_mask &= st.st_mode;
-      }
+    mode_t new_mask = !NILP (preserve_uid_gid) ? 0600 : 0666;
+    new_mask &= st.st_mode;
     ofd = emacs_open (SSDATA (encoded_newname),
                       (O_WRONLY | O_TRUNC | O_CREAT
                        | (NILP (ok_if_already_exists) ? O_EXCL : 0)),
@@ -2051,25 +2142,24 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
 #ifndef MSDOS
   /* Preserve the original file modes, and if requested, also its
      owner and group.  */
-  if (input_file_statable_p)
-    {
-      mode_t mode_mask = 07777;
-      if (!NILP (preserve_uid_gid))
-        {
-          /* Attempt to change owner and group.  If that doesn't work
-             attempt to change just the group, as that is sometimes allowed.
-             Adjust the mode mask to eliminate setuid or setgid bits
-             that are inappropriate if the owner and group are wrong.  */
-          if (fchown (ofd, st.st_uid, st.st_gid) != 0)
-            {
-              mode_mask &= ~06000;
-              if (fchown (ofd, -1, st.st_gid) == 0)
-                mode_mask |= 02000;
-            }
-        }
-      if (fchmod (ofd, st.st_mode & mode_mask) != 0)
-        report_file_error ("Doing chmod", Fcons (newname, Qnil));
-    }
+  {
+    mode_t mode_mask = 07777;
+    if (!NILP (preserve_uid_gid))
+      {
+        /* Attempt to change owner and group.  If that doesn't work
+           attempt to change just the group, as that is sometimes allowed.
+           Adjust the mode mask to eliminate setuid or setgid bits
+           that are inappropriate if the owner and group are wrong.  */
+        if (fchown (ofd, st.st_uid, st.st_gid) != 0)
+          {
+            mode_mask &= ~06000;
+            if (fchown (ofd, -1, st.st_gid) == 0)
+              mode_mask |= 02000;
+          }
+      }
+    if (fchmod (ofd, st.st_mode & mode_mask) != 0)
+      report_file_error ("Doing chmod", Fcons (newname, Qnil));
+  }
 #endif  /* not MSDOS */
 
 #if HAVE_LIBSELINUX
@@ -2085,16 +2175,24 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
     }
 #endif
 
-  if (input_file_statable_p)
+#ifdef HAVE_POSIX_ACL
+  if (acl != NULL)
     {
-      if (!NILP (keep_time))
-        {
-          EMACS_TIME atime = get_stat_atime (&st);
-          EMACS_TIME mtime = get_stat_mtime (&st);
-          if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime))
-            xsignal2 (Qfile_date_error,
-                      build_string ("Cannot set file date"), newname);
-        }
+      bool fail = acl_set_fd (ofd, acl) != 0;
+      if (fail && errno != ENOTSUP)
+        report_file_error ("Setting ACL", Fcons (newname, Qnil));
+
+      acl_free (acl);
+    }
+#endif
+
+  if (!NILP (keep_time))
+    {
+      EMACS_TIME atime = get_stat_atime (&st);
+      EMACS_TIME mtime = get_stat_mtime (&st);
+      if (set_file_times (ofd, SSDATA (encoded_newname), atime, mtime))
+        xsignal2 (Qfile_date_error,
+                  build_string ("Cannot set file date"), newname);
     }
 
   if (emacs_close (ofd) < 0)
@@ -2103,15 +2201,12 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
   emacs_close (ifd);
 
 #ifdef MSDOS
-  if (input_file_statable_p)
-    {
-      /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
-         and if it can't, it tells so.  Otherwise, under MSDOS we usually
-         get only the READ bit, which will make the copied file read-only,
-         so it's better not to chmod at all.  */
-      if ((_djstat_flags & _STFAIL_WRITEBIT) == 0)
-        chmod (SDATA (encoded_newname), st.st_mode & 07777);
-    }
+  /* In DJGPP v2.0 and later, fstat usually returns true file mode bits,
+     and if it can't, it tells so.  Otherwise, under MSDOS we usually
+     get only the READ bit, which will make the copied file read-only,
+     so it's better not to chmod at all.  */
+  if ((_djstat_flags & _STFAIL_WRITEBIT) == 0)
+    chmod (SDATA (encoded_newname), st.st_mode & 07777);
 #endif /* MSDOS */
 #endif /* not WINDOWSNT */
 
@@ -2219,14 +2314,17 @@ internal_delete_file_1 (Lisp_Object ignore)
   return Qt;
 }
 
-/* Delete file FILENAME.
+/* Delete file FILENAME, returning true if successful.
    This ignores `delete-by-moving-to-trash'.  */
 
-void
+bool
 internal_delete_file (Lisp_Object filename)
 {
-  internal_condition_case_2 (Fdelete_file, filename, Qnil,
-                             Qt, internal_delete_file_1);
+  Lisp_Object tem;
+
+  tem = internal_condition_case_2 (Fdelete_file, filename, Qnil,
+                                   Qt, internal_delete_file_1);
+  return NILP (tem);
 }
 
 DEFUN ("rename-file", Frename_file, Srename_file, 2, 3,
@@ -2647,6 +2745,29 @@ If there is no error, returns nil.  */)
   return Qnil;
 }
 
+/* Relative to directory FD, return the symbolic link value of FILENAME.
+   On failure, return nil.  */
+Lisp_Object
+emacs_readlinkat (int fd, char const *filename)
+{
+  static struct allocator const emacs_norealloc_allocator =
+    { xmalloc, NULL, xfree, memory_full };
+  Lisp_Object val;
+  char readlink_buf[1024];
+  char *buf = careadlinkat (fd, filename, readlink_buf, sizeof readlink_buf,
+                            &emacs_norealloc_allocator, readlinkat);
+  if (!buf)
+    return Qnil;
+
+  val = build_string (buf);
+  if (buf[0] == '/' && strchr (buf, ':'))
+    val = concat2 (build_string ("/:"), val);
+  if (buf != readlink_buf)
+    xfree (buf);
+  val = DECODE_FILE (val);
+  return val;
+}
+
 DEFUN ("file-symlink-p", Ffile_symlink_p, Sfile_symlink_p, 1, 1, 0,
        doc: /* Return non-nil if file FILENAME is the name of a symbolic link.
 The value is the link target, as a string.
@@ -2657,9 +2778,6 @@ points to a nonexistent file.  */)
   (Lisp_Object filename)
 {
   Lisp_Object handler;
-  char *buf;
-  Lisp_Object val;
-  char readlink_buf[READLINK_BUFSIZE];
 
   CHECK_STRING (filename);
   filename = Fexpand_file_name (filename, Qnil);
@@ -2672,17 +2790,7 @@ points to a nonexistent file.  */)
 
   filename = ENCODE_FILE (filename);
 
-  buf = emacs_readlink (SSDATA (filename), readlink_buf);
-  if (! buf)
-    return Qnil;
-
-  val = build_string (buf);
-  if (buf[0] == '/' && strchr (buf, ':'))
-    val = concat2 (build_string ("/:"), val);
-  if (buf != readlink_buf)
-    xfree (buf);
-  val = DECODE_FILE (val);
-  return val;
+  return emacs_readlinkat (AT_FDCWD, SSDATA (filename));
 }
 
 DEFUN ("file-directory-p", Ffile_directory_p, Sfile_directory_p, 1, 1, 0,
@@ -2898,8 +3006,10 @@ DEFUN ("set-file-selinux-context", Fset_file_selinux_context,
 CONTEXT should be a list (USER ROLE TYPE RANGE), where the list
 elements are strings naming the components of a SELinux context.
 
-This function does nothing if SELinux is disabled, or if Emacs was not
-compiled with SELinux support.  */)
+Value is t if setting of SELinux context was successful, nil otherwise.
+
+This function does nothing and returns nil if SELinux is disabled,
+or if Emacs was not compiled with SELinux support.  */)
   (Lisp_Object filename, Lisp_Object context)
 {
   Lisp_Object absname;
@@ -2965,6 +3075,7 @@ compiled with SELinux support.  */)
 
           context_free (parsed_con);
           freecon (con);
+          return fail ? Qnil : Qt;
         }
       else
         report_file_error ("Doing lgetfilecon", Fcons (absname, Qnil));
@@ -2974,6 +3085,109 @@ compiled with SELinux support.  */)
   return Qnil;
 }
 
+DEFUN ("file-acl", Ffile_acl, Sfile_acl, 1, 1, 0,
+       doc: /* Return ACL entries of file named FILENAME.
+The entries are returned in a format suitable for use in `set-file-acl'
+but is otherwise undocumented and subject to change.
+Return nil if file does not exist or is not accessible, or if Emacs
+was unable to determine the ACL entries.  */)
+  (Lisp_Object filename)
+{
+  Lisp_Object absname;
+  Lisp_Object handler;
+#ifdef HAVE_POSIX_ACL
+  acl_t acl;
+  Lisp_Object acl_string;
+  char *str;
+#endif
+
+  absname = expand_and_dir_to_file (filename,
+                                    BVAR (current_buffer, directory));
+
+  /* If the file name has special constructs in it,
+     call the corresponding file handler.  */
+  handler = Ffind_file_name_handler (absname, Qfile_acl);
+  if (!NILP (handler))
+    return call2 (handler, Qfile_acl, absname);
+
+#ifdef HAVE_POSIX_ACL
+  absname = ENCODE_FILE (absname);
+
+  acl = acl_get_file (SSDATA (absname), ACL_TYPE_ACCESS);
+  if (acl == NULL)
+    return Qnil;
+
+  str = acl_to_text (acl, NULL);
+  if (str == NULL)
+    {
+      acl_free (acl);
+      return Qnil;
+    }
+
+  acl_string = build_string (str);
+  acl_free (str);
+  acl_free (acl);
+
+  return acl_string;
+#endif
+
+  return Qnil;
+}
+
+DEFUN ("set-file-acl", Fset_file_acl, Sset_file_acl,
+       2, 2, 0,
+       doc: /* Set ACL of file named FILENAME to ACL-STRING.
+ACL-STRING should contain the textual representation of the ACL
+entries in a format suitable for the platform.
+
+Value is t if setting of ACL was successful, nil otherwise.
+
+Setting ACL for local files requires Emacs to be built with ACL
+support.  */)
+  (Lisp_Object filename, Lisp_Object acl_string)
+{
+  Lisp_Object absname;
+  Lisp_Object handler;
+#ifdef HAVE_POSIX_ACL
+  Lisp_Object encoded_absname;
+  acl_t acl;
+  bool fail;
+#endif
+
+  absname = Fexpand_file_name (filename, BVAR (current_buffer, directory));
+
+  /* If the file name has special constructs in it,
+     call the corresponding file handler.  */
+  handler = Ffind_file_name_handler (absname, Qset_file_acl);
+  if (!NILP (handler))
+    return call3 (handler, Qset_file_acl, absname, acl_string);
+
+#ifdef HAVE_POSIX_ACL
+  if (STRINGP (acl_string))
+    {
+      acl = acl_from_text (SSDATA (acl_string));
+      if (acl == NULL)
+        {
+          report_file_error ("Converting ACL", Fcons (absname, Qnil));
+          return Qnil;
+        }
+
+      encoded_absname = ENCODE_FILE (absname);
+
+      fail = (acl_set_file (SSDATA (encoded_absname), ACL_TYPE_ACCESS,
+                            acl)
+              != 0);
+      if (fail && errno != ENOTSUP)
+        report_file_error ("Setting ACL", Fcons (absname, Qnil));
+
+      acl_free (acl);
+      return fail ? Qnil : Qt;
+    }
+#endif
+
+  return Qnil;
+}
+
 DEFUN ("file-modes", Ffile_modes, Sfile_modes, 1, 1, 0,
        doc: /* Return mode bits of file named FILENAME, as an integer.
 Return nil, if file does not exist or is not accessible.  */)
@@ -3196,31 +3410,25 @@ decide_coding_unwind (Lisp_Object unwind_data)
   return Qnil;
 }
 
-
-/* Used to pass values from insert-file-contents to read_non_regular.  */
-
-static int non_regular_fd;
-static ptrdiff_t non_regular_inserted;
-static int non_regular_nbytes;
-
-
-/* Read from a non-regular file.
-   Read non_regular_nbytes bytes max from non_regular_fd.
-   Non_regular_inserted specifies where to put the read bytes.
-   Value is the number of bytes read.  */
+/* Read from a non-regular file.  STATE is a Lisp_Save_Value
+   object where slot 0 is the file descriptor, slot 1 specifies
+   an offset to put the read bytes, and slot 2 is the maximum
+   amount of bytes to read.  Value is the number of bytes read.  */
 
 static Lisp_Object
-read_non_regular (Lisp_Object ignore)
+read_non_regular (Lisp_Object state)
 {
   int nbytes;
 
   immediate_quit = 1;
   QUIT;
-  nbytes = emacs_read (non_regular_fd,
+  nbytes = emacs_read (XSAVE_INTEGER (state, 0),
                        ((char *) BEG_ADDR + PT_BYTE - BEG_BYTE
-                        + non_regular_inserted),
-                       non_regular_nbytes);
+                        + XSAVE_INTEGER (state, 1)),
+                       XSAVE_INTEGER (state, 2));
   immediate_quit = 0;
+  /* Fast recycle this object for the likely next call.  */
+  free_misc (state);
   return make_number (nbytes);
 }
 
@@ -3234,19 +3442,25 @@ read_non_regular_quit (Lisp_Object ignore)
   return Qnil;
 }
 
-/* Reposition FD to OFFSET, based on WHENCE.  This acts like lseek
-   except that it also tests for OFFSET being out of lseek's range.  */
+/* Return the file offset that VAL represents, checking for type
+   errors and overflow.  */
 static off_t
-emacs_lseek (int fd, EMACS_INT offset, int whence)
+file_offset (Lisp_Object val)
 {
-  /* Use "&" rather than "&&" to suppress a bogus GCC warning; see
-     <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43772>.  */
-  if (! ((offset >= TYPE_MINIMUM (off_t)) & (offset <= TYPE_MAXIMUM (off_t))))
+  if (RANGED_INTEGERP (0, val, TYPE_MAXIMUM (off_t)))
+    return XINT (val);
+
+  if (FLOATP (val))
     {
-      errno = EINVAL;
-      return -1;
+      double v = XFLOAT_DATA (val);
+      if (0 <= v
+          && (sizeof (off_t) < sizeof v
+              ? v <= TYPE_MAXIMUM (off_t)
+              : v < TYPE_MAXIMUM (off_t)))
+        return v;
     }
-  return lseek (fd, offset, whence);
+
+  wrong_type_argument (intern ("file-offset"), val);
 }
 
 /* Return a special time value indicating the error number ERRNUM.  */
@@ -3281,11 +3495,13 @@ the number of characters that replace previous buffer contents.
 
 This function does code conversion according to the value of
 `coding-system-for-read' or `file-coding-system-alist', and sets the
-variable `last-coding-system-used' to the coding system actually used.  */)
+variable `last-coding-system-used' to the coding system actually used.
+
+In addition, this function decodes the inserted text from known formats
+by calling `format-decode', which see.  */)
   (Lisp_Object filename, Lisp_Object visit, Lisp_Object beg, Lisp_Object end, Lisp_Object replace)
 {
   struct stat st;
-  int file_status;
   EMACS_TIME mtime;
   int fd;
   ptrdiff_t inserted = 0;
@@ -3302,7 +3518,6 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   int save_errno = 0;
   char read_buf[READ_BUF_SIZE];
   struct coding_system coding;
-  char buffer[1 << 14];
   bool replace_handled = 0;
   bool set_coding_system = 0;
   Lisp_Object coding_system;
@@ -3347,37 +3562,29 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   orig_filename = filename;
   filename = ENCODE_FILE (filename);
 
-  fd = -1;
-
-#ifdef WINDOWSNT
-  {
-    Lisp_Object tem = Vw32_get_true_file_attributes;
-
-    /* Tell stat to use expensive method to get accurate info.  */
-    Vw32_get_true_file_attributes = Qt;
-    file_status = stat (SSDATA (filename), &st);
-    Vw32_get_true_file_attributes = tem;
-  }
-#else
-  file_status = stat (SSDATA (filename), &st);
-#endif /* WINDOWSNT */
-
-  if (file_status == 0)
-    mtime = get_stat_mtime (&st);
-  else
+  fd = emacs_open (SSDATA (filename), O_RDONLY, 0);
+  if (fd < 0)
     {
-    badopen:
       save_errno = errno;
       if (NILP (visit))
         report_file_error ("Opening input file", Fcons (orig_filename, Qnil));
       mtime = time_error_value (save_errno);
       st.st_size = -1;
-      how_much = 0;
       if (!NILP (Vcoding_system_for_read))
         Fset (Qbuffer_file_coding_system, Vcoding_system_for_read);
       goto notfound;
     }
 
+  /* Replacement should preserve point as it preserves markers.  */
+  if (!NILP (replace))
+    record_unwind_protect (restore_point_unwind, Fpoint_marker ());
+
+  record_unwind_protect (close_file_unwind, make_number (fd));
+
+  if (fstat (fd, &st) != 0)
+    report_file_error ("Input file status", Fcons (orig_filename, Qnil));
+  mtime = get_stat_mtime (&st);
+
   /* This code will need to be changed in order to work on named
      pipes, and it's probably just not worth it.  So we should at
      least signal an error.  */
@@ -3393,17 +3600,6 @@ variable `last-coding-system-used' to the coding system actually used.  */)
                   build_string ("not a regular file"), orig_filename);
     }
 
-  if (fd < 0)
-    if ((fd = emacs_open (SSDATA (filename), O_RDONLY, 0)) < 0)
-      goto badopen;
-
-  /* Replacement should preserve point as it preserves markers.  */
-  if (!NILP (replace))
-    record_unwind_protect (restore_point_unwind, Fpoint_marker ());
-
-  record_unwind_protect (close_file_unwind, make_number (fd));
-
-
   if (!NILP (visit))
     {
       if (!NILP (beg) || !NILP (end))
@@ -3413,20 +3609,12 @@ variable `last-coding-system-used' to the coding system actually used.  */)
     }
 
   if (!NILP (beg))
-    {
-      if (! RANGED_INTEGERP (0, beg, TYPE_MAXIMUM (off_t)))
-        wrong_type_argument (intern ("file-offset"), beg);
-      beg_offset = XFASTINT (beg);
-    }
+    beg_offset = file_offset (beg);
   else
     beg_offset = 0;
 
   if (!NILP (end))
-    {
-      if (! RANGED_INTEGERP (0, end, TYPE_MAXIMUM (off_t)))
-        wrong_type_argument (intern ("file-offset"), end);
-      end_offset = XFASTINT (end);
-    }
+    end_offset = file_offset (end);
   else
     {
       if (not_regular)
@@ -3503,12 +3691,14 @@ variable `last-coding-system-used' to the coding system actually used.  */)
               else
                 {
                   nread = emacs_read (fd, read_buf, 1024);
-                  if (nread >= 0)
+                  if (nread == 1024)
                     {
-                      if (lseek (fd, st.st_size - (1024 * 3), SEEK_SET) < 0)
+                      int ntail;
+                      if (lseek (fd, - (1024 * 3), SEEK_END) < 0)
                         report_file_error ("Setting file position",
                                            Fcons (orig_filename, Qnil));
-                      nread += emacs_read (fd, read_buf + nread, 1024 * 3);
+                      ntail = emacs_read (fd, read_buf + nread, 1024 * 3);
+                      nread = ntail < 0 ? ntail : nread + ntail;
                     }
                 }
 
@@ -3629,7 +3819,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
         {
           int nread, bufpos;
 
-          nread = emacs_read (fd, buffer, sizeof buffer);
+          nread = emacs_read (fd, read_buf, sizeof read_buf);
           if (nread < 0)
             error ("IO error reading %s: %s",
                    SSDATA (orig_filename), emacs_strerror (errno));
@@ -3638,7 +3828,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
           if (CODING_REQUIRE_DETECTION (&coding))
             {
-              coding_system = detect_coding_system ((unsigned char *) buffer,
+              coding_system = detect_coding_system ((unsigned char *) read_buf,
                                                     nread, nread, 1, 0,
                                                     coding_system);
               setup_coding_system (coding_system, &coding);
@@ -3654,7 +3844,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
 
           bufpos = 0;
           while (bufpos < nread && same_at_start < ZV_BYTE
-                 && FETCH_BYTE (same_at_start) == buffer[bufpos])
+                 && FETCH_BYTE (same_at_start) == read_buf[bufpos])
             same_at_start++, bufpos++;
           /* If we found a discrepancy, stop the scan.
              Otherwise loop around and scan the next bufferful.  */
@@ -3688,7 +3878,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           if (curpos == 0)
             break;
           /* How much can we scan in the next step?  */
-          trial = min (curpos, sizeof buffer);
+          trial = min (curpos, sizeof read_buf);
           if (lseek (fd, curpos - trial, SEEK_SET) < 0)
             report_file_error ("Setting file position",
                                Fcons (orig_filename, Qnil));
@@ -3696,7 +3886,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           total_read = nread = 0;
           while (total_read < trial)
             {
-              nread = emacs_read (fd, buffer + total_read, trial - total_read);
+              nread = emacs_read (fd, read_buf + total_read, trial - total_read);
               if (nread < 0)
                 error ("IO error reading %s: %s",
                        SDATA (orig_filename), emacs_strerror (errno));
@@ -3712,7 +3902,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
           /* Compare with same_at_start to avoid counting some buffer text
              as matching both at the file's beginning and at the end.  */
           while (bufpos > 0 && same_at_end > same_at_start
-                 && FETCH_BYTE (same_at_end - 1) == buffer[bufpos - 1])
+                 && FETCH_BYTE (same_at_end - 1) == read_buf[bufpos - 1])
             same_at_end--, bufpos--;
 
           /* If we found a discrepancy, stop the scan.
@@ -3814,30 +4004,25 @@ variable `last-coding-system-used' to the coding system actually used.  */)
         report_file_error ("Setting file position",
                            Fcons (orig_filename, Qnil));
 
-      total = st.st_size;       /* Total bytes in the file.  */
-      how_much = 0;             /* Bytes read from file so far.  */
       inserted = 0;             /* Bytes put into CONVERSION_BUFFER so far.  */
       unprocessed = 0;          /* Bytes not processed in previous loop.  */
 
       GCPRO1 (conversion_buffer);
-      while (how_much < total)
+      while (1)
         {
-          /* We read one bunch by one (READ_BUF_SIZE bytes) to allow
-             quitting while reading a huge while.  */
-          /* `try'' is reserved in some compilers (Microsoft C).  */
-          int trytry = min (total - how_much, READ_BUF_SIZE - unprocessed);
+          /* Read at most READ_BUF_SIZE bytes at a time, to allow
+             quitting while reading a huge file.  */
 
           /* Allow quitting out of the actual I/O.  */
           immediate_quit = 1;
           QUIT;
-          this = emacs_read (fd, read_buf + unprocessed, trytry);
+          this = emacs_read (fd, read_buf + unprocessed,
+                             READ_BUF_SIZE - unprocessed);
           immediate_quit = 0;
 
           if (this <= 0)
             break;
 
-          how_much += this;
-
           BUF_TEMP_SET_PT (XBUFFER (conversion_buffer),
                            BUF_Z (XBUFFER (conversion_buffer)));
           decode_coding_c_string (&coding, (unsigned char *) read_buf,
@@ -3854,9 +4039,6 @@ variable `last-coding-system-used' to the coding system actually used.  */)
          so defer the removal till we reach the `handled' label.  */
       deferred_remove_unwind_protect = 1;
 
-      /* At this point, HOW_MUCH should equal TOTAL, or should be <= 0
-         if we couldn't read the file.  */
-
       if (this < 0)
         error ("IO error reading %s: %s",
                SDATA (orig_filename), emacs_strerror (errno));
@@ -3993,7 +4175,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
       prepare_to_modify_buffer (GPT, GPT, NULL);
     }
 
-  move_gap (PT);
+  move_gap_both (PT, PT_BYTE);
   if (GAP_SIZE < total)
     make_gap (total - GAP_SIZE);
 
@@ -4021,7 +4203,7 @@ variable `last-coding-system-used' to the coding system actually used.  */)
     while (how_much < total)
       {
         /* try is reserved in some compilers (Microsoft C) */
-        int trytry = min (total - how_much, READ_BUF_SIZE);
+        ptrdiff_t trytry = min (total - how_much, READ_BUF_SIZE);
         ptrdiff_t this;
 
         if (not_regular)
@@ -4031,19 +4213,18 @@ variable `last-coding-system-used' to the coding system actually used.  */)
             /* Maybe make more room.  */
             if (gap_size < trytry)
               {
-                make_gap (total - gap_size);
-                gap_size = GAP_SIZE;
+                make_gap (trytry - gap_size);
+                gap_size = GAP_SIZE - inserted;
               }
 
             /* Read from the file, capturing `quit'.  When an
                error occurs, end the loop, and arrange for a quit
                to be signaled after decoding the text we read.  */
-            non_regular_fd = fd;
-            non_regular_inserted = inserted;
-            non_regular_nbytes = trytry;
-            nbytes = internal_condition_case_1 (read_non_regular,
-                                                Qnil, Qerror,
-                                                read_non_regular_quit);
+            nbytes = internal_condition_case_1
+              (read_non_regular,
+               make_save_value ("iii", (ptrdiff_t) fd, inserted, trytry),
+               Qerror, read_non_regular_quit);
+
             if (NILP (nbytes))
               {
                 read_quit = 1;
@@ -4085,8 +4266,9 @@ variable `last-coding-system-used' to the coding system actually used.  */)
       }
   }
 
-  /* Now we have read all the file data into the gap.
-     If it was empty, undo marking the buffer modified.  */
+  /* Now we have either read all the file data into the gap,
+     or stop reading on I/O error or quit.  If nothing was
+     read, undo marking the buffer modified.  */
 
   if (inserted == 0)
     {
@@ -4099,6 +4281,15 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   else
     Vdeactivate_mark = Qt;
 
+  emacs_close (fd);
+
+  /* Discard the unwind protect for closing the file.  */
+  specpdl_ptr--;
+
+  if (how_much < 0)
+    error ("IO error reading %s: %s",
+           SDATA (orig_filename), emacs_strerror (errno));
+
   /* Make the text read part of the buffer.  */
   GAP_SIZE -= inserted;
   GPT      += inserted;
@@ -4112,15 +4303,6 @@ variable `last-coding-system-used' to the coding system actually used.  */)
     /* Put an anchor to ensure multi-byte form ends at gap.  */
     *GPT_ADDR = 0;
 
-  emacs_close (fd);
-
-  /* Discard the unwind protect for closing the file.  */
-  specpdl_ptr--;
-
-  if (how_much < 0)
-    error ("IO error reading %s: %s",
-           SDATA (orig_filename), emacs_strerror (errno));
-
  notfound:
 
   if (NILP (coding_system))
@@ -4412,11 +4594,9 @@ variable `last-coding-system-used' to the coding system actually used.  */)
   if (read_quit)
     Fsignal (Qquit, Qnil);
 
-  /* ??? Retval needs to be dealt with in all cases consistently.  */
+  /* Retval needs to be dealt with in all cases consistently.  */
   if (NILP (val))
-    val = Fcons (orig_filename,
-                 Fcons (make_number (inserted),
-                        Qnil));
+    val = list2 (orig_filename, make_number (inserted));
 
   RETURN_UNGCPRO (unbind_to (count, val));
 }
@@ -4432,14 +4612,24 @@ build_annotations_unwind (Lisp_Object arg)
 
 /* Decide the coding-system to encode the data with.  */
 
-static Lisp_Object
-choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
-                            Lisp_Object append, Lisp_Object visit, Lisp_Object lockname,
-                            struct coding_system *coding)
+DEFUN ("choose-write-coding-system", Fchoose_write_coding_system,
+       Schoose_write_coding_system, 3, 6, 0,
+       doc: /* Choose the coding system for writing a file.
+Arguments are as for `write-region'.
+This function is for internal use only.  It may prompt the user.  */ )
+  (Lisp_Object start, Lisp_Object end, Lisp_Object filename,
+   Lisp_Object append, Lisp_Object visit, Lisp_Object lockname)
 {
   Lisp_Object val;
   Lisp_Object eol_parent = Qnil;
 
+  /* Mimic write-region behavior.  */
+  if (NILP (start))
+    {
+      XSETFASTINT (start, BEGV);
+      XSETFASTINT (end, ZV);
+    }
+
   if (auto_saving
       && NILP (Fstring_equal (BVAR (current_buffer, filename),
                               BVAR (current_buffer, auto_save_file_name))))
@@ -4532,10 +4722,6 @@ choose_write_coding_system (Lisp_Object start, Lisp_Object end, Lisp_Object file
     }
 
   val = coding_inherit_eol_type (val, eol_parent);
-  setup_coding_system (val, coding);
-
-  if (!STRINGP (start) && !NILP (BVAR (current_buffer, selective_display)))
-    coding->mode |= CODING_MODE_SELECTIVE_DISPLAY;
   return val;
 }
 
@@ -4550,7 +4736,7 @@ If START is a string, then output that string to the file
 instead of any buffer contents; END is ignored.
 
 Optional fourth argument APPEND if non-nil means
-  append to existing file contents (if any).  If it is an integer,
+  append to existing file contents (if any).  If it is a number,
   seek to that offset in the file before writing.
 Optional fifth argument VISIT, if t or a string, means
   set the last-save-file-modtime of buffer to this file's modtime
@@ -4579,6 +4765,9 @@ This calls `write-region-annotate-functions' at the start, and
   (Lisp_Object start, Lisp_Object end, Lisp_Object filename, Lisp_Object append, Lisp_Object visit, Lisp_Object lockname, Lisp_Object mustbenew)
 {
   int desc;
+  int open_flags;
+  int mode;
+  off_t offset IF_LINT (= 0);
   bool ok;
   int save_errno = 0;
   const char *fn;
@@ -4688,9 +4877,14 @@ This calls `write-region-annotate-functions' at the start, and
      We used to make this choice before calling build_annotations, but that
      leads to problems when a write-annotate-function takes care of
      unsavable chars (as was the case with X-Symbol).  */
-  Vlast_coding_system_used
-    = choose_write_coding_system (start, end, filename,
-                                  append, visit, lockname, &coding);
+  Vlast_coding_system_used =
+    Fchoose_write_coding_system (start, end, filename,
+                                 append, visit, lockname);
+
+  setup_coding_system (Vlast_coding_system_used, &coding);
+
+  if (!STRINGP (start) && !NILP (BVAR (current_buffer, selective_display)))
+    coding.mode |= CODING_MODE_SELECTIVE_DISPLAY;
 
 #ifdef CLASH_DETECTION
   if (!auto_saving)
@@ -4698,27 +4892,20 @@ This calls `write-region-annotate-functions' at the start, and
 #endif /* CLASH_DETECTION */
 
   encoded_filename = ENCODE_FILE (filename);
-
   fn = SSDATA (encoded_filename);
-  desc = -1;
-  if (!NILP (append))
+  open_flags = O_WRONLY | O_BINARY | O_CREAT;
+  open_flags |= EQ (mustbenew, Qexcl) ? O_EXCL : !NILP (append) ? 0 : O_TRUNC;
+  if (NUMBERP (append))
+    offset = file_offset (append);
+  else if (!NILP (append))
+    open_flags |= O_APPEND;
 #ifdef DOS_NT
-    desc = emacs_open (fn, O_WRONLY | O_BINARY, 0);
-#else  /* not DOS_NT */
-    desc = emacs_open (fn, O_WRONLY, 0);
-#endif /* not DOS_NT */
+  mode = S_IREAD | S_IWRITE;
+#else
+  mode = auto_saving ? auto_save_mode_bits : 0666;
+#endif
 
-  if (desc < 0 && (NILP (append) || errno == ENOENT))
-#ifdef DOS_NT
-  desc = emacs_open (fn,
-                     O_WRONLY | O_CREAT | O_BINARY
-                     | (EQ (mustbenew, Qexcl) ? O_EXCL : O_TRUNC),
-                     S_IREAD | S_IWRITE);
-#else  /* not DOS_NT */
-  desc = emacs_open (fn, O_WRONLY | O_TRUNC | O_CREAT
-                     | (EQ (mustbenew, Qexcl) ? O_EXCL : 0),
-                     auto_saving ? auto_save_mode_bits : 0666);
-#endif /* not DOS_NT */
+  desc = emacs_open (fn, open_flags, mode);
 
   if (desc < 0)
     {
@@ -4733,14 +4920,9 @@ This calls `write-region-annotate-functions' at the start, and
 
   record_unwind_protect (close_file_unwind, make_number (desc));
 
-  if (!NILP (append) && !NILP (Ffile_regular_p (filename)))
+  if (NUMBERP (append))
     {
-      off_t ret;
-
-      if (NUMBERP (append))
-        ret = emacs_lseek (desc, XINT (append), SEEK_CUR);
-      else
-        ret = lseek (desc, 0, SEEK_END);
+      off_t ret = lseek (desc, offset, SEEK_SET);
       if (ret < 0)
         {
 #ifdef CLASH_DETECTION
@@ -4782,7 +4964,7 @@ This calls `write-region-annotate-functions' at the start, and
   immediate_quit = 0;
 
 #ifdef HAVE_FSYNC
-  /* Note fsync appears to change the modtime on BSD4.2 (both vax and sun).
+  /* fsync appears to change the modtime on BSD4.2.
      Disk full in NFS may be reported here.  */
   /* mib says that closing the file will try to write as fast as NFS can do
      it, and that means the fsync here is not crucial for autosave files.  */
@@ -4812,6 +4994,63 @@ This calls `write-region-annotate-functions' at the start, and
   /* Discard the unwind protect for close_file_unwind.  */
   specpdl_ptr = specpdl + count1;
 
+  /* Some file systems have a bug where st_mtime is not updated
+     properly after a write.  For example, CIFS might not see the
+     st_mtime change until after the file is opened again.
+
+     Attempt to detect this file system bug, and update MODTIME to the
+     newer st_mtime if the bug appears to be present.  This introduces
+     a race condition, so to avoid most instances of the race condition
+     on non-buggy file systems, skip this check if the most recently
+     encountered non-buggy file system was the current file system.
+
+     A race condition can occur if some other process modifies the
+     file between the fstat above and the fstat below, but the race is
+     unlikely and a similar race between the last write and the fstat
+     above cannot possibly be closed anyway.  */
+
+  if (EMACS_TIME_VALID_P (modtime)
+      && ! (valid_timestamp_file_system && st.st_dev == timestamp_file_system))
+    {
+      int desc1 = emacs_open (fn, O_WRONLY | O_BINARY, 0);
+      if (0 <= desc1)
+        {
+          struct stat st1;
+          if (fstat (desc1, &st1) == 0
+              && st.st_dev == st1.st_dev && st.st_ino == st1.st_ino)
+            {
+              /* Use the heuristic if it appears to be valid.  With neither
+                 O_EXCL nor O_TRUNC, if Emacs happened to write nothing to the
+                 file, the time stamp won't change.  Also, some non-POSIX
+                 systems don't update an empty file's time stamp when
+                 truncating it.  Finally, file systems with 100 ns or worse
+                 resolution sometimes seem to have bugs: on a system with ns
+                 resolution, checking ns % 100 incorrectly avoids the heuristic
+                 1% of the time, but the problem should be temporary as we will
+                 try again on the next time stamp.  */
+              bool use_heuristic
+                = ((open_flags & (O_EXCL | O_TRUNC)) != 0
+                   && st.st_size != 0
+                   && EMACS_NSECS (modtime) % 100 != 0);
+
+              EMACS_TIME modtime1 = get_stat_mtime (&st1);
+              if (use_heuristic
+                  && EMACS_TIME_EQ (modtime, modtime1)
+                  && st.st_size == st1.st_size)
+                {
+                  timestamp_file_system = st.st_dev;
+                  valid_timestamp_file_system = 1;
+                }
+              else
+                {
+                  st.st_size = st1.st_size;
+                  modtime = modtime1;
+                }
+            }
+          emacs_close (desc1);
+        }
+    }
+
   /* Call write-region-post-annotation-function. */
   while (CONSP (Vwrite_region_annotation_buffers))
     {
@@ -4864,7 +5103,7 @@ This calls `write-region-annotate-functions' at the start, and
     }
 
   if (!auto_saving)
-    message_with_string ((INTEGERP (append)
+    message_with_string ((NUMBERP (append)
                           ? "Updated %s"
                           : ! NILP (append)
                           ? "Added to %s"
@@ -5142,8 +5381,8 @@ See Info node `(elisp)Modification Time' for more details.  */)
            ? get_stat_mtime (&st)
            : time_error_value (errno));
   if (EMACS_TIME_EQ (mtime, b->modtime)
-      && (st.st_size == b->modtime_size
-          || b->modtime_size < 0))
+      && (b->modtime_size < 0
+          || st.st_size == b->modtime_size))
     return Qt;
   return Qnil;
 }
@@ -5170,7 +5409,15 @@ See Info node `(elisp)Modification Time' for more details.  */)
   (void)
 {
   if (EMACS_NSECS (current_buffer->modtime) < 0)
-    return make_number (0);
+    {
+      if (EMACS_NSECS (current_buffer->modtime) == NONEXISTENT_MODTIME_NSECS)
+        {
+          /* make_lisp_time won't work here if time_t is unsigned.  */
+          return list4 (make_number (-1), make_number (65535),
+                        make_number (0), make_number (0));
+        }
+      return make_number (0);
+    }
   return make_lisp_time (current_buffer->modtime);
 }
 
@@ -5220,10 +5467,8 @@ static Lisp_Object
 auto_save_error (Lisp_Object error_val)
 {
   Lisp_Object args[3], msg;
-  int i, nbytes;
+  int i;
   struct gcpro gcpro1;
-  char *msgbuf;
-  USE_SAFE_ALLOCA;
 
   auto_save_error_occurred = 1;
 
@@ -5234,20 +5479,16 @@ auto_save_error (Lisp_Object error_val)
   args[2] = Ferror_message_string (error_val);
   msg = Fformat (3, args);
   GCPRO1 (msg);
-  nbytes = SBYTES (msg);
-  msgbuf = SAFE_ALLOCA (nbytes);
-  memcpy (msgbuf, SDATA (msg), nbytes);
 
   for (i = 0; i < 3; ++i)
     {
       if (i == 0)
-        message2 (msgbuf, nbytes, STRING_MULTIBYTE (msg));
+        message3 (msg);
       else
-        message2_nolog (msgbuf, nbytes, STRING_MULTIBYTE (msg));
+        message3_nolog (msg);
       Fsleep_for (make_number (1), Qnil);
     }
 
-  SAFE_FREE ();
   UNGCPRO;
   return Qnil;
 }
@@ -5282,7 +5523,7 @@ static Lisp_Object
 do_auto_save_unwind (Lisp_Object arg)  /* used as unwind-protect function */
 
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg, 0);
   auto_saving = 0;
   if (stream != NULL)
     {
@@ -5392,7 +5633,7 @@ A non-nil CURRENT-ONLY argument means save only current buffer.  */)
     }
 
   record_unwind_protect (do_auto_save_unwind,
-                         make_save_value (stream, 0));
+                         make_save_pointer (stream));
   record_unwind_protect (do_auto_save_unwind_1,
                          make_number (minibuffer_auto_raise));
   minibuffer_auto_raise = 0;
@@ -5601,6 +5842,12 @@ Fread_file_name (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filena
 
 
 void
+init_fileio (void)
+{
+  valid_timestamp_file_system = 0;
+}
+
+void
 syms_of_fileio (void)
 {
   DEFSYM (Qoperations, "operations");
@@ -5633,8 +5880,11 @@ syms_of_fileio (void)
   DEFSYM (Qset_file_times, "set-file-times");
   DEFSYM (Qfile_selinux_context, "file-selinux-context");
   DEFSYM (Qset_file_selinux_context, "set-file-selinux-context");
+  DEFSYM (Qfile_acl, "file-acl");
+  DEFSYM (Qset_file_acl, "set-file-acl");
   DEFSYM (Qfile_newer_than_file_p, "file-newer-than-file-p");
   DEFSYM (Qinsert_file_contents, "insert-file-contents");
+  DEFSYM (Qchoose_write_coding_system, "choose-write-coding-system");
   DEFSYM (Qwrite_region, "write-region");
   DEFSYM (Qverify_visited_file_modtime, "verify-visited-file-modtime");
   DEFSYM (Qset_visited_file_modtime, "set-visited-file-modtime");
@@ -5852,11 +6102,14 @@ This includes interactive calls to `delete-file' and
   defsubr (&Sset_file_modes);
   defsubr (&Sset_file_times);
   defsubr (&Sfile_selinux_context);
+  defsubr (&Sfile_acl);
+  defsubr (&Sset_file_acl);
   defsubr (&Sset_file_selinux_context);
   defsubr (&Sset_default_file_modes);
   defsubr (&Sdefault_file_modes);
   defsubr (&Sfile_newer_than_file_p);
   defsubr (&Sinsert_file_contents);
+  defsubr (&Schoose_write_coding_system);
   defsubr (&Swrite_region);
   defsubr (&Scar_less_than_car);
   defsubr (&Sverify_visited_file_modtime);
diff --git a/src/filelock.c b/src/filelock.c
index 17f3f253249..228fe98e8c7 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -1,6 +1,6 @@
 /* Lock files for editing.
-   Copyright (C) 1985-1987, 1993-1994, 1996, 1998-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993-1994, 1996, 1998-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -390,12 +390,14 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   lock_info_type local_owner;
   intmax_t n;
   char *at, *dot, *colon;
-  char readlink_buf[READLINK_BUFSIZE];
-  char *lfinfo = emacs_readlink (lfname, readlink_buf);
+  Lisp_Object lfinfo_object = emacs_readlinkat (AT_FDCWD, lfname);
+  char *lfinfo;
+  struct gcpro gcpro1;
 
   /* If nonexistent lock file, all is well; otherwise, got strange error. */
-  if (!lfinfo)
+  if (NILP (lfinfo_object))
     return errno == ENOENT ? 0 : -1;
+  lfinfo = SSDATA (lfinfo_object);
 
   /* Even if the caller doesn't want the owner info, we still have to
      read it to determine return value.  */
@@ -407,12 +409,9 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   at = strrchr (lfinfo, '@');
   dot = strrchr (lfinfo, '.');
   if (!at || !dot)
-    {
-      if (lfinfo != readlink_buf)
-        xfree (lfinfo);
-      return -1;
-    }
+    return -1;
   len = at - lfinfo;
+  GCPRO1 (lfinfo_object);
   owner->user = xmalloc (len + 1);
   memcpy (owner->user, lfinfo, len);
   owner->user[len] = 0;
@@ -445,8 +444,7 @@ current_lock_owner (lock_info_type *owner, char *lfname)
   owner->host[len] = 0;
 
   /* We're done looking at the link info.  */
-  if (lfinfo != readlink_buf)
-    xfree (lfinfo);
+  UNGCPRO;
 
   /* On current host?  */
   if (STRINGP (Fsystem_name ())
diff --git a/src/firstfile.c b/src/firstfile.c
index 444fb71b55d..80c936719d6 100644
--- a/src/firstfile.c
+++ b/src/firstfile.c
@@ -1,5 +1,5 @@
 /* Mark beginning of data space to dump as pure, for GNU Emacs.
-   Copyright (C) 1997, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1997, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/floatfns.c b/src/floatfns.c
index 645a5957609..43576a16248 100644
--- a/src/floatfns.c
+++ b/src/floatfns.c
@@ -1,7 +1,7 @@
 /* Primitive operations on floating point for GNU Emacs Lisp interpreter.
 
-Copyright (C) 1988, 1993-1994, 1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1988, 1993-1994, 1999, 2001-2013 Free Software Foundation,
+Inc.
 
 Author: Wolfgang Rupprecht
 (according to ack.texi)
@@ -399,8 +399,8 @@ round2 (EMACS_INT i1, EMACS_INT i2)
      odd.  */
   EMACS_INT q = i1 / i2;
   EMACS_INT r = i1 % i2;
-  EMACS_INT abs_r = r < 0 ? -r : r;
-  EMACS_INT abs_r1 = (i2 < 0 ? -i2 : i2) - abs_r;
+  EMACS_INT abs_r = eabs (r);
+  EMACS_INT abs_r1 = eabs (i2) - abs_r;
   return q + (abs_r + (q & 1) <= abs_r1 ? 0 : (i2 ^ r) < 0 ? -1 : 1);
 }
 
diff --git a/src/fns.c b/src/fns.c
index 7c2222e9805..44ddf340856 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -1,6 +1,6 @@
 /* Random utility Lisp functions.
-   Copyright (C) 1985-1987, 1993-1995, 1997-2012
-                 Free Software Foundation, Inc.
+
+Copyright (C) 1985-1987, 1993-1995, 1997-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -66,7 +66,10 @@ and `most-positive-fixnum', inclusive, are equally likely.
 
 With positive integer LIMIT, return random number in interval [0,LIMIT).
 With argument t, set the random number seed from the current time and pid.
-Other values of LIMIT are ignored.  */)
+With a string argument, set the seed based on the string's contents.
+Other values of LIMIT are ignored.
+
+See Info node `(elisp)Random Numbers' for more details.  */)
   (Lisp_Object limit)
 {
   EMACS_INT val;
@@ -86,7 +89,7 @@ Other values of LIMIT are ignored.  */)
    before it's time to do a QUIT.  This must be a power of 2.  */
 enum { QUIT_COUNT_HEURISTIC = 1 << 16 };
 
-/* Random data-structure functions */
+/* Random data-structure functions.  */
 
 DEFUN ("length", Flength, Slength, 1, 1, 0,
        doc: /* Return the length of vector, list or string SEQUENCE.
@@ -211,12 +214,18 @@ Symbols are also allowed; their print names are used instead.  */)
 
 DEFUN ("compare-strings", Fcompare_strings, Scompare_strings, 6, 7, 0,
        doc: /* Compare the contents of two strings, converting to multibyte if needed.
-In string STR1, skip the first START1 characters and stop at END1.
-In string STR2, skip the first START2 characters and stop at END2.
-END1 and END2 default to the full lengths of the respective strings.
-
-Case is significant in this comparison if IGNORE-CASE is nil.
-Unibyte strings are converted to multibyte for comparison.
+The arguments START1, END1, START2, and END2, if non-nil, are
+positions specifying which parts of STR1 or STR2 to compare.  In
+string STR1, compare the part between START1 (inclusive) and END1
+\(exclusive).  If START1 is nil, it defaults to 0, the beginning of
+the string; if END1 is nil, it defaults to the length of the string.
+Likewise, in string STR2, compare the part between START2 and END2.
+
+The strings are compared by the numeric values of their characters.
+For instance, STR1 is "less than" STR2 if its first differing
+character has a smaller numeric value.  If IGNORE-CASE is non-nil,
+characters are converted to lower-case before comparing them.  Unibyte
+strings are converted to multibyte for comparison.
 
 The value is t if the strings (or specified portions) match.
 If string STR1 is less, the value is a negative number N;
@@ -2476,7 +2485,7 @@ is nil, and `use-dialog-box' is non-nil.  */)
 
       Fding (Qnil);
       Fdiscard_input ();
-      message ("Please answer yes or no.");
+      message1 ("Please answer yes or no.");
       Fsleep_for (make_number (2), Qnil);
     }
 }
@@ -2736,7 +2745,7 @@ ARGS are passed as extra arguments to the function.
 usage: (widget-apply WIDGET PROPERTY &rest ARGS)  */)
   (ptrdiff_t nargs, Lisp_Object *args)
 {
-  /* This function can GC. */
+  /* This function can GC.  */
   Lisp_Object newargs[3];
   struct gcpro gcpro1, gcpro2;
   Lisp_Object result;
@@ -2798,9 +2807,8 @@ The data read from the system are decoded using `locale-coding-system'.  */)
           val = build_unibyte_string (str);
           /* Fixme: Is this coding system necessarily right, even if
              it is consistent with CODESET?  If not, what to do?  */
-          Faset (v, make_number (i),
-                 code_convert_string_norecord (val, Vlocale_coding_system,
-                                               0));
+          ASET (v, i, code_convert_string_norecord (val, Vlocale_coding_system,
+                                                    0));
         }
       UNGCPRO;
       return v;
@@ -2820,8 +2828,8 @@ The data read from the system are decoded using `locale-coding-system'.  */)
         {
           str = nl_langinfo (months[i]);
           val = build_unibyte_string (str);
-          Faset (v, make_number (i),
-                 code_convert_string_norecord (val, Vlocale_coding_system, 0));
+          ASET (v, i, code_convert_string_norecord (val, Vlocale_coding_system,
+                                                    0));
         }
       UNGCPRO;
       return v;
@@ -4037,10 +4045,6 @@ sweep_weak_hash_tables (void)
 
 #define SXHASH_MAX_LEN   7
 
-/* Hash X, returning a value that fits into a Lisp integer.  */
-#define SXHASH_REDUCE(X) \
-  ((((X) ^ (X) >> (BITS_PER_EMACS_INT - FIXNUM_BITS))) & INTMASK)
-
 /* Return a hash for string PTR which has length LEN.  The hash value
    can be any EMACS_UINT value.  */
 
@@ -4073,7 +4077,7 @@ sxhash_string (char const *ptr, ptrdiff_t len)
 
 /* Return a hash for the floating point value VAL.  */
 
-static EMACS_INT
+static EMACS_UINT
 sxhash_float (double val)
 {
   EMACS_UINT hash = 0;
diff --git a/src/font.c b/src/font.c
index f6b6fa026c0..e2ea7262397 100644
--- a/src/font.c
+++ b/src/font.c
@@ -1,6 +1,6 @@
 /* font.c -- "Font" primitives.
 
-Copyright (C) 2006-2012  Free Software Foundation, Inc.
+Copyright (C) 2006-2013 Free Software Foundation, Inc.
 Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
   National Institute of Advanced Industrial Science and Technology (AIST)
   Registration Number H13PRO009
@@ -717,7 +717,7 @@ font_put_extra (Lisp_Object font, Lisp_Object prop, Lisp_Object val)
 }
 
 
-/* Font name parser and unparser */
+/* Font name parser and unparser.  */
 
 static int parse_matrix (const char *);
 static int font_expand_wildcards (Lisp_Object *, int);
@@ -1746,7 +1746,7 @@ font_parse_family_registry (Lisp_Object family, Lisp_Object registry, Lisp_Objec
 /* This part (through the next ^L) is still experimental and not
    tested much.  We may drastically change codes.  */
 
-/* OTF handler */
+/* OTF handler.  */
 
 #if 0
 
@@ -1857,11 +1857,11 @@ otf_open (Lisp_Object file)
   OTF *otf;
 
   if (! NILP (val))
-    otf = XSAVE_VALUE (XCDR (val))->pointer;
+    otf = XSAVE_POINTER (XCDR (val), 0);
   else
     {
       otf = STRINGP (file) ? OTF_open (SSDATA (file)) : NULL;
-      val = make_save_value (otf, 0);
+      val = make_save_pointer (otf);
       otf_list = Fcons (Fcons (file, val), otf_list);
     }
   return otf;
@@ -2035,7 +2035,7 @@ font_otf_Anchor (OTF_Anchor *anchor)
 #endif  /* 0 */
 
 
-/* Font sorting */
+/* Font sorting.  */
 
 static unsigned font_score (Lisp_Object, Lisp_Object *);
 static int font_compare (const void *, const void *);
@@ -2101,9 +2101,7 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
       {
         EMACS_INT diff = ((XINT (AREF (entity, i)) >> 8)
                           - (XINT (spec_prop[i]) >> 8));
-        if (diff < 0)
-          diff = - diff;
-        score |= min (diff, 127) << sort_shift_bits[i];
+        score |= min (eabs (diff), 127) << sort_shift_bits[i];
       }
 
   /* Score the size.  Maximum difference is 127.  */
@@ -2118,10 +2116,7 @@ font_score (Lisp_Object entity, Lisp_Object *spec_prop)
 
       if (CONSP (Vface_font_rescale_alist))
         pixel_size *= font_rescale_ratio (entity);
-      diff = pixel_size - XINT (AREF (entity, FONT_SIZE_INDEX));
-      if (diff < 0)
-        diff = - diff;
-      diff <<= 1;
+      diff = eabs (pixel_size - XINT (AREF (entity, FONT_SIZE_INDEX))) << 1;
       if (! NILP (spec_prop[FONT_DPI_INDEX])
           && ! EQ (spec_prop[FONT_DPI_INDEX], AREF (entity, FONT_DPI_INDEX)))
         diff |= 1;
@@ -2570,7 +2565,6 @@ font_get_cache (FRAME_PTR f, struct font_driver *driver)
   return val;
 }
 
-static int num_fonts;
 
 static void
 font_clear_cache (FRAME_PTR f, Lisp_Object cache, struct font_driver *driver)
@@ -2603,7 +2597,6 @@ font_clear_cache (FRAME_PTR f, Lisp_Object cache, struct font_driver *driver)
                         {
                           eassert (font && driver == font->driver);
                           driver->close (f, font);
-                          num_fonts--;
                         }
                     }
                   if (driver->free_entity)
@@ -2671,9 +2664,7 @@ font_delete_unmatched (Lisp_Object vec, Lisp_Object spec, int size)
         {
           int diff = XINT (AREF (entity, FONT_SIZE_INDEX)) - size;
 
-          if (diff != 0
-              && (diff < 0 ? -diff > FONT_PIXEL_SIZE_QUANTUM
-                  : diff > FONT_PIXEL_SIZE_QUANTUM))
+          if (eabs (diff) > FONT_PIXEL_SIZE_QUANTUM)
             prop = FONT_SPEC_MAX;
         }
       if (prop < FONT_SPEC_MAX
@@ -2863,7 +2854,6 @@ font_open_entity (FRAME_PTR f, Lisp_Object entity, int pixel_size)
     return Qnil;
   ASET (entity, FONT_OBJLIST_INDEX,
         Fcons (font_object, AREF (entity, FONT_OBJLIST_INDEX)));
-  num_fonts++;
 
   font = XFONT_OBJECT (font_object);
   min_width = (font->min_width ? font->min_width
@@ -2908,7 +2898,6 @@ font_close_object (FRAME_PTR f, Lisp_Object font_object)
   eassert (FRAME_X_DISPLAY_INFO (f)->n_fonts);
   FRAME_X_DISPLAY_INFO (f)->n_fonts--;
 #endif
-  num_fonts--;
 }
 
 
@@ -3585,7 +3574,7 @@ font_filter_properties (Lisp_Object font,
   Lisp_Object it;
   int i;
 
-  /* Set boolean values to Qt or Qnil */
+  /* Set boolean values to Qt or Qnil.  */
   for (i = 0; boolean_properties[i] != NULL; ++i)
     for (it = alist; ! NILP (it); it = XCDR (it))
       {
@@ -3700,11 +3689,11 @@ font_at (int c, ptrdiff_t pos, struct face *face, struct window *w,
 
 #ifdef HAVE_WINDOW_SYSTEM
 
-/* Check how many characters after POS (at most to *LIMIT) can be
-   displayed by the same font in the window W.  FACE, if non-NULL, is
-   the face selected for the character at POS.  If STRING is not nil,
-   it is the string to check instead of the current buffer.  In that
-   case, FACE must be not NULL.
+/* Check how many characters after character/byte position POS/POS_BYTE
+   (at most to *LIMIT) can be displayed by the same font in the window W.
+   FACE, if non-NULL, is the face selected for the character at POS.
+   If STRING is not nil, it is the string to check instead of the current
+   buffer.  In that case, FACE must be not NULL.
 
    The return value is the font-object for the character at POS.
    *LIMIT is set to the position where that font can't be used.
@@ -3712,15 +3701,15 @@ font_at (int c, ptrdiff_t pos, struct face *face, struct window *w,
    It is assured that the current buffer (or STRING) is multibyte.  */
 
 Lisp_Object
-font_range (ptrdiff_t pos, ptrdiff_t *limit, struct window *w, struct face *face, Lisp_Object string)
+font_range (ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t *limit,
+            struct window *w, struct face *face, Lisp_Object string)
 {
-  ptrdiff_t pos_byte, ignore;
+  ptrdiff_t ignore;
   int c;
   Lisp_Object font_object = Qnil;
 
   if (NILP (string))
     {
-      pos_byte = CHAR_TO_BYTE (pos);
       if (! face)
         {
           int face_id;
@@ -3731,10 +3720,7 @@ font_range (ptrdiff_t pos, ptrdiff_t *limit, struct window *w, struct face *face
         }
     }
   else
-    {
-      eassert (face);
-      pos_byte = string_char_to_byte (string, pos);
-    }
+    eassert (face);
 
   while (pos < *limit)
     {
@@ -3764,7 +3750,7 @@ font_range (ptrdiff_t pos, ptrdiff_t *limit, struct window *w, struct face *face
 #endif
 
 
-/* Lisp API */
+/* Lisp API.  */
 
 DEFUN ("fontp", Ffontp, Sfontp, 1, 2, 0,
        doc: /* Return t if OBJECT is a font-spec, font-entity, or font-object.
@@ -4614,7 +4600,7 @@ If the font is not OpenType font, CAPABILITY is nil.  */)
 
   CHECK_FONT_GET_OBJECT (font_object, font);
 
-  val = Fmake_vector (make_number (9), Qnil);
+  val = make_uninit_vector (9);
   ASET (val, 0, AREF (font_object, FONT_NAME_INDEX));
   ASET (val, 1, AREF (font_object, FONT_FILE_INDEX));
   ASET (val, 2, make_number (font->pixel_size));
@@ -4625,6 +4611,8 @@ If the font is not OpenType font, CAPABILITY is nil.  */)
   ASET (val, 7, make_number (font->average_width));
   if (font->driver->otf_capability)
     ASET (val, 8, Fcons (Qopentype, font->driver->otf_capability (font)));
+  else
+    ASET (val, 8, Qnil);
   return val;
 }
 
@@ -4840,7 +4828,7 @@ where
   OPENED-NAME is the name used for opening the font,
   FULL-NAME is the full name of the font,
   SIZE is the pixelsize of the font,
-  HEIGHT is the pixel-height of the font (i.e ascent + descent),
+  HEIGHT is the pixel-height of the font (i.e., ascent + descent),
   BASELINE-OFFSET is the upward offset pixels from ASCII baseline,
   RELATIVE-COMPOSE and DEFAULT-ASCENT are the numbers controlling
     how to compose characters.
@@ -4881,7 +4869,7 @@ If the named font is not yet loaded, return nil.  */)
     return Qnil;
   font = XFONT_OBJECT (font_object);
 
-  info = Fmake_vector (make_number (7), Qnil);
+  info = make_uninit_vector (7);
   ASET (info, 0, AREF (font_object, FONT_NAME_INDEX));
   ASET (info, 1, AREF (font_object, FONT_FULLNAME_INDEX));
   ASET (info, 2, make_number (font->pixel_size));
@@ -5174,7 +5162,7 @@ See `font-weight-table' for the format of the vector. */);
   XSYMBOL (intern_c_string ("font-width-table"))->constant = 1;
 
   staticpro (&font_style_table);
-  font_style_table = Fmake_vector (make_number (3), Qnil);
+  font_style_table = make_uninit_vector (3);
   ASET (font_style_table, 0, Vfont_weight_table);
   ASET (font_style_table, 1, Vfont_slant_table);
   ASET (font_style_table, 2, Vfont_width_table);
diff --git a/src/font.h b/src/font.h
index 3035a909efc..ffed0461ff7 100644
--- a/src/font.h
+++ b/src/font.h
@@ -1,5 +1,5 @@
 /* font.h -- Interface definition for font handling.
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
@@ -781,7 +781,7 @@ extern int font_unparse_fcname (Lisp_Object font, int pixel_size,
 extern void register_font_driver (struct font_driver *driver, FRAME_PTR f);
 extern void free_font_driver_list (FRAME_PTR f);
 extern Lisp_Object font_update_drivers (FRAME_PTR f, Lisp_Object list);
-extern Lisp_Object font_range (ptrdiff_t, ptrdiff_t *,
+extern Lisp_Object font_range (ptrdiff_t, ptrdiff_t, ptrdiff_t *,
                                struct window *, struct face *,
                                Lisp_Object);
 extern void font_fill_lglyph_metrics (Lisp_Object, Lisp_Object);
diff --git a/src/fontset.c b/src/fontset.c
index 660ca432fad..3578bc9403d 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -1,6 +1,6 @@
 /* Fontset handler.
 
-Copyright (C) 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 2001-2013 Free Software Foundation, Inc.
 Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
   2005, 2006, 2007, 2008, 2009, 2010, 2011
   National Institute of Advanced Industrial Science and Technology (AIST)
@@ -271,7 +271,8 @@ set_fontset_fallback (Lisp_Object fontset, Lisp_Object fallback)
 /* Macros for FONT-DEF and RFONT-DEF of fontset.  */
 #define FONT_DEF_NEW(font_def, font_spec, encoding, repertory)  \
   do {                                                          \
-    (font_def) = Fmake_vector (make_number (3), (font_spec));   \
+    (font_def) = make_uninit_vector (3);                        \
+    ASET ((font_def), 0, font_spec);                            \
     ASET ((font_def), 1, encoding);                             \
     ASET ((font_def), 2, repertory);                            \
   } while (0)
@@ -1591,7 +1592,7 @@ appended.  By default, FONT-SPEC overrides the previous settings.  */)
     {
       Lisp_Object arg;
 
-      arg = Fmake_vector (make_number (5), Qnil);
+      arg = make_uninit_vector (5);
       ASET (arg, 0, fontset);
       ASET (arg, 1, font_def);
       ASET (arg, 2, add);
diff --git a/src/fontset.h b/src/fontset.h
index 3eb8d633b6c..07ee5d65c25 100644
--- a/src/fontset.h
+++ b/src/fontset.h
@@ -1,5 +1,5 @@
 /* Header for fontset handler.
-   Copyright (C) 1998, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1998, 2001-2013 Free Software Foundation, Inc.
    Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
      2005, 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
diff --git a/src/frame.c b/src/frame.c
index 5cefad6ca46..0fa821682f3 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -1,6 +1,6 @@
 /* Generic frame functions.
 
-Copyright (C) 1993-1995, 1997, 1999-2012  Free Software Foundation, Inc.
+Copyright (C) 1993-1995, 1997, 1999-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -60,7 +60,7 @@ Lisp_Object Qns_parse_geometry;
 Lisp_Object Qframep, Qframe_live_p;
 Lisp_Object Qicon, Qmodeline;
 Lisp_Object Qonly, Qnone;
-Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
+Lisp_Object Qx, Qw32, Qpc, Qns;
 Lisp_Object Qvisible;
 Lisp_Object Qdisplay_type;
 static Lisp_Object Qbackground_mode;
@@ -225,8 +225,6 @@ See also `frame-live-p'.  */)
       return Qw32;
     case output_msdos_raw:
       return Qpc;
-    case output_mac:
-      return Qmac;
     case output_ns:
       return Qns;
     default:
@@ -502,8 +500,7 @@ make_initial_frame (void)
   tty_frame_count = 1;
   fset_name (f, build_pure_c_string ("F1"));
 
-  f->visible = 1;
-  f->async_visible = 1;
+  SET_FRAME_VISIBLE (f, 1);
 
   f->output_method = terminal->type;
   f->terminal = terminal;
@@ -542,8 +539,8 @@ make_terminal_frame (struct terminal *terminal)
 
   fset_name (f, make_formatted_string (name, "F%"pMd, ++tty_frame_count));
 
-  f->visible = 1;               /* FRAME_SET_VISIBLE wd set frame_garbaged. */
-  f->async_visible = 1;         /* Don't let visible be cleared later. */
+  SET_FRAME_VISIBLE (f, 1);
+
   f->terminal = terminal;
   f->terminal->reference_count++;
 #ifdef MSDOS
@@ -567,7 +564,7 @@ make_terminal_frame (struct terminal *terminal)
   /* Set the top frame to the newly created frame. */
   if (FRAMEP (FRAME_TTY (f)->top_frame)
       && FRAME_LIVE_P (XFRAME (FRAME_TTY (f)->top_frame)))
-    XFRAME (FRAME_TTY (f)->top_frame)->async_visible = 2; /* obscured */
+    SET_FRAME_VISIBLE (XFRAME (FRAME_TTY (f)->top_frame), 2); /* obscured */
 
   FRAME_TTY (f)->top_frame = frame;
 
@@ -808,8 +805,8 @@ do_switch_frame (Lisp_Object frame, int track, int for_deletion, Lisp_Object nor
     {
       if (FRAMEP (FRAME_TTY (XFRAME (frame))->top_frame))
         /* Mark previously displayed frame as now obscured.  */
-        XFRAME (FRAME_TTY (XFRAME (frame))->top_frame)->async_visible = 2;
-      XFRAME (frame)->async_visible = 1;
+        SET_FRAME_VISIBLE (XFRAME (FRAME_TTY (XFRAME (frame))->top_frame), 2);
+      SET_FRAME_VISIBLE (XFRAME (frame), 1);
       FRAME_TTY (XFRAME (frame))->top_frame = frame;
     }
 
@@ -916,7 +913,6 @@ candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
         }
       else if (EQ (minibuf, Qvisible))
         {
-          FRAME_SAMPLE_VISIBILITY (c);
           if (FRAME_VISIBLE_P (c))
             return candidate;
         }
@@ -930,7 +926,6 @@ candidate_frame (Lisp_Object candidate, Lisp_Object frame, Lisp_Object minibuf)
         }
       else if (XFASTINT (minibuf) == 0)
         {
-          FRAME_SAMPLE_VISIBILITY (c);
           if (FRAME_VISIBLE_P (c) || FRAME_ICONIFIED_P (c))
             return candidate;
         }
@@ -1054,10 +1049,7 @@ other_visible_frames (FRAME_PTR f)
          and note any recent change in visibility.  */
 #ifdef HAVE_WINDOW_SYSTEM
       if (FRAME_WINDOW_P (XFRAME (this)))
-        {
-          x_sync (XFRAME (this));
-          FRAME_SAMPLE_VISIBILITY (XFRAME (this));
-        }
+        x_sync (XFRAME (this));
 #endif
 
       if (FRAME_VISIBLE_P (XFRAME (this))
@@ -1233,7 +1225,7 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
   fset_root_window (f, Qnil);
 
   Vframe_list = Fdelq (frame, Vframe_list);
-  FRAME_SET_VISIBLE (f, 0);
+  SET_FRAME_VISIBLE (f, 0);
 
   /* Allow the vector of menu bar contents to be freed in the next
      garbage collection.  The frame object itself may not be garbage
@@ -1253,7 +1245,6 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
   xfree (FRAME_DELETEN_COST (f));
   xfree (FRAME_INSERTN_COST (f));
   xfree (FRAME_DELETE_COST (f));
-  xfree (FRAME_MESSAGE_BUF (f));
 
   /* Since some events are handled at the interrupt level, we may get
      an event for f at any time; if we zero out the frame's terminal
@@ -1268,10 +1259,10 @@ delete_frame (Lisp_Object frame, Lisp_Object force)
   {
     struct terminal *terminal = FRAME_TERMINAL (f);
     f->output_data.nothing = 0;
-    f->terminal = 0;             /* Now the frame is dead. */
+    f->terminal = 0;             /* Now the frame is dead.  */
 
     /* If needed, delete the terminal that this frame was on.
-       (This must be done after the frame is killed.) */
+       (This must be done after the frame is killed.)  */
     terminal->reference_count--;
 #ifdef USE_GTK
     /* FIXME: Deleting the terminal crashes emacs because of a GTK
@@ -1582,10 +1573,7 @@ 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 (f))
-    {
-      FRAME_SAMPLE_VISIBILITY (f);
-      x_make_frame_visible (f);
-    }
+    x_make_frame_visible (f);
 #endif
 
   make_frame_visible_1 (f->root_window);
@@ -1708,8 +1696,6 @@ currently being displayed on the terminal.  */)
 {
   CHECK_LIVE_FRAME (frame);
 
-  FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
-
   if (FRAME_VISIBLE_P (XFRAME (frame)))
     return Qt;
   if (FRAME_ICONIFIED_P (XFRAME (frame)))
@@ -2894,7 +2880,6 @@ x_report_frame_params (struct frame *f, Lisp_Object *alistptr)
                   make_formatted_string (buf, "%"pMu, w));
 #endif
   store_in_alist (alistptr, Qicon_name, f->icon_name);
-  FRAME_SAMPLE_VISIBILITY (f);
   store_in_alist (alistptr, Qvisibility,
                   (FRAME_VISIBLE_P (f) ? Qt
                    : FRAME_ICONIFIED_P (f) ? Qicon : Qnil));
@@ -4248,6 +4233,16 @@ Setting this variable does not affect existing frames, only new ones.  */);
   Vdefault_frame_scroll_bars = Qnil;
 #endif
 
+  DEFVAR_BOOL ("scroll-bar-adjust-thumb-portion",
+               scroll_bar_adjust_thumb_portion_p,
+               doc: /* Adjust thumb for overscrolling for Gtk+ and MOTIF.
+Non-nil means adjust the thumb in the scroll bar so it can be dragged downwards
+even if the end of the buffer is shown (i.e. overscrolling).
+Set to nil if you want the thumb to be at the bottom when the end of the buffer
+is shown.  Also, the thumb fills the whole scroll bar when the entire buffer
+is visible.  In this case you can not overscroll.  */);
+  scroll_bar_adjust_thumb_portion_p = 1;
+
   DEFVAR_LISP ("terminal-frame", Vterminal_frame,
                doc: /* The initial frame-object, which represents Emacs's stdout.  */);
 
diff --git a/src/frame.h b/src/frame.h
index 589b45fc0ff..c18b7662079 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -1,5 +1,5 @@
 /* Define frame-object for GNU Emacs.
-   Copyright (C) 1993-1994, 1999-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 1999-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -18,7 +18,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Don't multiply include: dispextern.h includes macterm.h which
    includes frame.h some emacs source includes both dispextern.h and
-   frame.h */
+   frame.h.  */
 
 #ifndef EMACS_FRAME_H
 #define EMACS_FRAME_H
@@ -33,7 +33,7 @@ INLINE_HEADER_BEGIN
 
 /* Miscellanea.  */
 
-/* Nonzero means there is at least one garbaged frame. */
+/* Nonzero means there is at least one garbaged frame.  */
 extern bool frame_garbaged;
 
 
@@ -46,7 +46,6 @@ enum output_method
   output_x_window,
   output_msdos_raw,
   output_w32,
-  output_mac,
   output_ns
 };
 
@@ -201,7 +200,7 @@ struct frame
      string's pointer (`name', above) because it might get relocated.  */
   char *namebuf;
 
-  /* Glyph pool and matrix. */
+  /* Glyph pool and matrix.  */
   struct glyph_pool *current_pool;
   struct glyph_pool *desired_pool;
   struct glyph_matrix *desired_matrix;
@@ -354,46 +353,30 @@ struct frame
   unsigned int external_menu_bar : 1;
 #endif
 
-  /* visible is nonzero if the frame is currently displayed; we check
+  /* Next two bitfields are mutually exclusive.  They might both be
+     zero if the frame has been made invisible without an icon.  */
+
+  /* Nonzero if the frame is currently displayed; we check
      it to see if we should bother updating the frame's contents.
-     DON'T SET IT DIRECTLY; instead, use FRAME_SET_VISIBLE.
 
      Note that, since invisible frames aren't updated, whenever a
-     frame becomes visible again, it must be marked as garbaged.  The
-     FRAME_SAMPLE_VISIBILITY macro takes care of this.
+     frame becomes visible again, it must be marked as garbaged.
 
      On ttys and on Windows NT/9X, to avoid wasting effort updating
      visible frames that are actually completely obscured by other
      windows on the display, we bend the meaning of visible slightly:
-     if greater than 1, then the frame is obscured - we still consider
+     if equal to 2, then the frame is obscured - we still consider
      it to be "visible" as seen from lisp, but we don't bother
      updating it.  We must take care to garbage the frame when it
-     ceases to be obscured though.
-
-     iconified is nonzero if the frame is currently iconified.
-
-     Asynchronous input handlers should NOT change these directly;
-     instead, they should change async_visible or async_iconified, and
-     let the FRAME_SAMPLE_VISIBILITY macro set visible and iconified
-     at the next redisplay.
-
-     These should probably be considered read-only by everyone except
-     FRAME_SAMPLE_VISIBILITY.
-
-     These two are mutually exclusive.  They might both be zero, if the
-     frame has been made invisible without an icon.  */
+     ceases to be obscured though.  See SET_FRAME_VISIBLE below.  */
   unsigned visible : 2;
-  unsigned iconified : 1;
 
-  /* Let's not use bitfields for volatile variables.  */
-
-  /* Asynchronous input handlers change these, and
-     FRAME_SAMPLE_VISIBILITY copies them into visible and iconified.
-     See FRAME_SAMPLE_VISIBILITY, below.  */
-  volatile char async_visible, async_iconified;
+  /* Nonzero if the frame is currently iconified.  Do not
+     set this directly, use SET_FRAME_ICONIFIED instead.  */
+  unsigned iconified : 1;
 
   /* Nonzero if this frame should be redrawn.  */
-  volatile char garbaged;
+  unsigned garbaged : 1;
 
   /* True if frame actually has a minibuffer window on it.
      0 if using a minibuffer window that isn't on this frame.  */
@@ -445,9 +428,6 @@ struct frame
   /* Width of bar cursor (if we are using that) for blink-off state.  */
   int blink_off_cursor_width;
 
-  /* Storage for messages to this frame. */
-  char *message_buf;
-
   /* Nonnegative if current redisplay should not do scroll computation
      for lines beyond a certain vpos.  This is the vpos.  */
   int scroll_bottom_vpos;
@@ -715,7 +695,7 @@ typedef struct frame *FRAME_PTR;
 #else
 #define FRAME_EXTERNAL_MENU_BAR(f) 0
 #endif
-#define FRAME_VISIBLE_P(f) ((f)->visible != 0)
+#define FRAME_VISIBLE_P(f) (f)->visible
 
 /* Nonzero if frame F is currently visible but hidden.  */
 #define FRAME_OBSCURED_P(f) ((f)->visible > 1)
@@ -723,9 +703,10 @@ typedef struct frame *FRAME_PTR;
 /* Nonzero if frame F is currently iconified.  */
 #define FRAME_ICONIFIED_P(f) (f)->iconified
 
-#define FRAME_SET_VISIBLE(f,p) \
-  ((f)->async_visible = (p), FRAME_SAMPLE_VISIBILITY (f))
+/* Mark frame F as currently garbaged.  */
 #define SET_FRAME_GARBAGED(f) (frame_garbaged = 1, f->garbaged = 1)
+
+/* Nonzero if frame F is currently garbaged.  */
 #define FRAME_GARBAGED_P(f) (f)->garbaged
 
 /* Nonzero means do not allow splitting this frame's window.  */
@@ -752,7 +733,6 @@ typedef struct frame *FRAME_PTR;
 #define FRAME_DELETE_COST(f) (f)->delete_line_cost
 #define FRAME_INSERTN_COST(f) (f)->insert_n_lines_cost
 #define FRAME_DELETEN_COST(f) (f)->delete_n_lines_cost
-#define FRAME_MESSAGE_BUF(f) (f)->message_buf
 #define FRAME_SCROLL_BOTTOM_VPOS(f) (f)->scroll_bottom_vpos
 #define FRAME_FOCUS_FRAME(f) f->focus_frame
 
@@ -871,39 +851,6 @@ typedef struct frame *FRAME_PTR;
 
 #define FRAME_MESSAGE_BUF_SIZE(f) (((int) FRAME_COLS (f)) * 4)
 
-/* Emacs's redisplay code could become confused if a frame's
-   visibility changes at arbitrary times.  For example, if a frame is
-   visible while the desired glyphs are being built, but becomes
-   invisible before they are updated, then some rows of the
-   desired_glyphs will be left marked as enabled after redisplay is
-   complete, which should never happen.  The next time the frame
-   becomes visible, redisplay will probably barf.
-
-   Currently, there are no similar situations involving iconified, but
-   the principle is the same.
-
-   So instead of having asynchronous input handlers directly set and
-   clear the frame's visibility and iconification flags, they just set
-   the async_visible and async_iconified flags; the redisplay code
-   calls the FRAME_SAMPLE_VISIBILITY macro before doing any redisplay,
-   which sets visible and iconified from their asynchronous
-   counterparts.
-
-   Synchronous code must use the FRAME_SET_VISIBLE macro.
-
-   Also, if a frame used to be invisible, but has just become visible,
-   it must be marked as garbaged, since redisplay hasn't been keeping
-   up its contents.
-
-   Note that a tty frame is visible if and only if it is the topmost
-   frame. */
-
-#define FRAME_SAMPLE_VISIBILITY(f) \
-  (((f)->async_visible && (f)->visible != (f)->async_visible) ? \
-   SET_FRAME_GARBAGED (f) : 0, \
-   (f)->visible = (f)->async_visible, \
-   (f)->iconified = (f)->async_iconified)
-
 #define CHECK_FRAME(x) \
   CHECK_TYPE (FRAMEP (x), Qframep, x)
 
@@ -937,12 +884,24 @@ typedef struct frame *FRAME_PTR;
         block_input ();                                         \
         if (hlinfo->mouse_face_mouse_frame)                     \
           note_mouse_highlight (hlinfo->mouse_face_mouse_frame, \
-                                hlinfo->mouse_face_mouse_x,     \
-                                hlinfo->mouse_face_mouse_y);    \
+                                hlinfo->mouse_face_mouse_x,     \
+                                hlinfo->mouse_face_mouse_y);    \
         unblock_input ();                                       \
       }                                                         \
   } while (0)
 
+/* Set visibility of frame F, marking F as garbaged if needed.  */
+
+#define SET_FRAME_VISIBLE(f, v)                         \
+  (((f)->visible == 0 || ((f)->visible == 2))           \
+   && ((v) == 1) ? SET_FRAME_GARBAGED (f) : 0,          \
+   (f)->visible = (eassert (0 <= (v) && (v) <= 2), (v)))
+
+/* Set iconify of frame F.  */
+
+#define SET_FRAME_ICONIFIED(f, i)                       \
+  (f)->iconified = (eassert (0 <= (i) && (i) <= 1), (i))
+
 extern Lisp_Object Qframep, Qframe_live_p;
 extern Lisp_Object Qtty, Qtty_type;
 extern Lisp_Object Qtty_color_mode;
@@ -1178,7 +1137,7 @@ extern Lisp_Object Qalpha;
 extern Lisp_Object Qleft_fringe, Qright_fringe;
 extern Lisp_Object Qheight, Qwidth;
 extern Lisp_Object Qminibuffer, Qmodeline;
-extern Lisp_Object Qx, Qw32, Qmac, Qpc, Qns;
+extern Lisp_Object Qx, Qw32, Qpc, Qns;
 extern Lisp_Object Qvisible;
 extern Lisp_Object Qdisplay_type;
 
diff --git a/src/fringe.c b/src/fringe.c
index a126292e1ff..fa6f889ba69 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -1,5 +1,6 @@
 /* Fringe handling (split from xdisp.c).
-   Copyright (C) 1985-1988, 1993-1995, 1997-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1360,8 +1361,8 @@ compute_fringe_widths (struct frame *f, int redraw)
 
   if (left_fringe_width || right_fringe_width)
     {
-      int left_wid = left_fringe_width >= 0 ? left_fringe_width : -left_fringe_width;
-      int right_wid = right_fringe_width >= 0 ? right_fringe_width : -right_fringe_width;
+      int left_wid = eabs (left_fringe_width);
+      int right_wid = eabs (right_fringe_width);
       int conf_wid = left_wid + right_wid;
       int font_wid = FRAME_COLUMN_WIDTH (f);
       int cols = (left_wid + right_wid + font_wid-1) / font_wid;
@@ -1744,7 +1745,7 @@ Return nil if POS is not visible in WINDOW.  */)
   else if (w == XWINDOW (selected_window))
     textpos = PT;
   else
-    textpos = XMARKER (w->pointm)->charpos;
+    textpos = marker_position (w->pointm);
 
   row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
   row = row_containing_pos (w, textpos, row, NULL, 0);
diff --git a/src/ftfont.c b/src/ftfont.c
index f07ad6f33c7..1fb1b574a1c 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -1,5 +1,5 @@
 /* ftfont.c -- FreeType font driver.
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
@@ -393,16 +393,14 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
       cache_data = xmalloc (sizeof *cache_data);
       cache_data->ft_face = NULL;
       cache_data->fc_charset = NULL;
-      val = make_save_value (NULL, 0);
-      XSAVE_VALUE (val)->integer = 0;
-      XSAVE_VALUE (val)->pointer = cache_data;
+      val = make_save_value ("pi", cache_data, 0);
       cache = Fcons (Qnil, val);
       Fputhash (key, cache, ft_face_cache);
     }
   else
     {
       val = XCDR (cache);
-      cache_data = XSAVE_VALUE (val)->pointer;
+      cache_data = XSAVE_POINTER (val, 0);
     }
 
   if (cache_for == FTFONT_CACHE_FOR_ENTITY)
@@ -468,7 +466,7 @@ ftfont_get_fc_charset (Lisp_Object entity)
 
   cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (val)->pointer;
+  cache_data = XSAVE_POINTER (val, 0);
   return cache_data->fc_charset;
 }
 
@@ -1200,9 +1198,9 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   filename = XCAR (val);
   idx = XCDR (val);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (XCDR (cache))->pointer;
+  cache_data = XSAVE_POINTER (XCDR (cache), 0);
   ft_face = cache_data->ft_face;
-  if (XSAVE_VALUE (val)->integer > 0)
+  if (XSAVE_INTEGER (val, 1) > 0)
     {
       /* FT_Face in this cache is already used by the different size.  */
       if (FT_New_Size (ft_face, &ft_size) != 0)
@@ -1213,13 +1211,13 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
           return Qnil;
         }
     }
-  XSAVE_VALUE (val)->integer++;
+  XSAVE_INTEGER (val, 1)++;
   size = XINT (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
     {
-      if (XSAVE_VALUE (val)->integer == 0)
+      if (XSAVE_INTEGER (val, 1) == 0)
         FT_Done_Face (ft_face);
       return Qnil;
     }
@@ -1328,10 +1326,10 @@ ftfont_close (FRAME_PTR f, struct font *font)
   cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
   eassert (CONSP (cache));
   val = XCDR (cache);
-  (XSAVE_VALUE (val)->integer)--;
-  if (XSAVE_VALUE (val)->integer == 0)
+  XSAVE_INTEGER (val, 1)--;
+  if (XSAVE_INTEGER (val, 1) == 0)
     {
-      struct ftfont_cache_data *cache_data = XSAVE_VALUE (val)->pointer;
+      struct ftfont_cache_data *cache_data = XSAVE_POINTER (val, 0);
 
       FT_Done_Face (cache_data->ft_face);
 #ifdef HAVE_LIBOTF
@@ -2557,9 +2555,8 @@ ftfont_shape_by_flt (Lisp_Object lgstring, struct font *font,
       LGLYPH_SET_DESCENT (lglyph, g->descent >> 6);
       if (g->adjusted)
         {
-          Lisp_Object vec;
+          Lisp_Object vec = make_uninit_vector (3);
 
-          vec = Fmake_vector (make_number (3), Qnil);
           ASET (vec, 0, make_number (g->xoff >> 6));
           ASET (vec, 1, make_number (g->yoff >> 6));
           ASET (vec, 2, make_number (g->xadv >> 6));
diff --git a/src/ftxfont.c b/src/ftxfont.c
index 5effe6e9104..8c56ee05adc 100644
--- a/src/ftxfont.c
+++ b/src/ftxfont.c
@@ -1,5 +1,5 @@
 /* ftxfont.c -- FreeType font driver on X (without using XFT).
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
diff --git a/src/getpagesize.h b/src/getpagesize.h
index 545082b2e78..6d0932abf1b 100644
--- a/src/getpagesize.h
+++ b/src/getpagesize.h
@@ -1,5 +1,6 @@
 /* Emulate getpagesize on systems that lack it.
-   Copyright (C) 1986, 1992, 1995, 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 1986, 1992, 1995, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/gmalloc.c b/src/gmalloc.c
index c325ca79910..bc1d85ac5fb 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -1,6 +1,6 @@
 /* Declarations for `malloc' and friends.
-   Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004,
-                 2005, 2006, 2007 Free Software Foundation, Inc.
+   Copyright (C) 1990-1993, 1995-1996, 1999, 2002-2007, 2013 Free
+   Software Foundation, Inc.
                   Written May 1989 by Mike Haertel.
 
 This library is free software; you can redistribute it and/or
@@ -14,9 +14,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -292,9 +290,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -972,9 +968,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -1286,9 +1280,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -1487,9 +1479,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -1520,9 +1510,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with the GNU C Library; see the file COPYING.  If not, write to
-the Free Software Foundation, 51 Franklin Street, Fifth Floor, Boston,
-MA 02110-1301, USA.  */
+along with the GNU C Library.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* uClibc defines __GNU_LIBRARY__, but it is not completely
    compatible.  */
@@ -1566,9 +1554,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.  */
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.  */
 
 void *(*__memalign_hook) (size_t size, size_t alignment);
 
@@ -1678,9 +1664,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
@@ -1722,9 +1706,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 General Public License for more details.
 
 You should have received a copy of the GNU General Public
-License along with this library; see the file COPYING.  If
-not, write to the Free Software Foundation, Inc., 51 Franklin Street,
-Fifth Floor, Boston, MA 02110-1301, USA.
+License along with this library.  If not, see <http://www.gnu.org/licenses/>.
 
    The author may be reached (Email) at the address mike@ai.mit.edu,
    or (US mail) as Mike Haertel c/o Free Software Foundation.  */
diff --git a/src/gnutls.c b/src/gnutls.c
index 03f753fa8cc..db0a6dac01c 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -1,5 +1,5 @@
 /* GnuTLS glue for GNU Emacs.
-   Copyright (C) 2010-2012  Free Software Foundation, Inc.
+   Copyright (C) 2010-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/gnutls.h b/src/gnutls.h
index 2b13908a748..f1a337e7b3e 100644
--- a/src/gnutls.h
+++ b/src/gnutls.h
@@ -1,5 +1,5 @@
 /* GnuTLS glue for GNU Emacs.
-   Copyright (C) 2010-2012  Free Software Foundation, Inc.
+   Copyright (C) 2010-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 52a6c37b0d5..d6e4dcebcd3 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1,6 +1,6 @@
 /* Functions for creating and updating GTK widgets.
 
-Copyright (C) 2003-2012  Free Software Foundation, Inc.
+Copyright (C) 2003-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -983,7 +983,7 @@ xg_frame_set_char_size (FRAME_PTR f, int cols, int rows)
      size as fast as possible.
      For unmapped windows, we can set rows/cols.  When
      the frame is mapped again we will (hopefully) get the correct size.  */
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     {
       /* Must call this to flush out events */
       (void)gtk_events_pending ();
@@ -1650,8 +1650,7 @@ xg_dialog_response_cb (GtkDialog *w,
 static Lisp_Object
 pop_down_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct xg_dialog_data *dd = (struct xg_dialog_data *) p->pointer;
+  struct xg_dialog_data *dd = XSAVE_POINTER (arg, 0);
 
   block_input ();
   if (dd->w) gtk_widget_destroy (dd->w);
@@ -1717,7 +1716,7 @@ xg_dialog_run (FRAME_PTR f, GtkWidget *w)
   g_signal_connect (G_OBJECT (w), "delete-event", G_CALLBACK (gtk_true), NULL);
   gtk_widget_show (w);
 
-  record_unwind_protect (pop_down_dialog, make_save_value (&dd, 0));
+  record_unwind_protect (pop_down_dialog, make_save_pointer (&dd));
 
   (void) xg_maybe_add_timer (&dd);
   g_main_loop_run (dd.loop);
@@ -2416,6 +2415,8 @@ make_menu_item (const char *utf8_label,
   return w;
 }
 
+#ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
+
 static int xg_detached_menus;
 
 /* Return true if there are detached menus.  */
@@ -2454,7 +2455,13 @@ tearoff_activate (GtkWidget *widget, gpointer client_data)
                         G_CALLBACK (tearoff_remove), 0);
     }
 }
-
+#else /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
+bool
+xg_have_tear_offs (void)
+{
+  return false;
+}
+#endif /* ! HAVE_GTK_TEAROFF_MENU_ITEM_NEW */
 
 /* Create a menu item widget, and connect the callbacks.
    ITEM describes the menu item.
@@ -2526,7 +2533,8 @@ xg_create_one_menuitem (widget_value *item,
    HIGHLIGHT_CB is the callback to call when entering/leaving menu items.
    If POP_UP_P, create a popup menu.
    If MENU_BAR_P, create a menu bar.
-   If ADD_TEAROFF_P, add a tearoff menu item.  Ignored if MENU_BAR_P.
+   If ADD_TEAROFF_P, add a tearoff menu item.  Ignored if MENU_BAR_P or
+   the Gtk+ version used does not have tearoffs.
    TOPMENU is the topmost GtkWidget that others shall be placed under.
    It may be NULL, in that case we create the appropriate widget
    (menu bar or menu item depending on POP_UP_P and MENU_BAR_P)
@@ -2599,6 +2607,7 @@ create_menus (widget_value *data,
                           "selection-done", deactivate_cb, 0);
     }
 
+#ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
   if (! menu_bar_p && add_tearoff_p)
     {
       GtkWidget *tearoff = gtk_tearoff_menu_item_new ();
@@ -2607,6 +2616,7 @@ create_menus (widget_value *data,
       g_signal_connect (G_OBJECT (tearoff), "activate",
                         G_CALLBACK (tearoff_activate), 0);
     }
+#endif
 
   for (item = data; item; item = item->next)
     {
@@ -2897,11 +2907,13 @@ xg_update_menubar (GtkWidget *menubar,
 
           gtk_label_set_text (wlabel, utf8_label);
 
+#ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
           /* If this item has a submenu that has been detached, change
              the title in the WM decorations also.  */
           if (submenu && gtk_menu_get_tearoff_state (GTK_MENU (submenu)))
             /* Set the title of the detached window.  */
             gtk_menu_set_title (GTK_MENU (submenu), utf8_label);
+#endif
 
           if (utf8_label) g_free (utf8_label);
           iter = g_list_next (iter);
@@ -3129,7 +3141,8 @@ xg_update_submenu (GtkWidget *submenu,
   {
     GtkWidget *w = GTK_WIDGET (iter->data);
 
-    /* Skip tearoff items, they have no counterpart in val.  */
+#ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
+  /* Skip tearoff items, they have no counterpart in val.  */
     if (GTK_IS_TEAROFF_MENU_ITEM (w))
       {
         has_tearoff_p = 1;
@@ -3137,6 +3150,7 @@ xg_update_submenu (GtkWidget *submenu,
         if (iter) w = GTK_WIDGET (iter->data);
         else break;
       }
+#endif
 
     /* Remember first radio button in a group.  If we get a mismatch in
        a radio group we must rebuild the whole group so that the connections
@@ -3780,13 +3794,17 @@ xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
 
       adj = gtk_range_get_adjustment (GTK_RANGE (wscroll));
 
-      /* We do the same as for MOTIF in xterm.c, assume 30 chars per line
-         rather than the real portion value.  This makes the thumb less likely
-         to resize and that looks better.  */
-      portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
-      /* When the thumb is at the bottom, position == whole.
-         So we need to increase `whole' to make space for the thumb.  */
-      whole += portion;
+      if (scroll_bar_adjust_thumb_portion_p)
+        {
+          /* We do the same as for MOTIF in xterm.c, use 30 chars per
+             line rather than the real portion value.  This makes the
+             thumb less likely to resize and that looks better.  */
+          portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
+
+          /* When the thumb is at the bottom, position == whole.
+             So we need to increase `whole' to make space for the thumb.  */
+          whole += portion;
+        }
 
       if (whole <= 0)
         top = 0, shown = 1;
@@ -3796,13 +3814,8 @@ xg_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar,
           shown = (gdouble) portion / whole;
         }
 
-      size = shown * XG_SB_RANGE;
-      size = min (size, XG_SB_RANGE);
-      size = max (size, 1);
-
-      value = top * XG_SB_RANGE;
-      value = min (value, XG_SB_MAX - size);
-      value = max (value, XG_SB_MIN);
+      size = clip_to_bounds (1, shown * XG_SB_RANGE, XG_SB_RANGE);
+      value = clip_to_bounds (XG_SB_MIN, top * XG_SB_RANGE, XG_SB_MAX - size);
 
       /* Assume all lines are of equal size.  */
       new_step = size / max (1, FRAME_LINES (f));
@@ -4143,7 +4156,7 @@ xg_tool_bar_detach_callback (GtkHandleBox *wbox,
   if (f)
     {
       GtkRequisition req, req2;
-      FRAME_X_OUTPUT (f)->toolbar_detached = 1;
+
       gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
       gtk_widget_get_preferred_size (w, NULL, &req2);
       req.width -= req2.width;
@@ -4178,7 +4191,7 @@ xg_tool_bar_attach_callback (GtkHandleBox *wbox,
   if (f)
     {
       GtkRequisition req, req2;
-      FRAME_X_OUTPUT (f)->toolbar_detached = 0;
+
       gtk_widget_get_preferred_size (GTK_WIDGET (wbox), NULL, &req);
       gtk_widget_get_preferred_size (w, NULL, &req2);
       req.width += req2.width;
@@ -4274,6 +4287,12 @@ xg_tool_bar_item_expose_callback (GtkWidget *w,
   gtk_toolbar_set_orientation (GTK_TOOLBAR (w), o)
 #endif
 
+#ifdef HAVE_GTK_HANDLE_BOX_NEW
+#define TOOLBAR_TOP_WIDGET(x) ((x)->handlebox_widget)
+#else
+#define TOOLBAR_TOP_WIDGET(x) ((x)->toolbar_widget)
+#endif
+
 /* Attach a tool bar to frame F.  */
 
 static void
@@ -4281,14 +4300,16 @@ xg_pack_tool_bar (FRAME_PTR f, Lisp_Object pos)
 {
   struct x_output *x = f->output_data.x;
   bool into_hbox = EQ (pos, Qleft) || EQ (pos, Qright);
+  GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
 
   toolbar_set_orientation (x->toolbar_widget,
                            into_hbox
                            ? GTK_ORIENTATION_VERTICAL
                            : GTK_ORIENTATION_HORIZONTAL);
+#ifdef HAVE_GTK_HANDLE_BOX_NEW
   if (!x->handlebox_widget)
     {
-      x->handlebox_widget = gtk_handle_box_new ();
+      top_widget = x->handlebox_widget = gtk_handle_box_new ();
       g_signal_connect (G_OBJECT (x->handlebox_widget), "child-detached",
                         G_CALLBACK (xg_tool_bar_detach_callback), f);
       g_signal_connect (G_OBJECT (x->handlebox_widget), "child-attached",
@@ -4296,34 +4317,55 @@ xg_pack_tool_bar (FRAME_PTR f, Lisp_Object pos)
       gtk_container_add (GTK_CONTAINER (x->handlebox_widget),
                          x->toolbar_widget);
     }
+#endif
 
   if (into_hbox)
     {
+#ifdef HAVE_GTK_HANDLE_BOX_NEW
       gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
                                           GTK_POS_TOP);
-      gtk_box_pack_start (GTK_BOX (x->hbox_widget), x->handlebox_widget,
+#endif
+      gtk_box_pack_start (GTK_BOX (x->hbox_widget), top_widget,
                           FALSE, FALSE, 0);
 
       if (EQ (pos, Qleft))
         gtk_box_reorder_child (GTK_BOX (x->hbox_widget),
-                               x->handlebox_widget,
+                               top_widget,
                                0);
-      x->toolbar_in_hbox = 1;
+      x->toolbar_in_hbox = true;
     }
   else
     {
       bool vbox_pos = x->menubar_widget != 0;
+#ifdef HAVE_GTK_HANDLE_BOX_NEW
       gtk_handle_box_set_handle_position (GTK_HANDLE_BOX (x->handlebox_widget),
                                           GTK_POS_LEFT);
-      gtk_box_pack_start (GTK_BOX (x->vbox_widget), x->handlebox_widget,
+#endif
+      gtk_box_pack_start (GTK_BOX (x->vbox_widget), top_widget,
                           FALSE, FALSE, 0);
 
       if (EQ (pos, Qtop))
         gtk_box_reorder_child (GTK_BOX (x->vbox_widget),
-                               x->handlebox_widget,
+                               top_widget,
                                vbox_pos);
-      x->toolbar_in_hbox = 0;
+      x->toolbar_in_hbox = false;
     }
+  x->toolbar_is_packed = true;
+}
+
+static bool xg_update_tool_bar_sizes (FRAME_PTR f);
+
+static void
+tb_size_cb (GtkWidget    *widget,
+            GdkRectangle *allocation,
+            gpointer      user_data)
+{
+  /* When tool bar is created it has one preferred size.  But when size is
+     allocated between widgets, it may get another.  So we must update
+     size hints if tool bar size changes.  Seen on Fedora 18 at least.  */
+  FRAME_PTR f = (FRAME_PTR) user_data;
+  if (xg_update_tool_bar_sizes (f))
+    x_wm_set_size_hint (f, 0, 0);
 }
 
 /* Create a tool bar for frame F.  */
@@ -4352,12 +4394,13 @@ xg_create_tool_bar (FRAME_PTR f)
     }
 
   x->toolbar_widget = gtk_toolbar_new ();
-  x->toolbar_detached = 0;
 
   gtk_widget_set_name (x->toolbar_widget, "emacs-toolbar");
 
   gtk_toolbar_set_style (GTK_TOOLBAR (x->toolbar_widget), GTK_TOOLBAR_ICONS);
   toolbar_set_orientation (x->toolbar_widget, GTK_ORIENTATION_HORIZONTAL);
+  g_signal_connect (x->toolbar_widget, "size-allocate",
+                    G_CALLBACK (tb_size_cb), f);
 #if GTK_CHECK_VERSION (3, 3, 6)
   gsty = gtk_widget_get_style_context (x->toolbar_widget);
   gtk_style_context_add_class (gsty, "primary-toolbar");
@@ -4567,13 +4610,14 @@ xg_update_tool_bar_sizes (FRAME_PTR f)
   struct x_output *x = f->output_data.x;
   GtkRequisition req;
   int nl = 0, nr = 0, nt = 0, nb = 0;
+  GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
 
-  gtk_widget_get_preferred_size (GTK_WIDGET (x->handlebox_widget), NULL, &req);
+  gtk_widget_get_preferred_size (GTK_WIDGET (top_widget), NULL, &req);
   if (x->toolbar_in_hbox)
     {
       int pos;
       gtk_container_child_get (GTK_CONTAINER (x->hbox_widget),
-                               x->handlebox_widget,
+                               top_widget,
                                "position", &pos, NULL);
       if (pos == 0) nl = req.width;
       else nr = req.width;
@@ -4582,7 +4626,7 @@ xg_update_tool_bar_sizes (FRAME_PTR f)
     {
       int pos;
       gtk_container_child_get (GTK_CONTAINER (x->vbox_widget),
-                               x->handlebox_widget,
+                               top_widget,
                                "position", &pos, NULL);
       if (pos == 0 || (pos == 1 && x->menubar_widget)) nt = req.height;
       else nb = req.height;
@@ -4617,7 +4661,6 @@ update_frame_tool_bar (FRAME_PTR f)
   GtkToolbar *wtoolbar;
   GtkToolItem *ti;
   GtkTextDirection dir;
-  bool pack_tool_bar = x->handlebox_widget == NULL;
   Lisp_Object style;
   bool text_image, horiz;
   struct xg_frame_tb_info *tbinfo;
@@ -4871,9 +4914,9 @@ update_frame_tool_bar (FRAME_PTR f)
 
   if (f->n_tool_bar_items != 0)
     {
-      if (pack_tool_bar)
+      if (! x->toolbar_is_packed)
         xg_pack_tool_bar (f, f->tool_bar_position);
-      gtk_widget_show_all (GTK_WIDGET (x->handlebox_widget));
+      gtk_widget_show_all (TOOLBAR_TOP_WIDGET (x));
       if (xg_update_tool_bar_sizes (f))
         xg_height_or_width_changed (f);
     }
@@ -4892,24 +4935,26 @@ free_frame_tool_bar (FRAME_PTR f)
   if (x->toolbar_widget)
     {
       struct xg_frame_tb_info *tbinfo;
-      bool is_packed = x->handlebox_widget != 0;
+      GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
+
       block_input ();
       /* We may have created the toolbar_widget in xg_create_tool_bar, but
          not the x->handlebox_widget which is created in xg_pack_tool_bar.  */
-      if (is_packed)
+      if (x->toolbar_is_packed)
         {
           if (x->toolbar_in_hbox)
             gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
-                                  x->handlebox_widget);
+                                  top_widget);
           else
             gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
-                                  x->handlebox_widget);
+                                  top_widget);
         }
       else
         gtk_widget_destroy (x->toolbar_widget);
 
       x->toolbar_widget = 0;
-      x->handlebox_widget = 0;
+      TOOLBAR_TOP_WIDGET (x) = 0;
+      x->toolbar_is_packed = false;
       FRAME_TOOLBAR_TOP_HEIGHT (f) = FRAME_TOOLBAR_BOTTOM_HEIGHT (f) = 0;
       FRAME_TOOLBAR_LEFT_WIDTH (f) = FRAME_TOOLBAR_RIGHT_WIDTH (f) = 0;
 
@@ -4933,20 +4978,25 @@ void
 xg_change_toolbar_position (FRAME_PTR f, Lisp_Object pos)
 {
   struct x_output *x = f->output_data.x;
+  GtkWidget *top_widget = TOOLBAR_TOP_WIDGET (x);
 
-  if (! x->toolbar_widget || ! x->handlebox_widget)
+  if (! x->toolbar_widget || ! top_widget)
     return;
 
   block_input ();
-  g_object_ref (x->handlebox_widget);
-  if (x->toolbar_in_hbox)
-    gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
-                          x->handlebox_widget);
-  else
-    gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
-                          x->handlebox_widget);
+  g_object_ref (top_widget);
+  if (x->toolbar_is_packed)
+    {
+      if (x->toolbar_in_hbox)
+        gtk_container_remove (GTK_CONTAINER (x->hbox_widget),
+                              top_widget);
+      else
+        gtk_container_remove (GTK_CONTAINER (x->vbox_widget),
+                              top_widget);
+    }
+
   xg_pack_tool_bar (f, pos);
-  g_object_unref (x->handlebox_widget);
+  g_object_unref (top_widget);
   if (xg_update_tool_bar_sizes (f))
     xg_height_or_width_changed (f);
 
@@ -4972,7 +5022,9 @@ xg_initialize (void)
 
   gdpy_def = NULL;
   xg_ignore_gtk_scrollbar = 0;
+#ifdef HAVE_GTK_TEAROFF_MENU_ITEM_NEW
   xg_detached_menus = 0;
+#endif
   xg_menu_cb_list.prev = xg_menu_cb_list.next =
     xg_menu_item_cb_list.prev = xg_menu_item_cb_list.next = 0;
 
@@ -5009,7 +5061,9 @@ xg_initialize (void)
                                 "cancel", 0);
   update_theme_scrollbar_width ();
 
+#ifdef HAVE_FREETYPE
   x_last_font_name = NULL;
+#endif
 }
 
 #endif /* USE_GTK */
diff --git a/src/gtkutil.h b/src/gtkutil.h
index 43f2b237a68..288b3e99299 100644
--- a/src/gtkutil.h
+++ b/src/gtkutil.h
@@ -1,6 +1,6 @@
 /* Definitions and headers for GTK widgets.
 
-Copyright (C) 2003-2012  Free Software Foundation, Inc.
+Copyright (C) 2003-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/image.c b/src/image.c
index 07db6cece1f..726b65d7338 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1,6 +1,6 @@
 /* Functions for image support on window system.
 
-Copyright (C) 1989, 1992-2012 Free Software Foundation, Inc.
+Copyright (C) 1989, 1992-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/indent.c b/src/indent.c
index a3abf88feeb..ce1639eae1e 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -1,6 +1,6 @@
 /* Indentation functions.
-   Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993-1995, 1998, 2000-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -138,7 +138,7 @@ recompute_width_table (struct buffer *buf, struct Lisp_Char_Table *disptab)
   struct Lisp_Vector *widthtab;
 
   if (!VECTORP (BVAR (buf, width_table)))
-    bset_width_table (buf, Fmake_vector (make_number (256), make_number (0)));
+    bset_width_table (buf, make_uninit_vector (256));
   widthtab = XVECTOR (BVAR (buf, width_table));
   eassert (widthtab->header.size == 256);
 
@@ -291,7 +291,7 @@ DEFUN ("current-column", Fcurrent_column, Scurrent_column, 0, 0, 0,
        doc: /* Return the horizontal position of point.  Beginning of line is column 0.
 This is calculated by adding together the widths of all the displayed
 representations of the character between the start of the previous line
-and point (eg. control characters will have a width of 2 or 4, tabs
+and point (e.g., control characters will have a width of 2 or 4, tabs
 will have a variable width).
 Ignores finite width of frame, which means that this function may return
 values greater than (frame-width).
@@ -571,7 +571,8 @@ scan_for_column (ptrdiff_t *endpos, EMACS_INT *goalcol, ptrdiff_t *prevcol)
             col += width;
             if (endp > scan) /* Avoid infinite loops with 0-width overlays.  */
               {
-                scan = endp; scan_byte = charpos_to_bytepos (scan);
+                scan = endp;
+                scan_byte = CHAR_TO_BYTE (scan);
                 continue;
               }
           }
@@ -1969,7 +1970,7 @@ whether or not it is currently displayed in some window.  */)
   struct window *w;
   Lisp_Object old_buffer;
   EMACS_INT old_charpos IF_LINT (= 0), old_bytepos IF_LINT (= 0);
-  struct gcpro gcpro1, gcpro2, gcpro3;
+  struct gcpro gcpro1;
   Lisp_Object lcols = Qnil;
   double cols IF_LINT (= 0);
   void *itdata = NULL;
@@ -1986,13 +1987,13 @@ whether or not it is currently displayed in some window.  */)
   w = decode_live_window (window);
 
   old_buffer = Qnil;
-  GCPRO3 (old_buffer, old_charpos, old_bytepos);
+  GCPRO1 (old_buffer);
   if (XBUFFER (w->buffer) != current_buffer)
     {
       /* Set the window's buffer temporarily to the current buffer.  */
       old_buffer = w->buffer;
-      old_charpos = XMARKER (w->pointm)->charpos;
-      old_bytepos = XMARKER (w->pointm)->bytepos;
+      old_charpos = marker_position (w->pointm);
+      old_bytepos = marker_byte_position (w->pointm);
       wset_buffer (w, Fcurrent_buffer ());
       set_marker_both (w->pointm, w->buffer,
                        BUF_PT (current_buffer), BUF_PT_BYTE (current_buffer));
@@ -2025,7 +2026,11 @@ whether or not it is currently displayed in some window.  */)
           const char *s = SSDATA (it.string);
           const char *e = s + SBYTES (it.string);
 
-          disp_string_at_start_p = it.string_from_display_prop_p;
+          /* If it.area is anything but TEXT_AREA, we need not bother
+             about the display string, as it doesn't affect cursor
+             positioning.  */
+          disp_string_at_start_p =
+            it.string_from_display_prop_p && it.area == TEXT_AREA;
           while (s < e)
             {
               if (*s++ == '\n')
diff --git a/src/indent.h b/src/indent.h
index abcd06036d1..acfd952754e 100644
--- a/src/indent.h
+++ b/src/indent.h
@@ -1,5 +1,5 @@
 /* Definitions for interface to indent.c
-   Copyright (C) 1985-1986, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/inotify.c b/src/inotify.c
new file mode 100644
index 00000000000..4efef9e55b7
--- /dev/null
+++ b/src/inotify.c
@@ -0,0 +1,436 @@
+/* Inotify support for Emacs
+
+Copyright (C) 2012-2013 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include <config.h>
+
+#ifdef HAVE_INOTIFY
+
+#include "lisp.h"
+#include "coding.h"
+#include "process.h"
+#include "keyboard.h"
+#include "character.h"
+#include "frame.h" /* Required for termhooks.h.  */
+#include "termhooks.h"
+
+static Lisp_Object Qaccess;        /* IN_ACCESS */
+static Lisp_Object Qattrib;        /* IN_ATTRIB */
+static Lisp_Object Qclose_write;   /* IN_CLOSE_WRITE */
+static Lisp_Object Qclose_nowrite; /* IN_CLOSE_NOWRITE */
+static Lisp_Object Qcreate;        /* IN_CREATE */
+static Lisp_Object Qdelete;        /* IN_DELETE */
+static Lisp_Object Qdelete_self;   /* IN_DELETE_SELF */
+static Lisp_Object Qmodify;        /* IN_MODIFY */
+static Lisp_Object Qmove_self;     /* IN_MOVE_SELF */
+static Lisp_Object Qmoved_from;    /* IN_MOVED_FROM */
+static Lisp_Object Qmoved_to;      /* IN_MOVED_TO */
+static Lisp_Object Qopen;          /* IN_OPEN */
+
+static Lisp_Object Qall_events;    /* IN_ALL_EVENTS */
+static Lisp_Object Qmove;          /* IN_MOVE */
+static Lisp_Object Qclose;         /* IN_CLOSE */
+
+static Lisp_Object Qdont_follow;   /* IN_DONT_FOLLOW */
+static Lisp_Object Qexcl_unlink;   /* IN_EXCL_UNLINK */
+static Lisp_Object Qmask_add;      /* IN_MASK_ADD */
+static Lisp_Object Qoneshot;       /* IN_ONESHOT */
+static Lisp_Object Qonlydir;       /* IN_ONLYDIR */
+
+static Lisp_Object Qignored;       /* IN_IGNORED */
+static Lisp_Object Qisdir;         /* IN_ISDIR */
+static Lisp_Object Qq_overflow;    /* IN_Q_OVERFLOW */
+static Lisp_Object Qunmount;       /* IN_UNMOUNT */
+
+#include <sys/inotify.h>
+#include <sys/ioctl.h>
+
+/* Ignore bits that might be undefined on old GNU/Linux systems.  */
+#ifndef IN_EXCL_UNLINK
+# define IN_EXCL_UNLINK 0
+#endif
+#ifndef IN_DONT_FOLLOW
+# define IN_DONT_FOLLOW 0
+#endif
+#ifndef IN_ONLYDIR
+# define IN_ONLYDIR 0
+#endif
+
+enum { uninitialized = -100 };
+/* File handle for inotify.  */
+static int inotifyfd = uninitialized;
+
+/* Assoc list of files being watched.
+   Format:
+   (watch-descriptor . callback)
+ */
+static Lisp_Object watch_list;
+
+static Lisp_Object
+make_watch_descriptor (int wd)
+{
+  /* TODO replace this with a Misc Object! */
+  return make_number (wd);
+}
+
+static Lisp_Object
+mask_to_aspects (uint32_t mask) {
+  Lisp_Object aspects = Qnil;
+  if (mask & IN_ACCESS)
+    aspects = Fcons (Qaccess, aspects);
+  if (mask & IN_ATTRIB)
+    aspects = Fcons (Qattrib, aspects);
+  if (mask & IN_CLOSE_WRITE)
+    aspects = Fcons (Qclose_write, aspects);
+  if (mask & IN_CLOSE_NOWRITE)
+    aspects = Fcons (Qclose_nowrite, aspects);
+  if (mask & IN_CREATE)
+    aspects = Fcons (Qcreate, aspects);
+  if (mask & IN_DELETE)
+    aspects = Fcons (Qdelete, aspects);
+  if (mask & IN_DELETE_SELF)
+    aspects = Fcons (Qdelete_self, aspects);
+  if (mask & IN_MODIFY)
+    aspects = Fcons (Qmodify, aspects);
+  if (mask & IN_MOVE_SELF)
+    aspects = Fcons (Qmove_self, aspects);
+  if (mask & IN_MOVED_FROM)
+    aspects = Fcons (Qmoved_from, aspects);
+  if (mask & IN_MOVED_TO)
+    aspects = Fcons (Qmoved_to, aspects);
+  if (mask & IN_OPEN)
+    aspects = Fcons (Qopen,  aspects);
+  if (mask & IN_IGNORED)
+    aspects = Fcons (Qignored, aspects);
+  if (mask & IN_ISDIR)
+    aspects = Fcons (Qisdir, aspects);
+  if (mask & IN_Q_OVERFLOW)
+    aspects = Fcons (Qq_overflow, aspects);
+  if (mask & IN_UNMOUNT)
+    aspects = Fcons (Qunmount, aspects);
+  return aspects;
+}
+
+static Lisp_Object
+inotifyevent_to_event (Lisp_Object watch_object, struct inotify_event const *ev)
+{
+  Lisp_Object name = Qnil;
+  if (ev->len > 0)
+    {
+      size_t const len = strlen (ev->name);
+      name = make_unibyte_string (ev->name, min (len, ev->len));
+      name = DECODE_FILE (name);
+    }
+
+  return list2 (list4 (make_watch_descriptor (ev->wd),
+                       mask_to_aspects (ev->mask),
+                       make_number (ev->cookie),
+                       name),
+                XCDR (watch_object));
+}
+
+/* This callback is called when the FD is available for read.  The inotify
+   events are read from FD and converted into input_events.  */
+static void
+inotify_callback (int fd, void *_)
+{
+  struct input_event event;
+  Lisp_Object watch_object;
+  int to_read;
+  char *buffer;
+  ssize_t n;
+  size_t i;
+
+  to_read = 0;
+  if (ioctl (fd, FIONREAD, &to_read) == -1)
+    report_file_error ("Error while trying to retrieve file system events",
+                       Qnil);
+  buffer = xmalloc (to_read);
+  n = read (fd, buffer, to_read);
+  if (n < 0)
+    {
+      xfree (buffer);
+      report_file_error ("Error while trying to read file system events",
+                         Qnil);
+    }
+
+  EVENT_INIT (event);
+  event.kind = FILE_NOTIFY_EVENT;
+
+  i = 0;
+  while (i < (size_t)n)
+    {
+      struct inotify_event *ev = (struct inotify_event*)&buffer[i];
+
+      watch_object = Fassoc (make_watch_descriptor (ev->wd), watch_list);
+      if (!NILP (watch_object))
+        {
+          event.arg = inotifyevent_to_event (watch_object, ev);
+
+          /* If event was removed automatically: Drop it from watch list.  */
+          if (ev->mask & IN_IGNORED)
+            watch_list = Fdelete (watch_object, watch_list);
+
+          if (!NILP (event.arg))
+            kbd_buffer_store_event (&event);
+        }
+
+      i += sizeof (*ev) + ev->len;
+    }
+
+  xfree (buffer);
+}
+
+static uint32_t
+symbol_to_inotifymask (Lisp_Object symb)
+{
+  if (EQ (symb, Qaccess))
+    return IN_ACCESS;
+  else if (EQ (symb, Qattrib))
+    return IN_ATTRIB;
+  else if (EQ (symb, Qclose_write))
+    return IN_CLOSE_WRITE;
+  else if (EQ (symb, Qclose_nowrite))
+    return IN_CLOSE_NOWRITE;
+  else if (EQ (symb, Qcreate))
+    return IN_CREATE;
+  else if (EQ (symb, Qdelete))
+    return IN_DELETE;
+  else if (EQ (symb, Qdelete_self))
+    return IN_DELETE_SELF;
+  else if (EQ (symb, Qmodify))
+    return IN_MODIFY;
+  else if (EQ (symb, Qmove_self))
+    return IN_MOVE_SELF;
+  else if (EQ (symb, Qmoved_from))
+    return IN_MOVED_FROM;
+  else if (EQ (symb, Qmoved_to))
+    return IN_MOVED_TO;
+  else if (EQ (symb, Qopen))
+    return IN_OPEN;
+  else if (EQ (symb, Qmove))
+    return IN_MOVE;
+  else if (EQ (symb, Qclose))
+    return IN_CLOSE;
+
+  else if (EQ (symb, Qdont_follow))
+    return IN_DONT_FOLLOW;
+  else if (EQ (symb, Qexcl_unlink))
+    return IN_EXCL_UNLINK;
+  else if (EQ (symb, Qmask_add))
+    return IN_MASK_ADD;
+  else if (EQ (symb, Qoneshot))
+    return IN_ONESHOT;
+  else if (EQ (symb, Qonlydir))
+    return IN_ONLYDIR;
+
+  else if (EQ (symb, Qt) || EQ (symb, Qall_events))
+    return IN_ALL_EVENTS;
+  else
+    signal_error ("Unknown aspect", symb);
+}
+
+static uint32_t
+aspect_to_inotifymask (Lisp_Object aspect)
+{
+  if (CONSP (aspect))
+    {
+      Lisp_Object x = aspect;
+      uint32_t mask = 0;
+      while (CONSP (x))
+        {
+          mask |= symbol_to_inotifymask (XCAR (x));
+          x = XCDR (x);
+        }
+      return mask;
+    }
+  else
+    return symbol_to_inotifymask (aspect);
+}
+
+DEFUN ("inotify-add-watch", Finotify_add_watch, Sinotify_add_watch, 3, 3, 0,
+       doc: /* Add a watch for FILE-NAME to inotify.
+
+A WATCH-DESCRIPTOR is returned on success.  ASPECT might be one of the following
+symbols or a list of those symbols:
+
+access
+attrib
+close-write
+close-nowrite
+create
+delete
+delete-self
+modify
+move-self
+moved-from
+moved-to
+open
+
+all-events or t
+move
+close
+
+The following symbols can also be added to a list of aspects
+
+dont-follow
+excl-unlink
+mask-add
+oneshot
+onlydir
+
+Watching a directory is not recursive.  CALLBACK gets called in case of an
+event.  It gets passed a single argument EVENT which contains an event structure
+of the format
+
+(WATCH-DESCRIPTOR ASPECTS COOKIE NAME)
+
+WATCH-DESCRIPTOR is the same object that was returned by this function.  It can
+be tested for equality using `equal'.  ASPECTS describes the event.  It is a
+list of ASPECT symbols described above and can also contain one of the following
+symbols
+
+ignored
+isdir
+q-overflow
+unmount
+
+COOKIE is an object that can be compared using `equal' to identify two matching
+renames (moved-from and moved-to).
+
+If a directory is watched then NAME is the name of file that caused the event.
+
+See inotify(7) and inotify_add_watch(2) for further information.  The inotify fd
+is managed internally and there is no corresponding inotify_init.  Use
+`inotify-rm-watch' to remove a watch.
+             */)
+     (Lisp_Object file_name, Lisp_Object aspect, Lisp_Object callback)
+{
+  uint32_t mask;
+  Lisp_Object watch_object;
+  Lisp_Object encoded_file_name;
+  Lisp_Object watch_descriptor;
+  int watchdesc = -1;
+
+  CHECK_STRING (file_name);
+
+  if (inotifyfd == uninitialized)
+    {
+      inotifyfd = inotify_init1 (IN_NONBLOCK|IN_CLOEXEC);
+      if (inotifyfd == -1)
+        {
+          inotifyfd = uninitialized;
+          report_file_error ("File watching feature (inotify) is not available",
+                             Qnil);
+        }
+      watch_list = Qnil;
+      add_read_fd (inotifyfd, &inotify_callback, NULL);
+    }
+
+  mask = aspect_to_inotifymask (aspect);
+  encoded_file_name = ENCODE_FILE (file_name);
+  watchdesc = inotify_add_watch (inotifyfd, SSDATA (encoded_file_name), mask);
+  if (watchdesc == -1)
+    report_file_error ("Could not add watch for file", Fcons (file_name, Qnil));
+
+  watch_descriptor = make_watch_descriptor (watchdesc);
+
+  /* Delete existing watch object. */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+      watch_list = Fdelete (watch_object, watch_list);
+
+  /* Store watch object in watch list. */
+  watch_object = Fcons (watch_descriptor, callback);
+  watch_list = Fcons (watch_object, watch_list);
+
+  return watch_descriptor;
+}
+
+DEFUN ("inotify-rm-watch", Finotify_rm_watch, Sinotify_rm_watch, 1, 1, 0,
+       doc: /* Remove an existing WATCH-DESCRIPTOR.
+
+WATCH-DESCRIPTOR should be an object returned by `inotify-add-watch'.
+
+See inotify_rm_watch(2) for more information.
+             */)
+     (Lisp_Object watch_descriptor)
+{
+  Lisp_Object watch_object;
+  int wd = XINT (watch_descriptor);
+
+  if (inotify_rm_watch (inotifyfd, wd) == -1)
+    report_file_error ("Could not rm watch", Fcons (watch_descriptor,
+                                                    Qnil));
+
+  /* Remove watch descriptor from watch list. */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+    watch_list = Fdelete (watch_object, watch_list);
+
+  /* Cleanup if no more files are watched. */
+  if (NILP (watch_list))
+    {
+      close (inotifyfd);
+      delete_read_fd (inotifyfd);
+      inotifyfd = uninitialized;
+    }
+
+  return Qt;
+}
+
+void
+syms_of_inotify (void)
+{
+  DEFSYM (Qaccess, "access");
+  DEFSYM (Qattrib, "attrib");
+  DEFSYM (Qclose_write, "close-write");
+  DEFSYM (Qclose_nowrite, "close-nowrite");
+  DEFSYM (Qcreate, "create");
+  DEFSYM (Qdelete, "delete");
+  DEFSYM (Qdelete_self, "delete-self");
+  DEFSYM (Qmodify, "modify");
+  DEFSYM (Qmove_self, "move-self");
+  DEFSYM (Qmoved_from, "moved-from");
+  DEFSYM (Qmoved_to, "moved-to");
+  DEFSYM (Qopen, "open");
+
+  DEFSYM (Qall_events, "all-events");
+  DEFSYM (Qmove, "move");
+  DEFSYM (Qclose, "close");
+
+  DEFSYM (Qdont_follow, "dont-follow");
+  DEFSYM (Qexcl_unlink, "excl-unlink");
+  DEFSYM (Qmask_add, "mask-add");
+  DEFSYM (Qoneshot, "oneshot");
+  DEFSYM (Qonlydir, "onlydir");
+
+  DEFSYM (Qignored, "ignored");
+  DEFSYM (Qisdir, "isdir");
+  DEFSYM (Qq_overflow, "q-overflow");
+  DEFSYM (Qunmount, "unmount");
+
+  defsubr (&Sinotify_add_watch);
+  defsubr (&Sinotify_rm_watch);
+
+  staticpro (&watch_list);
+
+  Fprovide (intern_c_string ("inotify"), Qnil);
+}
+
+#endif /* HAVE_INOTIFY */
diff --git a/src/insdel.c b/src/insdel.c
index 892ca3d5216..4cf4e6452a1 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1,6 +1,6 @@
 /* Buffer insertion/deletion and gap motion for GNU Emacs.
-   Copyright (C) 1985-1986, 1993-1995, 1997-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1993-1995, 1997-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -84,21 +84,14 @@ check_markers (void)
 
 #endif /* MARKER_DEBUG */
 
-/* Move gap to position CHARPOS.
-   Note that this can quit!  */
-
-void
-move_gap (ptrdiff_t charpos)
-{
-  move_gap_both (charpos, charpos_to_bytepos (charpos));
-}
-
 /* Move gap to byte position BYTEPOS, which is also char position CHARPOS.
    Note that this can quit!  */
 
 void
 move_gap_both (ptrdiff_t charpos, ptrdiff_t bytepos)
 {
+  eassert (charpos == BYTE_TO_CHAR (bytepos)
+           && bytepos == CHAR_TO_BYTE (charpos));
   if (bytepos < GPT_BYTE)
     gap_left (charpos, bytepos, 0);
   else if (bytepos > GPT_BYTE)
@@ -388,14 +381,13 @@ make_gap_larger (ptrdiff_t nbytes_added)
   ptrdiff_t real_gap_loc_byte;
   ptrdiff_t old_gap_size;
   ptrdiff_t current_size = Z_BYTE - BEG_BYTE + GAP_SIZE;
-  enum { enough_for_a_while = 2000 };
 
   if (BUF_BYTES_MAX - current_size < nbytes_added)
     buffer_overflow ();
 
   /* If we have to get more space, get enough to last a while;
      but do not exceed the maximum buffer size.  */
-  nbytes_added = min (nbytes_added + enough_for_a_while,
+  nbytes_added = min (nbytes_added + GAP_BYTES_DFL,
                       BUF_BYTES_MAX - current_size);
 
   enlarge_buffer_text (current_buffer, nbytes_added);
@@ -413,8 +405,7 @@ make_gap_larger (ptrdiff_t nbytes_added)
   GPT_BYTE = Z_BYTE + GAP_SIZE;
   GAP_SIZE = nbytes_added;
 
-  /* Move the new gap down to be consecutive with the end of the old one.
-     This adjusts the markers properly too.  */
+  /* Move the new gap down to be consecutive with the end of the old one.  */
   gap_left (real_gap_loc + old_gap_size, real_gap_loc_byte + old_gap_size, 1);
 
   /* Now combine the two into one large gap.  */
@@ -443,9 +434,9 @@ make_gap_smaller (ptrdiff_t nbytes_removed)
   ptrdiff_t real_beg_unchanged;
   ptrdiff_t new_gap_size;
 
-  /* Make sure the gap is at least 20 bytes.  */
-  if (GAP_SIZE - nbytes_removed < 20)
-    nbytes_removed = GAP_SIZE - 20;
+  /* Make sure the gap is at least GAP_BYTES_MIN bytes.  */
+  if (GAP_SIZE - nbytes_removed < GAP_BYTES_MIN)
+    nbytes_removed = GAP_SIZE - GAP_BYTES_MIN;
 
   /* Prevent quitting in move_gap.  */
   tem = Vinhibit_quit;
@@ -468,8 +459,7 @@ make_gap_smaller (ptrdiff_t nbytes_removed)
   Z_BYTE += new_gap_size;
   GAP_SIZE = nbytes_removed;
 
-  /* Move the unwanted pretend gap to the end of the buffer.  This
-     adjusts the markers properly too.  */
+  /* Move the unwanted pretend gap to the end of the buffer.  */
   gap_right (Z, Z_BYTE);
 
   enlarge_buffer_text (current_buffer, -nbytes_removed);
@@ -500,7 +490,20 @@ make_gap (ptrdiff_t nbytes_added)
     make_gap_smaller (-nbytes_added);
 #endif
 }
-
+
+/* Add NBYTES to B's gap.  It's enough to temporarily
+   fake current_buffer and avoid real switch to B.  */
+
+void
+make_gap_1 (struct buffer *b, ptrdiff_t nbytes)
+{
+  struct buffer *oldb = current_buffer;
+
+  current_buffer = b;
+  make_gap (nbytes);
+  current_buffer = oldb;
+}
+
 /* Copy NBYTES bytes of text from FROM_ADDR to TO_ADDR.
    FROM_MULTIBYTE says whether the incoming text is multibyte.
    TO_MULTIBYTE says whether to store the text as multibyte.
@@ -655,17 +658,6 @@ insert_before_markers_and_inherit (const char *string,
     }
 }
 
-/* Subroutine used by the insert functions above.  */
-
-void
-insert_1 (const char *string, ptrdiff_t nbytes,
-          bool inherit, bool prepare, bool before_markers)
-{
-  insert_1_both (string, chars_in_text ((unsigned char *) string, nbytes),
-                 nbytes, inherit, prepare, before_markers);
-}
-
-
 #ifdef BYTE_COMBINING_DEBUG
 
 /* See if the bytes before POS/POS_BYTE combine with bytes
@@ -1800,9 +1792,10 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
   if (!NILP (BVAR (current_buffer, read_only)))
     Fbarf_if_buffer_read_only ();
 
-  /* Let redisplay consider other windows than selected_window
-     if modifying another buffer.  */
-  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
+  /* If we're modifying the buffer other than shown in a selected window,
+     let redisplay consider other windows if this buffer is visible.  */
+  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer
+      && buffer_window_count (current_buffer))
     ++windows_or_buffers_changed;
 
   if (buffer_intervals (current_buffer))
@@ -1854,7 +1847,7 @@ prepare_to_modify_buffer (ptrdiff_t start, ptrdiff_t end,
           : (!NILP (Vselect_active_regions)
              && !NILP (Vtransient_mark_mode))))
     {
-      ptrdiff_t b = XMARKER (BVAR (current_buffer, mark))->charpos;
+      ptrdiff_t b = marker_position (BVAR (current_buffer, mark));
       ptrdiff_t e = PT;
       if (b < e)
         Vsaved_region_selection = make_buffer_string (b, e, 0);
@@ -2080,7 +2073,7 @@ Fcombine_after_change_execute_1 (Lisp_Object val)
 
 DEFUN ("combine-after-change-execute", Fcombine_after_change_execute,
        Scombine_after_change_execute, 0, 0, 0,
-       doc: /* This function is for use internally in `combine-after-change-calls'.  */)
+       doc: /* This function is for use internally in the function `combine-after-change-calls'.  */)
   (void)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -2172,7 +2165,7 @@ syms_of_insdel (void)
   combine_after_change_buffer = Qnil;
 
   DEFVAR_LISP ("combine-after-change-calls", Vcombine_after_change_calls,
-               doc: /* Used internally by the `combine-after-change-calls' macro.  */);
+               doc: /* Used internally by the function `combine-after-change-calls' macro.  */);
   Vcombine_after_change_calls = Qnil;
 
   DEFVAR_BOOL ("inhibit-modification-hooks", inhibit_modification_hooks,
diff --git a/src/intervals.c b/src/intervals.c
index 1ed93e1302d..db38c86c00b 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1,5 +1,6 @@
 /* Code for doing intervals.
-   Copyright (C) 1993-1995, 1997-1998, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-1995, 1997-1998, 2001-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1624,7 +1625,8 @@ graft_intervals_into_buffer (INTERVAL source, ptrdiff_t position,
           XSETBUFFER (buf, buffer);
           set_text_properties_1 (make_number (position),
                                  make_number (position + length),
-                                 Qnil, buf, 0);
+                                 Qnil, buf,
+                                 find_interval (tree, position));
         }
       /* Shouldn't be necessary.  --Stef  */
       buffer_balance_intervals (buffer);
diff --git a/src/intervals.h b/src/intervals.h
index 2b30101d0fa..cded8c0abb2 100644
--- a/src/intervals.h
+++ b/src/intervals.h
@@ -1,5 +1,5 @@
 /* Definitions and global variables for intervals.
-   Copyright (C) 1993-1994, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/keyboard.c b/src/keyboard.c
index fc155c5a5f7..77037f647e9 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1,6 +1,7 @@
 /* Keyboard and mouse input; editor command loop.
 
-Copyright (C) 1985-1989, 1993-1997, 1999-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993-1997, 1999-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -313,12 +314,18 @@ static Lisp_Object Qfunction_key;
 Lisp_Object Qmouse_click;
 #ifdef HAVE_NTGUI
 Lisp_Object Qlanguage_change;
+#ifdef WINDOWSNT
+Lisp_Object Qfile_w32notify;
+#endif
 #endif
 static Lisp_Object Qdrag_n_drop;
 static Lisp_Object Qsave_session;
 #ifdef HAVE_DBUS
 static Lisp_Object Qdbus_event;
 #endif
+#ifdef HAVE_INOTIFY
+static Lisp_Object Qfile_inotify;
+#endif /* HAVE_INOTIFY */
 static Lisp_Object Qconfig_changed_event;
 
 /* Lisp_Object Qmouse_movement; - also an event header */
@@ -410,10 +417,9 @@ static void (*keyboard_init_hook) (void);
 
 static bool get_input_pending (int);
 static bool readable_events (int);
-static Lisp_Object read_char_x_menu_prompt (ptrdiff_t, Lisp_Object *,
+static Lisp_Object read_char_x_menu_prompt (Lisp_Object,
                                             Lisp_Object, bool *);
-static Lisp_Object read_char_minibuf_menu_prompt (int, ptrdiff_t,
-                                                  Lisp_Object *);
+static Lisp_Object read_char_minibuf_menu_prompt (int, Lisp_Object);
 static Lisp_Object make_lispy_event (struct input_event *);
 static Lisp_Object make_lispy_movement (struct frame *, Lisp_Object,
                                         enum scroll_bar_part,
@@ -490,97 +496,103 @@ kset_system_key_syms (struct kboard *kb, Lisp_Object val)
 }
 
 
-/* Add C to the echo string, if echoing is going on.
-   C can be a character, which is printed prettily ("M-C-x" and all that
-   jazz), or a symbol, whose name is printed.  */
+/* Add C to the echo string, without echoing it immediately.  C can be
+   a character, which is pretty-printed, or a symbol, whose name is
+   printed.  */
 
 static void
-echo_char (Lisp_Object c)
+echo_add_key (Lisp_Object c)
 {
-  if (current_kboard->immediate_echo)
-    {
-      int size = KEY_DESCRIPTION_SIZE + 100;
-      char *buffer = alloca (size);
-      char *ptr = buffer;
-      Lisp_Object echo_string;
+  int size = KEY_DESCRIPTION_SIZE + 100;
+  char *buffer = alloca (size);
+  char *ptr = buffer;
+  Lisp_Object echo_string;
 
-      echo_string = KVAR (current_kboard, echo_string);
+  echo_string = KVAR (current_kboard, echo_string);
 
-      /* If someone has passed us a composite event, use its head symbol.  */
-      c = EVENT_HEAD (c);
+  /* If someone has passed us a composite event, use its head symbol.  */
+  c = EVENT_HEAD (c);
 
-      if (INTEGERP (c))
+  if (INTEGERP (c))
+    ptr = push_key_description (XINT (c), ptr);
+  else if (SYMBOLP (c))
+    {
+      Lisp_Object name = SYMBOL_NAME (c);
+      int nbytes = SBYTES (name);
+
+      if (size - (ptr - buffer) < nbytes)
         {
-          ptr = push_key_description (XINT (c), ptr);
+          int offset = ptr - buffer;
+          size = max (2 * size, size + nbytes);
+          buffer = alloca (size);
+          ptr = buffer + offset;
         }
-      else if (SYMBOLP (c))
-        {
-          Lisp_Object name = SYMBOL_NAME (c);
-          int nbytes = SBYTES (name);
 
-          if (size - (ptr - buffer) < nbytes)
-            {
-              int offset = ptr - buffer;
-              size = max (2 * size, size + nbytes);
-              buffer = alloca (size);
-              ptr = buffer + offset;
-            }
+      ptr += copy_text (SDATA (name), (unsigned char *) ptr, nbytes,
+                        STRING_MULTIBYTE (name), 1);
+    }
 
-          ptr += copy_text (SDATA (name), (unsigned char *) ptr, nbytes,
-                            STRING_MULTIBYTE (name), 1);
-        }
+  if ((NILP (echo_string) || SCHARS (echo_string) == 0)
+      && help_char_p (c))
+    {
+      const char *text = " (Type ? for further options)";
+      int len = strlen (text);
 
-      if ((NILP (echo_string) || SCHARS (echo_string) == 0)
-          && help_char_p (c))
+      if (size - (ptr - buffer) < len)
         {
-          const char *text = " (Type ? for further options)";
-          int len = strlen (text);
-
-          if (size - (ptr - buffer) < len)
-            {
-              int offset = ptr - buffer;
-              size += len;
-              buffer = alloca (size);
-              ptr = buffer + offset;
-            }
-
-          memcpy (ptr, text, len);
-          ptr += len;
+          int offset = ptr - buffer;
+          size += len;
+          buffer = alloca (size);
+          ptr = buffer + offset;
         }
 
-      /* Replace a dash from echo_dash with a space, otherwise
-         add a space at the end as a separator between keys.  */
-      if (STRINGP (echo_string)
-          && SCHARS (echo_string) > 1)
-        {
-          Lisp_Object last_char, prev_char, idx;
+      memcpy (ptr, text, len);
+      ptr += len;
+    }
 
-          idx = make_number (SCHARS (echo_string) - 2);
-          prev_char = Faref (echo_string, idx);
+  /* Replace a dash from echo_dash with a space, otherwise add a space
+     at the end as a separator between keys.  */
+  if (STRINGP (echo_string) && SCHARS (echo_string) > 1)
+    {
+      Lisp_Object last_char, prev_char, idx;
 
-          idx = make_number (SCHARS (echo_string) - 1);
-          last_char = Faref (echo_string, idx);
+      idx = make_number (SCHARS (echo_string) - 2);
+      prev_char = Faref (echo_string, idx);
 
-          /* We test PREV_CHAR to make sure this isn't the echoing
-             of a minus-sign.  */
-          if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
-            Faset (echo_string, idx, make_number (' '));
-          else
-            echo_string = concat2 (echo_string, build_string (" "));
-        }
-      else if (STRINGP (echo_string))
+      idx = make_number (SCHARS (echo_string) - 1);
+      last_char = Faref (echo_string, idx);
+
+      /* We test PREV_CHAR to make sure this isn't the echoing of a
+         minus-sign.  */
+      if (XINT (last_char) == '-' && XINT (prev_char) != ' ')
+        Faset (echo_string, idx, make_number (' '));
+      else
         echo_string = concat2 (echo_string, build_string (" "));
+    }
+  else if (STRINGP (echo_string) && SCHARS (echo_string) > 0)
+    echo_string = concat2 (echo_string, build_string (" "));
+
+  kset_echo_string
+    (current_kboard,
+     concat2 (echo_string, make_string (buffer, ptr - buffer)));
+}
 
-      kset_echo_string
-        (current_kboard,
-         concat2 (echo_string, make_string (buffer, ptr - buffer)));
+/* Add C to the echo string, if echoing is going on.  C can be a
+   character or a symbol.  */
 
+static void
+echo_char (Lisp_Object c)
+{
+  if (current_kboard->immediate_echo)
+    {
+      echo_add_key (c);
       echo_now ();
     }
 }
 
 /* Temporarily add a dash to the end of the echo string if it's not
-   empty, so that it serves as a mini-prompt for the very next character.  */
+   empty, so that it serves as a mini-prompt for the very next
+   character.  */
 
 static void
 echo_dash (void)
@@ -662,9 +674,8 @@ echo_now (void)
     }
 
   echoing = 1;
-  message3_nolog (KVAR (current_kboard, echo_string),
-                  SBYTES (KVAR (current_kboard, echo_string)),
-                  STRING_MULTIBYTE (KVAR (current_kboard, echo_string)));
+  /* FIXME: Use call (Qmessage) so it can be advised (e.g. emacspeak).  */
+  message3_nolog (KVAR (current_kboard, echo_string));
   echoing = 0;
 
   /* Record in what buffer we echoed, and from which kboard.  */
@@ -1174,13 +1185,13 @@ top_level_2 (void)
 static Lisp_Object
 top_level_1 (Lisp_Object ignore)
 {
-  /* On entry to the outer level, run the startup file */
+  /* On entry to the outer level, run the startup file.  */
   if (!NILP (Vtop_level))
     internal_condition_case (top_level_2, Qerror, cmd_error);
   else if (!NILP (Vpurify_flag))
-    message ("Bare impure Emacs (standard Lisp code not loaded)");
+    message1 ("Bare impure Emacs (standard Lisp code not loaded)");
   else
-    message ("Bare Emacs (standard Lisp code not loaded)");
+    message1 ("Bare Emacs (standard Lisp code not loaded)");
   return Qnil;
 }
 
@@ -1416,7 +1427,7 @@ command_loop_1 (void)
           sit_for (Vminibuffer_message_timeout, 0, 2);
 
           /* Clear the echo area.  */
-          message2 (0, 0, 0);
+          message1 (0);
           safe_run_hooks (Qecho_area_clear_hook);
 
           unbind_to (count, Qnil);
@@ -2219,13 +2230,12 @@ do { if (! polling_stopped_here) stop_polling ();	\
 do { if (polling_stopped_here) start_polling ();        \
        polling_stopped_here = 0; } while (0)
 
-/* read a character from the keyboard; call the redisplay if needed */
+/* Read a character from the keyboard; call the redisplay if needed.  */
 /* commandflag 0 means do not autosave, but do redisplay.
    -1 means do not redisplay, but do autosave.
    1 means do both.  */
 
-/* The arguments MAPS and NMAPS are for menu prompting.
-   MAPS is an array of keymaps;  NMAPS is the length of MAPS.
+/* The arguments MAP is for menu prompting.  MAP is a keymap.
 
    PREV_EVENT is the previous input event, or nil if we are reading
    the first event of a key sequence (or not reading a key sequence).
@@ -2247,7 +2257,7 @@ do { if (polling_stopped_here) start_polling ();	\
    Value is t if we showed a menu and the user rejected it.  */
 
 Lisp_Object
-read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
+read_char (int commandflag, Lisp_Object map,
            Lisp_Object prev_event,
            bool *used_mouse_menu, EMACS_TIME *end_time)
 {
@@ -2395,7 +2405,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       goto reread_first;
     }
 
-  /* if redisplay was requested */
+  /* If redisplay was requested.  */
   if (commandflag >= 0)
     {
       bool echo_current = EQ (echo_message_buffer, echo_area_buffer[0]);
@@ -2404,7 +2414,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
            user-visible, such as X selection_request events.  */
       if (input_pending
           || detect_input_pending_run_timers (0))
-        swallow_events (0);             /* may clear input_pending */
+        swallow_events (0);             /* May clear input_pending.  */
 
       /* Redisplay if no pending input.  */
       while (!input_pending)
@@ -2474,13 +2484,13 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
      menu prompting. If EVENT_HAS_PARAMETERS then we are reading
      after a mouse event so don't try a minibuf menu.  */
   c = Qnil;
-  if (nmaps > 0 && INTERACTIVE
+  if (KEYMAPP (map) && INTERACTIVE
       && !NILP (prev_event) && ! EVENT_HAS_PARAMETERS (prev_event)
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events)
       && !detect_input_pending_run_timers (0))
     {
-      c = read_char_minibuf_menu_prompt (commandflag, nmaps, maps);
+      c = read_char_minibuf_menu_prompt (commandflag, map);
 
       if (INTEGERP (c) && XINT (c) == -2)
         return c;               /* wrong_kboard_jmpbuf */
@@ -2604,7 +2614,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
      because the recursive call of read_char in read_char_minibuf_menu_prompt
      does not pass on any keymaps.  */
 
-  if (nmaps > 0 && INTERACTIVE
+  if (KEYMAPP (map) && INTERACTIVE
       && !NILP (prev_event)
       && EVENT_HAS_PARAMETERS (prev_event)
       && !EQ (XCAR (prev_event), Qmenu_bar)
@@ -2612,7 +2622,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       /* Don't bring up a menu if we already have another event.  */
       && NILP (Vunread_command_events))
     {
-      c = read_char_x_menu_prompt (nmaps, maps, prev_event, used_mouse_menu);
+      c = read_char_x_menu_prompt (map, prev_event, used_mouse_menu);
 
       /* Now that we have read an event, Emacs is not idle.  */
       if (!end_time)
@@ -2647,9 +2657,10 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
           && XINT (Vauto_save_timeout) > 0)
         {
           Lisp_Object tem0;
-          EMACS_INT timeout = (delay_level
-                               * min (XFASTINT (Vauto_save_timeout) / 4,
-                                      MOST_POSITIVE_FIXNUM / delay_level));
+          EMACS_INT timeout = XFASTINT (Vauto_save_timeout);
+
+          timeout = min (timeout, MOST_POSITIVE_FIXNUM / delay_level * 4);
+          timeout = delay_level * timeout / 4;
           save_getcjmp (save_jump);
           restore_getcjmp (local_getcjmp);
           tem0 = sit_for (make_number (timeout), 1, 1);
@@ -2990,7 +3001,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
 
       /* If we are not reading a key sequence,
          never use the echo area.  */
-      if (maps == 0)
+      if (!KEYMAPP (map))
         {
           specbind (Qinput_method_use_echo_area, Qt);
         }
@@ -3083,7 +3094,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
   last_input_event = c;
   num_input_events++;
 
-  /* Process the help character specially if enabled */
+  /* Process the help character specially if enabled.  */
   if (!NILP (Vhelp_form) && help_char_p (c))
     {
       ptrdiff_t count = SPECPDL_INDEX ();
@@ -3097,13 +3108,13 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
       cancel_echoing ();
       do
         {
-          c = read_char (0, 0, 0, Qnil, 0, NULL);
+          c = read_char (0, Qnil, Qnil, 0, NULL);
           if (EVENT_HAS_PARAMETERS (c)
               && EQ (EVENT_HEAD_KIND (EVENT_HEAD (c)), Qmouse_click))
             XSETCAR (help_form_saved_window_configs, Qnil);
         }
       while (BUFFERP (c));
-      /* Remove the help from the frame */
+      /* Remove the help from the frame.  */
       unbind_to (count, Qnil);
 
       redisplay ();
@@ -3111,7 +3122,7 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
         {
           cancel_echoing ();
           do
-            c = read_char (0, 0, 0, Qnil, 0, NULL);
+            c = read_char (0, Qnil, Qnil, 0, NULL);
           while (BUFFERP (c));
         }
     }
@@ -3904,6 +3915,18 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
+#ifdef WINDOWSNT
+      else if (event->kind == FILE_NOTIFY_EVENT)
+        {
+          /* Make an event (file-notify (DESCRIPTOR ACTION FILE) CALLBACK).  */
+          obj = Fcons (Qfile_w32notify,
+                       list2 (list3 (make_number (event->code),
+                                     XCAR (event->arg),
+                                     XCDR (event->arg)),
+                              event->frame_or_window));
+          kbd_fetch_ptr = event + 1;
+        }
+#endif
       else if (event->kind == SAVE_SESSION_EVENT)
         {
           obj = Fcons (Qsave_session, Fcons (event->arg, Qnil));
@@ -3961,6 +3984,13 @@ kbd_buffer_get_event (KBOARD **kbp,
           kbd_fetch_ptr = event + 1;
         }
 #endif
+#ifdef HAVE_INOTIFY
+      else if (event->kind == FILE_NOTIFY_EVENT)
+        {
+          obj = make_lispy_event (event);
+          kbd_fetch_ptr = event + 1;
+        }
+#endif
       else if (event->kind == CONFIG_CHANGED_EVENT)
         {
           obj = make_lispy_event (event);
@@ -5113,7 +5143,7 @@ make_lispy_position (struct frame *f, Lisp_Object x, Lisp_Object y,
             string_info = Fcons (string, make_number (charpos));
           textpos = (w == XWINDOW (selected_window)
                      && current_buffer == XBUFFER (w->buffer))
-            ? PT : XMARKER (w->pointm)->charpos;
+            ? PT : marker_position (w->pointm);
 
           xret = wx;
           yret = wy;
@@ -5874,6 +5904,13 @@ make_lispy_event (struct input_event *event)
       }
 #endif /* HAVE_DBUS */
 
+#ifdef HAVE_INOTIFY
+    case FILE_NOTIFY_EVENT:
+      {
+        return Fcons (Qfile_inotify, event->arg);
+      }
+#endif /* HAVE_INOTIFY */
+
     case CONFIG_CHANGED_EVENT:
         return Fcons (Qconfig_changed_event,
                       Fcons (event->arg,
@@ -6668,37 +6705,35 @@ get_input_pending (int flags)
 void
 record_asynch_buffer_change (void)
 {
-  struct input_event event;
-  Lisp_Object tem;
-  EVENT_INIT (event);
-
-  event.kind = BUFFER_SWITCH_EVENT;
-  event.frame_or_window = Qnil;
-  event.arg = Qnil;
-
   /* We don't need a buffer-switch event unless Emacs is waiting for input.
      The purpose of the event is to make read_key_sequence look up the
      keymaps again.  If we aren't in read_key_sequence, we don't need one,
      and the event could cause trouble by messing up (input-pending-p).
      Note: Fwaiting_for_user_input_p always returns nil when async
      subprocesses aren't supported.  */
-  tem = Fwaiting_for_user_input_p ();
-  if (NILP (tem))
-    return;
+  if (!NILP (Fwaiting_for_user_input_p ()))
+    {
+      struct input_event event;
+
+      EVENT_INIT (event);
+      event.kind = BUFFER_SWITCH_EVENT;
+      event.frame_or_window = Qnil;
+      event.arg = Qnil;
 
-  /* Make sure no interrupt happens while storing the event.  */
+      /* Make sure no interrupt happens while storing the event.  */
 #ifdef USABLE_SIGIO
-  if (interrupt_input)
-    kbd_buffer_store_event (&event);
-  else
+      if (interrupt_input)
+        kbd_buffer_store_event (&event);
+      else
 #endif
-    {
-      stop_polling ();
-      kbd_buffer_store_event (&event);
-      start_polling ();
+        {
+          stop_polling ();
+          kbd_buffer_store_event (&event);
+          start_polling ();
+        }
     }
 }
-
+
 /* Read any terminal input already buffered up by the system
    into the kbd_buffer, but do not wait.
 
@@ -8277,9 +8312,9 @@ init_tool_bar_items (Lisp_Object reuse)
 static void
 append_tool_bar_item (void)
 {
-  ptrdiff_t incr =
-    (ntool_bar_items
-     - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
+  ptrdiff_t incr
+    = (ntool_bar_items
+       - (ASIZE (tool_bar_items_vector) - TOOL_BAR_ITEM_NSLOTS));
 
   /* Enlarge tool_bar_items_vector if necessary.  */
   if (0 < incr)
@@ -8297,8 +8332,8 @@ append_tool_bar_item (void)
 
 
 
-/* Read a character using menus based on maps in the array MAPS.
-   NMAPS is the length of MAPS.  Return nil if there are no menus in the maps.
+/* Read a character using menus based on the keymap MAP.
+   Return nil if there are no menus in the maps.
    Return t if we displayed a menu but the user rejected it.
 
    PREV_EVENT is the previous input event, or nil if we are reading
@@ -8318,28 +8353,17 @@ append_tool_bar_item (void)
    and do auto-saving in the inner call of read_char.  */
 
 static Lisp_Object
-read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
+read_char_x_menu_prompt (Lisp_Object map,
                          Lisp_Object prev_event, bool *used_mouse_menu)
 {
-#ifdef HAVE_MENUS
-  ptrdiff_t mapno;
-#endif
-
   if (used_mouse_menu)
     *used_mouse_menu = 0;
 
-  /* Use local over global Menu maps */
+  /* Use local over global Menu maps.  */
 
   if (! menu_prompting)
     return Qnil;
 
-  /* Optionally disregard all but the global map.  */
-  if (inhibit_local_menu_bar_menus)
-    {
-      maps += (nmaps - 1);
-      nmaps = 1;
-    }
-
 #ifdef HAVE_MENUS
   /* If we got to this point via a mouse click,
      use a real menu for mouse selection.  */
@@ -8348,16 +8372,9 @@ read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
       && !EQ (XCAR (prev_event), Qtool_bar))
     {
       /* Display the menu and get the selection.  */
-      Lisp_Object *realmaps = alloca (nmaps * sizeof *realmaps);
       Lisp_Object value;
-      ptrdiff_t nmaps1 = 0;
 
-      /* Use the maps that are not nil.  */
-      for (mapno = 0; mapno < nmaps; mapno++)
-        if (!NILP (maps[mapno]))
-          realmaps[nmaps1++] = maps[mapno];
-
-      value = Fx_popup_menu (prev_event, Flist (nmaps1, realmaps));
+      value = Fx_popup_menu (prev_event, get_keymap (map, 0, 1));
       if (CONSP (value))
         {
           Lisp_Object tem;
@@ -8397,17 +8414,10 @@ read_char_x_menu_prompt (ptrdiff_t nmaps, Lisp_Object *maps,
   return Qnil ;
 }
 
-/* Buffer in use so far for the minibuf prompts for menu keymaps.
-   We make this bigger when necessary, and never free it.  */
-static char *read_char_minibuf_menu_text;
-/* Size of that buffer.  */
-static ptrdiff_t read_char_minibuf_menu_width;
-
 static Lisp_Object
 read_char_minibuf_menu_prompt (int commandflag,
-                               ptrdiff_t nmaps, Lisp_Object *maps)
+                               Lisp_Object map)
 {
-  ptrdiff_t mapno;
   register Lisp_Object name;
   ptrdiff_t nlength;
   /* FIXME: Use the minibuffer's frame width.  */
@@ -8415,53 +8425,35 @@ read_char_minibuf_menu_prompt (int commandflag,
   ptrdiff_t idx = -1;
   bool nobindings = 1;
   Lisp_Object rest, vector;
-  char *menu;
+  Lisp_Object prompt_strings = Qnil;
 
   vector = Qnil;
-  name = Qnil;
 
   if (! menu_prompting)
     return Qnil;
 
-  /* Get the menu name from the first map that has one (a prompt string).  */
-  for (mapno = 0; mapno < nmaps; mapno++)
-    {
-      name = Fkeymap_prompt (maps[mapno]);
-      if (!NILP (name))
-        break;
-    }
+  map = get_keymap (map, 0, 1);
+  name = Fkeymap_prompt (map);
 
   /* If we don't have any menus, just read a character normally.  */
   if (!STRINGP (name))
     return Qnil;
 
-  /* Make sure we have a big enough buffer for the menu text.  */
-  width = max (width, SBYTES (name));
-  if (STRING_BYTES_BOUND - 4 < width)
-    memory_full (SIZE_MAX);
-  if (width + 4 > read_char_minibuf_menu_width)
-    {
-      read_char_minibuf_menu_text
-        = xrealloc (read_char_minibuf_menu_text, width + 4);
-      read_char_minibuf_menu_width = width + 4;
-    }
-  menu = read_char_minibuf_menu_text;
+#define PUSH_C_STR(str, listvar) \
+  listvar = Fcons (make_unibyte_string (str, strlen (str)), listvar)
 
   /* Prompt string always starts with map's prompt, and a space.  */
-  strcpy (menu, SSDATA (name));
-  nlength = SBYTES (name);
-  menu[nlength++] = ':';
-  menu[nlength++] = ' ';
-  menu[nlength] = 0;
+  prompt_strings = Fcons (name, prompt_strings);
+  PUSH_C_STR (": ", prompt_strings);
+  nlength = SCHARS (name) + 2;
 
-  /* Start prompting at start of first map.  */
-  mapno = 0;
-  rest = maps[mapno];
+  rest = map;
 
   /* Present the documented bindings, a line at a time.  */
   while (1)
     {
       bool notfirst = 0;
+      Lisp_Object menu_strings = prompt_strings;
       ptrdiff_t i = nlength;
       Lisp_Object obj;
       Lisp_Object orig_defn_macro;
@@ -8471,18 +8463,16 @@ read_char_minibuf_menu_prompt (int commandflag,
         {
           Lisp_Object elt;
 
-          /* If reached end of map, start at beginning of next map.  */
+          /* FIXME: Use map_keymap to handle new keymap formats.  */
+
+          /* At end of map, wrap around if just starting,
+             or end this line if already have something on it.  */
           if (NILP (rest))
             {
-              mapno++;
-              /* At end of last map, wrap around to first map if just starting,
-                 or end this line if already have something on it.  */
-              if (mapno == nmaps)
-                {
-                  mapno = 0;
-                  if (notfirst || nobindings) break;
-                }
-              rest = maps[mapno];
+              if (notfirst || nobindings)
+                break;
+              else
+                rest = map;
             }
 
           /* Look at the next element of the map.  */
@@ -8566,7 +8556,7 @@ read_char_minibuf_menu_prompt (int commandflag,
                       /* Punctuate between strings.  */
                       if (notfirst)
                         {
-                          strcpy (menu + i, ", ");
+                          PUSH_C_STR (", ", menu_strings);
                           i += 2;
                         }
                       notfirst = 1;
@@ -8578,23 +8568,28 @@ read_char_minibuf_menu_prompt (int commandflag,
                         {
                           /* Add as much of string as fits.  */
                           thiswidth = min (SCHARS (desc), width - i);
-                          memcpy (menu + i, SDATA (desc), thiswidth);
+                          menu_strings
+                            = Fcons (Fsubstring (desc, make_number (0),
+                                                 make_number (thiswidth)),
+                                     menu_strings);
                           i += thiswidth;
-                          strcpy (menu + i, " = ");
+                          PUSH_C_STR (" = ", menu_strings);
                           i += 3;
                         }
 
                       /* Add as much of string as fits.  */
                       thiswidth = min (SCHARS (s), width - i);
-                      memcpy (menu + i, SDATA (s), thiswidth);
+                      menu_strings
+                        = Fcons (Fsubstring (s, make_number (0),
+                                             make_number (thiswidth)),
+                                 menu_strings);
                       i += thiswidth;
-                      menu[i] = 0;
                     }
                   else
                     {
                       /* If this element does not fit, end the line now,
                          and save the element for the next line.  */
-                      strcpy (menu + i, "...");
+                      PUSH_C_STR ("...", menu_strings);
                       break;
                     }
                 }
@@ -8611,23 +8606,19 @@ read_char_minibuf_menu_prompt (int commandflag,
         }
 
       /* Prompt with that and read response.  */
-      message2_nolog (menu, strlen (menu),
-                      ! NILP (BVAR (current_buffer, enable_multibyte_characters)));
+      message3_nolog (apply1 (intern ("concat"), Fnreverse (menu_strings)));
 
-      /* Make believe its not a keyboard macro in case the help char
+      /* Make believe it's not a keyboard macro in case the help char
          is pressed.  Help characters are not recorded because menu prompting
-         is not used on replay.
-         */
+         is not used on replay.  */
       orig_defn_macro = KVAR (current_kboard, defining_kbd_macro);
       kset_defining_kbd_macro (current_kboard, Qnil);
       do
-        obj = read_char (commandflag, 0, 0, Qt, 0, NULL);
+        obj = read_char (commandflag, Qnil, Qt, 0, NULL);
       while (BUFFERP (obj));
       kset_defining_kbd_macro (current_kboard, orig_defn_macro);
 
-      if (!INTEGERP (obj))
-        return obj;
-      else if (XINT (obj) == -2)
+      if (!INTEGERP (obj) || XINT (obj) == -2)
         return obj;
 
       if (! EQ (obj, menu_prompt_more_char)
@@ -8638,52 +8629,25 @@ read_char_minibuf_menu_prompt (int commandflag,
             store_kbd_macro_char (obj);
           return obj;
         }
-      /* Help char - go round again */
+      /* Help char - go round again.  */
     }
 }
 
 /* Reading key sequences.  */
 
-/* Follow KEY in the maps in CURRENT[0..NMAPS-1], placing its bindings
-   in DEFS[0..NMAPS-1].  Set NEXT[i] to DEFS[i] if DEFS[i] is a
-   keymap, or nil otherwise.  Return the index of the first keymap in
-   which KEY has any binding, or NMAPS if no map has a binding.
-
-   If KEY is a meta ASCII character, treat it like meta-prefix-char
-   followed by the corresponding non-meta character.  Keymaps in
-   CURRENT with non-prefix bindings for meta-prefix-char become nil in
-   NEXT.
-
-   If KEY has no bindings in any of the CURRENT maps, NEXT is left
-   unmodified.
-
-   NEXT may be the same array as CURRENT.  */
-
-static int
-follow_key (Lisp_Object key, ptrdiff_t nmaps, Lisp_Object *current,
-            Lisp_Object *defs, Lisp_Object *next)
+static Lisp_Object
+follow_key (Lisp_Object keymap, Lisp_Object key)
 {
-  ptrdiff_t i, first_binding;
-
-  first_binding = nmaps;
-  for (i = nmaps - 1; i >= 0; i--)
-    {
-      if (! NILP (current[i]))
-        {
-          defs[i] = access_keymap (current[i], key, 1, 0, 1);
-          if (! NILP (defs[i]))
-            first_binding = i;
-        }
-      else
-        defs[i] = Qnil;
-    }
-
-  /* Given the set of bindings we've found, produce the next set of maps.  */
-  if (first_binding < nmaps)
-    for (i = 0; i < nmaps; i++)
-      next[i] = NILP (defs[i]) ? Qnil : get_keymap (defs[i], 0, 1);
+  return access_keymap (get_keymap (keymap, 0, 1),
+                        key, 1, 0, 1);
+}
 
-  return first_binding;
+static Lisp_Object
+active_maps (Lisp_Object first_event)
+{
+  Lisp_Object position
+    = CONSP (first_event) ? CAR_SAFE (XCDR (first_event)) : Qnil;
+  return Fcons (Qkeymap, Fcurrent_active_maps (Qt, position));
 }
 
 /* Structure used to keep track of partial application of key remapping
@@ -8815,8 +8779,9 @@ keyremap_step (Lisp_Object *keybuf, int bufsize, volatile keyremap *fkey,
 static bool
 test_undefined (Lisp_Object binding)
 {
-  return (EQ (binding, Qundefined)
-          || (!NILP (binding) && SYMBOLP (binding)
+  return (NILP (binding)
+          || EQ (binding, Qundefined)
+          || (SYMBOLP (binding)
               && EQ (Fcommand_remapping (binding, Qnil, Qnil), Qundefined)));
 }
 
@@ -8862,7 +8827,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                    bool dont_downcase_last, bool can_return_switch_frame,
                    bool fix_current_buffer)
 {
-  Lisp_Object from_string;
   ptrdiff_t count = SPECPDL_INDEX ();
 
   /* How many keys there are in the current key sequence.  */
@@ -8873,34 +8837,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   ptrdiff_t echo_start IF_LINT (= 0);
   ptrdiff_t keys_start;
 
-  /* The number of keymaps we're scanning right now, and the number of
-     keymaps we have allocated space for.  */
-  ptrdiff_t nmaps;
-  ptrdiff_t nmaps_allocated = 0;
-
-  /* defs[0..nmaps-1] are the definitions of KEYBUF[0..t-1] in
-     the current keymaps.  */
-  Lisp_Object *defs = NULL;
+  Lisp_Object current_binding = Qnil;
+  Lisp_Object first_event = Qnil;
 
-  /* submaps[0..nmaps-1] are the prefix definitions of KEYBUF[0..t-1]
-     in the current keymaps, or nil where it is not a prefix.  */
-  Lisp_Object *submaps = NULL;
-
-  /* The local map to start out with at start of key sequence.  */
-  Lisp_Object orig_local_map;
-
-  /* The map from the `keymap' property to start out with at start of
-     key sequence.  */
-  Lisp_Object orig_keymap;
-
-  /* Positive if we have already considered switching to the local-map property
-     of the place where a mouse click occurred.  */
-  int localized_local_map = 0;
-
-  /* The index in submaps[] of the first keymap that has a binding for
-     this key sequence.  In other words, the lowest i such that
-     submaps[i] is non-nil.  */
-  ptrdiff_t first_binding;
   /* Index of the first key that has no binding.
      It is useless to try fkey.start larger than that.  */
   int first_unbound;
@@ -8943,11 +8882,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      While we're reading, we keep the event here.  */
   Lisp_Object delayed_switch_frame;
 
-  /* See the comment below...  */
-#if defined (GOBBLE_FIRST_EVENT)
-  Lisp_Object first_event;
-#endif
-
   Lisp_Object original_uppercase IF_LINT (= Qnil);
   int original_uppercase_position = -1;
 
@@ -8959,10 +8893,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   /* List of events for which a fake prefix key has been generated.  */
   Lisp_Object fake_prefixed_keys = Qnil;
 
-#if defined (GOBBLE_FIRST_EVENT)
-  int junk;
-#endif
-
   struct gcpro gcpro1;
 
   GCPRO1 (fake_prefixed_keys);
@@ -8998,21 +8928,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   keys_start = this_command_key_count;
   this_single_command_key_start = keys_start;
 
-#if defined (GOBBLE_FIRST_EVENT)
-  /* This doesn't quite work, because some of the things that read_char
-     does cannot safely be bypassed.  It seems too risky to try to make
-     this work right.  */
-
-  /* Read the first char of the sequence specially, before setting
-     up any keymaps, in case a filter runs and switches buffers on us.  */
-  first_event = read_char (NILP (prompt), 0, submaps, last_nonmenu_event,
-                           &junk, NULL);
-#endif /* GOBBLE_FIRST_EVENT */
-
-  orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-  orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
-  from_string = Qnil;
-
   /* We jump here when we need to reinitialize fkey and keytran; this
      happens if we switch keyboards between rescans.  */
  replay_entire_sequence:
@@ -9037,59 +8952,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
      keybuf with its symbol, or if the sequence starts with a mouse
      click and we need to switch buffers, we jump back here to rebuild
      the initial keymaps from the current buffer.  */
-  nmaps = 0;
-
-  if (!NILP (KVAR (current_kboard, Voverriding_terminal_local_map)))
-    {
-      if (2 > nmaps_allocated)
-        {
-          submaps = alloca (2 * sizeof *submaps);
-          defs    = alloca (2 * sizeof *defs);
-          nmaps_allocated = 2;
-        }
-      submaps[nmaps++] = KVAR (current_kboard, Voverriding_terminal_local_map);
-    }
-  else if (!NILP (Voverriding_local_map))
-    {
-      if (2 > nmaps_allocated)
-        {
-          submaps = alloca (2 * sizeof *submaps);
-          defs    = alloca (2 * sizeof *defs);
-          nmaps_allocated = 2;
-        }
-      submaps[nmaps++] = Voverriding_local_map;
-    }
-  else
-    {
-      ptrdiff_t nminor;
-      ptrdiff_t total;
-      Lisp_Object *maps;
-
-      nminor = current_minor_maps (0, &maps);
-      total = nminor + (!NILP (orig_keymap) ? 3 : 2);
-
-      if (total > nmaps_allocated)
-        {
-          submaps = alloca (total * sizeof *submaps);
-          defs    = alloca (total * sizeof *defs);
-          nmaps_allocated = total;
-        }
-
-      if (!NILP (orig_keymap))
-        submaps[nmaps++] = orig_keymap;
-
-      memcpy (submaps + nmaps, maps, nminor * sizeof (submaps[0]));
-
-      nmaps += nminor;
-
-      submaps[nmaps++] = orig_local_map;
-    }
-  submaps[nmaps++] = current_global_map;
-
-  /* Find an accurate initial value for first_binding.  */
-  for (first_binding = 0; first_binding < nmaps; first_binding++)
-    if (! NILP (submaps[first_binding]))
-      break;
+  current_binding = active_maps (first_event);
 
   /* Start from the beginning in keybuf.  */
   t = 0;
@@ -9103,9 +8966,9 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
   /* If the best binding for the current key sequence is a keymap, or
      we may be looking at a function key's escape sequence, keep on
      reading.  */
-  while (first_binding < nmaps
+  while (!NILP (current_binding)
          /* Keep reading as long as there's a prefix binding.  */
-         ? !NILP (submaps[first_binding])
+         ? KEYMAPP (current_binding)
          /* Don't return in the middle of a possible function key sequence,
             if the only bindings we found were via case conversion.
             Thus, if ESC O a has a function-key-map translation
@@ -9129,7 +8992,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          just one key.  */
       ptrdiff_t echo_local_start IF_LINT (= 0);
       int keys_local_start;
-      ptrdiff_t local_first_binding;
+      Lisp_Object new_binding;
 
       eassert (indec.end == t || (indec.end > t && indec.end <= mock_input));
       eassert (indec.start <= indec.end);
@@ -9166,7 +9029,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       if (INTERACTIVE)
         echo_local_start = echo_length ();
       keys_local_start = this_command_key_count;
-      local_first_binding = first_binding;
 
     replay_key:
       /* These are no-ops, unless we throw away a keystroke below and
@@ -9176,7 +9038,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
       if (INTERACTIVE && t < mock_input)
         echo_truncate (echo_local_start);
       this_command_key_count = keys_local_start;
-      first_binding = local_first_binding;
 
       /* By default, assume each event is "real".  */
       last_real_key_start = t;
@@ -9187,8 +9048,12 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           key = keybuf[t];
           add_command_key (key);
           if ((FLOATP (Vecho_keystrokes) || INTEGERP (Vecho_keystrokes))
-              && NILP (Fzerop (Vecho_keystrokes)))
-            echo_char (key);
+              && NILP (Fzerop (Vecho_keystrokes))
+              && current_kboard->immediate_echo)
+            {
+              echo_add_key (key);
+              echo_dash ();
+            }
         }
 
       /* If not, we should actually read a character.  */
@@ -9197,8 +9062,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
           {
             KBOARD *interrupted_kboard = current_kboard;
             struct frame *interrupted_frame = SELECTED_FRAME ();
-            key = read_char (NILP (prompt), nmaps,
-                             (Lisp_Object *) submaps, last_nonmenu_event,
+            key = read_char (NILP (prompt),
+                             current_binding, last_nonmenu_event,
                              &used_mouse_menu, NULL);
             if ((INTEGERP (key) && XINT (key) == -2) /* wrong_kboard_jmpbuf */
                 /* When switching to a new tty (with a new keyboard),
@@ -9253,8 +9118,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                               KVAR (interrupted_kboard, kbd_queue)));
                   }
                 mock_input = 0;
-                orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-                orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
                 goto replay_entire_sequence;
               }
           }
@@ -9295,12 +9158,11 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 {
                   if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                     Fkill_emacs (Qnil);
-                  if (XBUFFER (XWINDOW (selected_window)->buffer) != current_buffer)
+                  if (XBUFFER (XWINDOW (selected_window)->buffer)
+                      != current_buffer)
                     Fset_buffer (XWINDOW (selected_window)->buffer);
                 }
 
-              orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-              orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
               goto replay_sequence;
             }
 
@@ -9317,8 +9179,6 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
               keybuf[t++] = key;
               mock_input = t;
               Vquit_flag = Qnil;
-              orig_local_map = get_local_map (PT, current_buffer, Qlocal_map);
-              orig_keymap = get_local_map (PT, current_buffer, Qkeymap);
               goto replay_sequence;
             }
 
@@ -9338,6 +9198,22 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 }
             }
 
+          if (NILP (first_event))
+            {
+              first_event = key;
+              /* Even if first_event does not specify a particular
+                 window/position, it's important to recompute the maps here
+                 since a long time might have passed since we entered
+                 read_key_sequence, and a timer (or process-filter or
+                 special-event-map, ...) might have switched the current buffer
+                 or the selected window from under us in the mean time.  */
+              if (fix_current_buffer
+                  && (XBUFFER (XWINDOW (selected_window)->buffer)
+                      != current_buffer))
+                Fset_buffer (XWINDOW (selected_window)->buffer);
+              current_binding = active_maps (first_event);
+            }
+
           GROW_RAW_KEYBUF;
           ASET (raw_keybuf, raw_keybuf_count, key);
           raw_keybuf_count++;
@@ -9359,16 +9235,11 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          or when user programs play with this-command-keys.  */
       if (EVENT_HAS_PARAMETERS (key))
         {
-          Lisp_Object kind;
-          Lisp_Object string;
-
-          kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
+          Lisp_Object kind = EVENT_HEAD_KIND (EVENT_HEAD (key));
           if (EQ (kind, Qmouse_click))
             {
-              Lisp_Object window, posn;
-
-              window = POSN_WINDOW (EVENT_START (key));
-              posn   = POSN_POSN (EVENT_START (key));
+              Lisp_Object window = POSN_WINDOW (EVENT_START (key));
+              Lisp_Object posn = POSN_POSN (EVENT_START (key));
 
               if (CONSP (posn)
                   || (!NILP (fake_prefixed_keys)
@@ -9411,58 +9282,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                       if (! FRAME_LIVE_P (XFRAME (selected_frame)))
                         Fkill_emacs (Qnil);
                       set_buffer_internal (XBUFFER (XWINDOW (window)->buffer));
-                      orig_local_map = get_local_map (PT, current_buffer,
-                                                      Qlocal_map);
-                      orig_keymap = get_local_map (PT, current_buffer,
-                                                   Qkeymap);
                       goto replay_sequence;
                     }
-
-                  /* For a mouse click, get the local text-property keymap
-                     of the place clicked on, rather than point.  */
-                  if (CONSP (XCDR (key))
-                      && ! localized_local_map)
-                    {
-                      Lisp_Object map_here, start, pos;
-
-                      localized_local_map = 1;
-                      start = EVENT_START (key);
-
-                      if (CONSP (start) && POSN_INBUFFER_P (start))
-                        {
-                          pos = POSN_BUFFER_POSN (start);
-                          if (INTEGERP (pos)
-                              && XINT (pos) >= BEGV
-                              && XINT (pos) <= ZV)
-                            {
-                              map_here = get_local_map (XINT (pos),
-                                                        current_buffer,
-                                                        Qlocal_map);
-                              if (!EQ (map_here, orig_local_map))
-                                {
-                                  orig_local_map = map_here;
-                                  ++localized_local_map;
-                                }
-
-                              map_here = get_local_map (XINT (pos),
-                                                        current_buffer,
-                                                        Qkeymap);
-                              if (!EQ (map_here, orig_keymap))
-                                {
-                                  orig_keymap = map_here;
-                                  ++localized_local_map;
-                                }
-
-                              if (localized_local_map > 1)
-                                {
-                                  keybuf[t] = key;
-                                  mock_input = t + 1;
-
-                                  goto replay_sequence;
-                                }
-                            }
-                        }
-                    }
                 }
 
               /* Expand mode-line and scroll-bar events into two events:
@@ -9483,63 +9304,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                      prevent proper action when the event is pushed
                      back into unread-command-events.  */
                   fake_prefixed_keys = Fcons (key, fake_prefixed_keys);
-
-                  /* If on a mode line string with a local keymap,
-                     reconsider the key sequence with that keymap.  */
-                  if (string = POSN_STRING (EVENT_START (key)),
-                      (CONSP (string) && STRINGP (XCAR (string))))
-                    {
-                      Lisp_Object pos, map, map2;
-
-                      pos = XCDR (string);
-                      string = XCAR (string);
-                      if (XINT (pos) >= 0
-                          && XINT (pos) < SCHARS (string))
-                        {
-                          map = Fget_text_property (pos, Qlocal_map, string);
-                          if (!NILP (map))
-                            orig_local_map = map;
-                          map2 = Fget_text_property (pos, Qkeymap, string);
-                          if (!NILP (map2))
-                            orig_keymap = map2;
-                          if (!NILP (map) || !NILP (map2))
-                            goto replay_sequence;
-                        }
-                    }
-
                   goto replay_key;
                 }
-              else if (NILP (from_string)
-                       && (string = POSN_STRING (EVENT_START (key)),
-                           (CONSP (string) && STRINGP (XCAR (string)))))
-                {
-                  /* For a click on a string, i.e. overlay string or a
-                     string displayed via the `display' property,
-                     consider `local-map' and `keymap' properties of
-                     that string.  */
-                  Lisp_Object pos, map, map2;
-
-                  pos = XCDR (string);
-                  string = XCAR (string);
-                  if (XINT (pos) >= 0
-                      && XINT (pos) < SCHARS (string))
-                    {
-                      map = Fget_text_property (pos, Qlocal_map, string);
-                      if (!NILP (map))
-                        orig_local_map = map;
-                      map2 = Fget_text_property (pos, Qkeymap, string);
-                      if (!NILP (map2))
-                        orig_keymap = map2;
-
-                      if (!NILP (map) || !NILP (map2))
-                        {
-                          from_string = string;
-                          keybuf[t++] = key;
-                          mock_input = t;
-                          goto replay_sequence;
-                        }
-                    }
-                }
             }
           else if (CONSP (XCDR (key))
                    && CONSP (EVENT_START (key))
@@ -9555,7 +9321,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                   if (bufsize - t <= 1)
                     error ("Key sequence too long");
                   keybuf[t] = posn;
-                  keybuf[t+1] = key;
+                  keybuf[t + 1] = key;
 
                   /* Zap the position in key, so we know that we've
                      expanded it, and don't try to do so again.  */
@@ -9578,15 +9344,10 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
 
       /* We have finally decided that KEY is something we might want
          to look up.  */
-      first_binding = (follow_key (key,
-                                   nmaps   - first_binding,
-                                   submaps + first_binding,
-                                   defs    + first_binding,
-                                   submaps + first_binding)
-                       + first_binding);
+      new_binding = follow_key (current_binding, key);
 
       /* If KEY wasn't bound, we'll try some fallbacks.  */
-      if (first_binding < nmaps)
+      if (!NILP (new_binding))
         /* This is needed for the following scenario:
            event 0: a down-event that gets dropped by calling replay_key.
            event 1: some normal prefix like C-h.
@@ -9723,20 +9484,13 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                       new_click
                         = Fcons (new_head, Fcons (EVENT_START (key), Qnil));
 
-                      /* Look for a binding for this new key.  follow_key
-                         promises that it didn't munge submaps the
-                         last time we called it, since key was unbound.  */
-                      first_binding
-                        = (follow_key (new_click,
-                                       nmaps   - local_first_binding,
-                                       submaps + local_first_binding,
-                                       defs    + local_first_binding,
-                                       submaps + local_first_binding)
-                           + local_first_binding);
+                      /* Look for a binding for this new key.  */
+                      new_binding = follow_key (current_binding, new_click);
 
                       /* If that click is bound, go for it.  */
-                      if (first_binding < nmaps)
+                      if (!NILP (new_binding))
                         {
+                          current_binding = new_binding;
                           key = new_click;
                           break;
                         }
@@ -9745,6 +9499,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                 }
             }
         }
+      current_binding = new_binding;
 
       keybuf[t++] = key;
       /* Normally, last_nonmenu_event gets the previous key we read.
@@ -9776,9 +9531,8 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
             }
         }
 
-      if (first_binding < nmaps
-          && NILP (submaps[first_binding])
-          && !test_undefined (defs[first_binding])
+      if (!KEYMAPP (current_binding)
+          && !test_undefined (current_binding)
           && indec.start >= t)
         /* There is a binding and it's not a prefix.
            (and it doesn't have any input-decode-map translation pending).
@@ -9807,8 +9561,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
                                      first_binding >= nmaps) we don't want
                                      to apply this function-key-mapping.  */
                                   fkey.end + 1 == t
-                                  && (first_binding >= nmaps
-                                      || test_undefined (defs[first_binding])),
+                                  && (test_undefined (current_binding)),
                                   &diff, prompt);
             UNGCPRO;
             if (done)
@@ -9851,7 +9604,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          and cannot be part of a function key or translation,
          and is an upper case letter
          use the corresponding lower-case letter instead.  */
-      if (first_binding >= nmaps
+      if (NILP (current_binding)
           && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t
           && INTEGERP (key)
           && ((CHARACTERP (make_number (XINT (key) & ~CHAR_MODIFIER_MASK))
@@ -9882,7 +9635,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
          and cannot be part of a function key or translation,
          and is a shifted function key,
          use the corresponding unshifted function key instead.  */
-      if (first_binding >= nmaps
+      if (NILP (current_binding)
           && /* indec.start >= t && fkey.start >= t && */ keytran.start >= t)
         {
           Lisp_Object breakdown = parse_modifiers (key);
@@ -9923,9 +9676,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
         }
     }
   if (!dummyflag)
-    read_key_sequence_cmd = (first_binding < nmaps
-                             ? defs[first_binding]
-                             : Qnil);
+    read_key_sequence_cmd = current_binding;
   read_key_sequence_remapped
     /* Remap command through active keymaps.
        Do the remapping here, before the unbind_to so it uses the keymaps
@@ -9939,7 +9690,7 @@ read_key_sequence (Lisp_Object *keybuf, int bufsize, Lisp_Object prompt,
 
   /* Don't downcase the last character if the caller says don't.
      Don't downcase it if the result is undefined, either.  */
-  if ((dont_downcase_last || first_binding >= nmaps)
+  if ((dont_downcase_last || NILP (current_binding))
       && t > 0
       && t - 1 == original_uppercase_position)
     {
@@ -10036,7 +9787,7 @@ will read just one key sequence.  */)
 
   memset (keybuf, 0, sizeof keybuf);
   GCPRO1 (keybuf[0]);
-  gcpro1.nvars = (sizeof keybuf/sizeof (keybuf[0]));
+  gcpro1.nvars = (sizeof keybuf / sizeof (keybuf[0]));
 
   if (NILP (continue_echo))
     {
@@ -10050,7 +9801,7 @@ will read just one key sequence.  */)
     cancel_hourglass ();
 #endif
 
-  i = read_key_sequence (keybuf, (sizeof keybuf/sizeof (keybuf[0])),
+  i = read_key_sequence (keybuf, (sizeof keybuf / sizeof (keybuf[0])),
                          prompt, ! NILP (dont_downcase_last),
                          ! NILP (can_return_switch_frame), 0);
 
@@ -10129,7 +9880,7 @@ DEFUN ("command-execute", Fcommand_execute, Scommand_execute, 1, 4, 0,
        doc: /* Execute CMD as an editor command.
 CMD must be a symbol that satisfies the `commandp' predicate.
 Optional second arg RECORD-FLAG non-nil
-means unconditionally put this command in `command-history'.
+means unconditionally put this command in the variable `command-history'.
 Otherwise, that is done only if an arg is read using the minibuffer.
 The argument KEYS specifies the value to use instead of (this-command-keys)
 when reading the arguments; if it is nil, (this-command-keys) is used.
@@ -11333,10 +11084,18 @@ syms_of_keyboard (void)
   DEFSYM (Qlanguage_change, "language-change");
 #endif
 
+#ifdef WINDOWSNT
+  DEFSYM (Qfile_w32notify, "file-w32notify");
+#endif
+
 #ifdef HAVE_DBUS
   DEFSYM (Qdbus_event, "dbus-event");
 #endif
 
+#ifdef HAVE_INOTIFY
+  DEFSYM (Qfile_inotify, "file-inotify");
+#endif /* HAVE_INOTIFY */
+
   DEFSYM (QCenable, ":enable");
   DEFSYM (QCvisible, ":visible");
   DEFSYM (QChelp, ":help");
@@ -11634,10 +11393,6 @@ This variable is also the threshold for motion of the mouse
 to count as a drag.  */);
   double_click_fuzz = 3;
 
-  DEFVAR_BOOL ("inhibit-local-menu-bar-menus", inhibit_local_menu_bar_menus,
-               doc: /* Non-nil means inhibit local map menu bar menus.  */);
-  inhibit_local_menu_bar_menus = 0;
-
   DEFVAR_INT ("num-input-keys", num_input_keys,
               doc: /* Number of complete key sequences read as input so far.
 This includes key sequences read from keyboard macros.
@@ -11865,9 +11620,7 @@ If the binding is a function, it is called with one argument (the prompt)
 and its return value (a key sequence) is used.
 
 The events that come from bindings in `input-decode-map' are not
-themselves looked up in `input-decode-map'.
-
-This variable is keyboard-local.  */);
+themselves looked up in `input-decode-map'.  */);
 
   DEFVAR_LISP ("function-key-map", Vfunction_key_map,
                doc: /* The parent keymap of all `local-function-key-map' instances.
@@ -11879,9 +11632,8 @@ definition will take precedence.  */);
 
   DEFVAR_LISP ("key-translation-map", Vkey_translation_map,
                doc: /* Keymap of key translations that can override keymaps.
-This keymap works like `function-key-map', but comes after that,
-and its non-prefix bindings override ordinary bindings.
-Another difference is that it is global rather than keyboard-local.  */);
+This keymap works like `input-decode-map', but comes after `function-key-map'.
+Another difference is that it is global rather than terminal-local.  */);
   Vkey_translation_map = Fmake_sparse_keymap (Qnil);
 
   DEFVAR_LISP ("deferred-action-list", Vdeferred_action_list,
@@ -12006,8 +11758,8 @@ This takes effect only when Transient Mark mode is enabled.  */);
                Vsaved_region_selection,
                doc: /* Contents of active region prior to buffer modification.
 If `select-active-regions' is non-nil, Emacs sets this to the
-text in the region before modifying the buffer.  The next
-`deactivate-mark' call uses this to set the window selection.  */);
+text in the region before modifying the buffer.  The next call to
+the function `deactivate-mark' uses this to set the window selection.  */);
   Vsaved_region_selection = Qnil;
 
   DEFVAR_LISP ("selection-inhibit-update-commands",
@@ -12093,11 +11845,20 @@ keys_of_keyboard (void)
                             "dbus-handle-event");
 #endif
 
+#ifdef HAVE_INOTIFY
+  /* Define a special event which is raised for inotify callback
+     functions.  */
+  initial_define_lispy_key (Vspecial_event_map, "file-inotify",
+                            "inotify-handle-event");
+#endif /* HAVE_INOTIFY */
+
   initial_define_lispy_key (Vspecial_event_map, "config-changed-event",
                             "ignore");
 #if defined (WINDOWSNT)
   initial_define_lispy_key (Vspecial_event_map, "language-change",
                             "ignore");
+  initial_define_lispy_key (Vspecial_event_map, "file-w32notify",
+                            "w32notify-handle-event");
 #endif
 }
 
diff --git a/src/keyboard.h b/src/keyboard.h
index e57c8cc7193..c6ade35dd52 100644
--- a/src/keyboard.h
+++ b/src/keyboard.h
@@ -1,5 +1,6 @@
 /* Declarations useful when processing input.
-   Copyright (C) 1985-1987, 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -481,7 +482,7 @@ struct input_event;
 
 extern Lisp_Object parse_modifiers (Lisp_Object);
 extern Lisp_Object reorder_modifiers (Lisp_Object);
-extern Lisp_Object read_char (int, ptrdiff_t, Lisp_Object *, Lisp_Object,
+extern Lisp_Object read_char (int, Lisp_Object, Lisp_Object,
                               bool *, EMACS_TIME *);
 extern int parse_solitary_modifier (Lisp_Object symbol);
 
diff --git a/src/keymap.c b/src/keymap.c
index fbdd31e0de3..922c1703edf 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1,5 +1,6 @@
 /* Manipulation of keymaps
-   Copyright (C) 1985-1988, 1993-1995, 1998-2012 Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993-1995, 1998-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -564,15 +565,13 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
 {
   if (!NILP (val))
     {
-      map_keymap_function_t fun
-        = (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
-      args = XCDR (args);
+      map_keymap_function_t fun = XSAVE_POINTER (args, 0);
       /* If the key is a range, make a copy since map_char_table modifies
          it in place.  */
       if (CONSP (key))
         key = Fcons (XCAR (key), XCDR (key));
-      map_keymap_item (fun, XCDR (args), key, val,
-                       XSAVE_VALUE (XCAR (args))->pointer);
+      map_keymap_item (fun, XSAVE_OBJECT (args, 2), key,
+                       val, XSAVE_POINTER (args, 1));
     }
 }
 
@@ -610,12 +609,8 @@ map_keymap_internal (Lisp_Object map,
             }
         }
       else if (CHAR_TABLE_P (binding))
-        {
-          map_char_table (map_keymap_char_table_item, Qnil, binding,
-                          Fcons (make_save_value ((void *) fun, 0),
-                                 Fcons (make_save_value (data, 0),
-                                        args)));
-        }
+        map_char_table (map_keymap_char_table_item, Qnil, binding,
+                        make_save_value ("ppo", fun, data, args));
     }
   UNGCPRO;
   return tail;
@@ -1249,7 +1244,7 @@ remapping in all currently active keymaps.  */)
   return INTEGERP (command) ? Qnil : command;
 }
 
-/* Value is number if KEY is too long; nil if valid but has no definition. */
+/* Value is number if KEY is too long; nil if valid but has no definition.  */
 /* GC is possible in this function.  */
 
 DEFUN ("lookup-key", Flookup_key, Slookup_key, 2, 3, 0,
@@ -1541,7 +1536,7 @@ DEFUN ("current-active-maps", Fcurrent_active_maps, Scurrent_active_maps,
        doc: /* Return a list of the currently active keymaps.
 OLP if non-nil indicates that we should obey `overriding-local-map' and
 `overriding-terminal-local-map'.  POSITION can specify a click position
-like in the respective argument of `key-binding'. */)
+like in the respective argument of `key-binding'.  */)
   (Lisp_Object olp, Lisp_Object position)
 {
   ptrdiff_t count = SPECPDL_INDEX ();
@@ -1550,7 +1545,7 @@ like in the respective argument of `key-binding'. */)
 
   /* If a mouse click position is given, our variables are based on
      the buffer clicked on, not the current buffer.  So we may have to
-     switch the buffer here. */
+     switch the buffer here.  */
 
   if (CONSP (position))
     {
@@ -2047,7 +2042,7 @@ DEFUN ("key-description", Fkey_description, Skey_description, 1, 2, 0,
 Optional arg PREFIX is the sequence of keys leading up to KEYS.
 For example, [?\C-x ?l] is converted into the string \"C-x l\".
 
-The `kbd' macro is an approximate inverse of this.  */)
+For an approximate inverse of this, see `kbd'.  */)
   (Lisp_Object keys, Lisp_Object prefix)
 {
   ptrdiff_t len = 0;
diff --git a/src/keymap.h b/src/keymap.h
index c704ee0b050..eca0f1b4108 100644
--- a/src/keymap.h
+++ b/src/keymap.h
@@ -1,5 +1,5 @@
 /* Functions to manipulate keymaps.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/lastfile.c b/src/lastfile.c
index f8a64797362..019a6a99763 100644
--- a/src/lastfile.c
+++ b/src/lastfile.c
@@ -1,5 +1,5 @@
 /* Mark end of data space to dump as pure, for GNU Emacs.
-   Copyright (C) 1985, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/lisp.h b/src/lisp.h
index 91fc3dfa1c6..44a5bd571ff 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1,6 +1,7 @@
 /* Fundamental definitions for GNU Emacs Lisp interpreter.
 
-Copyright (C) 1985-1987, 1993-1995, 1997-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1987, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -226,7 +227,7 @@ enum enum_USE_LSB_TAG { USE_LSB_TAG = 0 };
 
 /* Lisp integers use 2 tags, to give them one extra bit, thus
    extending their range from, e.g., -2^28..2^28-1 to -2^29..2^29-1.  */
-static EMACS_INT const INTMASK = EMACS_INT_MAX >> (INTTYPEBITS - 1);
+#define INTMASK (EMACS_INT_MAX >> (INTTYPEBITS - 1))
 #define case_Lisp_Int case Lisp_Int0: case Lisp_Int1
 #define LISP_INT_TAG_P(x) (((x) & ~Lisp_Int1) == 0)
 
@@ -325,6 +326,10 @@ enum Lisp_Fwd_Type
    members that are accessible only from C.  A Lisp_Misc object is a
    wrapper for a C struct that can contain anything you like.
 
+   Explicit freeing is discouraged for Lisp objects in general.  But if
+   you really need to exploit this, use Lisp_Misc (check free_misc in
+   alloc.c to see why).  There is no way to free a vectorlike object.
+
    To add a new pseudovector type, extend the pvec_type enumeration;
    to add a new Lisp_Misc, extend the Lisp_Misc_Type enumeration.
 
@@ -334,6 +339,10 @@ enum Lisp_Fwd_Type
    enumeration and a 1-bit GC markbit) and make sure the overall size
    of the union is not increased by your addition.
 
+   For a new pseudovector, it's highly desirable to limit the size
+   of your data type by VBLOCK_BYTES_MAX bytes (defined in alloc.c).
+   Otherwise you will need to change sweep_vectors (also in alloc.c).
+
    Then you will need to add switch branches in print.c (in
    print_object, to print your object, and possibly also in
    print_preprocess) and to alloc.c, to mark your object (in
@@ -496,13 +505,9 @@ static EMACS_INT const VALMASK
   (XIL ((EMACS_INT) ((EMACS_UINT) (type) << VALBITS)  \
         + ((intptr_t) (ptr) & VALMASK)))
 
-#if DATA_SEG_BITS
 /* DATA_SEG_BITS forces extra bits to be or'd in with any pointers
    which were stored in a Lisp_Object.  */
 #define XPNTR(a) ((uintptr_t) ((XLI (a) & VALMASK)) | DATA_SEG_BITS))
-#else
-#define XPNTR(a) ((uintptr_t) (XLI (a) & VALMASK))
-#endif
 
 #endif /* not USE_LSB_TAG */
 
@@ -1295,6 +1300,14 @@ sxhash_combine (EMACS_UINT x, EMACS_UINT y)
   return (x << 4) + (x >> (BITS_PER_EMACS_INT - 4)) + y;
 }
 
+/* Hash X, returning a value that fits into a fixnum.  */
+
+LISP_INLINE EMACS_UINT
+SXHASH_REDUCE (EMACS_UINT x)
+{
+  return (x ^ x >> (BITS_PER_EMACS_INT - FIXNUM_BITS)) & INTMASK;
+}
+
 /* These structures are used for various misc types.  */
 
 struct Lisp_Misc_Any            /* Supertype of all Misc types.  */
@@ -1369,20 +1382,103 @@ struct Lisp_Overlay
     Lisp_Object plist;
   };
 
-/* Hold a C pointer for later use.
-   This type of object is used in the arg to record_unwind_protect.  */
+/* Types of data which may be saved in a Lisp_Save_Value.  */
+
+enum
+  {
+    SAVE_UNUSED,
+    SAVE_INTEGER,
+    SAVE_POINTER,
+    SAVE_OBJECT
+  };
+
+/* Special object used to hold a different values for later use.
+
+   This is mostly used to package C integers and pointers to call
+   record_unwind_protect.  Typical task is to pass just one C pointer
+   to unwind function.  You should pack pointer with make_save_pointer
+   and then get it back with XSAVE_POINTER, e.g.:
+
+   ...
+     struct my_data *md = get_my_data ();
+     record_unwind_protect (my_unwind, make_save_pointer (md));
+   ...
+
+   Lisp_Object my_unwind (Lisp_Object arg)
+   {
+     struct my_data *md = XSAVE_POINTER (arg, 0);
+     ...
+   }
+
+   If yon need to pass more than just one C pointer, you should
+   use make_save_value.  This function allows you to pack up to
+   4 integers, pointers or Lisp_Objects and conveniently get them
+   back with XSAVE_POINTER, XSAVE_INTEGER and XSAVE_OBJECT macros:
+
+   ...
+     struct my_data *md = get_my_data ();
+     ptrdiff_t my_offset = get_my_offset ();
+     Lisp_Object my_object = get_my_object ();
+     record_unwind_protect
+       (my_unwind, make_save_value ("pio", md, my_offset, my_object));
+   ...
+
+   Lisp_Object my_unwind (Lisp_Object arg)
+   {
+     struct my_data *md = XSAVE_POINTER (arg, 0);
+     ptrdiff_t my_offset = XSAVE_INTEGER (arg, 1);
+     Lisp_Object my_object = XSAVE_OBJECT (arg, 2);
+     ...
+   }
+
+   If ENABLE_CHECKING is in effect, XSAVE_xxx macros do type checking of the
+   saved objects and raise eassert if type of the saved object doesn't match
+   the type which is extracted.  In the example above, XSAVE_INTEGER (arg, 2)
+   or XSAVE_OBJECT (arg, 1) are wrong because integer was saved in slot 1 and
+   Lisp_Object was saved in slot 2 of ARG.  */
+
 struct Lisp_Save_Value
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
     unsigned gcmarkbit : 1;
-    int spacer : 14;
-    /* If DOGC is set, POINTER is the address of a memory
-       area containing INTEGER potential Lisp_Objects.  */
-    unsigned int dogc : 1;
-    void *pointer;
-    ptrdiff_t integer;
+    int spacer : 6;
+    /* If `area' is nonzero, `data[0].pointer' is the address of a memory area
+       containing `data[1].integer' potential Lisp_Objects.  The rest of `data'
+       fields are unused.  */
+    unsigned area : 1;
+    /* If `area' is zero, `data[N]' may hold different objects which type is
+       encoded in `typeN' fields as described by the anonymous enum above.
+       E.g. if `type0' is SAVE_INTEGER, `data[0].integer' is in use.  */
+    unsigned type0 : 2;
+    unsigned type1 : 2;
+    unsigned type2 : 2;
+    unsigned type3 : 2;
+    union {
+      void *pointer;
+      ptrdiff_t integer;
+      Lisp_Object object;
+    } data[4];
   };
 
+/* Macro to set and extract Nth saved pointer.  Type
+   checking is ugly because it's used as an lvalue.  */
+
+#define XSAVE_POINTER(obj, n)                                   \
+  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
+    ## n == SAVE_POINTER), n)].pointer
+
+/* Likewise for the saved integer.  */
+
+#define XSAVE_INTEGER(obj, n)                                   \
+  XSAVE_VALUE (obj)->data[(eassert (XSAVE_VALUE (obj)->type     \
+    ## n == SAVE_INTEGER), n)].integer
+
+/* Macro to extract Nth saved object.  This is never used as
+   an lvalue, so we can do more convenient type checking.  */
+
+#define XSAVE_OBJECT(obj, n)                                    \
+  (eassert (XSAVE_VALUE (obj)->type ## n == SAVE_OBJECT),       \
+   XSAVE_VALUE (obj)->data[n].object)
 
 /* A miscellaneous object, when it's on the free list.  */
 struct Lisp_Free
@@ -1441,7 +1537,8 @@ struct Lisp_Buffer_Objfwd
   {
     enum Lisp_Fwd_Type type;    /* = Lisp_Fwd_Buffer_Obj */
     int offset;
-    Lisp_Object slottype; /* Qnil, Lisp_Int, Lisp_Symbol, or Lisp_String.  */
+    /* One of Qnil, Qintegerp, Qsymbolp, Qstringp, Qfloatp or Qnumberp.  */
+    Lisp_Object predicate;
   };
 
 /* struct Lisp_Buffer_Local_Value is used in a symbol value cell when
@@ -2207,8 +2304,12 @@ struct gcpro
    2    Mark the stack, and check that everything GCPRO'd is
         marked.
    3    Mark using GCPRO's, mark stack last, and count how many
-        dead objects are kept alive.  */
+        dead objects are kept alive.
 
+   Formerly, method 0 was used.  Currently, method 1 is used unless
+   otherwise specified by hand when building, e.g.,
+   "make CPPFLAGS='-DGC_MARK_STACK=GC_USE_GCPROS_AS_BEFORE'".
+   Methods 2 and 3 are present mainly to debug the transition from 0 to 1.  */
 
 #define GC_USE_GCPROS_AS_BEFORE         0
 #define GC_MAKE_GCPROS_NOOPS            1
@@ -2765,10 +2866,10 @@ extern void syms_of_image (void);
 
 /* Defined in insdel.c.  */
 extern Lisp_Object Qinhibit_modification_hooks;
-extern void move_gap (ptrdiff_t);
 extern void move_gap_both (ptrdiff_t, ptrdiff_t);
 extern _Noreturn void buffer_overflow (void);
 extern void make_gap (ptrdiff_t);
+extern void make_gap_1 (struct buffer *, ptrdiff_t);
 extern ptrdiff_t copy_text (const unsigned char *, unsigned char *,
                             ptrdiff_t, bool, bool);
 extern int count_combining_before (const unsigned char *,
@@ -2777,7 +2878,6 @@ extern int count_combining_after (const unsigned char *,
                                   ptrdiff_t, ptrdiff_t, ptrdiff_t);
 extern void insert (const char *, ptrdiff_t);
 extern void insert_and_inherit (const char *, ptrdiff_t);
-extern void insert_1 (const char *, ptrdiff_t, bool, bool, bool);
 extern void insert_1_both (const char *, ptrdiff_t, ptrdiff_t,
                            bool, bool, bool);
 extern void insert_from_gap (ptrdiff_t, ptrdiff_t);
@@ -2851,11 +2951,9 @@ extern void clear_message (int, int);
 extern void message (const char *, ...) ATTRIBUTE_FORMAT_PRINTF (1, 2);
 extern void message1 (const char *);
 extern void message1_nolog (const char *);
-extern void message2 (const char *, ptrdiff_t, int);
-extern void message2_nolog (const char *, ptrdiff_t, int);
-extern void message3 (Lisp_Object, ptrdiff_t, int);
-extern void message3_nolog (Lisp_Object, ptrdiff_t, int);
-extern void message_dolog (const char *, ptrdiff_t, int, int);
+extern void message3 (Lisp_Object);
+extern void message3_nolog (Lisp_Object);
+extern void message_dolog (const char *, ptrdiff_t, bool, bool);
 extern void message_with_string (const char *, Lisp_Object, int);
 extern void message_log_maybe_newline (void);
 extern void update_echo_area (void);
@@ -2879,6 +2977,7 @@ extern void memory_warnings (void *, void (*warnfun) (const char *));
 
 /* Defined in alloc.c.  */
 extern void check_pure_size (void);
+extern void free_misc (Lisp_Object);
 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
 extern void malloc_warning (const char *);
 extern _Noreturn void memory_full (size_t);
@@ -2948,6 +3047,27 @@ extern void make_byte_code (struct Lisp_Vector *);
 extern Lisp_Object Qautomatic_gc;
 extern Lisp_Object Qchar_table_extra_slots;
 extern struct Lisp_Vector *allocate_vector (EMACS_INT);
+
+/* Make an unitialized vector for SIZE objects.  NOTE: you must
+   be sure that GC cannot happen until the vector is completely
+   initialized.  E.g. the following code is likely to crash:
+
+   v = make_uninit_vector (3);
+   ASET (v, 0, obj0);
+   ASET (v, 1, Ffunction_can_gc ());
+   ASET (v, 2, obj1);  */
+
+LISP_INLINE Lisp_Object
+make_uninit_vector (ptrdiff_t size)
+{
+  Lisp_Object v;
+  struct Lisp_Vector *p;
+
+  p = allocate_vector (size);
+  XSETVECTOR (v, p);
+  return v;
+}
+
 extern struct Lisp_Vector *allocate_pseudovector (int, int, enum pvec_type);
 #define ALLOCATE_PSEUDOVECTOR(typ,field,tag)                            \
   ((typ*)                                                               \
@@ -2963,8 +3083,8 @@ extern bool abort_on_gc;
 extern Lisp_Object make_float (double);
 extern void display_malloc_warning (void);
 extern ptrdiff_t inhibit_garbage_collection (void);
-extern Lisp_Object make_save_value (void *, ptrdiff_t);
-extern void free_save_value (Lisp_Object);
+extern Lisp_Object make_save_value (const char *, ...);
+extern Lisp_Object make_save_pointer (void *);
 extern Lisp_Object build_overlay (Lisp_Object, Lisp_Object, Lisp_Object);
 extern void free_marker (Lisp_Object);
 extern void free_cons (struct Lisp_Cons *);
@@ -3176,7 +3296,6 @@ extern void keys_of_buffer (void);
 extern ptrdiff_t marker_position (Lisp_Object);
 extern ptrdiff_t marker_byte_position (Lisp_Object);
 extern void clear_charpos_cache (struct buffer *);
-extern ptrdiff_t charpos_to_bytepos (ptrdiff_t);
 extern ptrdiff_t buf_charpos_to_bytepos (struct buffer *, ptrdiff_t);
 extern ptrdiff_t buf_bytepos_to_charpos (struct buffer *, ptrdiff_t);
 extern void unchain_marker (struct Lisp_Marker *marker);
@@ -3199,9 +3318,11 @@ EXFUN (Fread_file_name, 6);     /* Not a normal DEFUN.  */
 extern Lisp_Object close_file_unwind (Lisp_Object);
 extern Lisp_Object restore_point_unwind (Lisp_Object);
 extern _Noreturn void report_file_error (const char *, Lisp_Object);
-extern void internal_delete_file (Lisp_Object);
+extern bool internal_delete_file (Lisp_Object);
+extern Lisp_Object emacs_readlinkat (int, const char *);
 extern bool file_directory_p (const char *);
 extern bool file_accessible_directory_p (const char *);
+extern void init_fileio (void);
 extern void syms_of_fileio (void);
 extern Lisp_Object make_temp_name (Lisp_Object, bool);
 extern Lisp_Object Qdelete_file;
@@ -3214,15 +3335,15 @@ extern void record_unwind_save_match_data (void);
 struct re_registers;
 extern struct re_pattern_buffer *compile_pattern (Lisp_Object,
                                                   struct re_registers *,
-                                                  Lisp_Object, int, int);
+                                                  Lisp_Object, int, bool);
 extern ptrdiff_t fast_string_match (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_c_string_match_ignore_case (Lisp_Object, const char *,
                                                   ptrdiff_t);
 extern ptrdiff_t fast_string_match_ignore_case (Lisp_Object, Lisp_Object);
 extern ptrdiff_t fast_looking_at (Lisp_Object, ptrdiff_t, ptrdiff_t,
                                   ptrdiff_t, ptrdiff_t, Lisp_Object);
-extern ptrdiff_t scan_buffer (int, ptrdiff_t, ptrdiff_t, ptrdiff_t,
-                              ptrdiff_t *, bool);
+extern ptrdiff_t find_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t,
+                               ptrdiff_t *, bool);
 extern EMACS_INT scan_newline (ptrdiff_t, ptrdiff_t, ptrdiff_t, ptrdiff_t,
                                EMACS_INT, bool);
 extern ptrdiff_t find_next_newline (ptrdiff_t, int);
@@ -3452,6 +3573,8 @@ extern void init_sigio (int);
 extern void sys_subshell (void);
 extern void sys_suspend (void);
 extern void discard_tty_input (void);
+extern void block_tty_out_signal (void);
+extern void unblock_tty_out_signal (void);
 extern void init_sys_modes (struct tty_display_info *);
 extern void reset_sys_modes (struct tty_display_info *);
 extern void init_all_sys_modes (void);
@@ -3469,8 +3592,6 @@ extern int emacs_open (const char *, int, int);
 extern int emacs_close (int);
 extern ptrdiff_t emacs_read (int, char *, ptrdiff_t);
 extern ptrdiff_t emacs_write (int, const char *, ptrdiff_t);
-enum { READLINK_BUFSIZE = 1024 };
-extern char *emacs_readlink (const char *, char [READLINK_BUFSIZE]);
 
 extern void unlock_all_files (void);
 extern void lock_file (Lisp_Object);
@@ -3516,6 +3637,16 @@ extern void syms_of_fontset (void);
 extern Lisp_Object Qfont_param;
 #endif
 
+#ifdef WINDOWSNT
+/* Defined on w32notify.c.  */
+extern void syms_of_w32notify (void);
+#endif
+
+/* Defined in inotify.c */
+#ifdef HAVE_INOTIFY
+extern void syms_of_inotify (void);
+#endif
+
 /* Defined in xfaces.c.  */
 extern Lisp_Object Qdefault, Qtool_bar, Qfringe;
 extern Lisp_Object Qheader_line, Qscroll_bar, Qcursor;
@@ -3601,12 +3732,11 @@ extern char *egetenv (const char *);
 /* Set up the name of the machine we're running on.  */
 extern void init_system_name (void);
 
-/* We used to use `abs', but that clashes with system headers on some
-   platforms, and using a name reserved by Standard C is a bad idea
-   anyway.  */
-#if !defined (eabs)
+/* Return the absolute value of X.  X should be a signed integer
+   expression without side effects, and X's absolute value should not
+   exceed the maximum for its promoted type.  This is called 'eabs'
+   because 'abs' is reserved by the C standard.  */
 #define eabs(x)         ((x) < 0 ? -(x) : (x))
-#endif
 
 /* Return a fixnum or float, depending on whether VAL fits in a Lisp
    fixnum.  */
@@ -3635,16 +3765,16 @@ extern void *record_xmalloc (size_t);
    NITEMS items, each of the same type as *BUF.  MULTIPLIER must
    positive.  The code is tuned for MULTIPLIER being a constant.  */
 
-#define SAFE_NALLOCA(buf, multiplier, nitems)                   \
-  do {                                                          \
-    if ((nitems) <= MAX_ALLOCA / sizeof *(buf) / (multiplier))  \
-      (buf) = alloca (sizeof *(buf) * (multiplier) * (nitems)); \
-    else                                                        \
+#define SAFE_NALLOCA(buf, multiplier, nitems)                    \
+  do {                                                           \
+    if ((nitems) <= MAX_ALLOCA / sizeof *(buf) / (multiplier))   \
+      (buf) = alloca (sizeof *(buf) * (multiplier) * (nitems));  \
+    else                                                         \
       {                                                          \
         (buf) = xnmalloc (nitems, sizeof *(buf) * (multiplier)); \
         sa_must_free = 1;                                        \
         record_unwind_protect (safe_alloca_unwind,               \
-                               make_save_value (buf, 0));        \
+                               make_save_pointer (buf));         \
       }                                                          \
   } while (0)
 
@@ -3669,8 +3799,8 @@ extern void *record_xmalloc (size_t);
       {                                                        \
         Lisp_Object arg_;                                      \
         buf = xmalloc ((nelt) * word_size);                    \
-        arg_ = make_save_value (buf, nelt);                    \
-        XSAVE_VALUE (arg_)->dogc = 1;                          \
+        arg_ = make_save_value ("pi", buf, nelt);              \
+        XSAVE_VALUE (arg_)->area = 1;                          \
         sa_must_free = 1;                                      \
         record_unwind_protect (safe_alloca_unwind, arg_);      \
       }                                                        \
diff --git a/src/lisp.mk b/src/lisp.mk
index 8c2710110e3..174e53ed561 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -1,7 +1,7 @@
 ### lisp.mk --- src/Makefile fragment for GNU Emacs
 
-## Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2012
-##   Free Software Foundation, Inc.
+## Copyright (C) 1985, 1987-1988, 1993-1995, 1999-2013 Free Software
+## Foundation, Inc.
 
 ## This file is part of GNU Emacs.
 
diff --git a/src/lread.c b/src/lread.c
index 6647382a254..e7af86aa664 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1,6 +1,7 @@
 /* Lisp parsing and input streams.
 
-Copyright (C) 1985-1989, 1993-1995, 1997-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -95,11 +96,6 @@ static Lisp_Object Qload_in_progress;
    It must be set to nil before all top-level calls to read0.  */
 static Lisp_Object read_objects;
 
-/* True means READCHAR should read bytes one by one (not character)
-   when READCHARFUN is Qget_file_char or Qget_emacs_mule_file_char.
-   This is set by read1 temporarily while handling #@NUMBER.  */
-static bool load_each_byte;
-
 /* List of descriptors now open for Fload.  */
 static Lisp_Object load_descriptor_list;
 
@@ -327,7 +323,7 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
       return c;
     }
   c = (*readbyte) (-1, readcharfun);
-  if (c < 0 || load_each_byte)
+  if (c < 0)
     return c;
   if (multibyte)
     *multibyte = 1;
@@ -352,6 +348,30 @@ readchar (Lisp_Object readcharfun, bool *multibyte)
   return STRING_CHAR (buf);
 }
 
+static void
+skip_dyn_bytes (Lisp_Object readcharfun, ptrdiff_t n)
+{
+  if (EQ (readcharfun, Qget_file_char)
+      || EQ (readcharfun, Qget_emacs_mule_file_char))
+    {
+      block_input ();           /* FIXME: Not sure if it's needed.  */
+      fseek (instream, n, SEEK_CUR);
+      unblock_input ();
+    }
+  else
+    { /* We're not reading directly from a file.  In that case, it's difficult
+         to reliably count bytes, since these are usually meant for the file's
+         encoding, whereas we're now typically in the internal encoding.
+         But luckily, skip_dyn_bytes is used to skip over a single
+         dynamic-docstring (or dynamic byte-code) which is always quoted such
+         that \037 is the final char.  */
+      int c;
+      do {
+        c = READCHAR;
+      } while (c >= 0 && c != '\037');
+    }
+}
+
 /* Unread the character C in the way appropriate for the stream READCHARFUN.
    If the stream is a user function, call it with the char as argument.  */
 
@@ -406,14 +426,7 @@ unreadchar (Lisp_Object readcharfun, int c)
   else if (EQ (readcharfun, Qget_file_char)
            || EQ (readcharfun, Qget_emacs_mule_file_char))
     {
-      if (load_each_byte)
-        {
-          block_input ();
-          ungetc (c, instream);
-          unblock_input ();
-        }
-      else
-        unread_char = c;
+      unread_char = c;
     }
   else
     call1 (readcharfun, make_number (c));
@@ -601,17 +614,17 @@ read_filtered_event (bool no_switch_frame, bool ascii_required,
       end_time = add_emacs_time (current_emacs_time (), wait_time);
     }
 
-/* Read until we get an acceptable event.  */
+  /* Read until we get an acceptable event.  */
  retry:
   do
-    val = read_char (0, 0, 0, (input_method ? Qnil : Qt), 0,
+    val = read_char (0, Qnil, (input_method ? Qnil : Qt), 0,
                      NUMBERP (seconds) ? &end_time : NULL);
   while (INTEGERP (val) && XINT (val) == -2); /* wrong_kboard_jmpbuf */
 
   if (BUFFERP (val))
     goto retry;
 
-  /* switch-frame events are put off until after the next ASCII
+  /* `switch-frame' events are put off until after the next ASCII
      character.  This is better than signaling an error just because
      the last characters were typed to a separate minibuffer frame,
      for example.  Eventually, some code which can deal with
@@ -1297,7 +1310,7 @@ Return t if the file exists and loads successfully.  */)
         message_with_string ("Loading %s...", file, 1);
     }
 
-  record_unwind_protect (load_unwind, make_save_value (stream, 0));
+  record_unwind_protect (load_unwind, make_save_pointer (stream));
   record_unwind_protect (load_descriptor_unwind, load_descriptor_list);
   specbind (Qload_file_name, found);
   specbind (Qinhibit_file_name_operation, Qnil);
@@ -1356,7 +1369,7 @@ Return t if the file exists and loads successfully.  */)
 static Lisp_Object
 load_unwind (Lisp_Object arg)  /* Used as unwind-protect function in load.  */
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg, 0);
   if (stream != NULL)
     {
       block_input ();
@@ -2387,7 +2400,6 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
   bool multibyte;
 
   *pch = 0;
-  load_each_byte = 0;
 
  retry:
 
@@ -2597,7 +2609,7 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           return tmp;
         }
 
-      /* #@NUMBER is used to skip NUMBER following characters.
+      /* #@NUMBER is used to skip NUMBER following bytes.
          That's used in .elc files to skip over doc strings
          and function definitions.  */
       if (c == '@')
@@ -2605,7 +2617,6 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
           enum { extra = 100 };
           ptrdiff_t i, nskip = 0;
 
-          load_each_byte = 1;
           /* Read a decimal integer.  */
           while ((c = READCHAR) >= 0
                  && c >= '0' && c <= '9')
@@ -2615,8 +2626,15 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               nskip *= 10;
               nskip += c - '0';
             }
-          UNREAD (c);
-
+          if (nskip > 0)
+            /* We can't use UNREAD here, because in the code below we side-step
+               READCHAR.  Instead, assume the first char after #@NNN occupies
+               a single byte, which is the case normally since it's just
+               a space.  */
+            nskip--;
+          else
+            UNREAD (c);
+            
           if (load_force_doc_strings
               && (EQ (readcharfun, Qget_file_char)
                   || EQ (readcharfun, Qget_emacs_mule_file_char)))
@@ -2658,19 +2676,17 @@ read1 (Lisp_Object readcharfun, int *pch, bool first_in_list)
               saved_doc_string_position = file_tell (instream);
 
               /* Copy that many characters into saved_doc_string.  */
+              block_input ();
               for (i = 0; i < nskip && c >= 0; i++)
-                saved_doc_string[i] = c = READCHAR;
+                saved_doc_string[i] = c = getc (instream);
+              unblock_input ();
 
               saved_doc_string_length = i;
             }
           else
-            {
-              /* Skip that many characters.  */
-              for (i = 0; i < nskip && c >= 0; i++)
-                c = READCHAR;
-            }
+            /* Skip that many bytes.  */
+            skip_dyn_bytes (readcharfun, nskip);
 
-          load_each_byte = 0;
           goto retry;
         }
       if (c == '!')
@@ -3569,9 +3585,8 @@ read_list (bool flag, Lisp_Object readcharfun)
                          doc string, caller must make it
                          multibyte.  */
 
-                      EMACS_INT pos = XINT (XCDR (val));
                       /* Position is negative for user variables.  */
-                      if (pos < 0) pos = -pos;
+                      EMACS_INT pos = eabs (XINT (XCDR (val)));
                       if (pos >= saved_doc_string_position
                           && pos < (saved_doc_string_position
                                     + saved_doc_string_length))
@@ -4525,12 +4540,16 @@ The default is nil, which means use the function `read'.  */);
   Vload_read_function = Qnil;
 
   DEFVAR_LISP ("load-source-file-function", Vload_source_file_function,
-               doc: /* Function called in `load' for loading an Emacs Lisp source file.
-This function is for doing code conversion before reading the source file.
-If nil, loading is done without any code conversion.
-Arguments are FULLNAME, FILE, NOERROR, NOMESSAGE, where
- FULLNAME is the full name of FILE.
-See `load' for the meaning of the remaining arguments.  */);
+               doc: /* Function called in `load' to load an Emacs Lisp source file.
+The value should be a function for doing code conversion before
+reading a source file.  It can also be nil, in which case loading is
+done without any code conversion.
+
+If the value is a function, it is called with four arguments,
+FULLNAME, FILE, NOERROR, NOMESSAGE.  FULLNAME is the absolute name of
+the file to load, FILE is the non-absolute name (for messages etc.),
+and NOERROR and NOMESSAGE are the corresponding arguments passed to
+`load'.  The function should return t if the file was loaded.  */);
   Vload_source_file_function = Qnil;
 
   DEFVAR_BOOL ("load-force-doc-strings", load_force_doc_strings,
diff --git a/src/macros.c b/src/macros.c
index 632c851ee8c..0dcfbe5532c 100644
--- a/src/macros.c
+++ b/src/macros.c
@@ -1,6 +1,6 @@
 /* Keyboard macros.
 
-Copyright (C) 1985-1986, 1993, 2000-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -78,7 +78,7 @@ macro before appending to it. */)
         }
       current_kboard->kbd_macro_ptr = current_kboard->kbd_macro_buffer;
       current_kboard->kbd_macro_end = current_kboard->kbd_macro_buffer;
-      message ("Defining kbd macro...");
+      message1 ("Defining kbd macro...");
     }
   else
     {
@@ -125,7 +125,7 @@ macro before appending to it. */)
         Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
                             make_number (1), Qnil);
 
-      message ("Appending to kbd macro...");
+      message1 ("Appending to kbd macro...");
     }
   kset_defining_kbd_macro (current_kboard, Qt);
 
@@ -172,21 +172,21 @@ each iteration of the macro.  Iteration stops if LOOPFUNC returns nil.  */)
   if (!NILP (KVAR (current_kboard, defining_kbd_macro)))
     {
       end_kbd_macro ();
-      message ("Keyboard macro defined");
+      message1 ("Keyboard macro defined");
     }
 
   if (XFASTINT (repeat) == 0)
     Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro), repeat, loopfunc);
   else if (XINT (repeat) > 1)
     {
-      XSETINT (repeat, XINT (repeat)-1);
+      XSETINT (repeat, XINT (repeat) - 1);
       Fexecute_kbd_macro (KVAR (current_kboard, Vlast_kbd_macro),
                           repeat, loopfunc);
     }
   return Qnil;
 }
 
-/* Store character c into kbd macro being defined */
+/* Store character c into kbd macro being defined.  */
 
 void
 store_kbd_macro_char (Lisp_Object c)
diff --git a/src/macros.h b/src/macros.h
index d66784a0246..57cd1c4f2fd 100644
--- a/src/macros.h
+++ b/src/macros.h
@@ -1,5 +1,5 @@
 /* Definitions for keyboard macro interpretation in GNU Emacs.
-   Copyright (C) 1985, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index a296f6eb393..6e1873f8e49 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -1,5 +1,5 @@
 # -*- Makefile -*- for GNU Emacs on the Microsoft Windows API.
-# Copyright (C) 2000-2012  Free Software Foundation, Inc.
+# Copyright (C) 2000-2013 Free Software Foundation, Inc.
 
 # This file is part of GNU Emacs.
 
@@ -134,6 +134,7 @@ OBJ2 =  $(BLD)/sysdep.$(O)		\
         $(BLD)/w32menu.$(O)             \
         $(BLD)/w32reg.$(O)              \
         $(BLD)/w32font.$(O)             \
+        $(BLD)/w32notify.$(O)           \
         $(BLD)/w32uniscribe.$(O)
 
 LIBS =  $(TLIB0)        \
@@ -209,7 +210,7 @@ GLOBAL_SOURCES =   dosfns.c msdos.c \
         fontset.c menu.c dbusbind.c \
         w32.c w32console.c w32fns.c w32heap.c w32inevt.c cygw32.c \
         w32menu.c w32proc.c w32reg.c w32select.c w32term.c w32xfns.c \
-        font.c w32font.c w32uniscribe.c \
+        font.c w32font.c w32uniscribe.c w32notify.c \
         dispnew.c frame.c scroll.c xdisp.c window.c bidi.c \
         charset.c coding.c category.c ccl.c character.c chartab.c \
         cm.c term.c terminal.c xfaces.c \
@@ -461,6 +462,8 @@ U64_H          = $(GNU_LIB)/u64.h \
                  $(NT_INC)/stdint.h
 SHA512_H       = $(GNU_LIB)/sha512.h \
                  $(U64_H)
+SIG2STR_H      = $(GNU_LIB)/sig2str.h \
+                 $(GNU_LIB)/intprops.h
 SOCKET_H       = $(NT_INC)/sys/socket.h \
                  $(SRC)/w32.h
 STAT_TIME_H    = $(GNU_LIB)/stat-time.h \
@@ -471,6 +474,7 @@ SYSTTY_H       = $(SRC)/systty.h \
                  $(NT_INC)/sys/ioctl.h \
                  $(NT_INC)/unistd.h
 SYSWAIT_H      = $(SRC)/syswait.h \
+                 $(NT_INC)/stdbool.h \
                  $(NT_INC)/sys/wait.h
 TERMHOOKS_H    = $(SRC)/termhooks.h \
                  $(SYSTIME_H)
@@ -786,6 +790,7 @@ $(BLD)/editfns.$(O) : \
         $(CODING_H) \
         $(CONFIG_H) \
         $(FRAME_H) \
+        $(GRP_H) \
         $(INTERVALS_H) \
         $(LISP_H) \
         $(SYSTIME_H) \
@@ -799,6 +804,7 @@ $(BLD)/emacs.$(O) : \
         $(SRC)/keymap.h \
         $(SRC)/unexec.h \
         $(SRC)/w32.h \
+        $(SRC)/w32common.h \
         $(SRC)/w32heap.h \
         $(SRC)/w32select.h \
         $(NT_INC)/sys/file.h \
@@ -837,10 +843,13 @@ $(BLD)/fileio.$(O) : \
         $(SRC)/commands.h \
         $(SRC)/w32.h \
         $(NT_INC)/pwd.h \
+        $(NT_INC)/sys/acl.h \
         $(NT_INC)/sys/file.h \
         $(NT_INC)/sys/stat.h \
         $(NT_INC)/unistd.h \
+        $(GNU_LIB)/allocator.h \
         $(BUFFER_H) \
+        $(CAREADLINKAT_H) \
         $(CHARACTER_H) \
         $(CODING_H) \
         $(CONFIG_H) \
@@ -1179,6 +1188,7 @@ $(BLD)/w32.$(O) : \
         $(SRC)/w32select.h \
         $(NT_INC)/dirent.h \
         $(NT_INC)/pwd.h \
+        $(NT_INC)/sys/acl.h \
         $(NT_INC)/sys/file.h \
         $(NT_INC)/sys/time.h \
         $(GNU_LIB)/allocator.h \
@@ -1287,11 +1297,13 @@ $(BLD)/process.$(O) : \
         $(CHARACTER_H) \
         $(CODING_H) \
         $(CONFIG_H) \
+        $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
         $(FRAME_H) \
         $(KEYBOARD_H) \
         $(LISP_H) \
         $(PROCESS_H) \
+        $(SIG2STR_H) \
         $(SOCKET_H) \
         $(SYSSIGNAL_H) \
         $(SYSTIME_H) \
@@ -1387,11 +1399,9 @@ $(BLD)/sysdep.$(O) : \
         $(NT_INC)/sys/file.h \
         $(NT_INC)/sys/stat.h \
         $(NT_INC)/unistd.h \
-        $(GNU_LIB)/allocator.h \
         $(GNU_LIB)/execinfo.h \
         $(GNU_LIB)/ignore-value.h \
         $(GNU_LIB)/utimens.h \
-        $(CAREADLINKAT_H) \
         $(CONFIG_H) \
         $(C_CTYPE_H) \
         $(DISPEXTERN_H) \
@@ -1693,6 +1703,18 @@ $(BLD)/w32uniscribe.$(O) : \
         $(W32FONT_H) \
         $(W32TERM_H)
 
+$(BLD)/w32notify.$(O) : \
+        $(SRC)/w32notify.c \
+        $(SRC)/w32.h \
+        $(SRC)/w32common.h \
+        $(CODING_H) \
+        $(CONFIG_H) \
+        $(FRAME_H) \
+        $(KEYBOARD_H) \
+        $(LISP_H) \
+        $(TERMHOOKS_H) \
+        $(W32TERM_H)
+
 # Each object file depends on stamp_BLD, because in parallel builds we must
 # make sure $(BLD) exists before starting compilations.
 #
diff --git a/src/marker.c b/src/marker.c
index 69be4faec3a..0d992c0abfa 100644
--- a/src/marker.c
+++ b/src/marker.c
@@ -1,5 +1,6 @@
 /* Markers: examining, setting and deleting.
-   Copyright (C) 1985, 1997-1998, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1997-1998, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -82,9 +83,7 @@ clear_charpos_cache (struct buffer *b)
    and everywhere there is a marker.  So we find the one of these places
    that is closest to the specified position, and scan from there.  */
 
-/* charpos_to_bytepos returns the byte position corresponding to CHARPOS.  */
-
-/* This macro is a subroutine of charpos_to_bytepos.
+/* This macro is a subroutine of buf_charpos_to_bytepos.
    Note that it is desirable that BYTEPOS is not evaluated
    except when we really want its value.  */
 
@@ -128,11 +127,7 @@ clear_charpos_cache (struct buffer *b)
     }                                                                   \
 }
 
-ptrdiff_t
-charpos_to_bytepos (ptrdiff_t charpos)
-{
-  return buf_charpos_to_bytepos (current_buffer, charpos);
-}
+/* Return the byte position corresponding to CHARPOS in B.  */
 
 ptrdiff_t
 buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
@@ -141,8 +136,7 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
   ptrdiff_t best_above, best_above_byte;
   ptrdiff_t best_below, best_below_byte;
 
-  if (charpos < BUF_BEG (b) || charpos > BUF_Z (b))
-    emacs_abort ();
+  eassert (BUF_BEG (b) <= charpos && charpos <= BUF_Z (b));
 
   best_above = BUF_Z (b);
   best_above_byte = BUF_Z_BYTE (b);
@@ -242,9 +236,6 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
 
 #undef CONSIDER
 
-/* buf_bytepos_to_charpos returns the char position corresponding to
-   BYTEPOS.  */
-
 /* This macro is a subroutine of buf_bytepos_to_charpos.
    It is used when BYTEPOS is actually the byte position.  */
 
@@ -288,6 +279,8 @@ buf_charpos_to_bytepos (struct buffer *b, ptrdiff_t charpos)
     }                                                                   \
 }
 
+/* Return the character position corresponding to BYTEPOS in B.  */
+
 ptrdiff_t
 buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
 {
@@ -295,8 +288,7 @@ buf_bytepos_to_charpos (struct buffer *b, ptrdiff_t bytepos)
   ptrdiff_t best_above, best_above_byte;
   ptrdiff_t best_below, best_below_byte;
 
-  if (bytepos < BUF_BEG_BYTE (b) || bytepos > BUF_Z_BYTE (b))
-    emacs_abort ();
+  eassert (BUF_BEG_BYTE (b) <= bytepos && bytepos <= BUF_Z_BYTE (b));
 
   best_above = BUF_Z (b);
   best_above_byte = BUF_Z_BYTE (b);
@@ -507,11 +499,29 @@ set_marker_internal (Lisp_Object marker, Lisp_Object position,
     {
       register ptrdiff_t charpos, bytepos;
 
-      CHECK_NUMBER_COERCE_MARKER (position);
-      charpos = clip_to_bounds (restricted ? BUF_BEGV (b) : BUF_BEG (b),
-                               XINT (position),
-                               restricted ? BUF_ZV (b) : BUF_Z (b));
-      bytepos = buf_charpos_to_bytepos (b, charpos);
+      /* Do not use CHECK_NUMBER_COERCE_MARKER because we
+         don't want to call buf_charpos_to_bytepos if POSTION
+         is a marker and so we know the bytepos already.  */
+      if (INTEGERP (position))
+        charpos = XINT (position), bytepos = -1;
+      else if (MARKERP (position))
+        {
+          charpos = XMARKER (position)->charpos;
+          bytepos = XMARKER (position)->bytepos;
+        }
+      else
+        wrong_type_argument (Qinteger_or_marker_p, position);
+
+      charpos = clip_to_bounds
+        (restricted ? BUF_BEGV (b) : BUF_BEG (b), charpos,
+         restricted ? BUF_ZV (b) : BUF_Z (b));
+      if (bytepos == -1)
+        bytepos = buf_charpos_to_bytepos (b, charpos);
+      else
+        bytepos = clip_to_bounds
+          (restricted ? BUF_BEGV_BYTE (b) : BUF_BEG_BYTE (b),
+           bytepos, restricted ? BUF_ZV_BYTE (b) : BUF_Z_BYTE (b));
+
       attach_marker (m, b, charpos, bytepos);
     }
   return marker;
diff --git a/src/mem-limits.h b/src/mem-limits.h
index 57a0ca6fefd..941ccf5f121 100644
--- a/src/mem-limits.h
+++ b/src/mem-limits.h
@@ -1,5 +1,6 @@
 /* Includes for memory limit warnings.
-   Copyright (C) 1990, 1993-1996, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993-1996, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/menu.c b/src/menu.c
index 7cc110ce7e2..fdef54dd657 100644
--- a/src/menu.c
+++ b/src/menu.c
@@ -1,7 +1,7 @@
 /* Platform-independent code for terminal communications.
 
-Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/menu.h b/src/menu.h
index 67934c42d76..f60873eadb3 100644
--- a/src/menu.h
+++ b/src/menu.h
@@ -1,5 +1,5 @@
 /* Functions to manipulate menus.
-   Copyright (C) 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2008-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/minibuf.c b/src/minibuf.c
index dcc4af37c13..25425cb97dc 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -1,6 +1,6 @@
 /* Minibuffer input and completion.
 
-Copyright (C) 1985-1986, 1993-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1398,12 +1398,7 @@ is used to further constrain the set of candidates.  */)
                                       eltstring, zero,
                                       make_number (compare),
                                       completion_ignore_case ? Qt : Qnil);
-              if (EQ (tem, Qt))
-                matchsize = compare;
-              else if (XINT (tem) < 0)
-                matchsize = - XINT (tem) - 1;
-              else
-                matchsize = XINT (tem) - 1;
+              matchsize = EQ (tem, Qt) ? compare : eabs (XINT (tem)) - 1;
 
               if (completion_ignore_case)
                 {
diff --git a/src/msdos.c b/src/msdos.c
index 433bf1074d8..ac8c90455d7 100644
--- a/src/msdos.c
+++ b/src/msdos.c
@@ -1,6 +1,6 @@
 /* MS-DOS specific C utilities.          -*- coding: raw-text -*-
 
-Copyright (C) 1993-1997, 1999-2012  Free Software Foundation, Inc.
+Copyright (C) 1993-1997, 1999-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -3281,10 +3281,10 @@ XMenuActivate (Display *foo, XMenu *menu, int *pane, int *selidx,
      erasing it works correctly...  */
   if (! NILP (saved_echo_area_message))
     message_with_string ("%s", saved_echo_area_message, 0);
-  message (0);
+  message1 (0);
   while (statecount--)
     xfree (state[statecount].screen_behind);
-  IT_display_cursor (1);        /* turn cursor back on */
+  IT_display_cursor (1);        /* Turn cursor back on.  */
   /* Clean up any mouse events that are waiting inside Emacs event queue.
      These events are likely to be generated before the menu was even
      displayed, probably because the user pressed and released the button
@@ -3339,7 +3339,7 @@ void msdos_downcase_filename (unsigned char *);
 /* Destructively turn backslashes into slashes.  */
 
 void
-dostounix_filename (char *p)
+dostounix_filename (char *p, int ignore)
 {
   msdos_downcase_filename (p);
 
@@ -3603,7 +3603,7 @@ init_environment (int argc, char **argv, int skip_args)
   if (!s) s = "c:/command.com";
   t = alloca (strlen (s) + 1);
   strcpy (t, s);
-  dostounix_filename (t);
+  dostounix_filename (t, 0);
   setenv ("SHELL", t, 0);
 
   /* PATH is also downcased and backslashes mirrored.  */
@@ -3613,7 +3613,7 @@ init_environment (int argc, char **argv, int skip_args)
   /* Current directory is always considered part of MsDos's path but it is
      not normally mentioned.  Now it is.  */
   strcat (strcpy (t, ".;"), s);
-  dostounix_filename (t); /* Not a single file name, but this should work.  */
+  dostounix_filename (t, 0); /* Not a single file name, but this should work.  */
   setenv ("PATH", t, 1);
 
   /* In some sense all dos users have root privileges, so...  */
@@ -3957,14 +3957,6 @@ careadlinkat (int fd, char const *filename,
   return buffer;
 }
 
-ssize_t
-careadlinkatcwd (int fd, char const *filename, char *buffer,
-                 size_t buffer_size)
-{
-  (void) fd;
-  return readlink (filename, buffer, buffer_size);
-}
-
 
 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
 
diff --git a/src/msdos.h b/src/msdos.h
index a73c1f2901f..ee0d49464ae 100644
--- a/src/msdos.h
+++ b/src/msdos.h
@@ -1,5 +1,5 @@
 /* MS-DOS specific C utilities, interface.
-   Copyright (C) 1993, 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -29,7 +29,7 @@ void dos_set_window_size (int *, int *);
 
 int getdefdir (int, char*);
 void unixtodos_filename (char *);
-void dostounix_filename (char *);
+void dostounix_filename (char *, int);
 char *rootrelativepath (char *);
 void init_environment (int, char **, int);
 void internal_terminal_init (void);
diff --git a/src/nsfns.m b/src/nsfns.m
index 428cfcb9a10..fac61d2ab53 100644
--- a/src/nsfns.m
+++ b/src/nsfns.m
@@ -1,7 +1,7 @@
 /* Functions for the NeXT/Open/GNUstep and MacOSX window system.
 
-Copyright (C) 1989, 1992-1994, 2005-2006, 2008-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1989, 1992-1994, 2005-2006, 2008-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1503,12 +1503,12 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
   [panel setDelegate: fileDelegate];
 
   panelOK = 0;
-  if (! NILP (dir_only_p)) 
+  if (! NILP (dir_only_p))
     {
       [panel setCanChooseDirectories: YES];
       [panel setCanChooseFiles: NO];
     }
-  
+
   block_input ();
 #if defined (NS_IMPL_COCOA) && \
   MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_6
@@ -1519,7 +1519,7 @@ Optional arg DIR_ONLY_P, if non-nil, means choose only directories.  */)
     [panel setNameFieldStringValue: [initS lastPathComponent]];
   else
     [panel setNameFieldStringValue: @""];
-    
+
   ret = [panel runModal];
 #else
   if (NILP (mustmatch) && NILP (dir_only_p))
@@ -2106,7 +2106,9 @@ ns_do_applescript (Lisp_Object script, Lisp_Object *result)
 void
 ns_run_ascript (void)
 {
-  as_status = ns_do_applescript (as_script, as_result);
+  if (! NILP (as_script))
+    as_status = ns_do_applescript (as_script, as_result);
+  as_script = Qnil;
 }
 
 DEFUN ("ns-do-applescript", Fns_do_applescript, Sns_do_applescript, 1, 1, 0,
@@ -2143,11 +2145,14 @@ In case the execution fails, an error is signaled. */)
                                data2: NSAPP_DATA2_RUNASSCRIPT];
 
   [NSApp postEvent: nxev atStart: NO];
-  [NSApp run];
+
+  // If there are other events, the event loop may exit.  Keep running
+  // until the script has been handled.  */
+  while (! NILP (as_script))
+    [NSApp run];
 
   status = as_status;
   as_status = 0;
-  as_script = Qnil;
   as_result = 0;
   unblock_input ();
   if (status == 0)
diff --git a/src/nsfont.m b/src/nsfont.m
index 2ba38b7570e..ebee363651f 100644
--- a/src/nsfont.m
+++ b/src/nsfont.m
@@ -1,6 +1,6 @@
 /* Font back-end driver for the NeXT/Open/GNUstep and MacOSX window system.
    See font.h
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -44,6 +44,7 @@ Author: Adrian Robert (arobert@cogsci.ucsd.edu)
 #endif
 
 #define NSFONT_TRACE 0
+#define LCD_SMOOTHING_MARGIN 2
 
 extern Lisp_Object Qns;
 extern Lisp_Object Qnormal, Qbold, Qitalic;
@@ -74,10 +75,9 @@ static void ns_glyph_metrics (struct nsfont_info *font_info,
 static void
 ns_escape_name (char *name)
 {
-  int i =0, len =strlen (name);
-  for ( ; i<len; i++)
-    if (name[i] == ' ')
-      name[i] = '_';
+  for (; *name; name++)
+    if (*name == ' ')
+      *name = '_';
 }
 
 
@@ -85,10 +85,9 @@ ns_escape_name (char *name)
 static void
 ns_unescape_name (char *name)
 {
-  int i =0, len =strlen (name);
-  for ( ; i<len; i++)
-    if (name[i] == '_')
-      name[i] = ' ';
+  for (; *name; name++)
+    if (*name == '_')
+      *name = ' ';
 }
 
 
@@ -363,7 +362,7 @@ static NSString
     while CONSP (rts)
       {
         r = XCAR (XCAR (rts));
-        if (!strncmp(SSDATA(r), reg, strlen(SSDATA(r))))
+        if (!strncmp (SSDATA (r), reg, SBYTES (r)))
           {
             script = XCDR (XCAR (rts));
             return [NSString stringWithUTF8String: SSDATA (SYMBOL_NAME (script))];
@@ -546,6 +545,7 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
     NSSet *cFamilies;
     BOOL foundItal = NO;
 
+    block_input ();
     if (NSFONT_TRACE)
       {
         fprintf (stderr, "nsfont: %s for fontspec:\n    ",
@@ -560,10 +560,7 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
     if (isMatch)
         [fkeys removeObject: NSFontFamilyAttribute];
 
-    if ([fkeys count] > 0)
-      matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
-    else
-      matchingDescs = [NSMutableArray array];
+    matchingDescs = [fdesc matchingFontDescriptorsWithMandatoryKeys: fkeys];
 
     if (NSFONT_TRACE)
         NSLog(@"Got desc %@ and found %d matching fonts from it: ", fdesc,
@@ -598,6 +595,8 @@ ns_findfonts (Lisp_Object font_spec, BOOL isMatch)
         [s1 release];
       }
 
+    unblock_input ();
+
     /* Return something if was a match and nothing found. */
     if (isMatch)
       return ns_fallback_entity ();
@@ -701,10 +700,12 @@ static Lisp_Object
 nsfont_list_family (Lisp_Object frame)
 {
   Lisp_Object list = Qnil;
-  NSEnumerator *families =
-    [[[NSFontManager sharedFontManager] availableFontFamilies]
-      objectEnumerator];
+  NSEnumerator *families;
   NSString *family;
+
+  block_input ();
+  families = [[[NSFontManager sharedFontManager] availableFontFamilies]
+               objectEnumerator];
   while ((family = [families nextObject]))
       list = Fcons (intern ([family UTF8String]), list);
   /* FIXME: escape the name? */
@@ -713,6 +714,7 @@ nsfont_list_family (Lisp_Object frame)
     fprintf (stderr, "nsfont: list families returning %"pI"d entries\n",
              XINT (Flength (list)));
 
+  unblock_input ();
   return list;
 }
 
@@ -735,6 +737,8 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
   Lisp_Object font_object;
   int fixLeopardBug;
 
+  block_input ();
+
   if (NSFONT_TRACE)
     {
       fprintf (stderr, "nsfont: open size %d of fontentity:\n    ", pixel_size);
@@ -794,13 +798,14 @@ nsfont_open (FRAME_PTR f, Lisp_Object font_entity, int pixel_size)
   font_info = (struct nsfont_info *) XFONT_OBJECT (font_object);
   font = (struct font *) font_info;
   if (!font)
-    return Qnil; /* FIXME: other terms do, but return Qnil causes segfault */
+    {
+      unblock_input ();
+      return Qnil; /* FIXME: other terms do, but return Qnil causes segfault */
+    }
 
   font_info->glyphs = xzalloc (0x100 * sizeof *font_info->glyphs);
   font_info->metrics = xzalloc (0x100 * sizeof *font_info->metrics);
 
-  block_input ();
-
   /* for metrics */
 #ifdef NS_IMPL_COCOA
   sfont = [nsfont screenFontWithRenderingMode:
@@ -1051,6 +1056,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   char isComposite = s->first_glyph->type == COMPOSITE_GLYPH;
   int end = isComposite ? s->cmp_to : s->nchars;
 
+  block_input ();
   /* Select face based on input flags */
   switch (ns_tmp_flags)
     {
@@ -1240,7 +1246,6 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
     else
       CGContextSetShouldAntialias (gcontext, 1);
 
-    CGContextSetShouldSmoothFonts (gcontext, NO);
     CGContextSetTextMatrix (gcontext, fliptf);
 
     if (bgCol != nil)
@@ -1273,6 +1278,7 @@ nsfont_draw (struct glyph_string *s, int from, int to, int x, int y,
   /* Draw underline, overline, strike-through. */
   ns_draw_text_decoration (s, face, col, r.size.width, r.origin.x);
 
+  unblock_input ();
   return to-from;
 }
 
@@ -1406,11 +1412,12 @@ ns_glyph_metrics (struct nsfont_info *font_info, unsigned char block)
 
       lb = r.origin.x;
       rb = r.size.width - w;
+      // Add to bearing for LCD smoothing.  We don't know if it is there.
       if (lb < 0)
-        metrics->lbearing = round (lb);
+        metrics->lbearing = round (lb - LCD_SMOOTHING_MARGIN);
       if (font_info->ital)
         rb += 0.22 * font_info->height;
-      metrics->rbearing = lrint (w + rb);
+      metrics->rbearing = lrint (w + rb + LCD_SMOOTHING_MARGIN);
 
       metrics->descent = r.origin.y < 0 ? -r.origin.y : 0;
  /*lrint (hshrink * [sfont ascender] + expand * hd/2); */
diff --git a/src/nsgui.h b/src/nsgui.h
index 60c38b221fb..53d0c8b7c8d 100644
--- a/src/nsgui.h
+++ b/src/nsgui.h
@@ -1,5 +1,5 @@
 /* Definitions and headers for communication on the NeXT/Open/GNUstep API.
-   Copyright (C) 1995, 2005, 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 1995, 2005, 2008-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/nsimage.m b/src/nsimage.m
index 884c0763fd4..9d21ba8afca 100644
--- a/src/nsimage.m
+++ b/src/nsimage.m
@@ -1,6 +1,6 @@
 /* Image support for the NeXT/Open/GNUstep and MacOSX window system.
-   Copyright (C) 1989, 1992-1994, 2005-2006, 2008-2012
-     Free Software Foundation, Inc.
+   Copyright (C) 1989, 1992-1994, 2005-2006, 2008-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/nsmenu.m b/src/nsmenu.m
index d0ea8f5a47a..22ff4dd0b53 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -1,5 +1,5 @@
 /* NeXT/Open/GNUstep and MacOSX Cocoa menu and toolbar module.
-   Copyright (C) 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2007-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1110,6 +1110,8 @@ update_frame_tool_bar (FRAME_PTR f)
   FRAME_TOOLBAR_HEIGHT (f) =
     NSHeight ([window frameRectForContentRect: NSMakeRect (0, 0, 0, 0)])
     - FRAME_NS_TITLEBAR_HEIGHT (f);
+    if (FRAME_TOOLBAR_HEIGHT (f) < 0) // happens if frame is fullscreen.
+      FRAME_TOOLBAR_HEIGHT (f) = 0;
     unblock_input ();
 }
 
@@ -1347,8 +1349,7 @@ struct Popdown_data
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct Popdown_data *unwind_data = (struct Popdown_data *) p->pointer;
+  struct Popdown_data *unwind_data = XSAVE_POINTER (arg, 0);
 
   block_input ();
   if (popup_activated_flag)
@@ -1441,7 +1442,7 @@ ns_popup_dialog (Lisp_Object position, Lisp_Object contents, Lisp_Object header)
     unwind_data->pool = pool;
     unwind_data->dialog = dialog;
 
-    record_unwind_protect (pop_down_menu, make_save_value (unwind_data, 0));
+    record_unwind_protect (pop_down_menu, make_save_pointer (unwind_data));
     popup_activated_flag = 1;
     tem = [dialog runDialogAt: p];
     unbind_to (specpdl_count, Qnil);  /* calls pop_down_menu */
diff --git a/src/nsselect.m b/src/nsselect.m
index c0c412c6fb2..49380f87945 100644
--- a/src/nsselect.m
+++ b/src/nsselect.m
@@ -1,6 +1,6 @@
 /* NeXT/Open/GNUstep / MacOSX Cocoa selection processing for emacs.
-   Copyright (C) 1993-1994, 2005-2006, 2008-2012
-     Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 2005-2006, 2008-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -117,7 +117,7 @@ clean_local_selection_data (Lisp_Object obj)
 
       if (size == 1)
         return clean_local_selection_data (AREF (obj, 0));
-      copy = Fmake_vector (make_number (size), Qnil);
+      copy = make_uninit_vector (size);
       for (i = 0; i < size; i++)
         ASET (copy, i, clean_local_selection_data (AREF (obj, i)));
       return copy;
diff --git a/src/nsterm.h b/src/nsterm.h
index 005701ed415..41dbaf3c0f7 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -1,5 +1,6 @@
 /* Definitions and headers for communication with NeXT/Open/GNUstep API.
-   Copyright (C) 1989, 1993, 2005, 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1993, 2005, 2008-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -41,6 +42,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #ifndef MAC_OS_X_VERSION_10_8
 #define MAC_OS_X_VERSION_10_8 1080
 #endif
+
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
+#define HAVE_NATIVE_FS
+#endif
+
 #endif /* NS_IMPL_COCOA */
 
 #ifdef __OBJC__
@@ -87,6 +93,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    int tibar_height, tobar_height, bwidth;
    int maximized_width, maximized_height;
    NSWindow *nonfs_window;
+   BOOL fs_is_native;
 @public
    struct frame *emacsframe;
    int rows, cols;
@@ -114,6 +121,11 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 - (void) handleFS;
 - (void) setFSValue: (int)value;
 - (void) toggleFullScreen: (id) sender;
+- (BOOL) fsIsNative;
+- (BOOL) isFullscreen;
+#ifdef HAVE_NATIVE_FS
+- (void) updateCollectionBehaviour;
+#endif
 
 #ifdef NS_IMPL_GNUSTEP
 /* Not declared, but useful. */
@@ -674,9 +686,9 @@ struct x_output
 #define FRAME_FONT(f) ((f)->output_data.ns->font)
 
 #ifdef __OBJC__
-#define XNS_SCROLL_BAR(vec) ((id) XSAVE_VALUE (vec)->pointer)
+#define XNS_SCROLL_BAR(vec) ((id) XSAVE_POINTER (vec, 0))
 #else
-#define XNS_SCROLL_BAR(vec) XSAVE_VALUE (vec)->pointer
+#define XNS_SCROLL_BAR(vec) XSAVE_POINTER (vec, 0)
 #endif
 
 /* Compute pixel size for vertical scroll bars */
diff --git a/src/nsterm.m b/src/nsterm.m
index 55a106b7e03..1f09e031592 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -1,7 +1,7 @@
 /* NeXT/Open/GNUstep / MacOSX communication module.
 
-Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1989, 1993-1994, 2005-2006, 2008-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -69,11 +69,6 @@ int term_trace_num = 0;
 #define NSTRACE(x)
 #endif
 
-#if defined (NS_IMPL_COCOA) && \
-  MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_7
-#define NEW_STYLE_FS
-#endif
-
 extern NSString *NSMenuDidBeginTrackingNotification;
 
 /* ==========================================================================
@@ -224,6 +219,7 @@ static int n_emacs_events_pending = 0;
 static NSMutableArray *ns_pending_files, *ns_pending_service_names,
   *ns_pending_service_args;
 static BOOL ns_do_open_file = NO;
+static BOOL ns_last_use_native_fullscreen;
 
 static struct {
   struct input_event *q;
@@ -1000,11 +996,8 @@ ns_raise_frame (struct frame *f)
   NSView *view = FRAME_NS_VIEW (f);
   check_ns ();
   block_input ();
-  FRAME_SAMPLE_VISIBILITY (f);
   if (FRAME_VISIBLE_P (f))
-    {
-      [[view window] makeKeyAndOrderFront: NSApp];
-    }
+    [[view window] makeKeyAndOrderFront: NSApp];
   unblock_input ();
 }
 
@@ -1093,16 +1086,16 @@ x_make_frame_visible (struct frame *f)
   if (!FRAME_VISIBLE_P (f))
     {
       EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
-      f->async_visible = 1;
+
+      SET_FRAME_VISIBLE (f, 1);
       ns_raise_frame (f);
 
-#ifdef NEW_STYLE_FS
       /* Making a new frame from a fullscreen frame will make the new frame
          fullscreen also.  So skip handleFS as this will print an error.  */
-      if (f->want_fullscreen == FULLSCREEN_BOTH
-          && ([[view window] styleMask] & NSFullScreenWindowMask) != 0)
+      if ([view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH
+          && [view isFullscreen])
         return;
-#endif
+
       if (f->want_fullscreen != FULLSCREEN_NONE)
         {
           block_input ();
@@ -1123,8 +1116,8 @@ x_make_frame_invisible (struct frame *f)
   NSTRACE (x_make_frame_invisible);
   check_ns ();
   [[view window] orderOut: NSApp];
-  f->async_visible = 0;
-  f->async_iconified = 0;
+  SET_FRAME_VISIBLE (f, 0);
+  SET_FRAME_ICONIFIED (f, 0);
 }
 
 
@@ -1294,7 +1287,7 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
   pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, rows);
 
   /* If we have a toolbar, take its height into account. */
-  if (tb)
+  if (tb && ! [view isFullscreen])
     /* NOTE: previously this would generate wrong result if toolbar not
              yet displayed and fixing toolbar_height=32 helped, but
              now (200903) seems no longer needed */
@@ -1305,8 +1298,10 @@ x_set_window_size (struct frame *f, int change_grav, int cols, int rows)
     FRAME_TOOLBAR_HEIGHT (f) = 0;
 
   wr.size.width = pixelwidth + f->border_width;
-  wr.size.height = pixelheight + FRAME_NS_TITLEBAR_HEIGHT (f)
-                  + FRAME_TOOLBAR_HEIGHT (f);
+  wr.size.height = pixelheight;
+  if (! [view isFullscreen])
+    wr.size.height += FRAME_NS_TITLEBAR_HEIGHT (f)
+      + FRAME_TOOLBAR_HEIGHT (f);
 
   /* Do not try to constrain to this screen.  We may have multiple
      screens, and want Emacs to span those.  Constraining to screen
@@ -1354,9 +1349,10 @@ ns_fullscreen_hook (FRAME_PTR f)
 {
   EmacsView *view = (EmacsView *)FRAME_NS_VIEW (f);
 
-  if (! f->async_visible) return;
-#ifndef NEW_STYLE_FS
-  if (f->want_fullscreen == FULLSCREEN_BOTH)
+  if (!FRAME_VISIBLE_P (f))
+    return;
+
+   if (! [view fsIsNative] && f->want_fullscreen == FULLSCREEN_BOTH)
     {
       /* Old style fs don't initiate correctly if created from
          init/default-frame alist, so use a timer (not nice...).
@@ -1366,7 +1362,6 @@ ns_fullscreen_hook (FRAME_PTR f)
                                      userInfo: nil repeats: NO];
       return;
     }
-#endif
 
   block_input ();
   [view handleFS];
@@ -2566,7 +2561,7 @@ ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
    Draw a wavy line under glyph string s. The wave fills wave_height
    pixels from y.
 
-                    x          wave_length = 3
+                    x          wave_length = 2
                                  --
                 y    *   *   *   *   *
                      |* * * * * * * * *
@@ -2576,14 +2571,14 @@ ns_get_glyph_string_clip_rect (struct glyph_string *s, NativeRectangle *nr)
 static void
 ns_draw_underwave (struct glyph_string *s, CGFloat width, CGFloat x)
 {
-  int wave_height = 3, wave_length = 3;
+  int wave_height = 3, wave_length = 2;
   int y, dx, dy, odd, xmax;
   NSPoint a, b;
   NSRect waveClip;
 
   dx = wave_length;
   dy = wave_height - 1;
-  y =  s->ybase + 1;
+  y =  s->ybase - wave_height + 3;
   xmax = x + width;
 
   /* Find and set clipping rectangle */
@@ -2592,10 +2587,10 @@ ns_draw_underwave (struct glyph_string *s, CGFloat width, CGFloat x)
   NSRectClip (waveClip);
 
   /* Draw the waves */
-  a.x = x - ((int)(x) % dx);
+  a.x = x - ((int)(x) % dx) + 0.5;
   b.x = a.x + dx;
   odd = (int)(a.x/dx) % 2;
-  a.y = b.y = y;
+  a.y = b.y = y + 0.5;
 
   if (odd)
     a.y += dy;
@@ -2606,7 +2601,7 @@ ns_draw_underwave (struct glyph_string *s, CGFloat width, CGFloat x)
     {
       [NSBezierPath strokeLineFromPoint:a toPoint:b];
       a.x = b.x, a.y = b.y;
-      b.x += dx, b.y = y + odd*dy;
+      b.x += dx, b.y = y + 0.5 + odd*dy;
       odd = !odd;
     }
 
@@ -2646,6 +2641,7 @@ ns_draw_text_decoration (struct glyph_string *s, struct face *face,
 
           /* If the prev was underlined, match its appearance. */
           if (s->prev && s->prev->face->underline_p
+              && s->prev->face->underline_type == FACE_UNDER_LINE
               && s->prev->underline_thickness > 0)
             {
               thickness = s->prev->underline_thickness;
@@ -3368,6 +3364,30 @@ ns_send_appdefined (int value)
     }
 }
 
+#ifdef HAVE_NATIVE_FS
+static void
+check_native_fs ()
+{
+  Lisp_Object frame, tail;
+
+  if (ns_last_use_native_fullscreen == ns_use_native_fullscreen)
+    return;
+
+  ns_last_use_native_fullscreen = ns_use_native_fullscreen;
+
+  /* Clear the mouse-moved flag for every frame on this display.  */
+  FOR_EACH_FRAME (tail, frame)
+    {
+      struct frame *f = XFRAME (frame);
+      if (FRAME_NS_P (f))
+        {
+          EmacsView *view = FRAME_NS_VIEW (f);
+          [view updateCollectionBehaviour];
+        }
+    }
+}
+#endif
+
 static int
 ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 /* --------------------------------------------------------------------------
@@ -3381,6 +3401,10 @@ ns_read_socket (struct terminal *terminal, struct input_event *hold_quit)
 
 /* NSTRACE (ns_read_socket); */
 
+#ifdef HAVE_NATIVE_FS
+  check_native_fs ();
+#endif
+
   if ([NSApp modalWindow] != nil)
     return -1;
 
@@ -3458,6 +3482,10 @@ ns_select (int nfds, fd_set *readfds, fd_set *writefds,
 
 /*  NSTRACE (ns_select); */
 
+#ifdef HAVE_NATIVE_FS
+  check_native_fs ();
+#endif
+
   if (hold_event_q.nr > 0)
     {
       /* We already have events pending. */
@@ -3676,7 +3704,7 @@ ns_set_vertical_scroll_bar (struct window *window,
         }
 
       bar = [[EmacsScroller alloc] initFrame: r window: win];
-      wset_vertical_scroll_bar (window, make_save_value (bar, 0));
+      wset_vertical_scroll_bar (window, make_save_pointer (bar));
     }
   else
     {
@@ -4237,11 +4265,9 @@ ns_term_init (Lisp_Object display_name)
                             NSColorPboardType,
                             NSFontPboardType, nil] retain];
 
-#ifndef NEW_STYLE_FS
   /* If fullscreen is in init/default-frame-alist, focus isn't set
      right for fullscreen windows, so set this.  */
   [NSApp activateIgnoringOtherApps:YES];
-#endif
 
   [NSApp run];
   ns_do_open_file = YES;
@@ -4575,7 +4601,7 @@ not_in_argv (NSString *arg)
       if (waiting)
         {
           SELECT_TYPE fds;
-
+          FD_ZERO (&fds);
           FD_SET (selfds[0], &fds);
           result = select (selfds[0]+1, &fds, NULL, NULL, NULL);
           if (result > 0 && read (selfds[0], &c, 1) == 1 && c == 'g')
@@ -4980,6 +5006,7 @@ not_in_argv (NSString *arg)
 
           emacs_event->code = code;
           EV_TRAILER (theEvent);
+          processingCompose = NO;
           return;
         }
     }
@@ -5170,6 +5197,7 @@ not_in_argv (NSString *arg)
   if (NS_KEYLOG)
     NSLog (@"doCommandBySelector: %@", NSStringFromSelector (aSelector));
 
+  processingCompose = NO;
   if (aSelector == @selector (deleteBackward:))
     {
       /* happens when user backspaces over an ongoing composition:
@@ -5388,10 +5416,10 @@ not_in_argv (NSString *arg)
 {
   NSWindow *window = [self window];
   NSRect wr = [window frame];
-#ifdef NS_IMPL_GNUSTEP
-  int extra = 3;
-#else
   int extra = 0;
+  int gsextra = 0;
+#ifdef NS_IMPL_GNUSTEP
+  gsextra = 3;
 #endif
 
   int oldc = cols, oldr = rows;
@@ -5399,23 +5427,24 @@ not_in_argv (NSString *arg)
     oldh = FRAME_PIXEL_HEIGHT (emacsframe);
   int neww, newh;
 
-  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, wr.size.width + extra);
+  cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe, wr.size.width + gsextra);
 
   if (cols < MINWIDTH)
     cols = MINWIDTH;
 
-  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES
-    (emacsframe, wr.size.height
-     - FRAME_NS_TITLEBAR_HEIGHT (emacsframe) + extra
-     - FRAME_TOOLBAR_HEIGHT (emacsframe));
+  if (! [self isFullscreen])
+    {
+      extra = FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
+        + FRAME_TOOLBAR_HEIGHT (emacsframe) - gsextra;
+    }
+
+  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, wr.size.height - extra);
 
   if (rows < MINHEIGHT)
     rows = MINHEIGHT;
 
   neww = (int)wr.size.width - emacsframe->border_width;
-  newh = ((int)wr.size.height
-          - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
-          - FRAME_TOOLBAR_HEIGHT (emacsframe));
+  newh = (int)wr.size.height - extra;
 
   if (oldr != rows || oldc != cols || neww != oldw || newh != oldh)
     {
@@ -5433,6 +5462,12 @@ not_in_argv (NSString *arg)
 - (NSSize)windowWillResize: (NSWindow *)sender toSize: (NSSize)frameSize
 /* normalize frame to gridded text size */
 {
+  int extra = 0;
+  int gsextra = 0;
+#ifdef NS_IMPL_GNUSTEP
+  gsextra = 3;
+#endif
+  
   NSTRACE (windowWillResize);
 /*fprintf (stderr,"Window will resize: %.0f x %.0f\n",frameSize.width,frameSize.height); */
 
@@ -5450,22 +5485,12 @@ not_in_argv (NSString *arg)
     maximized_width = maximized_height = -1;
 
   cols = FRAME_PIXEL_WIDTH_TO_TEXT_COLS (emacsframe,
-#ifdef NS_IMPL_GNUSTEP
-                                        frameSize.width + 3);
-#else
-                                        frameSize.width);
-#endif
+                                         frameSize.width + gsextra);
   if (cols < MINWIDTH)
     cols = MINWIDTH;
 
-  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe, frameSize.height
-#ifdef NS_IMPL_GNUSTEP
-      - FRAME_NS_TITLEBAR_HEIGHT (emacsframe) + 3
-        - FRAME_TOOLBAR_HEIGHT (emacsframe));
-#else
-      - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
-        - FRAME_TOOLBAR_HEIGHT (emacsframe));
-#endif
+  rows = FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (emacsframe,
+                                           frameSize.height - extra);
   if (rows < MINHEIGHT)
     rows = MINHEIGHT;
 #ifdef NS_IMPL_COCOA
@@ -5508,12 +5533,13 @@ not_in_argv (NSString *arg)
 
 - (void)windowDidResize: (NSNotification *)notification
 {
-
-#if !defined (NEW_STYLE_FS) && ! defined (NS_IMPL_GNUSTEP)
-  NSWindow *theWindow = [notification object];
-  /* We can get notification on the non-FS window when in fullscreen mode.  */
-  if ([self window] != theWindow) return;
-#endif
+  if (! [self fsIsNative]) 
+    {
+      NSWindow *theWindow = [notification object];
+      /* We can get notification on the non-FS window when in
+         fullscreen mode.  */
+      if ([self window] != theWindow) return;
+    }
 
 #ifdef NS_IMPL_GNUSTEP
   NSWindow *theWindow = [notification object];
@@ -5629,6 +5655,11 @@ not_in_argv (NSString *arg)
   scrollbarsNeedingUpdate = 0;
   fs_state = FULLSCREEN_NONE;
   fs_before_fs = next_maximized = -1;
+#ifdef HAVE_NATIVE_FS
+  fs_is_native = ns_use_native_fullscreen;
+#else
+  fs_is_native = NO;
+#endif
   maximized_width = maximized_height = -1;
   nonfs_window = nil;
 
@@ -5655,7 +5686,7 @@ not_in_argv (NSString *arg)
                         backing: NSBackingStoreBuffered
                           defer: YES];
 
-#ifdef NEW_STYLE_FS
+#ifdef HAVE_NATIVE_FS
     [win setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
 #endif
 
@@ -5821,13 +5852,14 @@ not_in_argv (NSString *arg)
   NSTRACE (windowDidDeminiaturize);
   if (!emacsframe->output_data.ns)
     return;
-  emacsframe->async_iconified = 0;
-  emacsframe->async_visible   = 1;
+
+  SET_FRAME_ICONIFIED (emacsframe, 0);
+  SET_FRAME_VISIBLE (emacsframe, 1);
   windows_or_buffers_changed++;
 
   if (emacs_event)
     {
-      emacs_event->kind = ICONIFY_EVENT;
+      emacs_event->kind = DEICONIFY_EVENT;
       EV_TRAILER ((id)nil);
     }
 }
@@ -5838,7 +5870,8 @@ not_in_argv (NSString *arg)
   NSTRACE (windowDidExpose);
   if (!emacsframe->output_data.ns)
     return;
-  emacsframe->async_visible = 1;
+
+  SET_FRAME_VISIBLE (emacsframe, 1);
   SET_FRAME_GARBAGED (emacsframe);
 
   if (send_appdefined)
@@ -5852,8 +5885,8 @@ not_in_argv (NSString *arg)
   if (!emacsframe->output_data.ns)
     return;
 
-  emacsframe->async_iconified = 1;
-  emacsframe->async_visible = 0;
+  SET_FRAME_ICONIFIED (emacsframe, 1);
+  SET_FRAME_VISIBLE (emacsframe, 0);
 
   if (emacs_event)
     {
@@ -5862,6 +5895,15 @@ not_in_argv (NSString *arg)
     }
 }
 
+#ifdef HAVE_NATIVE_FS
+- (NSApplicationPresentationOptions)window:(NSWindow *)window
+      willUseFullScreenPresentationOptions:
+  (NSApplicationPresentationOptions)proposedOptions
+{
+  return proposedOptions|NSApplicationPresentationAutoHideToolbar;
+}
+#endif
+
 - (void)windowWillEnterFullScreen:(NSNotification *)notification
 {
   fs_before_fs = fs_state;
@@ -5870,17 +5912,13 @@ not_in_argv (NSString *arg)
 - (void)windowDidEnterFullScreen:(NSNotification *)notification
 {
   [self setFSValue: FULLSCREEN_BOTH];
-#ifdef NEW_STYLE_FS
-  // Fix bad background.
-  if ([toolbar isVisible])
+  if (! [self fsIsNative])
     {
-      [toolbar setVisible:NO];
-      [toolbar setVisible:YES];
+      [self windowDidBecomeKey:notification];
+      [nonfs_window orderOut:self];
     }
-#else
-  [self windowDidBecomeKey:notification];
-  [nonfs_window orderOut:self];
-#endif
+  else if (! FRAME_EXTERNAL_TOOL_BAR (emacsframe))
+    [toolbar setVisible:NO];
 }
 
 - (void)windowWillExitFullScreen:(NSNotification *)notification
@@ -5893,24 +5931,76 @@ not_in_argv (NSString *arg)
 {
   [self setFSValue: fs_before_fs];
   fs_before_fs = -1;
+  [self updateCollectionBehaviour];
+  if (FRAME_EXTERNAL_TOOL_BAR (emacsframe))
+    {
+      [toolbar setVisible:YES];
+      update_frame_tool_bar (emacsframe);
+      [self updateFrameSize:YES];
+      [[self window] display];
+    }
+  else
+    [toolbar setVisible:NO];
+
   if (next_maximized != -1)
     [[self window] performZoom:self];
 }
 
-- (void)toggleFullScreen: (id)sender
+- (BOOL)fsIsNative
+{
+  return fs_is_native;
+}
+
+- (BOOL)isFullscreen
 {
-#ifdef NEW_STYLE_FS
-  [[self window] toggleFullScreen:sender];
+  if (! fs_is_native) return nonfs_window != nil;
+#ifdef HAVE_NATIVE_FS
+  return ([[self window] styleMask] & NSFullScreenWindowMask) != 0;
 #else
-  NSWindow *w = [self window], *fw;
-  BOOL onFirstScreen = [[w screen]
-                         isEqual:[[NSScreen screens] objectAtIndex:0]];
-  struct frame *f = emacsframe;
+  return NO;
+#endif
+}
+
+#ifdef HAVE_NATIVE_FS
+- (void)updateCollectionBehaviour
+{
+  if (! [self isFullscreen])
+    {
+      NSWindow *win = [self window];
+      NSWindowCollectionBehavior b = [win collectionBehavior];
+      if (ns_use_native_fullscreen)
+        b |= NSWindowCollectionBehaviorFullScreenPrimary;
+      else
+        b &= ~NSWindowCollectionBehaviorFullScreenPrimary;
+
+      [win setCollectionBehavior: b];
+      fs_is_native = ns_use_native_fullscreen;
+    }
+}
+#endif
+ 
+- (void)toggleFullScreen: (id)sender
+{
+  NSWindow *w, *fw;
+  BOOL onFirstScreen;
+  struct frame *f;
   NSSize sz;
-  NSRect r, wr = [w frame];
-  NSColor *col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
-                                          (FRAME_DEFAULT_FACE (f)),
-                                          f);
+  NSRect r, wr;
+  NSColor *col;
+
+  if (fs_is_native)
+    {
+      [[self window] toggleFullScreen:sender];
+      return;
+    }
+
+  w = [self window];
+  onFirstScreen = [[w screen] isEqual:[[NSScreen screens] objectAtIndex:0]];
+  f = emacsframe;
+  wr = [w frame];
+  col = ns_lookup_indexed_color (NS_FACE_BACKGROUND
+                                 (FRAME_DEFAULT_FACE (f)),
+                                 f);
 
   sz.width = FRAME_COLUMN_WIDTH (f);
   sz.height = FRAME_LINE_HEIGHT (f);
@@ -5953,7 +6043,6 @@ not_in_argv (NSString *arg)
       FRAME_NS_TITLEBAR_HEIGHT (f) = 0;
       tobar_height = FRAME_TOOLBAR_HEIGHT (f);
       FRAME_TOOLBAR_HEIGHT (f) = 0;
-      FRAME_EXTERNAL_TOOL_BAR (f) = 0;
 
       nonfs_window = w;
 
@@ -5990,17 +6079,16 @@ not_in_argv (NSString *arg)
 
       f->border_width = bwidth;
       FRAME_NS_TITLEBAR_HEIGHT (f) = tibar_height;
-      FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
-      if (tobar_height)
-        FRAME_EXTERNAL_TOOL_BAR (f) = 1;
+      if (FRAME_EXTERNAL_TOOL_BAR (f))
+        FRAME_TOOLBAR_HEIGHT (f) = tobar_height;
 
       [self windowWillExitFullScreen:nil];
       [fw setFrame: [w frame] display:YES animate:YES];
       [fw close];
       [w makeKeyAndOrderFront:NSApp];
       [self windowDidExitFullScreen:nil];
+      [self updateFrameSize:YES];
     }
-#endif
 }
 
 - (void)handleFS
@@ -7154,6 +7242,18 @@ allowing it to be used at a lower level for accented character entry.");
 Only works on OSX 10.6 or later.  */);
   ns_auto_hide_menu_bar = Qnil;
 
+  DEFVAR_BOOL ("ns-use-native-fullscreen", ns_use_native_fullscreen,
+     doc: /*Non-nil means to use native fullscreen on OSX >= 10.7.
+Nil means use fullscreen the old (< 10.7) way.  The old way works better with
+multiple monitors, but lacks tool bar.  This variable is ignored on OSX < 10.7.
+Default is t for OSX >= 10.7, nil otherwise. */);
+#ifdef HAVE_NATIVE_FS
+  ns_use_native_fullscreen = YES;
+#else
+  ns_use_native_fullscreen = NO;
+#endif
+  ns_last_use_native_fullscreen = ns_use_native_fullscreen;
+
   /* TODO: move to common code */
   DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars,
                doc: /* Which toolkit scroll bars Emacs uses, if any.
diff --git a/src/pre-crt0.c b/src/pre-crt0.c
index ea5736eba2a..6b9618c8dc3 100644
--- a/src/pre-crt0.c
+++ b/src/pre-crt0.c
@@ -4,7 +4,7 @@
    that make environ an initialized variable.  However, we do
    need to make sure the label data_start exists anyway.  */
 
-/* Create a label to appear at the beginning of data space.  */
-
-int data_start = 0;
+/* Create a label to appear at the beginning of data space.
+   Its value is nonzero so that it cannot be put into bss.  */
 
+int data_start = 1;
diff --git a/src/print.c b/src/print.c
index bf86be5622e..4aae4118152 100644
--- a/src/print.c
+++ b/src/print.c
@@ -1,7 +1,7 @@
 /* Lisp object printing and output streams.
 
-Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1988, 1993-1995, 1997-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -102,7 +102,8 @@ int print_output_debug_flag EXTERNALLY_VISIBLE = 1;
    ptrdiff_t old_point_byte = -1, start_point_byte = -1;                \
    ptrdiff_t specpdl_count = SPECPDL_INDEX ();                          \
    int free_print_buffer = 0;                                           \
-   int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));  \
+   bool multibyte                                                       \
+     = !NILP (BVAR (current_buffer, enable_multibyte_characters));      \
    Lisp_Object original
 
 #define PRINTPREPARE                                                    \
@@ -1396,7 +1397,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           /* 1 means we must ensure that the next character we output
              cannot be taken as part of a hex character escape.  */
           int need_nonhex = 0;
-          int multibyte = STRING_MULTIBYTE (obj);
+          bool multibyte = STRING_MULTIBYTE (obj);
 
           GCPRO1 (obj);
 
@@ -1766,7 +1767,7 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
         {
           int len;
           strout ("#<window ", -1, -1, printcharfun);
-          len = sprintf (buf, "%d", XWINDOW (obj)->sequence_number);
+          len = sprintf (buf, "%p", XWINDOW (obj));
           strout (buf, len, len, printcharfun);
           if (!NILP (XWINDOW (obj)->buffer))
             {
@@ -2027,21 +2028,96 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           PRINTCHAR ('>');
           break;
 
-      /* Remaining cases shouldn't happen in normal usage, but let's print
-         them anyway for the benefit of the debugger.  */
+          /* Remaining cases shouldn't happen in normal usage, but let's
+             print them anyway for the benefit of the debugger.  */
+
         case Lisp_Misc_Free:
           strout ("#<misc free cell>", -1, -1, printcharfun);
           break;
 
         case Lisp_Misc_Save_Value:
-          strout ("#<save_value ", -1, -1, printcharfun);
           {
-            int len = sprintf (buf, "ptr=%p int=%"pD"d",
-                               XSAVE_VALUE (obj)->pointer,
-                               XSAVE_VALUE (obj)->integer);
-            strout (buf, len, len, printcharfun);
+            int i;
+            struct Lisp_Save_Value *v = XSAVE_VALUE (obj);
+
+            strout ("#<save-value ", -1, -1, printcharfun);
+
+            if (v->area)
+              {
+                ptrdiff_t amount = v->data[1].integer;
+
+#if GC_MARK_STACK
+
+                /* If GC_MARK_STACK, valid_lisp_object_p is quite reliable,
+                   and so we try to print up to 8 objects we have saved.
+                   Although valid_lisp_object_p is slow, this shouldn't be
+                   a real bottleneck because we do not use this code under
+                   normal circumstances.  */
+
+                int limit = min (amount, 8);
+                Lisp_Object *area = v->data[0].pointer;
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
+                strout (buf, i, i, printcharfun);
+
+                for (i = 0; i < limit; i++)
+                  {
+                    Lisp_Object maybe = area[i];
+
+                    if (valid_lisp_object_p (maybe) > 0)
+                      {
+                        PRINTCHAR (' ');
+                        print_object (maybe, printcharfun, escapeflag);
+                      }
+                    else
+                      strout (" <invalid>", -1, -1, printcharfun);
+                  }
+                if (i == limit && i < amount)
+                  strout (" ...", 4, 4, printcharfun);
+
+#else /* not GC_MARK_STACK */
+
+                /* If !GC_MARK_STACK, we have no reliable way to find
+                   whether Lisp_Object pointers points to an initialized
+                   objects, and so we do not ever trying to print them.  */
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
+                strout (buf, i, i, printcharfun);
+
+#endif /* GC_MARK_STACK */
+              }
+            else
+              {
+                /* Print each `data[N]' slot according to its type.  */
+
+#define PRINTX(index)                                                   \
+  do {                                                                  \
+    i = 0;                                                              \
+    if (v->type ## index == SAVE_UNUSED)                                \
+      i = sprintf (buf, "<unused>");                                    \
+    else if (v->type ## index == SAVE_INTEGER)                          \
+      i = sprintf (buf, "<integer %"pD"d>", v->data[index].integer);    \
+    else if (v->type ## index == SAVE_POINTER)                          \
+      i = sprintf (buf, "<pointer %p>", v->data[index].pointer);        \
+    else /* SAVE_OBJECT */                                              \
+      print_object (v->data[index].object, printcharfun, escapeflag);   \
+    if (i)                                                              \
+      strout (buf, i, i, printcharfun);                                 \
+  } while (0)
+
+                PRINTX (0);
+                PRINTCHAR (' ');
+                PRINTX (1);
+                PRINTCHAR (' ');
+                PRINTX (2);
+                PRINTCHAR (' ');
+                PRINTX (3);
+
+#undef PRINTX
+
+              }
+            PRINTCHAR ('>');
           }
-          PRINTCHAR ('>');
           break;
 
         default:
diff --git a/src/process.c b/src/process.c
index 7b21d060cf8..5b15ade1122 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1,7 +1,7 @@
 /* Asynchronous subprocess control for GNU Emacs.
 
-Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1996, 1998-1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -180,10 +180,6 @@ static Lisp_Object Qlast_nonmenu_event;
 #define SERIALCONN_P(p) (EQ (XPROCESS (p)->type, Qserial))
 #define SERIALCONN1_P(p) (EQ (p->type, Qserial))
 
-#ifndef HAVE_H_ERRNO
-extern int h_errno;
-#endif
-
 /* Number of events of change of status of a process.  */
 static EMACS_INT process_tick;
 /* Number of events for which the user or sentinel has been notified.  */
@@ -4222,7 +4218,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
   if (time_limit == 0 && nsecs == 0 && wait_proc && !NILP (Vinhibit_quit)
       && !(CONSP (wait_proc->status)
            && EQ (XCAR (wait_proc->status), Qexit)))
-    message ("Blocking call to accept-process-output with quit inhibited!!");
+    message1 ("Blocking call to accept-process-output with quit inhibited!!");
 
   /* If wait_proc is a process to watch, set wait_channel accordingly.  */
   if (wait_proc != NULL)
@@ -4773,11 +4769,7 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                  Therefore, if we get an error reading and errno =
                  EIO, just continue, because the child process has
                  exited and should clean itself up soon (e.g. when we
-                 get a SIGCHLD).
-
-                 However, it has been known to happen that the SIGCHLD
-                 got lost.  So raise the signal again just in case.
-                 It can't hurt.  */
+                 get a SIGCHLD).  */
               else if (nread == -1 && errno == EIO)
                 {
                   struct Lisp_Process *p = XPROCESS (proc);
@@ -4795,8 +4787,6 @@ wait_reading_process_output (intmax_t time_limit, int nsecs, int read_kbd,
                       p->tick = ++process_tick;
                       pset_status (p, Qfailed);
                     }
-                  else
-                    handle_child_signal (SIGCHLD);
                 }
 #endif /* HAVE_PTYS */
               /* If we can detect process termination, don't consider the
@@ -5562,19 +5552,19 @@ it is sent in several bunches.  This may happen even for shorter regions.
 Output from processes can arrive in between bunches.  */)
   (Lisp_Object process, Lisp_Object start, Lisp_Object end)
 {
-  Lisp_Object proc;
-  ptrdiff_t start1, end1;
+  Lisp_Object proc = get_process (process);
+  ptrdiff_t start_byte, end_byte;
 
-  proc = get_process (process);
   validate_region (&start, &end);
 
+  start_byte = CHAR_TO_BYTE (XINT (start));
+  end_byte = CHAR_TO_BYTE (XINT (end));
+
   if (XINT (start) < GPT && XINT (end) > GPT)
-    move_gap (XINT (start));
+    move_gap_both (XINT (start), start_byte);
 
-  start1 = CHAR_TO_BYTE (XINT (start));
-  end1 = CHAR_TO_BYTE (XINT (end));
-  send_process (proc, (char *) BYTE_POS_ADDR (start1), end1 - start1,
-                Fcurrent_buffer ());
+  send_process (proc, (char *) BYTE_POS_ADDR (start_byte),
+                end_byte - start_byte, Fcurrent_buffer ());
 
   return Qnil;
 }
diff --git a/src/process.h b/src/process.h
index a0521689abf..a003ffa147f 100644
--- a/src/process.h
+++ b/src/process.h
@@ -1,5 +1,5 @@
 /* Definitions for asynchronous process control in GNU Emacs.
-   Copyright (C) 1985, 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/profiler.c b/src/profiler.c
index 3d8f7243d2f..85d9c1ca88a 100644
--- a/src/profiler.c
+++ b/src/profiler.c
@@ -1,6 +1,6 @@
 /* Profiler implementation.
 
-Copyright (C) 2012 Free Software Foundation, Inc.
+Copyright (C) 2012-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -560,7 +560,7 @@ hashfn_profiler (struct hash_table_test *ht, Lisp_Object bt)
                ? XHASH (XCDR (XCDR (f))) : XHASH (f));
           hash = sxhash_combine (hash, hash1);
         }
-      return (hash & INTMASK);
+      return SXHASH_REDUCE (hash);
     }
   else
     return XHASH (bt);
diff --git a/src/puresize.h b/src/puresize.h
index 26395a5729d..2f717571c7c 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -1,5 +1,5 @@
 /* How much read-only Lisp storage a dumped Emacs needs.
-   Copyright (C) 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/ralloc.c b/src/ralloc.c
index e5bf76b0e6d..ec1ac40414c 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -1,5 +1,5 @@
 /* Block-relocating memory allocator.
-   Copyright (C) 1993, 1995, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993, 1995, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/regex.c b/src/regex.c
index 1473551e6cc..051a4fdc26b 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -2,7 +2,7 @@
    0.12.  (Implements POSIX draft P1003.2/D11.2, except for some of the
    internationalization features.)
 
-   Copyright (C) 1993-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-2013 Free Software Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-   USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* TODO:
    - structure the opcode space into opcode+flag.
diff --git a/src/regex.h b/src/regex.h
index e0ede012b20..f1fd837bd6f 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -1,8 +1,8 @@
 /* Definitions for data structures and routines for the regular
    expression library, version 0.12.
 
-   Copyright (C) 1985, 1989-1993, 1995, 2000-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1989-1993, 1995, 2000-2013 Free Software
+   Foundation, Inc.
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -15,9 +15,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
-   USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #ifndef _REGEX_H
 #define _REGEX_H 1
diff --git a/src/region-cache.c b/src/region-cache.c
index 832f4bfd214..14e6982cd9a 100644
--- a/src/region-cache.c
+++ b/src/region-cache.c
@@ -1,7 +1,7 @@
 /* Caching facts about regions of the buffer, for optimization.
 
-Copyright (C) 1985-1989, 1993, 1995, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1989, 1993, 1995, 2001-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/region-cache.h b/src/region-cache.h
index 7aebdbec262..e4c6b59ee95 100644
--- a/src/region-cache.h
+++ b/src/region-cache.h
@@ -1,7 +1,7 @@
 /* Header file: Caching facts about regions of the buffer, for optimization.
 
-Copyright (C) 1985-1986, 1993, 1995, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993, 1995, 2001-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -40,7 +40,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
    existing data structure, and disturb as little of the existing code
    as possible.
 
-   So here's the tack.  We add some caching to the scan_buffer
+   So here's the tack.  We add some caching to the find_newline
    function, so that when it searches for a newline, it notes that the
    region between the start and end of the search contained no
    newlines; then, the next time around, it consults this cache to see
diff --git a/src/scroll.c b/src/scroll.c
index 71ce43b2e48..9e11feb64d4 100644
--- a/src/scroll.c
+++ b/src/scroll.c
@@ -1,7 +1,7 @@
 /* Calculate what line insertion or deletion to do, and do it
 
-Copyright (C) 1985-1986, 1990, 1993-1994, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1990, 1993-1994, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/search.c b/src/search.c
index aacdbe33eef..d4508004bf6 100644
--- a/src/search.c
+++ b/src/search.c
@@ -1,7 +1,7 @@
 /* String search routines for GNU Emacs.
 
-Copyright (C) 1985-1987, 1993-1994, 1997-1999, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985-1987, 1993-1994, 1997-1999, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -209,7 +209,8 @@ clear_regexp_cache (void)
    for this pattern.  0 means backtrack only enough to get a valid match.  */
 
 struct re_pattern_buffer *
-compile_pattern (Lisp_Object pattern, struct re_registers *regp, Lisp_Object translate, int posix, int multibyte)
+compile_pattern (Lisp_Object pattern, struct re_registers *regp,
+                 Lisp_Object translate, int posix, bool multibyte)
 {
   struct regexp_cache *cp, **cpp;
 
@@ -534,9 +535,10 @@ fast_string_match_ignore_case (Lisp_Object regexp, Lisp_Object string)
    data.  */
 
 ptrdiff_t
-fast_looking_at (Lisp_Object regexp, ptrdiff_t pos, ptrdiff_t pos_byte, ptrdiff_t limit, ptrdiff_t limit_byte, Lisp_Object string)
+fast_looking_at (Lisp_Object regexp, ptrdiff_t pos, ptrdiff_t pos_byte,
+                 ptrdiff_t limit, ptrdiff_t limit_byte, Lisp_Object string)
 {
-  int multibyte;
+  bool multibyte;
   struct re_pattern_buffer *buf;
   unsigned char *p1, *p2;
   ptrdiff_t s1, s2;
@@ -619,7 +621,7 @@ newline_cache_on_off (struct buffer *buf)
 }
 
 
-/* Search for COUNT instances of the character TARGET between START and END.
+/* Search for COUNT newlines between START and END.
 
    If COUNT is positive, search forwards; END must be >= START.
    If COUNT is negative, search backwards for the -COUNTth instance;
@@ -634,28 +636,33 @@ newline_cache_on_off (struct buffer *buf)
    this is not the same as the usual convention for Emacs motion commands.
 
    If we don't find COUNT instances before reaching END, set *SHORTAGE
-   to the number of TARGETs left unfound, and return END.
+   to the number of newlines left unfound, and return END.
 
    If ALLOW_QUIT, set immediate_quit.  That's good to do
    except when inside redisplay.  */
 
 ptrdiff_t
-scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
-             ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
+find_newline (ptrdiff_t start, ptrdiff_t end,
+              ptrdiff_t count, ptrdiff_t *shortage, bool allow_quit)
 {
   struct region_cache *newline_cache;
+  ptrdiff_t end_byte = -1;
   int direction;
 
   if (count > 0)
     {
       direction = 1;
-      if (! end) end = ZV;
+      if (!end)
+        end = ZV, end_byte = ZV_BYTE;
     }
   else
     {
       direction = -1;
-      if (! end) end = BEGV;
+      if (!end)
+        end = BEGV, end_byte = BEGV_BYTE;
     }
+  if (end_byte == -1)
+    end_byte = CHAR_TO_BYTE (end);
 
   newline_cache_on_off (current_buffer);
   newline_cache = current_buffer->newline_cache;
@@ -673,13 +680,13 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
            the position of the last character before the next such
            obstacle --- the last character the dumb search loop should
            examine.  */
-        ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end) - 1;
+        ptrdiff_t ceiling_byte = end_byte - 1;
         ptrdiff_t start_byte;
         ptrdiff_t tem;
 
         /* If we're looking for a newline, consult the newline cache
            to see where we can avoid some scanning.  */
-        if (target == '\n' && newline_cache)
+        if (newline_cache)
           {
             ptrdiff_t next_change;
             immediate_quit = 0;
@@ -718,44 +725,44 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
 
           while (cursor < ceiling_addr)
             {
-              unsigned char *scan_start = cursor;
-
               /* The dumb loop.  */
-              while (*cursor != target && ++cursor < ceiling_addr)
-                ;
+              unsigned char *nl = memchr (cursor, '\n', ceiling_addr - cursor);
 
               /* If we're looking for newlines, cache the fact that
                  the region from start to cursor is free of them. */
-              if (target == '\n' && newline_cache)
-                know_region_cache (current_buffer, newline_cache,
-                                   BYTE_TO_CHAR (start_byte + scan_start - base),
-                                   BYTE_TO_CHAR (start_byte + cursor - base));
-
-              /* Did we find the target character?  */
-              if (cursor < ceiling_addr)
-                {
-                  if (--count == 0)
-                    {
-                      immediate_quit = 0;
-                      return BYTE_TO_CHAR (start_byte + cursor - base + 1);
-                    }
-                  cursor++;
-                }
+              if (newline_cache)
+                {
+                  unsigned char *low = cursor;
+                  unsigned char *lim = nl ? nl : ceiling_addr;
+                  know_region_cache (current_buffer, newline_cache,
+                                     BYTE_TO_CHAR (low - base + start_byte),
+                                     BYTE_TO_CHAR (lim - base + start_byte));
+                }
+
+              if (! nl)
+                break;
+
+              if (--count == 0)
+                {
+                  immediate_quit = 0;
+                  return BYTE_TO_CHAR (nl + 1 - base + start_byte);
+                }
+              cursor = nl + 1;
             }
 
-          start = BYTE_TO_CHAR (start_byte + cursor - base);
+          start = BYTE_TO_CHAR (ceiling_addr - base + start_byte);
         }
       }
   else
     while (start > end)
       {
         /* The last character to check before the next obstacle.  */
-        ptrdiff_t ceiling_byte = CHAR_TO_BYTE (end);
+        ptrdiff_t ceiling_byte = end_byte;
         ptrdiff_t start_byte;
         ptrdiff_t tem;
 
         /* Consult the newline cache, if appropriate.  */
-        if (target == '\n' && newline_cache)
+        if (newline_cache)
           {
             ptrdiff_t next_change;
             immediate_quit = 0;
@@ -789,31 +796,32 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
 
           while (cursor >= ceiling_addr)
             {
-              unsigned char *scan_start = cursor;
-
-              while (*cursor != target && --cursor >= ceiling_addr)
-                ;
+              unsigned char *nl = memrchr (ceiling_addr, '\n',
+                                           cursor + 1 - ceiling_addr);
 
               /* If we're looking for newlines, cache the fact that
                  the region from after the cursor to start is free of them.  */
-              if (target == '\n' && newline_cache)
-                know_region_cache (current_buffer, newline_cache,
-                                   BYTE_TO_CHAR (start_byte + cursor - base),
-                                   BYTE_TO_CHAR (start_byte + scan_start - base));
-
-              /* Did we find the target character?  */
-              if (cursor >= ceiling_addr)
-                {
-                  if (++count >= 0)
-                    {
-                      immediate_quit = 0;
-                      return BYTE_TO_CHAR (start_byte + cursor - base);
-                    }
-                  cursor--;
-                }
+              if (newline_cache)
+                {
+                  unsigned char *low = nl ? nl : ceiling_addr - 1;
+                  unsigned char *lim = cursor;
+                  know_region_cache (current_buffer, newline_cache,
+                                     BYTE_TO_CHAR (low - base + start_byte),
+                                     BYTE_TO_CHAR (lim - base + start_byte));
+                }
+
+              if (! nl)
+                break;
+
+              if (++count >= 0)
+                {
+                  immediate_quit = 0;
+                  return BYTE_TO_CHAR (nl - base + start_byte);
+                }
+              cursor = nl - 1;
             }
 
-          start = BYTE_TO_CHAR (start_byte + cursor - base);
+          start = BYTE_TO_CHAR (ceiling_addr - 1 - base + start_byte);
         }
       }
 
@@ -823,8 +831,7 @@ scan_buffer (int target, ptrdiff_t start, ptrdiff_t end,
   return start;
 }
 
-/* Search for COUNT instances of a line boundary, which means either a
-   newline or (if selective display enabled) a carriage return.
+/* Search for COUNT instances of a line boundary.
    Start at START.  If COUNT is negative, search backwards.
 
    We report the resulting position by calling TEMP_SET_PT_BOTH.
@@ -855,14 +862,9 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
 
   bool old_immediate_quit = immediate_quit;
 
-  /* The code that follows is like scan_buffer
-     but checks for either newline or carriage return.  */
-
   if (allow_quit)
     immediate_quit++;
 
-  start_byte = CHAR_TO_BYTE (start);
-
   if (count > 0)
     {
       while (start_byte < limit_byte)
@@ -871,29 +873,25 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
           ceiling = min (limit_byte - 1, ceiling);
           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
           base = (cursor = BYTE_POS_ADDR (start_byte));
-          while (1)
-            {
-              while (*cursor != '\n' && ++cursor != ceiling_addr)
-                ;
 
-              if (cursor != ceiling_addr)
+          do
+            {
+              unsigned char *nl = memchr (cursor, '\n', ceiling_addr - cursor);
+              if (! nl)
+                break;
+              if (--count == 0)
                 {
-                  if (--count == 0)
-                    {
-                      immediate_quit = old_immediate_quit;
-                      start_byte = start_byte + cursor - base + 1;
-                      start = BYTE_TO_CHAR (start_byte);
-                      TEMP_SET_PT_BOTH (start, start_byte);
-                      return 0;
-                    }
-                  else
-                    if (++cursor == ceiling_addr)
-                      break;
+                  immediate_quit = old_immediate_quit;
+                  start_byte += nl - base + 1;
+                  start = BYTE_TO_CHAR (start_byte);
+                  TEMP_SET_PT_BOTH (start, start_byte);
+                  return 0;
                 }
-              else
-                break;
+              cursor = nl + 1;
             }
-          start_byte += cursor - base;
+          while (cursor < ceiling_addr);
+
+          start_byte += ceiling_addr - base;
         }
     }
   else
@@ -902,31 +900,28 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
         {
           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
           ceiling = max (limit_byte, ceiling);
-          ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
+          ceiling_addr = BYTE_POS_ADDR (ceiling);
           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
           while (1)
             {
-              while (--cursor != ceiling_addr && *cursor != '\n')
-                ;
+              unsigned char *nl = memrchr (ceiling_addr, '\n',
+                                           cursor - ceiling_addr);
+              if (! nl)
+                break;
 
-              if (cursor != ceiling_addr)
+              if (++count == 0)
                 {
-                  if (++count == 0)
-                    {
-                      immediate_quit = old_immediate_quit;
-                      /* Return the position AFTER the match we found.  */
-                      start_byte = start_byte + cursor - base + 1;
-                      start = BYTE_TO_CHAR (start_byte);
-                      TEMP_SET_PT_BOTH (start, start_byte);
-                      return 0;
-                    }
+                  immediate_quit = old_immediate_quit;
+                  /* Return the position AFTER the match we found.  */
+                  start_byte += nl - base + 1;
+                  start = BYTE_TO_CHAR (start_byte);
+                  TEMP_SET_PT_BOTH (start, start_byte);
+                  return 0;
                 }
-              else
-                break;
+
+              cursor = nl;
             }
-          /* Here we add 1 to compensate for the last decrement
-             of CURSOR, which took it past the valid range.  */
-          start_byte += cursor - base + 1;
+          start_byte += ceiling_addr - base;
         }
     }
 
@@ -939,7 +934,7 @@ scan_newline (ptrdiff_t start, ptrdiff_t start_byte,
 ptrdiff_t
 find_next_newline_no_quit (ptrdiff_t from, ptrdiff_t cnt)
 {
-  return scan_buffer ('\n', from, 0, cnt, (ptrdiff_t *) 0, 0);
+  return find_newline (from, 0, cnt, (ptrdiff_t *) 0, 0);
 }
 
 /* Like find_next_newline, but returns position before the newline,
@@ -950,7 +945,7 @@ ptrdiff_t
 find_before_next_newline (ptrdiff_t from, ptrdiff_t to, ptrdiff_t cnt)
 {
   ptrdiff_t shortage;
-  ptrdiff_t pos = scan_buffer ('\n', from, to, cnt, &shortage, 1);
+  ptrdiff_t pos = find_newline (from, to, cnt, &shortage, 1);
 
   if (shortage == 0)
     pos--;
@@ -1016,8 +1011,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
 
       if (!EQ (noerror, Qt))
         {
-          if (lim < BEGV || lim > ZV)
-            emacs_abort ();
+          eassert (BEGV <= lim && lim <= ZV);
           SET_PT_BOTH (lim, lim_byte);
           return Qnil;
 #if 0 /* This would be clean, but maybe programs depend on
@@ -1029,9 +1023,7 @@ search_command (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror,
         return Qnil;
     }
 
-  if (np < BEGV || np > ZV)
-    emacs_abort ();
-
+  eassert (BEGV <= np && np <= ZV);
   SET_PT (np);
 
   return make_number (np);
@@ -1258,7 +1250,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
       ptrdiff_t raw_pattern_size;
       ptrdiff_t raw_pattern_size_byte;
       unsigned char *patbuf;
-      int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+      bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
       unsigned char *base_pat;
       /* Set to positive if we find a non-ASCII char that need
          translation.  Otherwise set to zero later.  */
@@ -1313,8 +1305,11 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
              non-nil, we can use boyer-moore search only if TRT can be
              represented by the byte array of 256 elements.  For that,
              all non-ASCII case-equivalents of all case-sensitive
-             characters in STRING must belong to the same charset and
-             row.  */
+             characters in STRING must belong to the same character
+             group (two characters belong to the same group iff their
+             multibyte forms are the same except for the last byte;
+             i.e. every 64 characters form a group; U+0000..U+003F,
+             U+0040..U+007F, U+0080..U+00BF, ...).  */
 
           while (--len >= 0)
             {
@@ -1406,7 +1401,7 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
           char_base = 0;
           while (--len >= 0)
             {
-              int c, translated;
+              int c, translated, inverse;
 
               /* If we got here and the RE flag is set, it's because we're
                  dealing with a regexp known to be trivial, so the backslash
@@ -1420,6 +1415,20 @@ search_buffer (Lisp_Object string, ptrdiff_t pos, ptrdiff_t pos_byte,
               c = *base_pat++;
               TRANSLATE (translated, trt, c);
               *pat++ = translated;
+              /* Check that none of C's equivalents violates the
+                 assumptions of boyer_moore.  */
+              TRANSLATE (inverse, inverse_trt, c);
+              while (1)
+                {
+                  if (inverse >= 0200)
+                    {
+                      boyer_moore_ok = 0;
+                      break;
+                    }
+                  if (c == inverse)
+                    break;
+                  TRANSLATE (inverse, inverse_trt, inverse);
+                }
             }
         }
 
@@ -1454,8 +1463,8 @@ simple_search (EMACS_INT n, unsigned char *pat,
                ptrdiff_t pos, ptrdiff_t pos_byte,
                ptrdiff_t lim, ptrdiff_t lim_byte)
 {
-  int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
-  int forward = n > 0;
+  bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
+  bool forward = n > 0;
   /* Number of buffer bytes matched.  Note that this may be different
      from len_byte in a multibyte buffer.  */
   ptrdiff_t match_byte = PTRDIFF_MIN;
@@ -1674,7 +1683,7 @@ boyer_moore (EMACS_INT n, unsigned char *base_pat,
   register ptrdiff_t i;
   register int j;
   unsigned char *pat, *pat_end;
-  int multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
+  bool multibyte = ! NILP (BVAR (current_buffer, enable_multibyte_characters));
 
   unsigned char simple_translate[0400];
   /* These are set to the preceding bytes of a byte to be translated
@@ -2500,8 +2509,8 @@ since only regular expressions have distinguished subexpressions.  */)
       ptrdiff_t length = SBYTES (newtext);
       unsigned char *substed;
       ptrdiff_t substed_alloc_size, substed_len;
-      int buf_multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
-      int str_multibyte = STRING_MULTIBYTE (newtext);
+      bool buf_multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+      bool str_multibyte = STRING_MULTIBYTE (newtext);
       int really_changed = 0;
 
       substed_alloc_size = ((STRING_BYTES_BOUND - 100) / 2 < length
@@ -2585,7 +2594,7 @@ since only regular expressions have distinguished subexpressions.  */)
               ptrdiff_t begbyte = CHAR_TO_BYTE (search_regs.start[idx]);
               add_len = CHAR_TO_BYTE (search_regs.end[idx]) - begbyte;
               if (search_regs.start[idx] < GPT && GPT < search_regs.end[idx])
-                move_gap (search_regs.start[idx]);
+                move_gap_both (search_regs.start[idx], begbyte);
               add_stuff = BYTE_POS_ADDR (begbyte);
             }
 
diff --git a/src/sheap.c b/src/sheap.c
index f6022ea3ce7..06e205bc0e5 100644
--- a/src/sheap.c
+++ b/src/sheap.c
@@ -1,7 +1,7 @@
 /* simulate `sbrk' with an array in .bss, for `unexec' support for Cygwin;
    complete rewrite of xemacs Cygwin `unexec' code
 
-   Copyright (C) 2004-2012 Free Software Foundation, Inc.
+   Copyright (C) 2004-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -91,5 +91,5 @@ report_sheap_usage (int die_if_pure_storage_exceeded)
   char buf[200];
   sprintf (buf, "Static heap usage: %d of %d bytes",
            bss_sbrk_ptr - bss_sbrk_buffer, STATIC_HEAP_SIZE);
-  message ("%s", buf);
+  message1 (buf);
 }
diff --git a/src/sound.c b/src/sound.c
index 0ee85312fd3..9c472fb0263 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -1,6 +1,6 @@
 /* sound.c -- sound support.
 
-Copyright (C) 1998-1999, 2001-2012 Free Software Foundation, Inc.
+Copyright (C) 1998-1999, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -334,7 +334,7 @@ sound_perror (const char *msg)
 static void
 sound_warning (const char *msg)
 {
-  message ("%s", msg);
+  message1 (msg);
 }
 
 
diff --git a/src/syntax.c b/src/syntax.c
index d3cafcc472e..390d732944d 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -1,6 +1,6 @@
 /* GNU Emacs routines to deal with syntax tables; also word and list parsing.
-   Copyright (C) 1985, 1987, 1993-1995, 1997-1999, 2001-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985, 1987, 1993-1995, 1997-1999, 2001-2013 Free
+   Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -121,6 +121,7 @@ struct lisp_parse_state
     /* Char number of start of containing expression */
     ptrdiff_t prevlevelstart;
     ptrdiff_t location;      /* Char number at which parsing stopped.  */
+    ptrdiff_t location_byte; /* Corresponding byte position.  */
     ptrdiff_t comstr_start;  /* Position of last comment/string starter.  */
     Lisp_Object levelstarts; /* Char numbers of starts-of-expression
                                 of levels (starting from outermost).  */
@@ -3277,6 +3278,7 @@ do { prev_from = from;				\
 
  stop:   /* Here if stopping before start of sexp. */
   from = prev_from;    /* We have just fetched the char that starts it; */
+  from_byte = prev_from_byte;
   goto done; /* but return the position before it. */
 
  endquoted:
@@ -3288,6 +3290,7 @@ do { prev_from = from;				\
   state.prevlevelstart
     = (curlevel == levelstart) ? -1 : (curlevel - 1)->last;
   state.location = from;
+  state.location_byte = from_byte;
   state.levelstarts = Qnil;
   while (curlevel > levelstart)
     state.levelstarts = Fcons (make_number ((--curlevel)->last),
@@ -3327,7 +3330,8 @@ Fifth arg OLDSTATE is a list like what this function returns.
 Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
  If it is symbol `syntax-table', stop after the start of a comment or a
  string, or after end of a comment or a string.  */)
-  (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth, Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
+  (Lisp_Object from, Lisp_Object to, Lisp_Object targetdepth,
+   Lisp_Object stopbefore, Lisp_Object oldstate, Lisp_Object commentstop)
 {
   struct lisp_parse_state state;
   EMACS_INT target;
@@ -3347,7 +3351,7 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
                       (NILP (commentstop)
                        ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));
 
-  SET_PT (state.location);
+  SET_PT_BOTH (state.location, state.location_byte);
 
   return Fcons (make_number (state.depth),
            Fcons (state.prevlevelstart < 0
@@ -3389,8 +3393,8 @@ init_syntax_once (void)
   Qchar_table_extra_slots = intern_c_string ("char-table-extra-slots");
 
   /* Create objects which can be shared among syntax tables.  */
-  Vsyntax_code_object = Fmake_vector (make_number (Smax), Qnil);
-  for (i = 0; i < ASIZE (Vsyntax_code_object); i++)
+  Vsyntax_code_object = make_uninit_vector (Smax);
+  for (i = 0; i < Smax; i++)
     ASET (Vsyntax_code_object, i, Fcons (make_number (i), Qnil));
 
   /* Now we are ready to set up this property, so we can
diff --git a/src/syntax.h b/src/syntax.h
index 6edb1585795..c9af240df0c 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -1,7 +1,7 @@
 /* Declarations having to do with GNU Emacs syntax tables.
 
-Copyright (C) 1985, 1993-1994, 1997-1998, 2001-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1985, 1993-1994, 1997-1998, 2001-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/sysdep.c b/src/sysdep.c
index 5291c5d59aa..606a5b038ca 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1,6 +1,6 @@
 /* Interfaces to system-dependent kernel and library entries.
-   Copyright (C) 1985-1988, 1993-1995, 1999-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1993-1995, 1999-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -30,9 +30,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <limits.h>
 #include <unistd.h>
 
-#include <allocator.h>
 #include <c-ctype.h>
-#include <careadlinkat.h>
 #include <ignore-value.h>
 #include <utimens.h>
 
@@ -529,10 +527,10 @@ sys_subshell (void)
 #ifdef DOS_NT    /* MW, Aug 1993 */
       getcwd (oldwd, sizeof oldwd);
       if (sh == 0)
-        sh = (char *) egetenv ("SUSPEND");      /* KFS, 1994-12-14 */
+        sh = egetenv ("SUSPEND");       /* KFS, 1994-12-14 */
 #endif
       if (sh == 0)
-        sh = (char *) egetenv ("SHELL");
+        sh = egetenv ("SHELL");
       if (sh == 0)
         sh = "sh";
 
@@ -714,6 +712,27 @@ init_foreground_group (void)
   inherited_pgroup = getpid () == pgrp ? 0 : pgrp;
 }
 
+/* Block and unblock SIGTTOU.  */
+
+void
+block_tty_out_signal (void)
+{
+#ifdef SIGTTOU
+  sigset_t blocked;
+  sigemptyset (&blocked);
+  sigaddset (&blocked, SIGTTOU);
+  pthread_sigmask (SIG_BLOCK, &blocked, 0);
+#endif
+}
+
+void
+unblock_tty_out_signal (void)
+{
+#ifdef SIGTTOU
+  pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
+#endif
+}
+
 /* 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
@@ -725,11 +744,10 @@ static void
 tcsetpgrp_without_stopping (int fd, pid_t pgid)
 {
 #ifdef SIGTTOU
-  signal_handler_t handler;
   block_input ();
-  handler = signal (SIGTTOU, SIG_IGN);
+  block_tty_out_signal ();
   tcsetpgrp (fd, pgid);
-  signal (SIGTTOU, handler);
+  unblock_tty_out_signal ();
   unblock_input ();
 #endif
 }
@@ -1658,6 +1676,25 @@ deliver_arith_signal (int sig)
   deliver_thread_signal (sig, handle_arith_signal);
 }
 
+#ifdef SIGDANGER
+
+/* Handler for SIGDANGER.  */
+static void
+handle_danger_signal (int sig)
+{
+  malloc_warning ("Operating system warns that virtual memory is running low.\n");
+
+  /* It might be unsafe to call do_auto_save now.  */
+  force_auto_save_soon ();
+}
+
+static void
+deliver_danger_signal (int sig)
+{
+  deliver_process_signal (sig, handle_danger_signal);
+}
+#endif
+
 /* Treat SIG as a terminating signal, unless it is already ignored and
    we are in --batch mode.  Among other things, this makes nohup work.  */
 static void
@@ -2110,7 +2147,7 @@ emacs_backtrace (int backtrace_limit)
 void
 emacs_abort (void)
 {
-  terminate_due_to_signal (SIGABRT, 10);
+  terminate_due_to_signal (SIGABRT, 40);
 }
 #endif
 
@@ -2208,22 +2245,6 @@ emacs_write (int fildes, const char *buf, ptrdiff_t nbyte)
 
   return (bytes_written);
 }
-
-static struct allocator const emacs_norealloc_allocator =
-  { xmalloc, NULL, xfree, memory_full };
-
-/* Get the symbolic link value of FILENAME.  Return a pointer to a
-   NUL-terminated string.  If readlink fails, return NULL and set
-   errno.  If the value fits in INITIAL_BUF, return INITIAL_BUF.
-   Otherwise, allocate memory and return a pointer to that memory.  If
-   memory allocation fails, diagnose and fail without returning.  If
-   successful, store the length of the symbolic link into *LINKLEN.  */
-char *
-emacs_readlink (char const *filename, char initial_buf[READLINK_BUFSIZE])
-{
-  return careadlinkat (AT_FDCWD, filename, initial_buf, READLINK_BUFSIZE,
-                       &emacs_norealloc_allocator, careadlinkatcwd);
-}
 
 /* Return a struct timeval that is roughly equivalent to T.
    Use the least timeval not less than T.
diff --git a/src/sysselect.h b/src/sysselect.h
index 24bdf469ced..0a4f7e3ad96 100644
--- a/src/sysselect.h
+++ b/src/sysselect.h
@@ -1,5 +1,5 @@
 /* sysselect.h - System-dependent definitions for the select function.
-   Copyright (C) 1995, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1995, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/syssignal.h b/src/syssignal.h
index 8f9b5f0546a..d7399c6cb8c 100644
--- a/src/syssignal.h
+++ b/src/syssignal.h
@@ -1,6 +1,6 @@
 /* syssignal.h - System-dependent definitions for signals.
 
-Copyright (C) 1993, 1999, 2001-2012 Free Software Foundation, Inc.
+Copyright (C) 1993, 1999, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/systime.h b/src/systime.h
index 9ce7ce646fb..fa5e7270cb5 100644
--- a/src/systime.h
+++ b/src/systime.h
@@ -1,5 +1,5 @@
 /* systime.h - System-dependent definitions for time manipulations.
-   Copyright (C) 1993-1994, 2002-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 2002-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/systty.h b/src/systty.h
index 80bcaedf740..6d38c980725 100644
--- a/src/systty.h
+++ b/src/systty.h
@@ -1,5 +1,5 @@
 /* systty.h - System-dependent definitions for terminals.
-   Copyright (C) 1993-1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/syswait.h b/src/syswait.h
index 360407d558e..03e5cb5fe2e 100644
--- a/src/syswait.h
+++ b/src/syswait.h
@@ -1,5 +1,5 @@
 /* Define wait system call interface for Emacs.
-   Copyright (C) 1993-1995, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993-1995, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/term.c b/src/term.c
index 241875de52f..a31fd51084e 100644
--- a/src/term.c
+++ b/src/term.c
@@ -1,6 +1,6 @@
 /* Terminal control module for terminals described by TERMCAP
-   Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -953,8 +953,8 @@ tty_ins_del_lines (struct frame *f, int vpos, int n)
   const char *single = n > 0 ? tty->TS_ins_line : tty->TS_del_line;
   const char *scroll = n > 0 ? tty->TS_rev_scroll : tty->TS_fwd_scroll;
 
-  register int i = n > 0 ? n : -n;
-  register char *buf;
+  int i = eabs (n);
+  char *buf;
 
   /* If the lines below the insertion are being pushed
      into the end of the window, this is the same as clearing;
@@ -2374,7 +2374,7 @@ A suspended tty may be resumed by calling `resume-tty' on it.  */)
       t->display_info.tty->output = 0;
 
       if (FRAMEP (t->display_info.tty->top_frame))
-        FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 0);
+        SET_FRAME_VISIBLE (XFRAME (t->display_info.tty->top_frame), 0);
 
     }
 
@@ -2423,7 +2423,7 @@ frame's terminal). */)
       if (fd == -1)
         error ("Can not reopen tty device %s: %s", t->display_info.tty->name, strerror (errno));
 
-      if (strcmp (t->display_info.tty->name, DEV_TTY))
+      if (!O_IGNORE_CTTY && strcmp (t->display_info.tty->name, DEV_TTY) != 0)
         dissociate_if_controlling_tty (fd);
 
       t->display_info.tty->output = fdopen (fd, "w+");
@@ -2444,7 +2444,7 @@ frame's terminal). */)
           get_tty_size (fileno (t->display_info.tty->input), &width, &height);
           if (width != old_width || height != old_height)
             change_frame_size (f, height, width, 0, 0, 0);
-          FRAME_SET_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
+          SET_FRAME_VISIBLE (XFRAME (t->display_info.tty->top_frame), 1);
         }
 
       set_tty_hooks (t);
@@ -2903,13 +2903,23 @@ set_tty_hooks (struct terminal *terminal)
   terminal->delete_terminal_hook = &delete_tty;
 }
 
-/* Drop the controlling terminal if fd is the same device. */
+/* If FD is the controlling terminal, drop it.  */
 static void
 dissociate_if_controlling_tty (int fd)
 {
-  pid_t pgid = tcgetpgrp (fd); /* If tcgetpgrp succeeds, fd is the ctty. */
-  if (0 <= pgid)
-    setsid ();
+  /* If tcgetpgrp succeeds, fd is the controlling terminal,
+     so dissociate it by invoking setsid.  */
+  if (0 <= tcgetpgrp (fd) && setsid () < 0)
+    {
+#ifdef TIOCNOTTY
+      /* setsid failed, presumably because Emacs is already a process
+         group leader.  Fall back on the obsolescent way to dissociate
+         a controlling tty.  */
+      block_tty_out_signal ();
+      ioctl (fd, TIOCNOTTY, 0);
+      unblock_tty_out_signal ();
+#endif
+    }
 }
 
 /* Create a termcap display on the tty device with the given name and
@@ -3030,14 +3040,9 @@ init_tty (const char *name, const char *terminal_type, int must_succeed)
 
   /* On some systems, tgetent tries to access the controlling
      terminal. */
-  {
-    sigset_t blocked;
-    sigemptyset (&blocked);
-    sigaddset (&blocked, SIGTTOU);
-    pthread_sigmask (SIG_BLOCK, &blocked, 0);
-    status = tgetent (tty->termcap_term_buffer, terminal_type);
-    pthread_sigmask (SIG_UNBLOCK, &blocked, 0);
-  }
+  block_tty_out_signal ();
+  status = tgetent (tty->termcap_term_buffer, terminal_type);
+  unblock_tty_out_signal ();
 
   if (status < 0)
     {
diff --git a/src/termcap.c b/src/termcap.c
index e494cd113d9..99bbfce27f5 100644
--- a/src/termcap.c
+++ b/src/termcap.c
@@ -1,6 +1,6 @@
 /* Work-alike for termcap, plus extra features.
-   Copyright (C) 1985, 1986, 1993, 1994, 1995, 2000, 2001, 2002, 2003,
-                 2004, 2005, 2006, 2007, 2008, 2011 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1993-1995, 2000-2008, 2011, 2013 Free
+   Software Foundation, Inc.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -13,9 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING.  If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Emacs config.h may rename various library functions such as malloc.  */
 #include <config.h>
@@ -395,7 +393,7 @@ tgetent (char *bp, const char *name)
   if (termcap_name && (*termcap_name == '\\'
                        || *termcap_name == '/'
                        || termcap_name[1] == ':'))
-    dostounix_filename (termcap_name);
+    dostounix_filename (termcap_name, 0);
 #endif
 
   filep = termcap_name && valid_filename_p (termcap_name);
diff --git a/src/termchar.h b/src/termchar.h
index 8bffd3e546b..1c8e8646d4e 100644
--- a/src/termchar.h
+++ b/src/termchar.h
@@ -1,5 +1,5 @@
 /* Flags and parameters describing terminal's characteristics.
-   Copyright (C) 1985-1986, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/termhooks.h b/src/termhooks.h
index b35c927fc53..7385298d3d4 100644
--- a/src/termhooks.h
+++ b/src/termhooks.h
@@ -1,6 +1,7 @@
 /* Parameters and display hooks for terminal devices.
 
-Copyright (C) 1985-1986, 1993-1994, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1985-1986, 1993-1994, 2001-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -211,6 +212,11 @@ enum event_kind
   , NS_NONKEY_EVENT
 #endif
 
+#if defined (HAVE_INOTIFY) || defined (HAVE_NTGUI)
+  /* File or directory was changed.  */
+  , FILE_NOTIFY_EVENT
+#endif
+
 };
 
 /* If a struct input_event has a kind which is SELECTION_REQUEST_EVENT
diff --git a/src/terminal.c b/src/terminal.c
index 854ca61f19c..5e1f1ff77f7 100644
--- a/src/terminal.c
+++ b/src/terminal.c
@@ -1,5 +1,5 @@
 /* Functions related to terminal devices.
-   Copyright (C) 2005-2012 Free Software Foundation, Inc.
+   Copyright (C) 2005-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -398,8 +398,6 @@ possible return values.  */)
       return Qw32;
     case output_msdos_raw:
       return Qpc;
-    case output_mac:
-      return Qmac;
     case output_ns:
       return Qns;
     default:
diff --git a/src/terminfo.c b/src/terminfo.c
index 124c452a4a9..0e5e1985461 100644
--- a/src/terminfo.c
+++ b/src/terminfo.c
@@ -1,5 +1,5 @@
 /* Interface from Emacs to terminfo.
-   Copyright (C) 1985-1986, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/termopts.h b/src/termopts.h
index 05fa0a52eee..8b702b9bf6d 100644
--- a/src/termopts.h
+++ b/src/termopts.h
@@ -1,5 +1,6 @@
 /* Flags and parameters describing user options for handling the terminal.
-   Copyright (C) 1985-1986, 1990, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1990, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/textprop.c b/src/textprop.c
index 1ce44ad60ac..c1f6e59bf2e 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -1,5 +1,6 @@
 /* Interface code for dealing with text properties.
-   Copyright (C) 1993-1995, 1997, 1999-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993-1995, 1997, 1999-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -1323,14 +1324,13 @@ set_text_properties (Lisp_Object start, Lisp_Object end, Lisp_Object properties,
 }
 
 /* Replace properties of text from START to END with new list of
-   properties PROPERTIES.  BUFFER is the buffer containing
+   properties PROPERTIES.  OBJECT is the buffer or string containing
    the text.  This does not obey any hooks.
-   You can provide the interval that START is located in as I,
-   or pass NULL for I and this function will find it.
+   You should provide the interval that START is located in as I.
    START and END can be in any order.  */
 
 void
-set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object buffer, INTERVAL i)
+set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object properties, Lisp_Object object, INTERVAL i)
 {
   register INTERVAL prev_changed = NULL;
   register ptrdiff_t s, len;
@@ -1349,8 +1349,7 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
   else
     return;
 
-  if (i == NULL)
-    i = find_interval (buffer_intervals (XBUFFER (buffer)), s);
+  eassert (i);
 
   if (i->position != s)
     {
@@ -1361,11 +1360,11 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
         {
           copy_properties (unchanged, i);
           i = split_interval_left (i, len);
-          set_properties (properties, i, buffer);
+          set_properties (properties, i, object);
           return;
         }
 
-      set_properties (properties, i, buffer);
+      set_properties (properties, i, object);
 
       if (LENGTH (i) == len)
         return;
@@ -1388,7 +1387,7 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
           /* We have to call set_properties even if we are going to
              merge the intervals, so as to make the undo records
              and cause redisplay to happen.  */
-          set_properties (properties, i, buffer);
+          set_properties (properties, i, object);
           if (prev_changed)
             merge_interval_left (i);
           return;
@@ -1399,7 +1398,7 @@ set_text_properties_1 (Lisp_Object start, Lisp_Object end, Lisp_Object propertie
       /* We have to call set_properties even if we are going to
          merge the intervals, so as to make the undo records
          and cause redisplay to happen.  */
-      set_properties (properties, i, buffer);
+      set_properties (properties, i, object);
       if (!prev_changed)
         prev_changed = i;
       else
diff --git a/src/tparam.c b/src/tparam.c
index 164f61d471b..c3ecfb9e3a3 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -1,6 +1,6 @@
 /* Merge parameters into a termcap entry string.
-   Copyright (C) 1985, 1987, 1993, 1995, 2000, 2001, 2002, 2003, 2004,
-                 2005, 2006, 2007, 2008  Free Software Foundation, Inc.
+   Copyright (C) 1985, 1987, 1993, 1995, 2000-2008, 2013 Free Software
+   Foundation, Inc.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
@@ -13,9 +13,7 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
-along with this program; see the file COPYING.  If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
 
 /* Emacs config.h may rename various library functions such as malloc.  */
 #include <config.h>
diff --git a/src/tparam.h b/src/tparam.h
index e845f3e8202..94f226d7d6a 100644
--- a/src/tparam.h
+++ b/src/tparam.h
@@ -1,6 +1,6 @@
 /* Interface definitions for termcap entries.
 
-Copyright (C) 2011-2012  Free Software Foundation, Inc.
+Copyright (C) 2011-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/undo.c b/src/undo.c
index e878ef4dcf9..63edc8e9b8d 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -1,5 +1,6 @@
 /* undo handling for GNU Emacs.
-   Copyright (C) 1990, 1993-1994, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993-1994, 2000-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -451,217 +452,6 @@ user_error (const char *msg)
 }
 
 
-DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
-       doc: /* Undo N records from the front of the list LIST.
-Return what remains of the list.  */)
-  (Lisp_Object n, Lisp_Object list)
-{
-  struct gcpro gcpro1, gcpro2;
-  Lisp_Object next;
-  ptrdiff_t count = SPECPDL_INDEX ();
-  register EMACS_INT arg;
-  Lisp_Object oldlist;
-  int did_apply = 0;
-
-#if 0  /* This is a good feature, but would make undo-start
-          unable to do what is expected.  */
-  Lisp_Object tem;
-
-  /* If the head of the list is a boundary, it is the boundary
-     preceding this command.  Get rid of it and don't count it.  */
-  tem = Fcar (list);
-  if (NILP (tem))
-    list = Fcdr (list);
-#endif
-
-  CHECK_NUMBER (n);
-  arg = XINT (n);
-  next = Qnil;
-  GCPRO2 (next, list);
-  /* I don't think we need to gcpro oldlist, as we use it only
-     to check for EQ.  ++kfs  */
-
-  /* In a writable buffer, enable undoing read-only text that is so
-     because of text properties.  */
-  if (NILP (BVAR (current_buffer, read_only)))
-    specbind (Qinhibit_read_only, Qt);
-
-  /* Don't let `intangible' properties interfere with undo.  */
-  specbind (Qinhibit_point_motion_hooks, Qt);
-
-  oldlist = BVAR (current_buffer, undo_list);
-
-  while (arg > 0)
-    {
-      while (CONSP (list))
-        {
-          next = XCAR (list);
-          list = XCDR (list);
-          /* Exit inner loop at undo boundary.  */
-          if (NILP (next))
-            break;
-          /* Handle an integer by setting point to that value.  */
-          if (INTEGERP (next))
-            SET_PT (clip_to_bounds (BEGV, XINT (next), ZV));
-          else if (CONSP (next))
-            {
-              Lisp_Object car, cdr;
-
-              car = XCAR (next);
-              cdr = XCDR (next);
-              if (EQ (car, Qt))
-                {
-                  /* Element (t . TIME) records previous modtime.
-                     Preserve any flag of NONEXISTENT_MODTIME_NSECS or
-                     UNKNOWN_MODTIME_NSECS.  */
-                  struct buffer *base_buffer = current_buffer;
-                  EMACS_TIME mod_time;
-
-                  if (CONSP (cdr)
-                      && CONSP (XCDR (cdr))
-                      && CONSP (XCDR (XCDR (cdr)))
-                      && CONSP (XCDR (XCDR (XCDR (cdr))))
-                      && INTEGERP (XCAR (XCDR (XCDR (XCDR (cdr)))))
-                      && XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) < 0)
-                    mod_time =
-                      (make_emacs_time
-                       (0, XINT (XCAR (XCDR (XCDR (XCDR (cdr))))) / 1000));
-                  else
-                    mod_time = lisp_time_argument (cdr);
-
-                  if (current_buffer->base_buffer)
-                    base_buffer = current_buffer->base_buffer;
-
-                  /* If this records an obsolete save
-                     (not matching the actual disk file)
-                     then don't mark unmodified.  */
-                  if (EMACS_TIME_NE (mod_time, base_buffer->modtime))
-                    continue;
-#ifdef CLASH_DETECTION
-                  Funlock_buffer ();
-#endif /* CLASH_DETECTION */
-                  Fset_buffer_modified_p (Qnil);
-                }
-              else if (EQ (car, Qnil))
-                {
-                  /* Element (nil PROP VAL BEG . END) is property change.  */
-                  Lisp_Object beg, end, prop, val;
-
-                  prop = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  val = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  beg = Fcar (cdr);
-                  end = Fcdr (cdr);
-
-                  if (XINT (beg) < BEGV || XINT (end) > ZV)
-                    user_error ("Changes to be undone are outside visible portion of buffer");
-                  Fput_text_property (beg, end, prop, val, Qnil);
-                }
-              else if (INTEGERP (car) && INTEGERP (cdr))
-                {
-                  /* Element (BEG . END) means range was inserted.  */
-
-                  if (XINT (car) < BEGV
-                      || XINT (cdr) > ZV)
-                    user_error ("Changes to be undone are outside visible portion of buffer");
-                  /* Set point first thing, so that undoing this undo
-                     does not send point back to where it is now.  */
-                  Fgoto_char (car);
-                  Fdelete_region (car, cdr);
-                }
-              else if (EQ (car, Qapply))
-                {
-                  /* Element (apply FUN . ARGS) means call FUN to undo.  */
-                  struct buffer *save_buffer = current_buffer;
-
-                  car = Fcar (cdr);
-                  cdr = Fcdr (cdr);
-                  if (INTEGERP (car))
-                    {
-                      /* Long format: (apply DELTA START END FUN . ARGS).  */
-                      Lisp_Object delta = car;
-                      Lisp_Object start = Fcar (cdr);
-                      Lisp_Object end   = Fcar (Fcdr (cdr));
-                      Lisp_Object start_mark = Fcopy_marker (start, Qnil);
-                      Lisp_Object end_mark   = Fcopy_marker (end, Qt);
-
-                      cdr = Fcdr (Fcdr (cdr));
-                      apply1 (Fcar (cdr), Fcdr (cdr));
-
-                      /* Check that the function did what the entry said it
-                         would do.  */
-                      if (!EQ (start, Fmarker_position (start_mark))
-                          || (XINT (delta) + XINT (end)
-                              != marker_position (end_mark)))
-                        error ("Changes to be undone by function different than announced");
-                      Fset_marker (start_mark, Qnil, Qnil);
-                      Fset_marker (end_mark, Qnil, Qnil);
-                    }
-                  else
-                    apply1 (car, cdr);
-
-                  if (save_buffer != current_buffer)
-                    error ("Undo function switched buffer");
-                  did_apply = 1;
-                }
-              else if (STRINGP (car) && INTEGERP (cdr))
-                {
-                  /* Element (STRING . POS) means STRING was deleted.  */
-                  Lisp_Object membuf;
-                  EMACS_INT pos = XINT (cdr);
-
-                  membuf = car;
-                  if (pos < 0)
-                    {
-                      if (-pos < BEGV || -pos > ZV)
-                        user_error ("Changes to be undone are outside visible portion of buffer");
-                      SET_PT (-pos);
-                      Finsert (1, &membuf);
-                    }
-                  else
-                    {
-                      if (pos < BEGV || pos > ZV)
-                        user_error ("Changes to be undone are outside visible portion of buffer");
-                      SET_PT (pos);
-
-                      /* Now that we record marker adjustments
-                         (caused by deletion) for undo,
-                         we should always insert after markers,
-                         so that undoing the marker adjustments
-                         put the markers back in the right place.  */
-                      Finsert (1, &membuf);
-                      SET_PT (pos);
-                    }
-                }
-              else if (MARKERP (car) && INTEGERP (cdr))
-                {
-                  /* (MARKER . INTEGER) means a marker MARKER
-                     was adjusted by INTEGER.  */
-                  if (XMARKER (car)->buffer)
-                    Fset_marker (car,
-                                 make_number (marker_position (car) - XINT (cdr)),
-                                 Fmarker_buffer (car));
-                }
-            }
-        }
-      arg--;
-    }
-
-
-  /* Make sure an apply entry produces at least one undo entry,
-     so the test in `undo' for continuing an undo series
-     will work right.  */
-  if (did_apply
-      && EQ (oldlist, BVAR (current_buffer, undo_list)))
-    bset_undo_list
-      (current_buffer,
-       Fcons (list3 (Qapply, Qcdr, Qnil), BVAR (current_buffer, undo_list)));
-
-  UNGCPRO;
-  return unbind_to (count, list);
-}
-
 void
 syms_of_undo (void)
 {
@@ -674,7 +464,6 @@ syms_of_undo (void)
   last_undo_buffer = NULL;
   last_boundary_buffer = NULL;
 
-  defsubr (&Sprimitive_undo);
   defsubr (&Sundo_boundary);
 
   DEFVAR_INT ("undo-limit", undo_limit,
diff --git a/src/unexaix.c b/src/unexaix.c
index c01a22a79f6..da44480fdca 100644
--- a/src/unexaix.c
+++ b/src/unexaix.c
@@ -1,5 +1,6 @@
 /* Dump an executable image.
-   Copyright (C) 1985-1988, 1999, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1985-1988, 1999, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -50,6 +51,8 @@ what you give them.   Help stamp out software-hoarding!  */
 #include "getpagesize.h"
 
 #include <sys/types.h>
+#include <inttypes.h>
+#include <stdarg.h>
 #include <stdio.h>
 #include <sys/stat.h>
 #include <errno.h>
@@ -58,10 +61,8 @@ what you give them.   Help stamp out software-hoarding!  */
 
 #include "mem-limits.h"
 
-char *start_of_text (void);                     /* Start of text */
-
-extern int _data;
-extern int _text;
+extern char _data[];
+extern char _text[];
 
 #include <filehdr.h>
 #include <aouthdr.h>
@@ -70,15 +71,15 @@ extern int _text;
 
 static struct filehdr f_hdr;            /* File header */
 static struct aouthdr f_ohdr;           /* Optional file header (a.out) */
-static long bias;                       /* Bias to add for growth */
-static long lnnoptr;                    /* Pointer to line-number info within file */
+static off_t bias;                      /* Bias to add for growth */
+static off_t lnnoptr;                   /* Pointer to line-number info within file */
 
-static long text_scnptr;
-static long data_scnptr;
+static off_t text_scnptr;
+static off_t data_scnptr;
 #define ALIGN(val, pwr) (((val) + ((1L<<(pwr))-1)) & ~((1L<<(pwr))-1))
-static long load_scnptr;
-static long orig_load_scnptr;
-static long orig_data_scnptr;
+static off_t load_scnptr;
+static off_t orig_load_scnptr;
+static off_t orig_data_scnptr;
 static int unrelocate_symbols (int, int, const char *, const char *);
 
 #ifndef MAX_SECTIONS
@@ -91,23 +92,30 @@ static int pagemask;
 
 #include "lisp.h"
 
-static void
+static _Noreturn void
 report_error (const char *file, int fd)
 {
   if (fd)
-    close (fd);
+    {
+      int failed_errno = errno;
+      close (fd);
+      errno = failed_errno;
+    }
   report_file_error ("Cannot unexec", Fcons (build_string (file), Qnil));
 }
 
-#define ERROR0(msg) report_error_1 (new, msg, 0, 0); return -1
-#define ERROR1(msg,x) report_error_1 (new, msg, x, 0); return -1
-#define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
+#define ERROR0(msg) report_error_1 (new, msg)
+#define ERROR1(msg,x) report_error_1 (new, msg, x)
+#define ERROR2(msg,x,y) report_error_1 (new, msg, x, y)
 
-static void
-report_error_1 (int fd, const char *msg, int a1, int a2)
+static _Noreturn void ATTRIBUTE_FORMAT_PRINTF (2, 3)
+report_error_1 (int fd, const char *msg, ...)
 {
+  va_list ap;
   close (fd);
-  error (msg, a1, a2);
+  va_start (ap, msg);
+  verror (msg, ap);
+  va_end (ap);
 }
 
 static int make_hdr (int, int, const char *, const char *);
@@ -162,8 +170,8 @@ make_hdr (int new, int a_out,
           const char *a_name, const char *new_name)
 {
   int scns;
-  unsigned int bss_start;
-  unsigned int data_start;
+  uintptr_t bss_start;
+  uintptr_t data_start;
 
   struct scnhdr section[MAX_SECTIONS];
   struct scnhdr * f_thdr;               /* Text section header */
@@ -178,17 +186,17 @@ make_hdr (int new, int a_out,
   pagemask = getpagesize () - 1;
 
   /* Adjust text/data boundary. */
-  data_start = (long) start_of_data ();
-  data_start = ADDR_CORRECT (data_start);
+  data_start = (uintptr_t) _data;
 
   data_start = data_start & ~pagemask; /* (Down) to page boundary. */
 
-  bss_start = ADDR_CORRECT (sbrk (0)) + pagemask;
+  bss_start = (uintptr_t) sbrk (0) + pagemask;
   bss_start &= ~ pagemask;
 
   if (data_start > bss_start)   /* Can't have negative data size. */
     {
-      ERROR2 ("unexec: data_start (%u) can't be greater than bss_start (%u)",
+      ERROR2 (("unexec: data_start (0x%"PRIxPTR
+               ") can't be greater than bss_start (0x%"PRIxPTR")"),
               data_start, bss_start);
     }
 
@@ -278,7 +286,7 @@ make_hdr (int new, int a_out,
 
   /* fix scnptr's */
   {
-    ulong ptr = section[0].s_scnptr;
+    off_t ptr = section[0].s_scnptr;
 
     bias = -1;
     for (scns = 0; scns < f_hdr.f_nscns; scns++)
@@ -374,12 +382,12 @@ copy_text_and_data (int new)
   char *end;
   char *ptr;
 
-  lseek (new, (long) text_scnptr, SEEK_SET);
-  ptr = start_of_text () + text_scnptr;
+  lseek (new, text_scnptr, SEEK_SET);
+  ptr = _text + text_scnptr;
   end = ptr + f_ohdr.tsize;
   write_segment (new, ptr, end);
 
-  lseek (new, (long) data_scnptr, SEEK_SET);
+  lseek (new, data_scnptr, SEEK_SET);
   ptr = (char *) f_ohdr.data_start;
   end = ptr + f_ohdr.dsize;
   write_segment (new, ptr, end);
@@ -392,7 +400,6 @@ static void
 write_segment (int new, char *ptr, char *end)
 {
   int i, nwrite, ret;
-  char buf[80];
   char zeros[UnexBlockSz];
 
   for (i = 0; ptr < end;)
@@ -413,9 +420,13 @@ write_segment (int new, char *ptr, char *end)
         }
       else if (nwrite != ret)
         {
+          int write_errno = errno;
+          char buf[1000];
+          void *addr = ptr;
           sprintf (buf,
-                   "unexec write failure: addr 0x%lx, fileno %d, size 0x%x, wrote 0x%x, errno %d",
-                   (unsigned long)ptr, new, nwrite, ret, errno);
+                   "unexec write failure: addr %p, fileno %d, size 0x%x, wrote 0x%x, errno %d",
+                   addr, new, nwrite, ret, errno);
+          errno = write_errno;
           PERROR (buf);
         }
       i += nwrite;
@@ -536,13 +547,13 @@ unrelocate_symbols (int new, int a_out,
   int i;
   LDHDR ldhdr;
   LDREL ldrel;
-  ulong t_reloc = (ulong) &_text - f_ohdr.text_start;
+  off_t t_reloc = (intptr_t) _text - f_ohdr.text_start;
 #ifndef ALIGN_DATA_RELOC
-  ulong d_reloc = (ulong) &_data - f_ohdr.data_start;
+  off_t d_reloc = (intptr_t) _data - f_ohdr.data_start;
 #else
   /* This worked (and was needed) before AIX 4.2.
      I have no idea why. -- Mike */
-  ulong d_reloc = (ulong) &_data - ALIGN (f_ohdr.data_start, 2);
+  off_t d_reloc = (intptr_t) _data - ALIGN (f_ohdr.data_start, 2);
 #endif
   int * p;
 
@@ -627,16 +638,3 @@ unrelocate_symbols (int new, int a_out,
     }
   return 0;
 }
-
-/*
- *      Return the address of the start of the text segment prior to
- *      doing an unexec.  After unexec the return value is undefined.
- *      See crt0.c for further explanation and _start.
- *
- */
-
-char *
-start_of_text (void)
-{
-  return ((char *) 0x10000000);
-}
diff --git a/src/unexcoff.c b/src/unexcoff.c
index 6e29951a962..466a5c0e491 100644
--- a/src/unexcoff.c
+++ b/src/unexcoff.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 1985-1988, 1992-1994, 2001-2012  Free Software Foundation, Inc.
+/* Copyright (C) 1985-1988, 1992-1994, 2001-2013 Free Software
+ * Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/unexcw.c b/src/unexcw.c
index 8c5d574530d..af93e158e14 100644
--- a/src/unexcw.c
+++ b/src/unexcw.c
@@ -1,7 +1,7 @@
 /* unexec() support for Cygwin;
    complete rewrite of xemacs Cygwin unexec() code
 
-   Copyright (C) 2004-2012 Free Software Foundation, Inc.
+   Copyright (C) 2004-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -183,6 +183,19 @@ fixup_executable (int fd)
                 exe_header->file_optional_header.FileAlignment *
                 exe_header->file_optional_header.FileAlignment;
 
+              /* Make sure the generated bootstrap binary isn't
+               * sparse.  NT doesn't use a file cache for sparse
+               * executables, so if we bootstrap Emacs using a sparse
+               * bootstrap-emacs.exe, bootstrap takes about twenty
+               * times longer than it would otherwise.  */
+
+              ret = posix_fallocate (fd,
+                                     ( exe_header->section_header[i].s_scnptr +
+                                       exe_header->section_header[i].s_size ),
+                                     1);
+
+              assert (ret != -1);
+
               ret =
                 lseek (fd,
                        (long) (exe_header->section_header[i].s_scnptr +
diff --git a/src/unexelf.c b/src/unexelf.c
index b9f8e05e959..d3659404f9c 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -1,5 +1,5 @@
-/* Copyright (C) 1985-1988, 1990, 1992, 1999-2012
-                 Free Software Foundation, Inc.
+/* Copyright (C) 1985-1988, 1990, 1992, 1999-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/unexmacosx.c b/src/unexmacosx.c
index d304e85d490..8d4e636fa5c 100644
--- a/src/unexmacosx.c
+++ b/src/unexmacosx.c
@@ -1,5 +1,5 @@
 /* Dump Emacs in Mach-O format for use on Mac OS X.
-   Copyright (C) 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/unexw32.c b/src/unexw32.c
index 1e591a78b73..e8b553a87d3 100644
--- a/src/unexw32.c
+++ b/src/unexw32.c
@@ -1,5 +1,5 @@
 /* unexec for GNU Emacs on Windows NT.
-   Copyright (C) 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -85,13 +85,6 @@ DWORD_PTR  extra_bss_size_static = 0;
 
 PIMAGE_SECTION_HEADER heap_section;
 
-#ifdef HAVE_NTGUI
-extern HINSTANCE hinst;
-HINSTANCE hprevinst = NULL;
-LPSTR lpCmdLine = "";
-int nCmdShow = 0;
-#endif /* HAVE_NTGUI */
-
 /* Startup code for running on NT.  When we are running as the dumped
    version, we need to bootstrap our heap and .bss section into our
    address space before we can actually hand off control to the startup
@@ -121,15 +114,6 @@ _start (void)
   /* Prevent Emacs from being locked up (eg. in batch mode) when
      accessing devices that aren't mounted (eg. removable media drives).  */
   SetErrorMode (SEM_FAILCRITICALERRORS);
-
-  /* Invoke the NT CRT startup routine now that our housecleaning
-     is finished.  */
-#ifdef HAVE_NTGUI
-  /* determine WinMain args like crt0.c does */
-  hinst = GetModuleHandle (NULL);
-  lpCmdLine = GetCommandLine ();
-  nCmdShow = SW_SHOWDEFAULT;
-#endif
   mainCRTStartup ();
 }
 
@@ -738,7 +722,7 @@ unexec (const char *new_name, const char *old_name)
   /* Ignore old_name, and get our actual location from the OS.  */
   if (!GetModuleFileName (NULL, in_filename, MAX_PATH))
     abort ();
-  dostounix_filename (in_filename);
+  dostounix_filename (in_filename, 0);
   strcpy (out_filename, in_filename);
 
   /* Change the base of the output filename to match the requested name.  */
diff --git a/src/vm-limit.c b/src/vm-limit.c
index befc01d400f..9dbb1b884b7 100644
--- a/src/vm-limit.c
+++ b/src/vm-limit.c
@@ -1,5 +1,5 @@
 /* Functions for memory limit warnings.
-   Copyright (C) 1990, 1992, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1990, 1992, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w16select.c b/src/w16select.c
index b8aaa3619ba..3bcc663e565 100644
--- a/src/w16select.c
+++ b/src/w16select.c
@@ -1,6 +1,6 @@
 /* 16-bit Windows Selection processing for emacs on MS-Windows
 
-Copyright (C) 1996-1997, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1996-1997, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -532,13 +532,13 @@ DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_dat
       switch (put_status)
         {
           case 1:
-            message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
+            message3 (make_unibyte_string (no_mem_msg, sizeof (no_mem_msg) - 1));
             break;
           case 2:
-            message2 (binary_msg, sizeof (binary_msg) - 1, 0);
+            message3 (make_unibyte_string (binary_msg, sizeof (binary_msg) - 1));
             break;
           case 3:
-            message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
+            message3 (make_unibyte_string (system_error_msg, sizeof (system_error_msg) - 1));
             break;
         }
       sit_for (make_number (2), 0, 2);
diff --git a/src/w32.c b/src/w32.c
index b6bb653369d..ed86b1238ae 100644
--- a/src/w32.c
+++ b/src/w32.c
@@ -1,5 +1,5 @@
 /* Utility and Unix shadow routines for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1994-1995, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1994-1995, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -37,7 +37,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* must include CRT headers *before* config.h */
 
 #include <config.h>
-#include <mbstring.h>   /* for _mbspbrk */
+#include <mbstring.h>   /* for _mbspbrk, _mbslwr, _mbsrchr, ... */
 
 #undef access
 #undef chdir
@@ -101,22 +101,31 @@ typedef struct _MEMORY_STATUS_EX {
    _WIN32_WINNT than what we use.  w32api supplied with MinGW 3.15
    defines it in psapi.h  */
 typedef struct _PROCESS_MEMORY_COUNTERS_EX {
-  DWORD cb;
-  DWORD PageFaultCount;
-  DWORD PeakWorkingSetSize;
-  DWORD WorkingSetSize;
-  DWORD QuotaPeakPagedPoolUsage;
-  DWORD QuotaPagedPoolUsage;
-  DWORD QuotaPeakNonPagedPoolUsage;
-  DWORD QuotaNonPagedPoolUsage;
-  DWORD PagefileUsage;
-  DWORD PeakPagefileUsage;
-  DWORD PrivateUsage;
+  DWORD  cb;
+  DWORD  PageFaultCount;
+  SIZE_T PeakWorkingSetSize;
+  SIZE_T WorkingSetSize;
+  SIZE_T QuotaPeakPagedPoolUsage;
+  SIZE_T QuotaPagedPoolUsage;
+  SIZE_T QuotaPeakNonPagedPoolUsage;
+  SIZE_T QuotaNonPagedPoolUsage;
+  SIZE_T PagefileUsage;
+  SIZE_T PeakPagefileUsage;
+  SIZE_T PrivateUsage;
 } PROCESS_MEMORY_COUNTERS_EX,*PPROCESS_MEMORY_COUNTERS_EX;
 #endif
 
 #include <winioctl.h>
 #include <aclapi.h>
+#include <sddl.h>
+
+#include <sys/acl.h>
+
+/* This is not in MinGW's sddl.h (but they are in MSVC headers), so we
+   define them by hand if not already defined.  */
+#ifndef SDDL_REVISION_1
+#define SDDL_REVISION_1 1
+#endif  /* SDDL_REVISION_1 */
 
 #ifdef _MSC_VER
 /* MSVC doesn't provide the definition of REPARSE_DATA_BUFFER and the
@@ -257,6 +266,11 @@ static BOOL g_b_init_copy_sid;
 static BOOL g_b_init_get_native_system_info;
 static BOOL g_b_init_get_system_times;
 static BOOL g_b_init_create_symbolic_link;
+static BOOL g_b_init_get_security_descriptor_dacl;
+static BOOL g_b_init_convert_sd_to_sddl;
+static BOOL g_b_init_convert_sddl_to_sd;
+static BOOL g_b_init_is_valid_security_descriptor;
+static BOOL g_b_init_set_file_security;
 
 /*
   BEGIN: Wrapper functions around OpenProcessToken
@@ -286,9 +300,11 @@ GetProcessTimes_Proc get_process_times_fn = NULL;
 #ifdef _UNICODE
 const char * const LookupAccountSid_Name = "LookupAccountSidW";
 const char * const GetFileSecurity_Name =  "GetFileSecurityW";
+const char * const SetFileSecurity_Name =  "SetFileSecurityW";
 #else
 const char * const LookupAccountSid_Name = "LookupAccountSidA";
 const char * const GetFileSecurity_Name =  "GetFileSecurityA";
+const char * const SetFileSecurity_Name =  "SetFileSecurityA";
 #endif
 typedef BOOL (WINAPI * LookupAccountSid_Proc) (
     LPCTSTR lpSystemName,
@@ -318,6 +334,10 @@ typedef BOOL (WINAPI * GetFileSecurity_Proc) (
     PSECURITY_DESCRIPTOR pSecurityDescriptor,
     DWORD nLength,
     LPDWORD lpnLengthNeeded);
+typedef BOOL (WINAPI *SetFileSecurity_Proc) (
+    LPCTSTR lpFileName,
+    SECURITY_INFORMATION SecurityInformation,
+    PSECURITY_DESCRIPTOR pSecurityDescriptor);
 typedef BOOL (WINAPI * GetSecurityDescriptorOwner_Proc) (
     PSECURITY_DESCRIPTOR pSecurityDescriptor,
     PSID *pOwner,
@@ -326,6 +346,11 @@ typedef BOOL (WINAPI * GetSecurityDescriptorGroup_Proc) (
     PSECURITY_DESCRIPTOR pSecurityDescriptor,
     PSID *pGroup,
     LPBOOL lpbGroupDefaulted);
+typedef BOOL (WINAPI *GetSecurityDescriptorDacl_Proc) (
+    PSECURITY_DESCRIPTOR pSecurityDescriptor,
+    LPBOOL lpbDaclPresent,
+    PACL *pDacl,
+    LPBOOL lpbDaclDefaulted);
 typedef BOOL (WINAPI * IsValidSid_Proc) (
     PSID sid);
 typedef HANDLE (WINAPI * CreateToolhelp32Snapshot_Proc) (
@@ -351,8 +376,8 @@ typedef BOOL (WINAPI * GetProcessMemoryInfo_Proc) (
     DWORD cb);
 typedef BOOL (WINAPI * GetProcessWorkingSetSize_Proc) (
     HANDLE hProcess,
-    DWORD * lpMinimumWorkingSetSize,
-    DWORD * lpMaximumWorkingSetSize);
+    PSIZE_T lpMinimumWorkingSetSize,
+    PSIZE_T lpMaximumWorkingSetSize);
 typedef BOOL (WINAPI * GlobalMemoryStatus_Proc) (
     LPMEMORYSTATUS lpBuffer);
 typedef BOOL (WINAPI * GlobalMemoryStatusEx_Proc) (
@@ -376,6 +401,18 @@ typedef BOOLEAN (WINAPI *CreateSymbolicLink_Proc) (
     LPTSTR lpSymlinkFileName,
     LPTSTR lpTargetFileName,
     DWORD  dwFlags);
+typedef BOOL (WINAPI *ConvertStringSecurityDescriptorToSecurityDescriptor_Proc) (
+    LPCTSTR StringSecurityDescriptor,
+    DWORD StringSDRevision,
+    PSECURITY_DESCRIPTOR  *SecurityDescriptor,
+    PULONG  SecurityDescriptorSize);
+typedef BOOL (WINAPI *ConvertSecurityDescriptorToStringSecurityDescriptor_Proc) (
+    PSECURITY_DESCRIPTOR  SecurityDescriptor,
+    DWORD RequestedStringSDRevision,
+    SECURITY_INFORMATION SecurityInformation,
+    LPTSTR  *StringSecurityDescriptor,
+    PULONG StringSecurityDescriptorLen);
+typedef BOOL (WINAPI *IsValidSecurityDescriptor_Proc) (PSECURITY_DESCRIPTOR);
 
   /* ** A utility function ** */
 static BOOL
@@ -621,6 +658,7 @@ get_file_security (LPCTSTR lpFileName,
   HMODULE hm_advapi32 = NULL;
   if (is_windows_9x () == TRUE)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   if (g_b_init_get_file_security == 0)
@@ -633,6 +671,7 @@ get_file_security (LPCTSTR lpFileName,
     }
   if (s_pfn_Get_File_Security == NULL)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   return (s_pfn_Get_File_Security (lpFileName, RequestedInformation,
@@ -641,6 +680,35 @@ get_file_security (LPCTSTR lpFileName,
 }
 
 static BOOL WINAPI
+set_file_security (LPCTSTR lpFileName,
+                   SECURITY_INFORMATION SecurityInformation,
+                   PSECURITY_DESCRIPTOR pSecurityDescriptor)
+{
+  static SetFileSecurity_Proc s_pfn_Set_File_Security = NULL;
+  HMODULE hm_advapi32 = NULL;
+  if (is_windows_9x () == TRUE)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+  if (g_b_init_set_file_security == 0)
+    {
+      g_b_init_set_file_security = 1;
+      hm_advapi32 = LoadLibrary ("Advapi32.dll");
+      s_pfn_Set_File_Security =
+        (SetFileSecurity_Proc) GetProcAddress (
+            hm_advapi32, SetFileSecurity_Name);
+    }
+  if (s_pfn_Set_File_Security == NULL)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+  return (s_pfn_Set_File_Security (lpFileName, SecurityInformation,
+                                   pSecurityDescriptor));
+}
+
+static BOOL WINAPI
 get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
                                PSID *pOwner,
                                LPBOOL lpbOwnerDefaulted)
@@ -649,6 +717,7 @@ get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
   HMODULE hm_advapi32 = NULL;
   if (is_windows_9x () == TRUE)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   if (g_b_init_get_security_descriptor_owner == 0)
@@ -661,6 +730,7 @@ get_security_descriptor_owner (PSECURITY_DESCRIPTOR pSecurityDescriptor,
     }
   if (s_pfn_Get_Security_Descriptor_Owner == NULL)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   return (s_pfn_Get_Security_Descriptor_Owner (pSecurityDescriptor, pOwner,
@@ -676,6 +746,7 @@ get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
   HMODULE hm_advapi32 = NULL;
   if (is_windows_9x () == TRUE)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   if (g_b_init_get_security_descriptor_group == 0)
@@ -688,6 +759,7 @@ get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
     }
   if (s_pfn_Get_Security_Descriptor_Group == NULL)
     {
+      errno = ENOTSUP;
       return FALSE;
     }
   return (s_pfn_Get_Security_Descriptor_Group (pSecurityDescriptor, pGroup,
@@ -695,6 +767,37 @@ get_security_descriptor_group (PSECURITY_DESCRIPTOR pSecurityDescriptor,
 }
 
 static BOOL WINAPI
+get_security_descriptor_dacl (PSECURITY_DESCRIPTOR pSecurityDescriptor,
+                              LPBOOL lpbDaclPresent,
+                              PACL *pDacl,
+                              LPBOOL lpbDaclDefaulted)
+{
+  static GetSecurityDescriptorDacl_Proc s_pfn_Get_Security_Descriptor_Dacl = NULL;
+  HMODULE hm_advapi32 = NULL;
+  if (is_windows_9x () == TRUE)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+  if (g_b_init_get_security_descriptor_dacl == 0)
+    {
+      g_b_init_get_security_descriptor_dacl = 1;
+      hm_advapi32 = LoadLibrary ("Advapi32.dll");
+      s_pfn_Get_Security_Descriptor_Dacl =
+        (GetSecurityDescriptorDacl_Proc) GetProcAddress (
+            hm_advapi32, "GetSecurityDescriptorDacl");
+    }
+  if (s_pfn_Get_Security_Descriptor_Dacl == NULL)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+  return (s_pfn_Get_Security_Descriptor_Dacl (pSecurityDescriptor,
+                                              lpbDaclPresent, pDacl,
+                                              lpbDaclDefaulted));
+}
+
+static BOOL WINAPI
 is_valid_sid (PSID sid)
 {
   static IsValidSid_Proc s_pfn_Is_Valid_Sid = NULL;
@@ -888,6 +991,120 @@ create_symbolic_link (LPTSTR lpSymlinkFilename,
     }
   return retval;
 }
+
+static BOOL WINAPI
+is_valid_security_descriptor (PSECURITY_DESCRIPTOR pSecurityDescriptor)
+{
+  static IsValidSecurityDescriptor_Proc s_pfn_Is_Valid_Security_Descriptor_Proc = NULL;
+
+  if (is_windows_9x () == TRUE)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  if (g_b_init_is_valid_security_descriptor == 0)
+    {
+      g_b_init_is_valid_security_descriptor = 1;
+      s_pfn_Is_Valid_Security_Descriptor_Proc =
+        (IsValidSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
+                                                        "IsValidSecurityDescriptor");
+    }
+  if (s_pfn_Is_Valid_Security_Descriptor_Proc == NULL)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  return s_pfn_Is_Valid_Security_Descriptor_Proc (pSecurityDescriptor);
+}
+
+static BOOL WINAPI
+convert_sd_to_sddl (PSECURITY_DESCRIPTOR SecurityDescriptor,
+                    DWORD RequestedStringSDRevision,
+                    SECURITY_INFORMATION SecurityInformation,
+                    LPTSTR  *StringSecurityDescriptor,
+                    PULONG StringSecurityDescriptorLen)
+{
+  static ConvertSecurityDescriptorToStringSecurityDescriptor_Proc s_pfn_Convert_SD_To_SDDL = NULL;
+  BOOL retval;
+
+  if (is_windows_9x () == TRUE)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  if (g_b_init_convert_sd_to_sddl == 0)
+    {
+      g_b_init_convert_sd_to_sddl = 1;
+#ifdef _UNICODE
+      s_pfn_Convert_SD_To_SDDL =
+        (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
+                                                                                  "ConvertSecurityDescriptorToStringSecurityDescriptorW");
+#else
+      s_pfn_Convert_SD_To_SDDL =
+        (ConvertSecurityDescriptorToStringSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
+                                                                                  "ConvertSecurityDescriptorToStringSecurityDescriptorA");
+#endif
+    }
+  if (s_pfn_Convert_SD_To_SDDL == NULL)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  retval = s_pfn_Convert_SD_To_SDDL (SecurityDescriptor,
+                                     RequestedStringSDRevision,
+                                     SecurityInformation,
+                                     StringSecurityDescriptor,
+                                     StringSecurityDescriptorLen);
+
+  return retval;
+}
+
+static BOOL WINAPI
+convert_sddl_to_sd (LPCTSTR StringSecurityDescriptor,
+                    DWORD StringSDRevision,
+                    PSECURITY_DESCRIPTOR  *SecurityDescriptor,
+                    PULONG  SecurityDescriptorSize)
+{
+  static ConvertStringSecurityDescriptorToSecurityDescriptor_Proc s_pfn_Convert_SDDL_To_SD = NULL;
+  BOOL retval;
+
+  if (is_windows_9x () == TRUE)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  if (g_b_init_convert_sddl_to_sd == 0)
+    {
+      g_b_init_convert_sddl_to_sd = 1;
+#ifdef _UNICODE
+      s_pfn_Convert_SDDL_To_SD =
+        (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
+                                                                                  "ConvertStringSecurityDescriptorToSecurityDescriptorW");
+#else
+      s_pfn_Convert_SDDL_To_SD =
+        (ConvertStringSecurityDescriptorToSecurityDescriptor_Proc)GetProcAddress (GetModuleHandle ("Advapi32.dll"),
+                                                                                  "ConvertStringSecurityDescriptorToSecurityDescriptorA");
+#endif
+    }
+  if (s_pfn_Convert_SDDL_To_SD == NULL)
+    {
+      errno = ENOTSUP;
+      return FALSE;
+    }
+
+  retval = s_pfn_Convert_SDDL_To_SD (StringSecurityDescriptor,
+                                     StringSDRevision,
+                                     SecurityDescriptor,
+                                     SecurityDescriptorSize);
+
+  return retval;
+}
+
 
 
 /* Return 1 if P is a valid pointer to an object of size SIZE.  Return
@@ -1314,35 +1531,110 @@ srandom (int seed)
   srand (seed);
 }
 
+/* Current codepage for encoding file names.  */
+static int file_name_codepage;
+
+/* Return the maximum length in bytes of a multibyte character
+   sequence encoded in the current ANSI codepage.  This is required to
+   correctly walk the encoded file names one character at a time.  */
+static int
+max_filename_mbslen (void)
+{
+  /* A simple cache to avoid calling GetCPInfo every time we need to
+     normalize a file name.  The file-name encoding is not supposed to
+     be changed too frequently, if ever.  */
+  static Lisp_Object last_file_name_encoding;
+  static int last_max_mbslen;
+  Lisp_Object current_encoding;
+
+  current_encoding = Vfile_name_coding_system;
+  if (NILP (current_encoding))
+    current_encoding = Vdefault_file_name_coding_system;
+
+  if (!EQ (last_file_name_encoding, current_encoding))
+    {
+      CPINFO cp_info;
+
+      last_file_name_encoding = current_encoding;
+      /* Default to the current ANSI codepage.  */
+      file_name_codepage = w32_ansi_code_page;
+      if (!NILP (current_encoding))
+        {
+          char *cpname = SDATA (SYMBOL_NAME (current_encoding));
+          char *cp = NULL, *end;
+          int cpnum;
+
+          if (strncmp (cpname, "cp", 2) == 0)
+            cp = cpname + 2;
+          else if (strncmp (cpname, "windows-", 8) == 0)
+            cp = cpname + 8;
+
+          if (cp)
+            {
+              end = cp;
+              cpnum = strtol (cp, &end, 10);
+              if (cpnum && *end == '\0' && end - cp >= 2)
+                file_name_codepage = cpnum;
+            }
+        }
+
+      if (!file_name_codepage)
+        file_name_codepage = CP_ACP; /* CP_ACP = 0, but let's not assume that */
+
+      if (!GetCPInfo (file_name_codepage, &cp_info))
+        {
+          file_name_codepage = CP_ACP;
+          if (!GetCPInfo (file_name_codepage, &cp_info))
+            emacs_abort ();
+        }
+      last_max_mbslen = cp_info.MaxCharSize;
+    }
+
+  return last_max_mbslen;
+}
 
 /* Normalize filename by converting all path separators to
    the specified separator.  Also conditionally convert upper
    case path name components to lower case.  */
 
 static void
-normalize_filename (register char *fp, char path_sep)
+normalize_filename (register char *fp, char path_sep, int multibyte)
 {
   char sep;
-  char *elem;
+  char *elem, *p2;
+  int dbcs_p = max_filename_mbslen () > 1;
+
+  /* Multibyte file names are in the Emacs internal representation, so
+     we can traverse them by bytes with no problems.  */
+  if (multibyte)
+    dbcs_p = 0;
 
   /* Always lower-case drive letters a-z, even if the filesystem
      preserves case in filenames.
      This is so filenames can be compared by string comparison
      functions that are case-sensitive.  Even case-preserving filesystems
      do not distinguish case in drive letters.  */
-  if (fp[1] == ':' && *fp >= 'A' && *fp <= 'Z')
+  if (dbcs_p)
+    p2 = CharNextExA (file_name_codepage, fp, 0);
+  else
+    p2 = fp + 1;
+
+  if (*p2 == ':' && *fp >= 'A' && *fp <= 'Z')
     {
       *fp += 'a' - 'A';
       fp += 2;
     }
 
-  if (NILP (Vw32_downcase_file_names))
+  if (multibyte || NILP (Vw32_downcase_file_names))
     {
       while (*fp)
         {
           if (*fp == '/' || *fp == '\\')
             *fp = path_sep;
-          fp++;
+          if (!dbcs_p)
+            fp++;
+          else
+            fp = CharNextExA (file_name_codepage, fp, 0);
         }
       return;
     }
@@ -1365,27 +1657,36 @@ normalize_filename (register char *fp, char path_sep)
         if (elem && elem != fp)
           {
             *fp = 0;            /* temporary end of string */
-            _strlwr (elem);     /* while we convert to lower case */
+            _mbslwr (elem);     /* while we convert to lower case */
           }
         *fp = sep;              /* convert (or restore) path separator */
         elem = fp + 1;          /* next element starts after separator */
         sep = path_sep;
       }
-  } while (*fp++);
+    if (*fp)
+      {
+        if (!dbcs_p)
+          fp++;
+        else
+          fp = CharNextExA (file_name_codepage, fp, 0);
+      }
+  } while (*fp);
 }
 
-/* Destructively turn backslashes into slashes.  */
+/* Destructively turn backslashes into slashes.  MULTIBYTE non-zero
+   means the file name is a multibyte string in Emacs's internal
+   representation.  */
 void
-dostounix_filename (register char *p)
+dostounix_filename (register char *p, int multibyte)
 {
-  normalize_filename (p, '/');
+  normalize_filename (p, '/', multibyte);
 }
 
 /* Destructively turn slashes into backslashes.  */
 void
 unixtodos_filename (register char *p)
 {
-  normalize_filename (p, '\\');
+  normalize_filename (p, '\\', 0);
 }
 
 /* Remove all CR's that are followed by a LF.
@@ -1436,12 +1737,17 @@ parse_root (char * name, char ** pPath)
   else if (IS_DIRECTORY_SEP (name[0]) && IS_DIRECTORY_SEP (name[1]))
     {
       int slashes = 2;
+      int dbcs_p = max_filename_mbslen () > 1;
+
       name += 2;
       do
         {
           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
             break;
-          name++;
+          if (dbcs_p)
+            name = CharNextExA (file_name_codepage, name, 0);
+          else
+            name++;
         }
       while ( *name );
       if (IS_DIRECTORY_SEP (name[0]))
@@ -1506,7 +1812,7 @@ w32_get_long_filename (char * name, char * buf, int size)
   while (p != NULL && *p)
     {
       q = p;
-      p = strchr (q, '\\');
+      p = _mbschr (q, '\\');
       if (p) *p = '\0';
       len = get_long_basename (full, o, size);
       if (len > 0)
@@ -1567,6 +1873,7 @@ unsetenv (const char *name)
   /* It is safe to use 'alloca' with 32K size, since the stack is at
      least 2MB, and we set it to 8MB in the link command line.  */
   var = alloca (name_len + 2);
+  strncpy (var, name, name_len);
   var[name_len++] = '=';
   var[name_len] = '\0';
   return _putenv (var);
@@ -1777,16 +2084,16 @@ init_environment (char ** argv)
 
       if (!GetModuleFileName (NULL, modname, MAX_PATH))
         emacs_abort ();
-      if ((p = strrchr (modname, '\\')) == NULL)
+      if ((p = _mbsrchr (modname, '\\')) == NULL)
         emacs_abort ();
       *p = 0;
 
-      if ((p = strrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
+      if ((p = _mbsrchr (modname, '\\')) && xstrcasecmp (p, "\\bin") == 0)
         {
           char buf[SET_ENV_BUF_SIZE];
 
           *p = 0;
-          for (p = modname; *p; p++)
+          for (p = modname; *p; p = CharNext (p))
             if (*p == '\\') *p = '/';
 
           _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
@@ -1801,17 +2108,17 @@ init_environment (char ** argv)
                      || xstrcasecmp (p, "\\AMD64") == 0))
         {
           *p = 0;
-          p = strrchr (modname, '\\');
+          p = _mbsrchr (modname, '\\');
           if (p != NULL)
             {
               *p = 0;
-              p = strrchr (modname, '\\');
+              p = _mbsrchr (modname, '\\');
               if (p && xstrcasecmp (p, "\\src") == 0)
                 {
                   char buf[SET_ENV_BUF_SIZE];
 
                   *p = 0;
-                  for (p = modname; *p; p++)
+                  for (p = modname; *p; p = CharNext (p))
                     if (*p == '\\') *p = '/';
 
                   _snprintf (buf, sizeof (buf)-1, "emacs_dir=%s", modname);
@@ -1922,7 +2229,7 @@ emacs_root_dir (void)
     emacs_abort ();
   strcpy (root_dir, p);
   root_dir[parse_root (root_dir, NULL)] = '\0';
-  dostounix_filename (root_dir);
+  dostounix_filename (root_dir, 0);
   return root_dir;
 }
 
@@ -2346,12 +2653,23 @@ get_volume_info (const char * name, const char ** pPath)
     {
       char *str = temp;
       int slashes = 4;
+      int dbcs_p = max_filename_mbslen () > 1;
+
       rootname = temp;
       do
         {
           if (IS_DIRECTORY_SEP (*name) && --slashes == 0)
             break;
-          *str++ = *name++;
+          if (!dbcs_p)
+            *str++ = *name++;
+          else
+            {
+              const char *p = name;
+
+              name = CharNextExA (file_name_codepage, name, 0);
+              memcpy (str, p, name - p);
+              str += name - p;
+            }
         }
       while ( *name );
 
@@ -2514,7 +2832,7 @@ static char  *read_unc_volume (HANDLE, char *, int);
 static void   close_unc_volume (HANDLE);
 
 DIR *
-opendir (char *filename)
+opendir (const char *filename)
 {
   DIR *dirp;
 
@@ -2587,11 +2905,23 @@ readdir (DIR *dirp)
     {
       char filename[MAXNAMLEN + 3];
       int ln;
+      int dbcs_p = max_filename_mbslen () > 1;
 
       strcpy (filename, dir_pathname);
       ln = strlen (filename) - 1;
-      if (!IS_DIRECTORY_SEP (filename[ln]))
-        strcat (filename, "\\");
+      if (!dbcs_p)
+        {
+          if (!IS_DIRECTORY_SEP (filename[ln]))
+            strcat (filename, "\\");
+        }
+      else
+        {
+          char *end = filename + ln + 1;
+          char *last_char = CharPrevExA (file_name_codepage, filename, end, 0);
+
+          if (!IS_DIRECTORY_SEP (*last_char))
+            strcat (filename, "\\");
+        }
       strcat (filename, "*");
 
       /* Note: No need to resolve symlinks in FILENAME, because
@@ -2642,15 +2972,22 @@ readdir (DIR *dirp)
     strcpy (dir_static.d_name, dir_find_data.cFileName);
   dir_static.d_namlen = strlen (dir_static.d_name);
   if (dir_is_fat)
-    _strlwr (dir_static.d_name);
+    _mbslwr (dir_static.d_name);
   else if (downcase)
     {
       register char *p;
-      for (p = dir_static.d_name; *p; p++)
-        if (*p >= 'a' && *p <= 'z')
-          break;
+      int dbcs_p = max_filename_mbslen () > 1;
+      for (p = dir_static.d_name; *p; )
+        {
+          if (*p >= 'a' && *p <= 'z')
+            break;
+          if (dbcs_p)
+            p = CharNextExA (file_name_codepage, p, 0);
+          else
+            p++;
+        }
       if (!*p)
-        _strlwr (dir_static.d_name);
+        _mbslwr (dir_static.d_name);
     }
 
   return &dir_static;
@@ -2689,6 +3026,7 @@ read_unc_volume (HANDLE henum, char *readbuf, int size)
   DWORD bufsize = 512;
   char *buffer;
   char *ptr;
+  int dbcs_p = max_filename_mbslen () > 1;
 
   count = 1;
   buffer = alloca (bufsize);
@@ -2699,7 +3037,13 @@ read_unc_volume (HANDLE henum, char *readbuf, int size)
   /* WNetEnumResource returns \\resource\share...skip forward to "share". */
   ptr = ((LPNETRESOURCE) buffer)->lpRemoteName;
   ptr += 2;
-  while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
+  if (!dbcs_p)
+    while (*ptr && !IS_DIRECTORY_SEP (*ptr)) ptr++;
+  else
+    {
+      while (*ptr && !IS_DIRECTORY_SEP (*ptr))
+        ptr = CharNextExA (file_name_codepage, ptr, 0);
+    }
   ptr++;
 
   strncpy (readbuf, ptr, size);
@@ -2736,9 +3080,11 @@ logon_network_drive (const char *path)
 {
   NETRESOURCE resource;
   char share[MAX_PATH];
-  int i, n_slashes;
+  int n_slashes;
   char drive[4];
   UINT drvtype;
+  char *p;
+  int dbcs_p;
 
   if (IS_DIRECTORY_SEP (path[0]) && IS_DIRECTORY_SEP (path[1]))
     drvtype = DRIVE_REMOTE;
@@ -2760,13 +3106,18 @@ logon_network_drive (const char *path)
   n_slashes = 2;
   strncpy (share, path, MAX_PATH);
   /* Truncate to just server and share name.  */
-  for (i = 2; i < MAX_PATH; i++)
+  dbcs_p = max_filename_mbslen () > 1;
+  for (p = share + 2; *p && p < share + MAX_PATH; )
     {
-      if (IS_DIRECTORY_SEP (share[i]) && ++n_slashes > 3)
+      if (IS_DIRECTORY_SEP (*p) && ++n_slashes > 3)
         {
-          share[i] = '\0';
+          *p = '\0';
           break;
         }
+      if (dbcs_p)
+        p = CharNextExA (file_name_codepage, p, 0);
+      else
+        p++;
     }
 
   resource.dwType = RESOURCETYPE_DISK;
@@ -2869,14 +3220,6 @@ sys_chmod (const char * path, int mode)
 }
 
 int
-sys_chown (const char *path, uid_t owner, gid_t group)
-{
-  if (sys_chmod (path, S_IREAD) == -1) /* check if file exists */
-    return -1;
-  return 0;
-}
-
-int
 sys_creat (const char * path, int mode)
 {
   return _creat (map_w32_filename (path, NULL), mode);
@@ -3063,9 +3406,12 @@ sys_open (const char * path, int oflag, int mode)
      and system files. Force all file handles to be
      non-inheritable. */
   int res = _open (mpath, (oflag & ~_O_CREAT) | _O_NOINHERIT, mode);
-  if (res >= 0)
-    return res;
-  return _open (mpath, oflag | _O_NOINHERIT, mode);
+  if (res < 0)
+    res = _open (mpath, oflag | _O_NOINHERIT, mode);
+  if (res >= 0 && res < MAXDESC)
+    fd_info[res].flags = 0;
+
+  return res;
 }
 
 int
@@ -3427,18 +3773,15 @@ w32_add_to_cache (PSID sid, unsigned id, char *name)
 #define GID 2
 
 static int
-get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
-                 unsigned *id, char *nm, int what)
+get_name_and_id (PSECURITY_DESCRIPTOR psd, unsigned *id, char *nm, int what)
 {
   PSID sid = NULL;
-  char machine[MAX_COMPUTERNAME_LENGTH+1];
   BOOL dflt;
   SID_NAME_USE ignore;
   char name[UNLEN+1];
   DWORD name_len = sizeof (name);
   char domain[1024];
   DWORD domain_len = sizeof (domain);
-  char *mp = NULL;
   int use_dflt = 0;
   int result;
 
@@ -3453,22 +3796,7 @@ get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
     use_dflt = 1;
   else if (!w32_cached_id (sid, id, nm))
     {
-      /* If FNAME is a UNC, we need to lookup account on the
-         specified machine.  */
-      if (IS_DIRECTORY_SEP (fname[0]) && IS_DIRECTORY_SEP (fname[1])
-          && fname[2] != '\0')
-        {
-          const char *s;
-          char *p;
-
-          for (s = fname + 2, p = machine;
-               *s && !IS_DIRECTORY_SEP (*s); s++, p++)
-            *p = *s;
-          *p = '\0';
-          mp = machine;
-        }
-
-      if (!lookup_account_sid (mp, sid, name, &name_len,
+      if (!lookup_account_sid (NULL, sid, name, &name_len,
                                domain, &domain_len, &ignore)
           || name_len > UNLEN+1)
         use_dflt = 1;
@@ -3483,9 +3811,7 @@ get_name_and_id (PSECURITY_DESCRIPTOR psd, const char *fname,
 }
 
 static void
-get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
-                          const char *fname,
-                          struct stat *st)
+get_file_owner_and_group (PSECURITY_DESCRIPTOR psd, struct stat *st)
 {
   int dflt_usr = 0, dflt_grp = 0;
 
@@ -3496,9 +3822,9 @@ get_file_owner_and_group (PSECURITY_DESCRIPTOR psd,
     }
   else
     {
-      if (get_name_and_id (psd, fname, &st->st_uid, st->st_uname, UID))
+      if (get_name_and_id (psd, &st->st_uid, st->st_uname, UID))
         dflt_usr = 1;
-      if (get_name_and_id (psd, fname, &st->st_gid, st->st_gname, GID))
+      if (get_name_and_id (psd, &st->st_gid, st->st_gname, GID))
         dflt_grp = 1;
     }
   /* Consider files to belong to current user/group, if we cannot get
@@ -3537,6 +3863,10 @@ is_slow_fs (const char *name)
   return !(devtype == DRIVE_FIXED || devtype == DRIVE_RAMDISK);
 }
 
+/* If this is non-zero, the caller wants accurate information about
+   file's owner and group, which could be expensive to get.  */
+int w32_stat_get_owner_group;
+
 /* MSVC stat function can't cope with UNC names and has other bugs, so
    replace it with our own.  This also allows us to calculate consistent
    inode values and owner/group without hacks in the main Emacs code. */
@@ -3557,6 +3887,7 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
   DWORD access_rights = 0;
   DWORD fattrs = 0, serialnum = 0, fs_high = 0, fs_low = 0, nlinks = 1;
   FILETIME ctime, atime, wtime;
+  int dbcs_p;
 
   if (path == NULL || buf == NULL)
     {
@@ -3708,6 +4039,7 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
       /* We produce the fallback owner and group data, based on the
          current user that runs Emacs, in the following cases:
 
+          . caller didn't request owner and group info
           . this is Windows 9X
           . getting security by handle failed, and we need to produce
             information for the target of a symlink (this is better
@@ -3716,23 +4048,25 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
 
          If getting security by handle fails, and we don't need to
          resolve symlinks, we try getting security by name.  */
-      if (is_windows_9x () != TRUE)
-        psd = get_file_security_desc_by_handle (fh);
-      if (psd)
-        {
-          get_file_owner_and_group (psd, name, buf);
-          LocalFree (psd);
-        }
-      else if (is_windows_9x () == TRUE)
-        get_file_owner_and_group (NULL, name, buf);
-      else if (!(is_a_symlink && follow_symlinks))
+      if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
+        get_file_owner_and_group (NULL, buf);
+      else
         {
-          psd = get_file_security_desc_by_name (name);
-          get_file_owner_and_group (psd, name, buf);
-          xfree (psd);
+          psd = get_file_security_desc_by_handle (fh);
+          if (psd)
+            {
+              get_file_owner_and_group (psd, buf);
+              LocalFree (psd);
+            }
+          else if (!(is_a_symlink && follow_symlinks))
+            {
+              psd = get_file_security_desc_by_name (name);
+              get_file_owner_and_group (psd, buf);
+              xfree (psd);
+            }
+          else
+            get_file_owner_and_group (NULL, buf);
         }
-      else
-        get_file_owner_and_group (NULL, name, buf);
       CloseHandle (fh);
     }
   else
@@ -3751,6 +4085,7 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
          did not ask for extra precision, resolving symlinks will fly
          in the face of that request, since the user then wants the
          lightweight version of the code.  */
+      dbcs_p = max_filename_mbslen () > 1;
       rootdir = (path >= save_name + len - 1
                  && (IS_DIRECTORY_SEP (*path) || *path == 0));
 
@@ -3778,8 +4113,19 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
         }
       else if (rootdir)
         {
-          if (!IS_DIRECTORY_SEP (name[len-1]))
-            strcat (name, "\\");
+          if (!dbcs_p)
+            {
+              if (!IS_DIRECTORY_SEP (name[len-1]))
+                strcat (name, "\\");
+            }
+          else
+            {
+              char *end = name + len;
+              char *n = CharPrevExA (file_name_codepage, name, end, 0);
+
+              if (!IS_DIRECTORY_SEP (*n))
+                strcat (name, "\\");
+            }
           if (GetDriveType (name) < 2)
             {
               errno = ENOENT;
@@ -3791,15 +4137,37 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
         }
       else
         {
-          if (IS_DIRECTORY_SEP (name[len-1]))
-            name[len - 1] = 0;
+          if (!dbcs_p)
+            {
+              if (IS_DIRECTORY_SEP (name[len-1]))
+                name[len - 1] = 0;
+            }
+          else
+            {
+              char *end = name + len;
+              char *n = CharPrevExA (file_name_codepage, name, end, 0);
+
+              if (IS_DIRECTORY_SEP (*n))
+                *n = 0;
+            }
 
           /* (This is hacky, but helps when doing file completions on
              network drives.)  Optimize by using information available from
              active readdir if possible.  */
           len = strlen (dir_pathname);
-          if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
-            len--;
+          if (!dbcs_p)
+            {
+              if (IS_DIRECTORY_SEP (dir_pathname[len-1]))
+                len--;
+            }
+          else
+            {
+              char *end = dir_pathname + len;
+              char *n = CharPrevExA (file_name_codepage, dir_pathname, end, 0);
+
+              if (IS_DIRECTORY_SEP (*n))
+                len--;
+            }
           if (dir_find_handle != INVALID_HANDLE_VALUE
               && !(is_a_symlink && follow_symlinks)
               && strnicmp (save_name, dir_pathname, len) == 0
@@ -3840,7 +4208,7 @@ stat_worker (const char * path, struct stat * buf, int follow_symlinks)
       else
         buf->st_mode = S_IFREG;
 
-      get_file_owner_and_group (NULL, name, buf);
+      get_file_owner_and_group (NULL, buf);
     }
 
 #if 0
@@ -3905,6 +4273,30 @@ lstat (const char * path, struct stat * buf)
   return stat_worker (path, buf, 0);
 }
 
+int
+fstatat (int fd, char const *name, struct stat *st, int flags)
+{
+  /* Rely on a hack: an open directory is modeled as file descriptor 0.
+     This is good enough for the current usage in Emacs, but is fragile.
+
+     FIXME: Add proper support for fdopendir, fstatat, readlinkat.
+     Gnulib does this and can serve as a model.  */
+  char fullname[MAX_PATH];
+
+  if (fd != AT_FDCWD)
+    {
+      if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
+          < 0)
+        {
+          errno = ENAMETOOLONG;
+          return -1;
+        }
+      name = fullname;
+    }
+
+  return stat_worker (name, st, ! (flags & AT_SYMLINK_NOFOLLOW));
+}
+
 /* Provide fstat and utime as well as stat for consistent handling of
    file timestamps. */
 int
@@ -3959,13 +4351,23 @@ fstat (int desc, struct stat * buf)
   else
     buf->st_ino = fake_inode;
 
-  /* Consider files to belong to current user.
-     FIXME: this should use GetSecurityInfo API, but it is only
-     available for _WIN32_WINNT >= 0x501.  */
-  buf->st_uid = dflt_passwd.pw_uid;
-  buf->st_gid = dflt_passwd.pw_gid;
-  strcpy (buf->st_uname, dflt_passwd.pw_name);
-  strcpy (buf->st_gname, dflt_group.gr_name);
+  /* If the caller so requested, get the true file owner and group.
+     Otherwise, consider the file to belong to the current user.  */
+  if (!w32_stat_get_owner_group || is_windows_9x () == TRUE)
+    get_file_owner_and_group (NULL, buf);
+  else
+    {
+      PSECURITY_DESCRIPTOR psd = NULL;
+
+      psd = get_file_security_desc_by_handle (fh);
+      if (psd)
+        {
+          get_file_owner_and_group (psd, buf);
+          LocalFree (psd);
+        }
+      else
+        get_file_owner_and_group (NULL, buf);
+    }
 
   buf->st_dev = info.dwVolumeSerialNumber;
   buf->st_rdev = info.dwVolumeSerialNumber;
@@ -4060,6 +4462,7 @@ symlink (char const *filename, char const *linkname)
   char linkfn[MAX_PATH], *tgtfn;
   DWORD flags = 0;
   int dir_access, filename_ends_in_slash;
+  int dbcs_p;
 
   /* Diagnostics follows Posix as much as possible.  */
   if (filename == NULL || linkname == NULL)
@@ -4085,6 +4488,8 @@ symlink (char const *filename, char const *linkname)
       return -1;
     }
 
+  dbcs_p = max_filename_mbslen () > 1;
+
   /* Note: since empty FILENAME was already rejected, we can safely
      refer to FILENAME[1].  */
   if (!(IS_DIRECTORY_SEP (filename[0]) || IS_DEVICE_SEP (filename[1])))
@@ -4099,8 +4504,21 @@ symlink (char const *filename, char const *linkname)
       char tem[MAX_PATH];
       char *p = linkfn + strlen (linkfn);
 
-      while (p > linkfn && !IS_ANY_SEP (p[-1]))
-        p--;
+      if (!dbcs_p)
+        {
+          while (p > linkfn && !IS_ANY_SEP (p[-1]))
+            p--;
+        }
+      else
+        {
+          char *p1 = CharPrevExA (file_name_codepage, linkfn, p, 0);
+
+          while (p > linkfn && !IS_ANY_SEP (*p1))
+            {
+              p = p1;
+              p1 = CharPrevExA (file_name_codepage, linkfn, p1, 0);
+            }
+        }
       if (p > linkfn)
         strncpy (tem, linkfn, p - linkfn);
       tem[p - linkfn] = '\0';
@@ -4115,7 +4533,15 @@ symlink (char const *filename, char const *linkname)
      exist, but ends in a slash, we create a symlink to directory.  If
      FILENAME exists and is a directory, we always create a symlink to
      directory.  */
-  filename_ends_in_slash = IS_DIRECTORY_SEP (filename[strlen (filename) - 1]);
+  if (!dbcs_p)
+    filename_ends_in_slash = IS_DIRECTORY_SEP (filename[strlen (filename) - 1]);
+  else
+    {
+      const char *end = filename + strlen (filename);
+      const char *n = CharPrevExA (file_name_codepage, filename, end, 0);
+
+      filename_ends_in_slash = IS_DIRECTORY_SEP (*n);
+    }
   if (dir_access == 0 || filename_ends_in_slash)
     flags = SYMBOLIC_LINK_FLAG_DIRECTORY;
 
@@ -4294,7 +4720,7 @@ readlink (const char *name, char *buf, size_t buf_size)
         errno = EINVAL;
       else
         {
-          /* Copy the link target name, in wide characters, fro
+          /* Copy the link target name, in wide characters, from
              reparse_data, then convert it to multibyte encoding in
              the current locale's codepage.  */
           WCHAR *lwname;
@@ -4305,6 +4731,8 @@ readlink (const char *name, char *buf, size_t buf_size)
           WCHAR *lwname_src =
             reparse_data->SymbolicLinkReparseBuffer.PathBuffer
             + reparse_data->SymbolicLinkReparseBuffer.PrintNameOffset/sizeof(WCHAR);
+          /* This updates file_name_codepage which we need below.  */
+          int dbcs_p = max_filename_mbslen () > 1;
 
           /* According to MSDN, PrintNameLength does not include the
              terminating null character.  */
@@ -4312,9 +4740,7 @@ readlink (const char *name, char *buf, size_t buf_size)
           memcpy (lwname, lwname_src, lwname_len);
           lwname[lwname_len/sizeof(WCHAR)] = 0; /* null-terminate */
 
-          /* FIXME: Should we use the current file-name coding system
-             instead of the fixed value of the ANSI codepage?  */
-          lname_len = WideCharToMultiByte (w32_ansi_code_page, 0, lwname, -1,
+          lname_len = WideCharToMultiByte (file_name_codepage, 0, lwname, -1,
                                            lname, MAX_PATH, NULL, NULL);
           if (!lname_len)
             {
@@ -4340,18 +4766,33 @@ readlink (const char *name, char *buf, size_t buf_size)
           else
             {
               size_t size_to_copy = buf_size;
-              BYTE *p = lname;
+              BYTE *p = lname, *p2;
               BYTE *pend = p + lname_len;
 
               /* Normalize like dostounix_filename does, but we don't
                  want to assume that lname is null-terminated.  */
-              if (*p && p[1] == ':' && *p >= 'A' && *p <= 'Z')
-                *p += 'a' - 'A';
+              if (dbcs_p)
+                p2 = CharNextExA (file_name_codepage, p, 0);
+              else
+                p2 = p + 1;
+              if (*p && *p2 == ':' && *p >= 'A' && *p <= 'Z')
+                {
+                  *p += 'a' - 'A';
+                  p += 2;
+                }
               while (p <= pend)
                 {
                   if (*p == '\\')
                     *p = '/';
-                  ++p;
+                  if (dbcs_p)
+                    {
+                      p = CharNextExA (file_name_codepage, p, 0);
+                      /* CharNextExA doesn't advance at null character.  */
+                      if (!*p)
+                        break;
+                    }
+                  else
+                    ++p;
                 }
               /* Testing for null-terminated LNAME is paranoia:
                  WideCharToMultiByte should always return a
@@ -4398,6 +4839,28 @@ readlink (const char *name, char *buf, size_t buf_size)
   return retval;
 }
 
+ssize_t
+readlinkat (int fd, char const *name, char *buffer,
+            size_t buffer_size)
+{
+  /* Rely on a hack: an open directory is modeled as file descriptor 0,
+     as in fstatat.  FIXME: Add proper support for readlinkat.  */
+  char fullname[MAX_PATH];
+
+  if (fd != AT_FDCWD)
+    {
+      if (_snprintf (fullname, sizeof fullname, "%s/%s", dir_pathname, name)
+          < 0)
+        {
+          errno = ENAMETOOLONG;
+          return -1;
+        }
+      name = fullname;
+    }
+
+  return readlink (name, buffer, buffer_size);
+}
+
 /* If FILE is a symlink, return its target (stored in a static
    buffer); otherwise return FILE.
 
@@ -4425,6 +4888,7 @@ chase_symlinks (const char *file)
   char link[MAX_PATH];
   ssize_t res, link_len;
   int loop_count = 0;
+  int dbcs_p;
 
   if (is_windows_9x () == TRUE || !is_symlink (file))
     return (char *)file;
@@ -4432,13 +4896,27 @@ chase_symlinks (const char *file)
   if ((link_len = GetFullPathName (file, MAX_PATH, link, NULL)) == 0)
     return (char *)file;
 
+  dbcs_p = max_filename_mbslen () > 1;
   target[0] = '\0';
   do {
 
     /* Remove trailing slashes, as we want to resolve the last
        non-trivial part of the link name.  */
-    while (link_len > 3 && IS_DIRECTORY_SEP (link[link_len-1]))
-      link[link_len--] = '\0';
+    if (!dbcs_p)
+      {
+        while (link_len > 3 && IS_DIRECTORY_SEP (link[link_len-1]))
+          link[link_len--] = '\0';
+      }
+    else if (link_len > 3)
+      {
+        char *n = CharPrevExA (file_name_codepage, link, link + link_len, 0);
+
+        while (n >= link + 2 && IS_DIRECTORY_SEP (*n))
+          {
+            n[1] = '\0';
+            n = CharPrevExA (file_name_codepage, link, n, 0);
+          }
+      }
 
     res = readlink (link, target, MAX_PATH);
     if (res > 0)
@@ -4451,8 +4929,21 @@ chase_symlinks (const char *file)
                the symlink, then copy the result back to target.  */
             char *p = link + link_len;
 
-            while (p > link && !IS_ANY_SEP (p[-1]))
-              p--;
+            if (!dbcs_p)
+              {
+                while (p > link && !IS_ANY_SEP (p[-1]))
+                  p--;
+              }
+            else
+              {
+                char *p1 = CharPrevExA (file_name_codepage, link, p, 0);
+
+                while (p > link && !IS_ANY_SEP (*p1))
+                  {
+                    p = p1;
+                    p1 = CharPrevExA (file_name_codepage, link, p1, 0);
+                  }
+              }
             strcpy (p, target);
             strcpy (target, link);
           }
@@ -4470,6 +4961,245 @@ chase_symlinks (const char *file)
   return target;
 }
 
+
+/* Posix ACL emulation.  */
+
+int
+acl_valid (acl_t acl)
+{
+  return is_valid_security_descriptor ((PSECURITY_DESCRIPTOR)acl) ? 0 : -1;
+}
+
+char *
+acl_to_text (acl_t acl, ssize_t *size)
+{
+  LPTSTR str_acl;
+  SECURITY_INFORMATION flags =
+    OWNER_SECURITY_INFORMATION |
+    GROUP_SECURITY_INFORMATION |
+    DACL_SECURITY_INFORMATION;
+  char *retval = NULL;
+  ULONG local_size;
+  int e = errno;
+
+  errno = 0;
+
+  if (convert_sd_to_sddl ((PSECURITY_DESCRIPTOR)acl, SDDL_REVISION_1, flags, &str_acl, &local_size))
+    {
+      errno = e;
+      /* We don't want to mix heaps, so we duplicate the string in our
+         heap and free the one allocated by the API.  */
+      retval = xstrdup (str_acl);
+      if (size)
+        *size = local_size;
+      LocalFree (str_acl);
+    }
+  else if (errno != ENOTSUP)
+    errno = EINVAL;
+
+  return retval;
+}
+
+acl_t
+acl_from_text (const char *acl_str)
+{
+  PSECURITY_DESCRIPTOR psd, retval = NULL;
+  ULONG sd_size;
+  int e = errno;
+
+  errno = 0;
+
+  if (convert_sddl_to_sd (acl_str, SDDL_REVISION_1, &psd, &sd_size))
+    {
+      errno = e;
+      retval = xmalloc (sd_size);
+      memcpy (retval, psd, sd_size);
+      LocalFree (psd);
+    }
+  else if (errno != ENOTSUP)
+    errno = EINVAL;
+
+  return retval;
+}
+
+int
+acl_free (void *ptr)
+{
+  xfree (ptr);
+  return 0;
+}
+
+acl_t
+acl_get_file (const char *fname, acl_type_t type)
+{
+  PSECURITY_DESCRIPTOR psd = NULL;
+  const char *filename;
+
+  if (type == ACL_TYPE_ACCESS)
+    {
+      DWORD sd_len, err;
+      SECURITY_INFORMATION si =
+        OWNER_SECURITY_INFORMATION |
+        GROUP_SECURITY_INFORMATION |
+        DACL_SECURITY_INFORMATION ;
+      int e = errno;
+
+      filename = map_w32_filename (fname, NULL);
+      if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
+        fname = chase_symlinks (filename);
+      else
+        fname = filename;
+
+      errno = 0;
+      if (!get_file_security (fname, si, psd, 0, &sd_len)
+          && errno != ENOTSUP)
+        {
+          err = GetLastError ();
+          if (err == ERROR_INSUFFICIENT_BUFFER)
+            {
+              psd = xmalloc (sd_len);
+              if (!get_file_security (fname, si, psd, sd_len, &sd_len))
+                {
+                  xfree (psd);
+                  errno = EIO;
+                  psd = NULL;
+                }
+            }
+          else if (err == ERROR_FILE_NOT_FOUND
+                   || err == ERROR_PATH_NOT_FOUND)
+            errno = ENOENT;
+          else
+            errno = EIO;
+        }
+      else if (!errno)
+        errno = e;
+    }
+  else if (type != ACL_TYPE_DEFAULT)
+    errno = EINVAL;
+
+  return psd;
+}
+
+int
+acl_set_file (const char *fname, acl_type_t type, acl_t acl)
+{
+  TOKEN_PRIVILEGES old1, old2;
+  DWORD err;
+  int st = 0, retval = -1;
+  SECURITY_INFORMATION flags = 0;
+  PSID psid;
+  PACL pacl;
+  BOOL dflt;
+  BOOL dacl_present;
+  int e;
+  const char *filename;
+
+  if (acl_valid (acl) != 0
+      || (type != ACL_TYPE_DEFAULT && type != ACL_TYPE_ACCESS))
+    {
+      errno = EINVAL;
+      return -1;
+    }
+
+  if (type == ACL_TYPE_DEFAULT)
+    {
+      errno = ENOSYS;
+      return -1;
+    }
+
+  filename = map_w32_filename (fname, NULL);
+  if ((volume_info.flags & FILE_SUPPORTS_REPARSE_POINTS) != 0)
+    fname = chase_symlinks (filename);
+  else
+    fname = filename;
+
+  if (get_security_descriptor_owner ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
+      && psid)
+    flags |= OWNER_SECURITY_INFORMATION;
+  if (get_security_descriptor_group ((PSECURITY_DESCRIPTOR)acl, &psid, &dflt)
+      && psid)
+    flags |= GROUP_SECURITY_INFORMATION;
+  if (get_security_descriptor_dacl ((PSECURITY_DESCRIPTOR)acl, &dacl_present,
+                                    &pacl, &dflt)
+      && dacl_present)
+    flags |= DACL_SECURITY_INFORMATION;
+  if (!flags)
+    return 0;
+
+  /* According to KB-245153, setting the owner will succeed if either:
+     (1) the caller is the user who will be the new owner, and has the
+         SE_TAKE_OWNERSHIP privilege, or
+     (2) the caller has the SE_RESTORE privilege, in which case she can
+         set any valid user or group as the owner
+
+     We request below both SE_TAKE_OWNERSHIP and SE_RESTORE
+     privileges, and disregard any failures in obtaining them.  If
+     these privileges cannot be obtained, and do not already exist in
+     the calling thread's security token, this function could fail
+     with EPERM.  */
+  if (enable_privilege (SE_TAKE_OWNERSHIP_NAME, TRUE, &old1))
+    st++;
+  if (enable_privilege (SE_RESTORE_NAME, TRUE, &old2))
+    st++;
+
+  e = errno;
+  errno = 0;
+  if (!set_file_security ((char *)fname, flags, (PSECURITY_DESCRIPTOR)acl))
+    {
+      err = GetLastError ();
+
+      if (errno == ENOTSUP)
+        ;
+      else if (err == ERROR_INVALID_OWNER
+               || err == ERROR_NOT_ALL_ASSIGNED
+               || err == ERROR_ACCESS_DENIED)
+        {
+          /* Maybe the requested ACL and the one the file already has
+             are identical, in which case we can silently ignore the
+             failure.  (And no, Windows doesn't.)  */
+          acl_t current_acl = acl_get_file (fname, ACL_TYPE_ACCESS);
+
+          errno = EPERM;
+          if (current_acl)
+            {
+              char *acl_from = acl_to_text (current_acl, NULL);
+              char *acl_to = acl_to_text (acl, NULL);
+
+              if (acl_from && acl_to && xstrcasecmp (acl_from, acl_to) == 0)
+                {
+                  retval = 0;
+                  errno = e;
+                }
+              if (acl_from)
+                acl_free (acl_from);
+              if (acl_to)
+                acl_free (acl_to);
+              acl_free (current_acl);
+            }
+        }
+      else if (err == ERROR_FILE_NOT_FOUND || err == ERROR_PATH_NOT_FOUND)
+        errno = ENOENT;
+      else
+        errno = EACCES;
+    }
+  else
+    {
+      retval = 0;
+      errno = e;
+    }
+
+  if (st)
+    {
+      if (st >= 2)
+        restore_privilege (&old2);
+      restore_privilege (&old1);
+      revert_to_self ();
+    }
+
+  return retval;
+}
+
+
 /* MS-Windows version of careadlinkat (cf. ../lib/careadlinkat.c).  We
    have a fixed max size for file names, so we don't need the kind of
    alloc/malloc/realloc dance the gnulib version does.  We also don't
@@ -4483,12 +5213,6 @@ careadlinkat (int fd, char const *filename,
   char linkname[MAX_PATH];
   ssize_t link_size;
 
-  if (fd != AT_FDCWD)
-    {
-      errno = EINVAL;
-      return NULL;
-    }
-
   link_size = preadlinkat (fd, filename, linkname, sizeof(linkname));
 
   if (link_size > 0)
@@ -4506,14 +5230,6 @@ careadlinkat (int fd, char const *filename,
   return NULL;
 }
 
-ssize_t
-careadlinkatcwd (int fd, char const *filename, char *buffer,
-                 size_t buffer_size)
-{
-  (void) fd;
-  return readlink (filename, buffer, buffer_size);
-}
-
 
 /* Support for browsing other processes and their attributes.  See
    process.c for the Lisp bindings.  */
@@ -4685,8 +5401,8 @@ get_process_memory_info (HANDLE h_proc,
 
 static BOOL WINAPI
 get_process_working_set_size (HANDLE h_proc,
-                              DWORD *minrss,
-                              DWORD *maxrss)
+                              PSIZE_T minrss,
+                              PSIZE_T maxrss)
 {
   static GetProcessWorkingSetSize_Proc
     s_pfn_Get_Process_Working_Set_Size = NULL;
@@ -4931,7 +5647,7 @@ system_process_attributes (Lisp_Object pid)
   unsigned egid;
   PROCESS_MEMORY_COUNTERS mem;
   PROCESS_MEMORY_COUNTERS_EX mem_ex;
-  DWORD minrss, maxrss;
+  SIZE_T minrss, maxrss;
   MEMORYSTATUS memst;
   MEMORY_STATUS_EX memstex;
   double totphys = 0.0;
@@ -5159,7 +5875,7 @@ system_process_attributes (Lisp_Object pid)
       && get_process_memory_info (h_proc, (PROCESS_MEMORY_COUNTERS *)&mem_ex,
                                   sizeof (mem_ex)))
     {
-      DWORD rss = mem_ex.WorkingSetSize / 1024;
+      SIZE_T rss = mem_ex.WorkingSetSize / 1024;
 
       attrs = Fcons (Fcons (Qmajflt,
                             make_fixnum_or_float (mem_ex.PageFaultCount)),
@@ -5174,7 +5890,7 @@ system_process_attributes (Lisp_Object pid)
   else if (h_proc
            && get_process_memory_info (h_proc, &mem, sizeof (mem)))
     {
-      DWORD rss = mem_ex.WorkingSetSize / 1024;
+      SIZE_T rss = mem_ex.WorkingSetSize / 1024;
 
       attrs = Fcons (Fcons (Qmajflt,
                             make_fixnum_or_float (mem.PageFaultCount)),
@@ -5368,35 +6084,39 @@ init_winsock (int load_now)
 
 int h_errno = 0;
 
-/* function to set h_errno for compatibility; map winsock error codes to
-   normal system codes where they overlap (non-overlapping definitions
-   are already in <sys/socket.h> */
+/* Function to map winsock error codes to errno codes for those errno
+   code defined in errno.h (errno values not defined by errno.h are
+   already in nt/inc/sys/socket.h).  */
 static void
 set_errno (void)
 {
+  int wsa_err;
+
+  h_errno = 0;
   if (winsock_lib == NULL)
-    h_errno = EINVAL;
+    wsa_err = EINVAL;
   else
-    h_errno = pfn_WSAGetLastError ();
+    wsa_err = pfn_WSAGetLastError ();
 
-  switch (h_errno)
+  switch (wsa_err)
     {
-    case WSAEACCES:             h_errno = EACCES; break;
-    case WSAEBADF:              h_errno = EBADF; break;
-    case WSAEFAULT:             h_errno = EFAULT; break;
-    case WSAEINTR:              h_errno = EINTR; break;
-    case WSAEINVAL:             h_errno = EINVAL; break;
-    case WSAEMFILE:             h_errno = EMFILE; break;
-    case WSAENAMETOOLONG:       h_errno = ENAMETOOLONG; break;
-    case WSAENOTEMPTY:          h_errno = ENOTEMPTY; break;
+    case WSAEACCES:             errno = EACCES; break;
+    case WSAEBADF:              errno = EBADF; break;
+    case WSAEFAULT:             errno = EFAULT; break;
+    case WSAEINTR:              errno = EINTR; break;
+    case WSAEINVAL:             errno = EINVAL; break;
+    case WSAEMFILE:             errno = EMFILE; break;
+    case WSAENAMETOOLONG:       errno = ENAMETOOLONG; break;
+    case WSAENOTEMPTY:          errno = ENOTEMPTY; break;
+    default:                    errno = wsa_err; break;
     }
-  errno = h_errno;
 }
 
 static void
 check_errno (void)
 {
-  if (h_errno == 0 && winsock_lib != NULL)
+  h_errno = 0;
+  if (winsock_lib != NULL)
     pfn_WSASetLastError (0);
 }
 
@@ -5508,7 +6228,7 @@ sys_socket (int af, int type, int protocol)
 
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return INVALID_SOCKET;
     }
 
@@ -5585,6 +6305,7 @@ socket_to_fd (SOCKET s)
               }
           }
       }
+      eassert (fd < MAXDESC);
       fd_info[fd].hnd = (HANDLE) s;
 
       /* set our own internal flags */
@@ -5613,8 +6334,9 @@ socket_to_fd (SOCKET s)
       /* clean up */
       _close (fd);
     }
+  else
   pfn_closesocket (s);
-  h_errno = EMFILE;
+  errno = EMFILE;
   return -1;
 }
 
@@ -5623,7 +6345,7 @@ sys_bind (int s, const struct sockaddr * addr, int namelen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENOTSOCK;
+      errno = ENOTSOCK;
       return SOCKET_ERROR;
     }
 
@@ -5635,7 +6357,7 @@ sys_bind (int s, const struct sockaddr * addr, int namelen)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5644,7 +6366,7 @@ sys_connect (int s, const struct sockaddr * name, int namelen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENOTSOCK;
+      errno = ENOTSOCK;
       return SOCKET_ERROR;
     }
 
@@ -5656,7 +6378,7 @@ sys_connect (int s, const struct sockaddr * name, int namelen)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5685,12 +6407,20 @@ int
 sys_gethostname (char * name, int namelen)
 {
   if (winsock_lib != NULL)
-    return pfn_gethostname (name, namelen);
+    {
+      int retval;
+
+      check_errno ();
+      retval = pfn_gethostname (name, namelen);
+      if (retval == SOCKET_ERROR)
+        set_errno ();
+      return retval;
+    }
 
   if (namelen > MAX_COMPUTERNAME_LENGTH)
     return !GetComputerName (name, (DWORD *)&namelen);
 
-  h_errno = EFAULT;
+  errno = EFAULT;
   return SOCKET_ERROR;
 }
 
@@ -5698,17 +6428,24 @@ struct hostent *
 sys_gethostbyname (const char * name)
 {
   struct hostent * host;
+  int h_err = h_errno;
 
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      h_errno = NO_RECOVERY;
+      errno = ENETDOWN;
       return NULL;
     }
 
   check_errno ();
   host = pfn_gethostbyname (name);
   if (!host)
-    set_errno ();
+    {
+      set_errno ();
+      h_errno = errno;
+    }
+  else
+    h_errno = h_err;
   return host;
 }
 
@@ -5719,7 +6456,7 @@ sys_getservbyname (const char * name, const char * proto)
 
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return NULL;
     }
 
@@ -5735,7 +6472,7 @@ sys_getpeername (int s, struct sockaddr *addr, int * namelen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5747,7 +6484,7 @@ sys_getpeername (int s, struct sockaddr *addr, int * namelen)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5756,7 +6493,7 @@ sys_shutdown (int s, int how)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5768,7 +6505,7 @@ sys_shutdown (int s, int how)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5777,7 +6514,7 @@ sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5790,7 +6527,7 @@ sys_setsockopt (int s, int level, int optname, const void * optval, int optlen)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5799,7 +6536,7 @@ sys_listen (int s, int backlog)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5813,7 +6550,7 @@ sys_listen (int s, int backlog)
         fd_info[s].flags |= FILE_LISTEN;
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5822,7 +6559,7 @@ sys_getsockname (int s, struct sockaddr * name, int * namelen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5834,7 +6571,7 @@ sys_getsockname (int s, struct sockaddr * name, int * namelen)
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5843,7 +6580,7 @@ sys_accept (int s, struct sockaddr * addr, int * addrlen)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return -1;
     }
 
@@ -5857,11 +6594,14 @@ sys_accept (int s, struct sockaddr * addr, int * addrlen)
       else
         fd = socket_to_fd (t);
 
-      fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
-      ResetEvent (fd_info[s].cp->char_avail);
+      if (fd >= 0)
+        {
+          fd_info[s].cp->status = STATUS_READ_ACKNOWLEDGED;
+          ResetEvent (fd_info[s].cp->char_avail);
+        }
       return fd;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return -1;
 }
 
@@ -5871,7 +6611,7 @@ sys_recvfrom (int s, char * buf, int len, int flags,
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5883,7 +6623,7 @@ sys_recvfrom (int s, char * buf, int len, int flags,
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5893,7 +6633,7 @@ sys_sendto (int s, const char * buf, int len, int flags,
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return SOCKET_ERROR;
     }
 
@@ -5905,7 +6645,7 @@ sys_sendto (int s, const char * buf, int len, int flags,
         set_errno ();
       return rc;
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5916,7 +6656,7 @@ fcntl (int s, int cmd, int options)
 {
   if (winsock_lib == NULL)
     {
-      h_errno = ENETDOWN;
+      errno = ENETDOWN;
       return -1;
     }
 
@@ -5935,11 +6675,11 @@ fcntl (int s, int cmd, int options)
         }
       else
         {
-          h_errno = EINVAL;
+          errno = EINVAL;
           return SOCKET_ERROR;
         }
     }
-  h_errno = ENOTSOCK;
+  errno = ENOTSOCK;
   return SOCKET_ERROR;
 }
 
@@ -5986,20 +6726,34 @@ sys_close (int fd)
 
                   winsock_inuse--; /* count open sockets */
                 }
-              delete_child (cp);
+              /* If the process handle is NULL, it's either a socket
+                 or serial connection, or a subprocess that was
+                 already reaped by reap_subprocess, but whose
+                 resources were not yet freed, because its output was
+                 not fully read yet by the time it was reaped.  (This
+                 usually happens with async subprocesses whose output
+                 is being read by Emacs.)  Otherwise, this process was
+                 not reaped yet, so we set its FD to a negative value
+                 to make sure sys_select will eventually get to
+                 calling the SIGCHLD handler for it, which will then
+                 invoke waitpid and reap_subprocess.  */
+              if (cp->procinfo.hProcess == NULL)
+                delete_child (cp);
+              else
+                cp->fd = -1;
             }
         }
     }
 
+  if (fd >= 0 && fd < MAXDESC)
+    fd_info[fd].flags = 0;
+
   /* Note that sockets do not need special treatment here (at least on
      NT and Windows 95 using the standard tcp/ip stacks) - it appears that
      closesocket is equivalent to CloseHandle, which is to be expected
      because socket handles are fully fledged kernel handles. */
   rc = _close (fd);
 
-  if (rc == 0 && fd < MAXDESC)
-    fd_info[fd].flags = 0;
-
   return rc;
 }
 
@@ -6062,6 +6816,7 @@ sys_pipe (int * phandles)
         {
           _close (phandles[0]);
           _close (phandles[1]);
+          errno = EMFILE;
           rc = -1;
         }
       else
@@ -6078,7 +6833,8 @@ sys_pipe (int * phandles)
 }
 
 /* Function to do blocking read of one byte, needed to implement
-   select.  It is only allowed on sockets and pipes. */
+   select.  It is only allowed on communication ports, sockets, or
+   pipes. */
 int
 _sys_read_ahead (int fd)
 {
@@ -6134,19 +6890,31 @@ _sys_read_ahead (int fd)
 
       /* Configure timeouts for blocking read.  */
       if (!GetCommTimeouts (hnd, &ct))
-        return STATUS_READ_ERROR;
+        {
+          cp->status = STATUS_READ_ERROR;
+          return STATUS_READ_ERROR;
+        }
       ct.ReadIntervalTimeout            = 0;
       ct.ReadTotalTimeoutMultiplier     = 0;
       ct.ReadTotalTimeoutConstant       = 0;
       if (!SetCommTimeouts (hnd, &ct))
-        return STATUS_READ_ERROR;
+        {
+          cp->status = STATUS_READ_ERROR;
+          return STATUS_READ_ERROR;
+        }
 
       if (!ReadFile (hnd, &cp->chr, sizeof (char), (DWORD*) &rc, ovl))
         {
           if (GetLastError () != ERROR_IO_PENDING)
-            return STATUS_READ_ERROR;
+            {
+              cp->status = STATUS_READ_ERROR;
+              return STATUS_READ_ERROR;
+            }
           if (!GetOverlappedResult (hnd, ovl, (DWORD*) &rc, TRUE))
-            return STATUS_READ_ERROR;
+            {
+              cp->status = STATUS_READ_ERROR;
+              return STATUS_READ_ERROR;
+            }
         }
     }
   else if (fd_info[fd].flags & FILE_SOCKET)
@@ -6342,7 +7110,7 @@ sys_read (int fd, char * buffer, unsigned int count)
               pfn_ioctlsocket (SOCK_HANDLE (fd), FIONREAD, &waiting);
               if (waiting == 0 && nchars == 0)
                 {
-                  h_errno = errno = EWOULDBLOCK;
+                  errno = EWOULDBLOCK;
                   return -1;
                 }
 
@@ -6840,6 +7608,11 @@ globals_of_w32 (void)
   g_b_init_get_native_system_info = 0;
   g_b_init_get_system_times = 0;
   g_b_init_create_symbolic_link = 0;
+  g_b_init_get_security_descriptor_dacl = 0;
+  g_b_init_convert_sd_to_sddl = 0;
+  g_b_init_convert_sddl_to_sd = 0;
+  g_b_init_is_valid_security_descriptor = 0;
+  g_b_init_set_file_security = 0;
   num_of_processors = 0;
   /* The following sets a handler for shutdown notifications for
      console apps. This actually applies to Emacs in both console and
@@ -6849,6 +7622,9 @@ globals_of_w32 (void)
 
   /* "None" is the default group name on standalone workstations.  */
   strcpy (dflt_group_name, "None");
+
+  /* Reset, in case it has some value inherited from dump time.  */
+  w32_stat_get_owner_group = 0;
 }
 
 /* For make-serial-process  */
diff --git a/src/w32.h b/src/w32.h
index 23eda830268..6bf165f52ba 100644
--- a/src/w32.h
+++ b/src/w32.h
@@ -2,7 +2,7 @@
 #define EMACS_W32_H
 
 /* Support routines for the NT version of Emacs.
-   Copyright (C) 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -68,17 +68,47 @@ enum {
    a socket, the process handle in pi is NULL. */
 typedef struct _child_process
 {
-  int                   fd;
-  int                   pid;
-  HANDLE                char_avail;
-  HANDLE                char_consumed;
-  HANDLE                thrd;
-  HWND                  hwnd;
-  PROCESS_INFORMATION   procinfo;
-  volatile int          status;
-  char                  chr;
-  OVERLAPPED            ovl_read;
-  OVERLAPPED            ovl_write;
+  /* File descriptor for sockets and serial port connections, and for
+     reading output from async subprocesses; otherwise -1.  */
+  int                 fd;
+  /* PID for subprocess, either async or not; otherwise -1.  */
+  int                 pid;
+  /* Handle to an event object that is signaled when a read operation
+     is completed, either successfully (in which case there're indeed
+     "characters available") or not.  Used by sys_select to wait for
+     output from subprocesses or socket/serial connections.  */
+  HANDLE              char_avail;
+  /* Handle to an event that is signaled to wake up the reader thread
+     and tell it to try reading more output from a subprocess.  */
+  HANDLE              char_consumed;
+  /* Handle to the reader thread to read output from a subprocess or a
+     socket or a comm port.  */
+  HANDLE              thrd;
+  /* Handle to the console window of a subprocess.  Used to forcibly
+     terminate it by sys_kill.  */
+  HWND                hwnd;
+  /* Information about subprocess returned by CreateProcess.  Includes
+     handles to the subprocess and its primary thread, and the
+     corresponding process ID and thread ID numbers.  The PID is
+     mirrored by the 'pid' member above.  The process handle is used
+     to wait on it.  */
+  PROCESS_INFORMATION procinfo;
+  /* Status of subprocess/connection and of reading its output.  For
+     values, see the enumeration above.  */
+  volatile int        status;
+  /* Holds a single character read by _sys_read_ahead, when a
+     subprocess has some output ready.  */
+  char                chr;
+  /* Used for async read operations on serial comm ports.  */
+  OVERLAPPED          ovl_read;
+  /* Used for async write operations on serial comm ports.  */
+  OVERLAPPED          ovl_write;
+  /* Input file, if any, for this subprocess.  Should only be non-NULL
+     for async subprocesses.  */
+  char               *input_file;
+  /* If non-zero, the subprocess input file is temporary and should be
+     deleted when the subprocess exits.  */
+  int                 pending_deletion;
 } child_process;
 
 #define MAXDESC FD_SETSIZE
@@ -150,7 +180,7 @@ extern void init_environment (char **);
 extern void check_windows_init_file (void);
 extern void syms_of_ntproc (void);
 extern void syms_of_ntterm (void);
-extern void dostounix_filename (register char *);
+extern void dostounix_filename (register char *, int);
 extern void unixtodos_filename (register char *);
 extern BOOL init_winsock (int load_now);
 extern void srandom (int);
@@ -160,7 +190,9 @@ extern int sys_pipe (int *);
 
 extern void set_process_dir (char *);
 extern int sys_spawnve (int, char *, char **, char **);
-extern void register_child (int, int);
+extern void register_child (pid_t, int);
+extern void record_infile (pid_t, char *);
+extern void record_pending_deletion (char *);
 
 extern void sys_sleep (int);
 extern int sys_link (const char *, const char *);
diff --git a/src/w32common.h b/src/w32common.h
index 5e9b61824ae..79fe5cc367c 100644
--- a/src/w32common.h
+++ b/src/w32common.h
@@ -1,5 +1,5 @@
 /* Common functions for Microsoft Windows builds of Emacs
-   Copyright (C) 2012 Free Software Foundation, Inc.
+   Copyright (C) 2012-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32console.c b/src/w32console.c
index f0574689bf1..06b2c7aa24e 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -1,5 +1,5 @@
 /* Terminal hooks for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1992, 1999, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1992, 1999, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -746,6 +746,9 @@ initialize_w32_display (struct terminal *term)
   else
     w32_console_unicode_input = 0;
 
+  /* This is needed by w32notify.c:send_notifications.  */
+  dwMainThreadId = GetCurrentThreadId ();
+
   /* Setup w32_display_info structure for this frame. */
 
   w32_initialize_display_info (build_string ("Console"));
diff --git a/src/w32fns.c b/src/w32fns.c
index 1a181079c82..5fab2c9a3df 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -1,6 +1,6 @@
 /* Graphical user interface functions for the Microsoft Windows API.
 
-Copyright (C) 1989, 1992-2012  Free Software Foundation, Inc.
+Copyright (C) 1989, 1992-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1821,7 +1821,6 @@ static LRESULT CALLBACK w32_wnd_proc (HWND, UINT, WPARAM, LPARAM);
 static BOOL
 w32_init_class (HINSTANCE hinst)
 {
-
   if (w32_unicode_gui)
     {
       WNDCLASSW  uwc;
@@ -3957,6 +3956,9 @@ w32_wnd_proc (HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 
         return retval;
       }
+    case WM_EMACS_FILENOTIFY:
+      my_post_msg (&wmsg, hwnd, msg, wParam, lParam);
+      return 1;
 
     default:
       /* Check for messages registered at runtime. */
@@ -5941,7 +5943,7 @@ Text larger than the specified size is clipped.  */)
                   SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
 
     /* Let redisplay know that we have made the frame visible already.  */
-    f->async_visible = 1;
+    SET_FRAME_VISIBLE (f, 1);
 
     ShowWindow (FRAME_W32_WINDOW (f), SW_SHOWNOACTIVATE);
   }
@@ -6252,7 +6254,7 @@ Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.  */)
             /* we get one of the two final 0 bytes for free. */
             1 + sizeof (wchar_t) * wcslen (filename_buf)));
 #else /* !NTGUI_UNICODE */
-        dostounix_filename (filename_buf);
+        dostounix_filename (filename_buf, 0);
         filename = DECODE_FILE (build_string (filename_buf));
 #endif /* NTGUI_UNICODE */
 
@@ -6482,12 +6484,12 @@ w32_parse_hot_key (Lisp_Object key)
 
   CHECK_VECTOR (key);
 
-  if (XFASTINT (Flength (key)) != 1)
+  if (ASIZE (key) != 1)
     return Qnil;
 
   GCPRO1 (key);
 
-  c = Faref (key, make_number (0));
+  c = AREF (key, 0);
 
   if (CONSP (c) && lucid_event_type_list_p (c))
     c = Fevent_convert_list (c);
@@ -7024,6 +7026,9 @@ cache_system_info (void)
       DWORD data;
     } version;
 
+  /* Cache the module handle of Emacs itself.  */
+  hinst = GetModuleHandle (NULL);
+
   /* Cache the version of the operating system.  */
   version.data = GetVersion ();
   w32_major_version = version.info.major;
@@ -7036,7 +7041,7 @@ cache_system_info (void)
 
   /* Cache page size, allocation unit, processor type, etc.  */
   GetSystemInfo (&sysinfo_cache);
-  syspage_mask = sysinfo_cache.dwPageSize - 1;
+  syspage_mask = (DWORD_PTR)sysinfo_cache.dwPageSize - 1;
 
   /* Cache os info.  */
   osinfo_cache.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
diff --git a/src/w32font.c b/src/w32font.c
index d7d25d89939..5c5a15cc340 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -1,5 +1,5 @@
 /* Font backend for the Microsoft Windows API.
-   Copyright (C) 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2007-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32font.h b/src/w32font.h
index 8fa00a9b524..b4345478a22 100644
--- a/src/w32font.h
+++ b/src/w32font.h
@@ -1,5 +1,5 @@
 /* Shared GDI and Uniscribe Font backend declarations for the Windows API.
-   Copyright (C) 2007-2012 Free Software Foundation, Inc.
+   Copyright (C) 2007-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32gui.h b/src/w32gui.h
index 0da8de97f23..739ff3c92e9 100644
--- a/src/w32gui.h
+++ b/src/w32gui.h
@@ -1,5 +1,5 @@
 /* Definitions and headers for communication on the Microsoft Windows API.
-   Copyright (C) 1995, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1995, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -79,9 +79,6 @@ typedef struct _XImage
 #define FACE_DEFAULT (~0)
 
 extern HINSTANCE hinst;
-extern HINSTANCE hprevinst;
-extern LPSTR lpCmdLine;
-extern int nCmdShow;
 
 /* Bit Gravity */
 
diff --git a/src/w32heap.c b/src/w32heap.c
index 311e1064434..81206ce2834 100644
--- a/src/w32heap.c
+++ b/src/w32heap.c
@@ -1,5 +1,5 @@
 /* Heap management routines for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -98,7 +98,11 @@ allocate_heap (void)
 #ifdef _WIN64
   size_t size = 0x4000000000i64; /* start by asking for 32GB */
 #else
-  size_t size = 0x80000000; /* start by asking for 2GB */
+  /* We used to start with 2GB here, but on Windows 7 that would leave
+     too little room in the address space for threads started by
+     Windows on our behalf, e.g. when we pop up the file selection
+     dialog.  */
+  size_t size = 0x68000000; /* start by asking for 1.7GB */
 #endif
   void *ptr = NULL;
 
diff --git a/src/w32heap.h b/src/w32heap.h
index 1630864875f..82b59dd027f 100644
--- a/src/w32heap.h
+++ b/src/w32heap.h
@@ -1,5 +1,5 @@
 /* Heap management routines (including unexec) for GNU Emacs on Windows NT.
-   Copyright (C) 1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32inevt.c b/src/w32inevt.c
index 899a6fb89bf..3c38cf806e8 100644
--- a/src/w32inevt.c
+++ b/src/w32inevt.c
@@ -1,5 +1,6 @@
 /* Input event support for Emacs on the Microsoft Windows API.
-   Copyright (C) 1992-1993, 1995, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1992-1993, 1995, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -576,6 +577,74 @@ maybe_generate_resize_event (void)
                      0, 0, 0);
 }
 
+static int
+handle_file_notifications (struct input_event *hold_quit)
+{
+  BYTE *p = file_notifications;
+  FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
+  const DWORD min_size
+    = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+  struct input_event inev;
+  int nevents = 0;
+
+  /* We cannot process notification before Emacs is fully initialized,
+     since we need the UTF-16LE coding-system to be set up.  */
+  if (!initialized)
+    {
+      notification_buffer_in_use = 0;
+      return nevents;
+    }
+
+  enter_crit ();
+  if (notification_buffer_in_use)
+    {
+      DWORD info_size = notifications_size;
+      Lisp_Object cs = intern ("utf-16le");
+      Lisp_Object obj = w32_get_watch_object (notifications_desc);
+
+      /* notifications_size could be zero when the buffer of
+         notifications overflowed on the OS level, or when the
+         directory being watched was itself deleted.  Do nothing in
+         that case.  */
+      if (info_size
+          && !NILP (obj) && CONSP (obj))
+        {
+          Lisp_Object callback = XCDR (obj);
+
+          EVENT_INIT (inev);
+
+          while (info_size >= min_size)
+            {
+              Lisp_Object utf_16_fn
+                = make_unibyte_string ((char *)fni->FileName,
+                                       fni->FileNameLength);
+              /* Note: mule-conf is preloaded, so utf-16le must
+                 already be defined at this point.  */
+              Lisp_Object fname
+                = code_convert_string_norecord (utf_16_fn, cs, 0);
+              Lisp_Object action = lispy_file_action (fni->Action);
+
+              inev.kind = FILE_NOTIFY_EVENT;
+              inev.code = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
+              inev.timestamp = GetTickCount ();
+              inev.modifiers = 0;
+              inev.frame_or_window = callback;
+              inev.arg = Fcons (action, fname);
+              kbd_buffer_store_event_hold (&inev, hold_quit);
+
+              if (!fni->NextEntryOffset)
+                break;
+              p += fni->NextEntryOffset;
+              fni = (PFILE_NOTIFY_INFORMATION)p;
+              info_size -= fni->NextEntryOffset;
+            }
+        }
+      notification_buffer_in_use = 0;
+    }
+  leave_crit ();
+  return nevents;
+}
+
 /* Here's an overview of how Emacs input works in non-GUI sessions on
    MS-Windows.  (For description of the GUI input, see the commentary
    before w32_msg_pump in w32fns.c.)
@@ -619,12 +688,16 @@ w32_console_read_socket (struct terminal *terminal,
 
   for (;;)
     {
+      int nfnotify = handle_file_notifications (hold_quit);
+
       nev = fill_queue (0);
       if (nev <= 0)
         {
           /* If nev == -1, there was some kind of error
-             If nev == 0 then waitp must be zero and no events were available
+             If nev == 0 then no events were available
              so return.  */
+          if (nfnotify)
+            nev = 0;
           break;
         }
 
diff --git a/src/w32inevt.h b/src/w32inevt.h
index 319688b877b..8a7e4fed06a 100644
--- a/src/w32inevt.h
+++ b/src/w32inevt.h
@@ -1,5 +1,5 @@
 /* Input routines for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1995, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1995, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32menu.c b/src/w32menu.c
index 84fb1bdc71e..03904cf20b8 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -1,6 +1,6 @@
 /* Menu support for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1986, 1988, 1993-1994, 1996, 1998-1999, 2001-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1986, 1988, 1993-1994, 1996, 1998-1999, 2001-2013 Free
+   Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32notify.c b/src/w32notify.c
new file mode 100644
index 00000000000..1bcaa794565
--- /dev/null
+++ b/src/w32notify.c
@@ -0,0 +1,637 @@
+/* Filesystem notifications support for GNU Emacs on the Microsoft Windows API.
+   Copyright (C) 2012-2013 Free Software Foundation, Inc.
+
+This file is part of GNU Emacs.
+
+GNU Emacs is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+GNU Emacs is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
+
+/* Written by Eli Zaretskii <eliz@gnu.org>.
+
+   Design overview:
+
+   For each watch request, we launch a separate worker thread.  The
+   worker thread runs the watch_worker function, which issues an
+   asynchronous call to ReadDirectoryChangesW, and then waits in
+   SleepEx for that call to complete.  Waiting in SleepEx puts the
+   thread in an "alertable" state, so it wakes up when either (a) the
+   call to ReadDirectoryChangesW completes, or (b) the main thread
+   instructs the worker thread to terminate by sending it an APC, see
+   below.
+
+   When the ReadDirectoryChangesW call completes, its completion
+   routine watch_completion is automatically called.  watch_completion
+   stashes the received file events in a buffer used to communicate
+   them to the main thread (using a critical section, so that several
+   threads could use the same buffer), posts a special message,
+   WM_EMACS_FILENOTIFY, to the Emacs's message queue, and returns.
+   That causes the SleepEx function call inside watch_worker to
+   return, and watch_worker then issues another call to
+   ReadDirectoryChangesW.  (Except when it does not, see below.)
+
+   In a GUI session, The WM_EMACS_FILENOTIFY message, posted to the
+   message queue gets dispatched to the main Emacs window procedure,
+   which queues it for processing by w32_read_socket.  When
+   w32_read_socket sees this message, it accesses the buffer with file
+   notifications (using a critical section), extracts the information,
+   converts it to a series of FILE_NOTIFY_EVENT events, and stuffs
+   them into the input event queue to be processed by keyboard.c input
+   machinery (read_char via a call to kbd_buffer_get_event).
+
+   In a non-GUI session, we send the WM_EMACS_FILENOTIFY message to
+   the main (a.k.a. "Lisp") thread instead, since there are no window
+   procedures in console programs.  That message wakes up
+   MsgWaitForMultipleObjects inside sys_select, which then signals to
+   its caller that some keyboard input is available.  This causes
+   w32_console_read_socket to be called, which accesses the buffer
+   with file notifications and stuffs them into the input event queue
+   for keyboard.c to process.
+
+   When the FILE_NOTIFY_EVENT event is processed by keyboard.c's
+   kbd_buffer_get_event, it is converted to a Lispy event that can be
+   bound to a command.  The default binding is w32notify-handle-event,
+   defined on subr.el.
+
+   After w32_read_socket or w32_console_read_socket are done
+   processing the notifications, they reset a flag signaling to all
+   watch worker threads that the notifications buffer is available for
+   more input.
+
+   When the watch is removed by a call to w32notify-rm-watch, the main
+   thread requests that the worker thread terminates by queuing an APC
+   for the worker thread.  The APC specifies the watch_end function to
+   be called.  watch_end calls CancelIo on the outstanding
+   ReadDirectoryChangesW call and closes the handle on which the
+   watched directory was open.  When watch_end returns, the
+   watch_completion function is called one last time with the
+   ERROR_OPERATION_ABORTED status, which causes it to clean up and set
+   a flag telling watch_worker to exit without issuing another
+   ReadDirectoryChangesW call.  Since watch_worker is the thread
+   procedure of the worker thread, exiting it causes the thread to
+   exit.  The main thread waits for some time for the worker thread to
+   exit, and if it doesn't, terminates it forcibly.  */
+
+#include <stddef.h>
+#include <errno.h>
+
+/* must include CRT headers *before* config.h */
+#include <config.h>
+
+#include <windows.h>
+
+#include "lisp.h"
+#include "w32term.h"    /* for enter_crit/leave_crit and WM_EMACS_FILENOTIFY */
+#include "w32common.h"  /* for OS version data */
+#include "w32.h"        /* for w32_strerror */
+#include "coding.h"
+#include "keyboard.h"
+#include "frame.h"      /* needed by termhooks.h */
+#include "termhooks.h"  /* for FILE_NOTIFY_EVENT */
+
+#define DIRWATCH_SIGNATURE 0x01233210
+
+struct notification {
+  BYTE *buf;            /* buffer for ReadDirectoryChangesW */
+  OVERLAPPED *io_info;  /* the OVERLAPPED structure for async I/O */
+  BOOL subtree;         /* whether to watch subdirectories */
+  DWORD filter;         /* bit mask for events to watch */
+  char *watchee;        /* the file we are interested in */
+  HANDLE dir;           /* handle to the watched directory */
+  HANDLE thr;           /* handle to the thread that watches */
+  volatile int terminate; /* if non-zero, request for the thread to terminate */
+  unsigned signature;
+};
+
+/* Used for communicating notifications to the main thread.  */
+volatile int notification_buffer_in_use;
+BYTE file_notifications[16384];
+DWORD notifications_size;
+void *notifications_desc;
+
+static Lisp_Object Qfile_name, Qdirectory_name, Qattributes, Qsize;
+static Lisp_Object Qlast_write_time, Qlast_access_time, Qcreation_time;
+static Lisp_Object Qsecurity_desc, Qsubtree, watch_list;
+
+/* Signal to the main thread that we have file notifications for it to
+   process.  */
+static void
+send_notifications (BYTE *info, DWORD info_size, void *desc,
+                    volatile int *terminate)
+{
+  int done = 0;
+  FRAME_PTR f = SELECTED_FRAME ();
+
+  /* A single buffer is used to communicate all notifications to the
+     main thread.  Since both the main thread and several watcher
+     threads could be active at the same time, we use a critical area
+     and an "in-use" flag to synchronize them.  A watcher thread can
+     only put its notifications in the buffer if it acquires the
+     critical area and finds the "in-use" flag reset.  The main thread
+     resets the flag after it is done processing notifications.
+
+     FIXME: is there a better way of dealing with this?  */
+  while (!done && !*terminate)
+    {
+      enter_crit ();
+      if (!notification_buffer_in_use)
+        {
+          if (info_size)
+            memcpy (file_notifications, info, info_size);
+          notifications_size = info_size;
+          notifications_desc = desc;
+          /* If PostMessage fails, the message queue is full.  If that
+             happens, the last thing they will worry about is file
+             notifications.  So we effectively discard the
+             notification in that case.  */
+          if ((FRAME_TERMCAP_P (f)
+               /* We send the message to the main (a.k.a. "Lisp")
+                  thread, where it will wake up MsgWaitForMultipleObjects
+                  inside sys_select, causing it to report that there's
+                  some keyboard input available.  This will in turn cause
+                  w32_console_read_socket to be called, which will pick
+                  up the file notifications.  */
+               && PostThreadMessage (dwMainThreadId, WM_EMACS_FILENOTIFY, 0, 0))
+              || (FRAME_W32_P (f)
+                  && PostMessage (FRAME_W32_WINDOW (f),
+                                  WM_EMACS_FILENOTIFY, 0, 0)))
+            notification_buffer_in_use = 1;
+          done = 1;
+        }
+      leave_crit ();
+      if (!done)
+        Sleep (5);
+    }
+}
+
+/* An APC routine to cancel outstanding directory watch.  Invoked by
+   the main thread via QueueUserAPC.  This is needed because only the
+   thread that issued the ReadDirectoryChangesW call can call CancelIo
+   to cancel that.  (CancelIoEx is only available since Vista, so we
+   cannot use it on XP.)  */
+VOID CALLBACK
+watch_end (ULONG_PTR arg)
+{
+  HANDLE hdir = (HANDLE)arg;
+
+  if (hdir && hdir != INVALID_HANDLE_VALUE)
+    {
+      CancelIo (hdir);
+      CloseHandle (hdir);
+    }
+}
+
+/* A completion routine (a.k.a. "APC function") for handling events
+   read by ReadDirectoryChangesW.  Called by the OS when the thread
+   which issued the asynchronous ReadDirectoryChangesW call is in the
+   "alertable state", i.e. waiting inside SleepEx call.  */
+VOID CALLBACK
+watch_completion (DWORD status, DWORD bytes_ret, OVERLAPPED *io_info)
+{
+  struct notification *dirwatch;
+
+  /* Who knows what happened?  Perhaps the OVERLAPPED structure was
+     freed by someone already?  In any case, we cannot do anything
+     with this request, so just punt and skip it.  FIXME: should we
+     raise the 'terminate' flag in this case?  */
+  if (!io_info)
+    return;
+
+  /* We have a pointer to our dirwatch structure conveniently stashed
+     away in the hEvent member of the OVERLAPPED struct.  According to
+     MSDN documentation of ReadDirectoryChangesW: "The hEvent member
+     of the OVERLAPPED structure is not used by the system, so you can
+     use it yourself."  */
+  dirwatch = (struct notification *)io_info->hEvent;
+  if (status == ERROR_OPERATION_ABORTED)
+    {
+      /* We've been called because the main thread told us to issue
+         CancelIo on the directory we watch, and watch_end did so.
+         The directory handle is already closed.  We should clean up
+         and exit, signaling to the thread worker routine not to
+         issue another call to ReadDirectoryChangesW.  Note that we
+         don't free the dirwatch object itself nor the memory consumed
+         by its buffers; this is done by the main thread in
+         remove_watch.  Calling malloc/free from a thread other than
+         the main thread is a no-no.  */
+      dirwatch->dir = NULL;
+      dirwatch->terminate = 1;
+    }
+  else
+    {
+      /* Tell the main thread we have notifications for it.  */
+      send_notifications (dirwatch->buf, bytes_ret, dirwatch,
+                          &dirwatch->terminate);
+    }
+}
+
+/* Worker routine for the watch thread.  */
+static DWORD WINAPI
+watch_worker (LPVOID arg)
+{
+  struct notification *dirwatch = (struct notification *)arg;
+
+  do {
+    BOOL status;
+    DWORD sleep_result;
+    DWORD bytes_ret = 0;
+
+    if (dirwatch->dir)
+      {
+        status = ReadDirectoryChangesW (dirwatch->dir, dirwatch->buf, 16384,
+                                        dirwatch->subtree, dirwatch->filter,
+                                        &bytes_ret,
+                                        dirwatch->io_info, watch_completion);
+        if (!status)
+          {
+            DebPrint (("watch_worker, abnormal exit: %lu\n", GetLastError ()));
+            /* We cannot remove the dirwatch object from watch_list,
+               because we are in a separate thread.  For the same
+               reason, we also cannot free memory consumed by the
+               buffers allocated for the dirwatch object.  So we close
+               the directory handle, but do not free the object itself
+               or its buffers.  We also don't touch the signature.
+               This way, remove_watch can still identify the object,
+               remove it, and free its memory.  */
+            CloseHandle (dirwatch->dir);
+            dirwatch->dir = NULL;
+            return 1;
+          }
+      }
+    /* Sleep indefinitely until awoken by the I/O completion, which
+       could be either a change notification or a cancellation of the
+       watch.  */
+    sleep_result = SleepEx (INFINITE, TRUE);
+  } while (!dirwatch->terminate);
+
+  return 0;
+}
+
+/* Launch a thread to watch changes to FILE in a directory open on
+   handle HDIR.  */
+static struct notification *
+start_watching (const char *file, HANDLE hdir, BOOL subdirs, DWORD flags)
+{
+  struct notification *dirwatch = xzalloc (sizeof (struct notification));
+  HANDLE thr;
+
+  dirwatch->signature = DIRWATCH_SIGNATURE;
+  dirwatch->buf = xmalloc (16384);
+  dirwatch->io_info = xzalloc (sizeof(OVERLAPPED));
+  /* Stash a pointer to dirwatch structure for use by the completion
+     routine.  According to MSDN documentation of ReadDirectoryChangesW:
+     "The hEvent member of the OVERLAPPED structure is not used by the
+     system, so you can use it yourself." */
+  dirwatch->io_info->hEvent = dirwatch;
+  dirwatch->subtree = subdirs;
+  dirwatch->filter = flags;
+  dirwatch->watchee = xstrdup (file);
+  dirwatch->terminate = 0;
+  dirwatch->dir = hdir;
+
+  /* See w32proc.c where it calls CreateThread for the story behind
+     the 2nd and 5th argument in the call to CreateThread.  */
+  dirwatch->thr = CreateThread (NULL, 64 * 1024, watch_worker, (void *)dirwatch,
+                                0x00010000, NULL);
+
+  if (!dirwatch->thr)
+    {
+      xfree (dirwatch->buf);
+      xfree (dirwatch->io_info);
+      xfree (dirwatch->watchee);
+      xfree (dirwatch);
+      dirwatch = NULL;
+    }
+  return dirwatch;
+}
+
+/* Called from the main thread to start watching FILE in PARENT_DIR,
+   subject to FLAGS.  If SUBDIRS is TRUE, watch the subdirectories of
+   PARENT_DIR as well.  Value is a pointer to 'struct notification'
+   used by the thread that watches the changes.  */
+static struct notification *
+add_watch (const char *parent_dir, const char *file, BOOL subdirs, DWORD flags)
+{
+  HANDLE hdir;
+  struct notification *dirwatch = NULL;
+
+  if (!file || !*file)
+    return NULL;
+
+  hdir = CreateFile (parent_dir,
+                     FILE_LIST_DIRECTORY,
+                     /* FILE_SHARE_DELETE doesn't preclude other
+                        processes from deleting files inside
+                        parent_dir.  */
+                     FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                     NULL, OPEN_EXISTING,
+                     FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OVERLAPPED,
+                     NULL);
+  if (hdir == INVALID_HANDLE_VALUE)
+    return NULL;
+
+  if ((dirwatch = start_watching (file, hdir, subdirs, flags)) == NULL)
+    CloseHandle (hdir);
+
+  return dirwatch;
+}
+
+/* Stop watching a directory specified by a pointer to its dirwatch object.  */
+static int
+remove_watch (struct notification *dirwatch)
+{
+  if (dirwatch && dirwatch->signature == DIRWATCH_SIGNATURE)
+    {
+      int i;
+      BOOL status;
+      DWORD exit_code, err;
+
+      /* Only the thread that issued the outstanding I/O call can call
+         CancelIo on it.  (CancelIoEx is available only since Vista.)
+         So we need to queue an APC for the worker thread telling it
+         to terminate.  */
+      if (!QueueUserAPC (watch_end, dirwatch->thr, (ULONG_PTR)dirwatch->dir))
+        DebPrint (("QueueUserAPC failed (%lu)!\n", GetLastError ()));
+      /* We also set the terminate flag, for when the thread is
+         waiting on the critical section that never gets acquired.
+         FIXME: is there a cleaner method?  Using SleepEx there is a
+         no-no, as that will lead to recursive APC invocations and
+         stack overflow.  */
+      dirwatch->terminate = 1;
+      /* Wait for the thread to exit.  FIXME: is there a better method
+         that is not overly complex?  */
+      for (i = 0; i < 50; i++)
+        {
+          if (!((status = GetExitCodeThread (dirwatch->thr, &exit_code))
+                && exit_code == STILL_ACTIVE))
+            break;
+          Sleep (10);
+        }
+      if ((status == FALSE && (err = GetLastError ()) == ERROR_INVALID_HANDLE)
+          || exit_code == STILL_ACTIVE)
+        {
+          if (!(status == FALSE && err == ERROR_INVALID_HANDLE))
+            {
+              TerminateThread (dirwatch->thr, 0);
+              if (dirwatch->dir)
+                CloseHandle (dirwatch->dir);
+            }
+        }
+
+      /* Clean up.  */
+      if (dirwatch->thr)
+        {
+          CloseHandle (dirwatch->thr);
+          dirwatch->thr = NULL;
+        }
+      xfree (dirwatch->buf);
+      xfree (dirwatch->io_info);
+      xfree (dirwatch->watchee);
+      xfree (dirwatch);
+
+      return 0;
+    }
+  else
+    {
+      DebPrint (("Unknown dirwatch object!\n"));
+      return -1;
+    }
+}
+
+static DWORD
+filter_list_to_flags (Lisp_Object filter_list)
+{
+  DWORD flags = 0;
+
+  if (NILP (filter_list))
+    return flags;
+
+  if (!NILP (Fmember (Qfile_name, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_FILE_NAME;
+  if (!NILP (Fmember (Qdirectory_name, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_DIR_NAME;
+  if (!NILP (Fmember (Qattributes, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_ATTRIBUTES;
+  if (!NILP (Fmember (Qsize, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_SIZE;
+  if (!NILP (Fmember (Qlast_write_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_LAST_WRITE;
+  if (!NILP (Fmember (Qlast_access_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
+  if (!NILP (Fmember (Qcreation_time, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_CREATION;
+  if (!NILP (Fmember (Qsecurity_desc, filter_list)))
+    flags |= FILE_NOTIFY_CHANGE_SECURITY;
+
+  return flags;
+}
+
+DEFUN ("w32notify-add-watch", Fw32notify_add_watch,
+       Sw32notify_add_watch, 3, 3, 0,
+       doc: /* Add a watch for filesystem events pertaining to FILE.
+
+This arranges for filesystem events pertaining to FILE to be reported
+to Emacs.  Use `w32notify-rm-watch' to cancel the watch.
+
+Value is a descriptor for the added watch.  If the file cannot be
+watched for some reason, this function signals a `file-error' error.
+
+FILTER is a list of conditions for reporting an event.  It can include
+the following symbols:
+
+  'file-name'          -- report file creation, deletion, or renaming
+  'directory-name'     -- report directory creation, deletion, or renaming
+  'attributes'         -- report changes in attributes
+  'size'               -- report changes in file-size
+  'last-write-time'    -- report changes in last-write time
+  'last-access-time'   -- report changes in last-access time
+  'creation-time'      -- report changes in creation time
+  'security-desc'      -- report changes in security descriptor
+
+If FILE is a directory, and FILTER includes 'subtree', then all the
+subdirectories will also be watched and changes in them reported.
+
+When any event happens that satisfies the conditions specified by
+FILTER, Emacs will call the CALLBACK function passing it a single
+argument EVENT, which is of the form
+
+  (DESCRIPTOR ACTION FILE)
+
+DESCRIPTOR is the same object as the one returned by this function.
+ACTION is the description of the event.  It could be any one of the
+following:
+
+  'added'        -- FILE was added
+  'removed'      -- FILE was deleted
+  'modified'     -- FILE's contents or its attributes were modified
+  'renamed-from' -- a file was renamed whose old name was FILE
+  'renamed-to'   -- a file was renamed and its new name is FILE
+
+FILE is the name of the file whose event is being reported.
+
+Note that some networked filesystems, such as Samba-mounted Unix
+volumes, might not send notifications about file changes.  In these
+cases, this function will return a valid descriptor, but notifications
+will never come in.  Volumes shared from remote Windows machines do
+generate notifications correctly, though.  */)
+  (Lisp_Object file, Lisp_Object filter, Lisp_Object callback)
+{
+  Lisp_Object encoded_file, watch_object, watch_descriptor;
+  char parent_dir[MAX_PATH], *basename;
+  size_t fn_len;
+  DWORD flags;
+  BOOL subdirs = FALSE;
+  struct notification *dirwatch = NULL;
+  Lisp_Object lisp_errstr;
+  char *errstr;
+
+  CHECK_LIST (filter);
+
+  /* The underlying features are available only since XP.  */
+  if (os_subtype == OS_9X
+      || (w32_major_version == 5 && w32_major_version < 1))
+    {
+      errno = ENOSYS;
+      report_file_error ("Watching filesystem events is not supported",
+                         Qnil);
+    }
+
+  /* We need a full absolute file name of FILE, and we need to remove
+     any trailing slashes from it, so that GetFullPathName below gets
+     the basename part correctly.  */
+  file = Fdirectory_file_name (Fexpand_file_name (file, Qnil));
+  encoded_file = ENCODE_FILE (file);
+
+  fn_len = GetFullPathName (SDATA (encoded_file), MAX_PATH, parent_dir,
+                            &basename);
+  if (!fn_len)
+    {
+      errstr = w32_strerror (0);
+      errno = EINVAL;
+      if (!NILP (Vlocale_coding_system))
+        lisp_errstr
+          = code_convert_string_norecord (build_unibyte_string (errstr),
+                                          Vlocale_coding_system, 0);
+      else
+        lisp_errstr = build_string (errstr);
+      report_file_error ("GetFullPathName failed",
+                         Fcons (lisp_errstr, Fcons (file, Qnil)));
+    }
+  /* We need the parent directory without the slash that follows it.
+     If BASENAME is NULL, the argument was the root directory on its
+     drive.  */
+  if (basename)
+    basename[-1] = '\0';
+  else
+    subdirs = TRUE;
+
+  if (!NILP (Fmember (Qsubtree, filter)))
+    subdirs = TRUE;
+
+  flags = filter_list_to_flags (filter);
+
+  dirwatch = add_watch (parent_dir, basename, subdirs, flags);
+  if (!dirwatch)
+    {
+      DWORD err = GetLastError ();
+
+      errno = EINVAL;
+      if (err)
+        {
+          errstr = w32_strerror (err);
+          if (!NILP (Vlocale_coding_system))
+            lisp_errstr
+              = code_convert_string_norecord (build_unibyte_string (errstr),
+                                              Vlocale_coding_system, 0);
+          else
+            lisp_errstr = build_string (errstr);
+          report_file_error ("Cannot watch file",
+                             Fcons (lisp_errstr, Fcons (file, Qnil)));
+        }
+      else
+        report_file_error ("Cannot watch file", Fcons (file, Qnil));
+    }
+  /* Store watch object in watch list. */
+  watch_descriptor = XIL ((EMACS_INT)dirwatch);
+  watch_object = Fcons (watch_descriptor, callback);
+  watch_list = Fcons (watch_object, watch_list);
+
+  return watch_descriptor;
+}
+
+DEFUN ("w32notify-rm-watch", Fw32notify_rm_watch,
+       Sw32notify_rm_watch, 1, 1, 0,
+       doc: /* Remove an existing watch specified by its WATCH-DESCRIPTOR.
+
+WATCH-DESCRIPTOR should be an object returned by `w32notify-add-watch'.  */)
+     (Lisp_Object watch_descriptor)
+{
+  Lisp_Object watch_object;
+  struct notification *dirwatch;
+  int status = -1;
+
+  /* Remove the watch object from watch list.  Do this before freeing
+     the object, do that even if we fail to free it, watch_list is
+     kept free of junk.  */
+  watch_object = Fassoc (watch_descriptor, watch_list);
+  if (!NILP (watch_object))
+    {
+      watch_list = Fdelete (watch_object, watch_list);
+      dirwatch = (struct notification *)XLI (watch_descriptor);
+      if (w32_valid_pointer_p (dirwatch, sizeof(struct notification)))
+        status = remove_watch (dirwatch);
+    }
+
+  if (status == -1)
+    report_file_error ("Invalid watch descriptor", Fcons (watch_descriptor,
+                                                          Qnil));
+
+  return Qnil;
+}
+
+Lisp_Object
+w32_get_watch_object (void *desc)
+{
+  Lisp_Object descriptor = XIL ((EMACS_INT)desc);
+
+  /* This is called from the input queue handling code, inside a
+     critical section, so we cannot possibly QUIT if watch_list is not
+     in the right condition.  */
+  return NILP (watch_list) ? Qnil : assoc_no_quit (descriptor, watch_list);
+}
+
+void
+globals_of_w32notify (void)
+{
+  watch_list = Qnil;
+}
+
+void
+syms_of_w32notify (void)
+{
+  DEFSYM (Qfile_name, "file-name");
+  DEFSYM (Qdirectory_name, "directory-name");
+  DEFSYM (Qattributes, "attributes");
+  DEFSYM (Qsize, "size");
+  DEFSYM (Qlast_write_time, "last-write-time");
+  DEFSYM (Qlast_access_time, "last-access-time");
+  DEFSYM (Qcreation_time, "creation-time");
+  DEFSYM (Qsecurity_desc, "security-desc");
+  DEFSYM (Qsubtree, "subtree");
+
+  defsubr (&Sw32notify_add_watch);
+  defsubr (&Sw32notify_rm_watch);
+
+  staticpro (&watch_list);
+
+  Fprovide (intern_c_string ("w32notify"), Qnil);
+}
diff --git a/src/w32proc.c b/src/w32proc.c
index d888200c556..3f3e97c77a0 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -1,5 +1,5 @@
 /* Process support for GNU Emacs on the Microsoft Windows API.
-   Copyright (C) 1992, 1995, 1999-2012  Free Software Foundation, Inc.
+   Copyright (C) 1992, 1995, 1999-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -800,9 +800,51 @@ new_child (void)
   DWORD id;
 
   for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
-    if (!CHILD_ACTIVE (cp))
+    if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
       goto Initialize;
   if (child_proc_count == MAX_CHILDREN)
+    {
+      int i = 0;
+      child_process *dead_cp = NULL;
+
+      DebPrint (("new_child: No vacant slots, looking for dead processes\n"));
+      for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
+        if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
+          {
+            DWORD status = 0;
+
+            if (!GetExitCodeProcess (cp->procinfo.hProcess, &status))
+              {
+                DebPrint (("new_child.GetExitCodeProcess: error %lu for PID %lu\n",
+                           GetLastError (), cp->procinfo.dwProcessId));
+                status = STILL_ACTIVE;
+              }
+            if (status != STILL_ACTIVE
+                || WaitForSingleObject (cp->procinfo.hProcess, 0) == WAIT_OBJECT_0)
+              {
+                DebPrint (("new_child: Freeing slot of dead process %d, fd %d\n",
+                           cp->procinfo.dwProcessId, cp->fd));
+                CloseHandle (cp->procinfo.hProcess);
+                cp->procinfo.hProcess = NULL;
+                CloseHandle (cp->procinfo.hThread);
+                cp->procinfo.hThread = NULL;
+                /* Free up to 2 dead slots at a time, so that if we
+                   have a lot of them, they will eventually all be
+                   freed when the tornado ends.  */
+                if (i == 0)
+                  dead_cp = cp;
+                else
+                  break;
+                i++;
+              }
+          }
+      if (dead_cp)
+        {
+          cp = dead_cp;
+          goto Initialize;
+        }
+    }
+  if (child_proc_count == MAX_CHILDREN)
     return NULL;
   cp = &child_procs[child_proc_count++];
 
@@ -812,6 +854,8 @@ new_child (void)
   cp->pid = -1;
   cp->procinfo.hProcess = NULL;
   cp->status = STATUS_READ_ERROR;
+  cp->input_file = NULL;
+  cp->pending_deletion = 0;
 
   /* use manual reset event so that select() will function properly */
   cp->char_avail = CreateEvent (NULL, TRUE, FALSE, NULL);
@@ -857,9 +901,24 @@ delete_child (child_process *cp)
     if (fd_info[i].cp == cp)
       emacs_abort ();
 
-  if (!CHILD_ACTIVE (cp))
+  if (!CHILD_ACTIVE (cp) && cp->procinfo.hProcess == NULL)
     return;
 
+  /* Delete the child's temporary input file, if any, that is pending
+     deletion.  */
+  if (cp->input_file)
+    {
+      if (cp->pending_deletion)
+        {
+          if (unlink (cp->input_file))
+            DebPrint (("delete_child.unlink (%s) failed, errno: %d\n",
+                       cp->input_file, errno));
+          cp->pending_deletion = 0;
+        }
+      xfree (cp->input_file);
+      cp->input_file = NULL;
+    }
+
   /* reap thread if necessary */
   if (cp->thrd)
     {
@@ -901,7 +960,8 @@ delete_child (child_process *cp)
   if (cp == child_procs + child_proc_count - 1)
     {
       for (i = child_proc_count-1; i >= 0; i--)
-        if (CHILD_ACTIVE (&child_procs[i]))
+        if (CHILD_ACTIVE (&child_procs[i])
+            || child_procs[i].procinfo.hProcess != NULL)
           {
             child_proc_count = i + 1;
             break;
@@ -918,7 +978,8 @@ find_child_pid (DWORD pid)
   child_process *cp;
 
   for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
-    if (CHILD_ACTIVE (cp) && pid == cp->pid)
+    if ((CHILD_ACTIVE (cp) || cp->procinfo.hProcess != NULL)
+        && pid == cp->pid)
       return cp;
   return NULL;
 }
@@ -946,17 +1007,23 @@ reader_thread (void *arg)
     {
       int rc;
 
-      if (fd_info[cp->fd].flags & FILE_LISTEN)
+      if (cp->fd >= 0 && fd_info[cp->fd].flags & FILE_LISTEN)
         rc = _sys_wait_accept (cp->fd);
       else
         rc = _sys_read_ahead (cp->fd);
 
+      /* Don't bother waiting for the event if we already have been
+         told to exit by delete_child.  */
+      if (cp->status == STATUS_READ_ERROR || !cp->char_avail)
+        break;
+
       /* The name char_avail is a misnomer - it really just means the
          read-ahead has completed, whether successfully or not. */
       if (!SetEvent (cp->char_avail))
         {
-          DebPrint (("reader_thread.SetEvent failed with %lu for fd %ld\n",
-                     GetLastError (), cp->fd));
+          DebPrint (("reader_thread.SetEvent(0x%x) failed with %lu for fd %ld (PID %d)\n",
+                     (DWORD_PTR)cp->char_avail, GetLastError (),
+                     cp->fd, cp->pid));
           return 1;
         }
 
@@ -967,6 +1034,11 @@ reader_thread (void *arg)
       if (rc == STATUS_READ_FAILED)
         break;
 
+      /* Don't bother waiting for the acknowledge if we already have
+         been told to exit by delete_child.  */
+      if (cp->status == STATUS_READ_ERROR || !cp->char_consumed)
+        break;
+
       /* Wait until our input is acknowledged before reading again */
       if (WaitForSingleObject (cp->char_consumed, INFINITE) != WAIT_OBJECT_0)
         {
@@ -974,6 +1046,10 @@ reader_thread (void *arg)
                      "%lu for fd %ld\n", GetLastError (), cp->fd));
           break;
         }
+      /* delete_child sets status to STATUS_READ_ERROR when it wants
+         us to exit.  */
+      if (cp->status == STATUS_READ_ERROR)
+        break;
     }
   return 0;
 }
@@ -1056,11 +1132,11 @@ create_child (char *exe, char *cmdline, char *env, int is_gui_app,
    This way the select emulator knows how to match file handles with
    entries in child_procs.  */
 void
-register_child (int pid, int fd)
+register_child (pid_t pid, int fd)
 {
   child_process *cp;
 
-  cp = find_child_pid (pid);
+  cp = find_child_pid ((DWORD)pid);
   if (cp == NULL)
     {
       DebPrint (("register_child unable to find pid %lu\n", pid));
@@ -1087,10 +1163,46 @@ register_child (int pid, int fd)
   fd_info[fd].cp = cp;
 }
 
-/* When a process dies its pipe will break so the reader thread will
-   signal failure to the select emulator.
-   The select emulator then calls this routine to clean up.
-   Since the thread signaled failure we can assume it is exiting.  */
+/* Record INFILE as an input file for process PID.  */
+void
+record_infile (pid_t pid, char *infile)
+{
+  child_process *cp;
+
+  /* INFILE should never be NULL, since xstrdup would have signaled
+     memory full condition in that case, see callproc.c where this
+     function is called.  */
+  eassert (infile);
+
+  cp = find_child_pid ((DWORD)pid);
+  if (cp == NULL)
+    {
+      DebPrint (("record_infile is unable to find pid %lu\n", pid));
+      return;
+    }
+
+  cp->input_file = infile;
+}
+
+/* Mark the input file INFILE of the corresponding subprocess as
+   temporary, to be deleted when the subprocess exits.  */
+void
+record_pending_deletion (char *infile)
+{
+  child_process *cp;
+
+  eassert (infile);
+
+  for (cp = child_procs + (child_proc_count-1); cp >= child_procs; cp--)
+    if (CHILD_ACTIVE (cp)
+        && cp->input_file && xstrcasecmp (cp->input_file, infile) == 0)
+      {
+        cp->pending_deletion = 1;
+        break;
+      }
+}
+
+/* Called from waitpid when a process exits.  */
 static void
 reap_subprocess (child_process *cp)
 {
@@ -1100,7 +1212,7 @@ reap_subprocess (child_process *cp)
 #ifdef FULL_DEBUG
       /* Process should have already died before we are called.  */
       if (WaitForSingleObject (cp->procinfo.hProcess, 0) != WAIT_OBJECT_0)
-        DebPrint (("reap_subprocess: child fpr fd %d has not died yet!", cp->fd));
+        DebPrint (("reap_subprocess: child for fd %d has not died yet!", cp->fd));
 #endif
       CloseHandle (cp->procinfo.hProcess);
       cp->procinfo.hProcess = NULL;
@@ -1108,11 +1220,11 @@ reap_subprocess (child_process *cp)
       cp->procinfo.hThread = NULL;
     }
 
-  /* For asynchronous children, the child_proc resources will be freed
-     when the last pipe read descriptor is closed; for synchronous
-     children, we must explicitly free the resources now because
-     register_child has not been called. */
-  if (cp->fd == -1)
+  /* If cp->fd was not closed yet, we might be still reading the
+     process output, so don't free its resources just yet.  The call
+     to delete_child on behalf of this subprocess will be made by
+     sys_read when the subprocess output is fully read.  */
+  if (cp->fd < 0)
     delete_child (cp);
 }
 
@@ -1468,11 +1580,10 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
   Lisp_Object program, full;
   char *cmdline, *env, *parg, **targ;
   int arglen, numenv;
-  int pid;
+  pid_t pid;
   child_process *cp;
   int is_dos_app, is_cygnus_app, is_gui_app;
   int do_quoting = 0;
-  char escape_char;
   /* We pass our process ID to our children by setting up an environment
      variable in their environment.  */
   char ppid_env_var_buffer[64];
@@ -1485,6 +1596,8 @@ sys_spawnve (int mode, char *cmdname, char **argv, char **envp)
      Some extra whitespace characters need quoting in Cygwin programs,
      so this list is conditionally modified below.  */
   char *sepchars = " \t*?";
+  /* This is for native w32 apps; modified below for Cygwin apps.  */
+  char escape_char = '\\';
 
   /* We don't care about the other modes */
   if (mode != _P_NOWAIT)
@@ -1857,7 +1970,7 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
           }
         else
           {
-            /* Child process and socket input */
+            /* Child process and socket/comm port input.  */
             cp = fd_info[i].cp;
             if (cp)
               {
@@ -1870,7 +1983,7 @@ sys_select (int nfds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
                     /* Wake up the reader thread for this process */
                     cp->status = STATUS_READ_READY;
                     if (!SetEvent (cp->char_consumed))
-                      DebPrint (("nt_select.SetEvent failed with "
+                      DebPrint (("sys_select.SetEvent failed with "
                                  "%lu for fd %ld\n", GetLastError (), i));
                   }
 
@@ -1938,7 +2051,7 @@ count_children:
     /* Some child_procs might be sockets; ignore them.  Also some
        children may have died already, but we haven't finished reading
        the process output; ignore them too.  */
-    if (CHILD_ACTIVE (cp) && cp->procinfo.hProcess
+    if ((CHILD_ACTIVE (cp) && cp->procinfo.hProcess)
         && (cp->fd < 0
             || (fd_info[cp->fd].flags & FILE_SEND_SIGCHLD) == 0
             || (fd_info[cp->fd].flags & FILE_AT_EOF) != 0)
@@ -2018,7 +2131,24 @@ count_children:
              (*) Note that MsgWaitForMultipleObjects above is an
              internal dispatch point for messages that are sent to
              windows created by this thread.  */
-          drain_message_queue ();
+          if (drain_message_queue ()
+              /* If drain_message_queue returns non-zero, that means
+                 we received a WM_EMACS_FILENOTIFY message.  If this
+                 is a TTY frame, we must signal the caller that keyboard
+                 input is available, so that w32_console_read_socket
+                 will be called to pick up the notifications.  If we
+                 don't do that, file notifications will only work when
+                 the Emacs TTY frame has focus.  */
+              && FRAME_TERMCAP_P (SELECTED_FRAME ())
+              /* they asked for stdin reads */
+              && FD_ISSET (0, &orfds)
+              /* the stdin handle is valid */
+              && keyboard_handle)
+            {
+              FD_SET (0, rfds);
+              if (nr == 0)
+                nr = 1;
+            }
         }
       else if (active >= nh)
         {
@@ -2115,7 +2245,7 @@ find_child_console (HWND hwnd, LPARAM arg)
 
 /* Emulate 'kill', but only for other processes.  */
 int
-sys_kill (int pid, int sig)
+sys_kill (pid_t pid, int sig)
 {
   child_process *cp;
   HANDLE proc_hand;
@@ -2471,8 +2601,9 @@ All path elements in FILENAME are converted to their short names.  */)
   if (GetShortPathName (SDATA (ENCODE_FILE (filename)), shortname, MAX_PATH) == 0)
     return Qnil;
 
-  dostounix_filename (shortname);
+  dostounix_filename (shortname, 0);
 
+  /* No need to DECODE_FILE, because 8.3 names are pure ASCII.   */
   return build_string (shortname);
 }
 
@@ -2499,7 +2630,7 @@ All path elements in FILENAME are converted to their long names.  */)
   if (!w32_get_long_filename (SDATA (ENCODE_FILE (filename)), longname, MAX_PATH))
     return Qnil;
 
-  dostounix_filename (longname);
+  dostounix_filename (longname, 0);
 
   /* If we were passed only a drive, make sure that a slash is not appended
      for consistency with directories.  Allow for drive mapping via SUBST
diff --git a/src/w32reg.c b/src/w32reg.c
index 8b6c76503a6..e7c4e9ea351 100644
--- a/src/w32reg.c
+++ b/src/w32reg.c
@@ -1,5 +1,6 @@
 /* Emulate the X Resource Manager through the registry.
-   Copyright (C) 1990, 1993-1994, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993-1994, 2001-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32select.c b/src/w32select.c
index 6a2a840f914..3c966595d6d 100644
--- a/src/w32select.c
+++ b/src/w32select.c
@@ -1,6 +1,6 @@
 /* Selection processing for Emacs on the Microsoft Windows API.
 
-Copyright (C) 1993-1994, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1993-1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32select.h b/src/w32select.h
index 4f4de59f7fe..f6223b881d2 100644
--- a/src/w32select.h
+++ b/src/w32select.h
@@ -1,6 +1,6 @@
 /* Selection processing for Emacs on the Microsoft W32 API.
 
-Copyright (C) 1993-1994, 2001-2012 Free Software Foundation, Inc.
+Copyright (C) 1993-1994, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/w32term.c b/src/w32term.c
index e26777543fb..170f33ecd67 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -1,6 +1,6 @@
 /* Implementation of GUI terminal on the Microsoft Windows API.
 
-Copyright (C) 1989, 1993-2012 Free Software Foundation, Inc.
+Copyright (C) 1989, 1993-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -191,11 +191,7 @@ static Time last_mouse_movement_time;
 
 /* Incremented by w32_read_socket whenever it really tries to read
    events.  */
-#ifdef __STDC__
 static int volatile input_signal_count;
-#else
-static int input_signal_count;
-#endif
 
 #ifdef CYGWIN
 int w32_message_fd = -1;
@@ -246,6 +242,8 @@ static void x_check_font (struct frame *, struct font *);
 #endif
 
 static Lisp_Object Qvendor_specific_keysyms;
+static Lisp_Object Qadded, Qremoved, Qmodified;
+static Lisp_Object Qrenamed_from, Qrenamed_to;
 
 
 /***********************************************************************
@@ -356,7 +354,7 @@ w32_restore_glyph_string_clip (struct glyph_string *s)
 void
 w32_draw_underwave (struct glyph_string *s, COLORREF color)
 {
-  int wave_height = 2, wave_length = 3;
+  int wave_height = 3, wave_length = 2;
   int dx, dy, x0, y0, width, x1, y1, x2, y2, odd, xmax;
   XRectangle wave_clip, string_clip, final_clip;
   RECT w32_final_clip, w32_string_clip;
@@ -365,7 +363,7 @@ w32_draw_underwave (struct glyph_string *s, COLORREF color)
   dx = wave_length;
   dy = wave_height - 1;
   x0 = s->x;
-  y0 = s->ybase + 1;
+  y0 = s->ybase - wave_height + 3;
   width = s->width;
   xmax = x0 + width;
 
@@ -2454,7 +2452,8 @@ x_draw_glyph_string (struct glyph_string *s)
               unsigned long thickness, position;
               int y;
 
-              if (s->prev && s->prev->face->underline_p)
+              if (s->prev && s->prev->face->underline_p
+                  && s->prev->face->underline_type == FACE_UNDER_LINE)
                 {
                   /* We use the same underline style as the previous one.  */
                   thickness = s->prev->underline_thickness;
@@ -3204,6 +3203,124 @@ construct_drag_n_drop (struct input_event *result, W32Msg *msg, struct frame *f)
 }
 
 
+/* File event notifications (see w32notify.c).  */
+
+Lisp_Object
+lispy_file_action (DWORD action)
+{
+  static char unknown_fmt[] = "unknown-action(%d)";
+  Lisp_Object retval;
+
+  switch (action)
+    {
+    case FILE_ACTION_ADDED:
+      retval = Qadded;
+      break;
+    case FILE_ACTION_REMOVED:
+      retval = Qremoved;
+      break;
+    case FILE_ACTION_MODIFIED:
+      retval = Qmodified;
+      break;
+    case FILE_ACTION_RENAMED_OLD_NAME:
+      retval = Qrenamed_from;
+      break;
+    case FILE_ACTION_RENAMED_NEW_NAME:
+      retval = Qrenamed_to;
+      break;
+    default:
+      {
+        char buf[sizeof(unknown_fmt) - 1 + INT_STRLEN_BOUND (DWORD)];
+
+        sprintf (buf, unknown_fmt, action);
+        retval = intern (buf);
+      }
+      break;
+    }
+
+  return retval;
+}
+
+#ifdef WINDOWSNT
+/* Put file notifications into the Emacs input event queue.  This
+   function runs when the WM_EMACS_FILENOTIFY message arrives from a
+   watcher thread.  */
+static void
+queue_notifications (struct input_event *event, W32Msg *msg, struct frame *f,
+                     int *evcount)
+{
+  BYTE *p = file_notifications;
+  FILE_NOTIFY_INFORMATION *fni = (PFILE_NOTIFY_INFORMATION)p;
+  const DWORD min_size
+    = offsetof (FILE_NOTIFY_INFORMATION, FileName) + sizeof(wchar_t);
+  Lisp_Object frame;
+
+  /* We cannot process notification before Emacs is fully initialized,
+     since we need the UTF-16LE coding-system to be set up.  */
+  if (!initialized)
+    {
+      notification_buffer_in_use = 0;
+      return;
+    }
+
+  XSETFRAME (frame, f);
+
+  enter_crit ();
+  if (notification_buffer_in_use)
+    {
+      DWORD info_size = notifications_size;
+      Lisp_Object cs = intern ("utf-16le");
+      Lisp_Object obj = w32_get_watch_object (notifications_desc);
+
+      /* notifications_size could be zero when the buffer of
+         notifications overflowed on the OS level, or when the
+         directory being watched was itself deleted.  Do nothing in
+         that case.  */
+      if (info_size
+          && !NILP (obj) && CONSP (obj))
+        {
+          Lisp_Object callback = XCDR (obj);
+
+          while (info_size >= min_size)
+            {
+              Lisp_Object utf_16_fn
+                = make_unibyte_string ((char *)fni->FileName,
+                                       fni->FileNameLength);
+              /* Note: mule-conf is preloaded, so utf-16le must
+                 already be defined at this point.  */
+              Lisp_Object fname
+                = code_convert_string_norecord (utf_16_fn, cs, 0);
+              Lisp_Object action = lispy_file_action (fni->Action);
+
+              event->kind = FILE_NOTIFY_EVENT;
+              event->code
+                = (ptrdiff_t)XINT (XIL ((EMACS_INT)notifications_desc));
+              event->timestamp = msg->msg.time;
+              event->modifiers = 0;
+              event->frame_or_window = callback;
+              event->arg = Fcons (action, fname);
+              kbd_buffer_store_event (event);
+              (*evcount)++;
+
+              if (!fni->NextEntryOffset)
+                break;
+              p += fni->NextEntryOffset;
+              fni = (PFILE_NOTIFY_INFORMATION)p;
+              info_size -= fni->NextEntryOffset;
+            }
+        }
+      notification_buffer_in_use = 0;
+    }
+  else
+    DebPrint (("We were promised notifications, but in-use flag is zero!\n"));
+  leave_crit ();
+
+  /* We've stuffed all the events ourselves, so w32_read_socket shouldn't.  */
+  event->kind = NO_EVENT;
+}
+#endif
+
+
 /* Function to report a mouse movement to the mainstream Emacs code.
    The input handler calls this.
 
@@ -4198,24 +4315,25 @@ w32_read_socket (struct terminal *terminal,
                   DebPrint (("clipped frame %p (%s) got WM_PAINT - ignored\n", f,
                              SDATA (f->name)));
                 }
-              else if (f->async_visible != 1)
+              else if (FRAME_VISIBLE_P (f) != 1)
                 {
+                  bool iconified = FRAME_ICONIFIED_P (f);
+
                   /* Definitely not obscured, so mark as visible.  */
-                  f->async_visible = 1;
-                  f->async_iconified = 0;
+                  SET_FRAME_VISIBLE (f, 1);
+                  SET_FRAME_ICONIFIED (f, 0);
                   SET_FRAME_GARBAGED (f);
                   DebPrint (("frame %p (%s) reexposed by WM_PAINT\n", f,
                              SDATA (f->name)));
 
                   /* WM_PAINT serves as MapNotify as well, so report
                      visibility changes properly.  */
-                  if (f->iconified)
+                  if (iconified)
                     {
                       inev.kind = DEICONIFY_EVENT;
                       XSETFRAME (inev.frame_or_window, f);
                     }
-                  else if (! NILP (Vframe_list)
-                           && ! NILP (XCDR (Vframe_list)))
+                  else if (!NILP (Vframe_list) && !NILP (XCDR (Vframe_list)))
                     /* Force a redisplay sooner or later to update the
                        frame titles in case this is the second frame.  */
                     record_asynch_buffer_change ();
@@ -4258,7 +4376,7 @@ w32_read_socket (struct terminal *terminal,
         case WM_SYSKEYDOWN:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
 
-          if (f && !f->iconified)
+          if (f && !FRAME_ICONIFIED_P (f))
             {
               if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
                   && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
@@ -4283,7 +4401,7 @@ w32_read_socket (struct terminal *terminal,
         case WM_CHAR:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
 
-          if (f && !f->iconified)
+          if (f && !FRAME_ICONIFIED_P (f))
             {
               if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
                   && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
@@ -4361,7 +4479,7 @@ w32_read_socket (struct terminal *terminal,
         case WM_APPCOMMAND:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
 
-          if (f && !f->iconified)
+          if (f && !FRAME_ICONIFIED_P (f))
             {
               if (!hlinfo->mouse_face_hidden && INTEGERP (Vmouse_highlight)
                   && !EQ (f->tool_bar_window, hlinfo->mouse_face_window))
@@ -4601,7 +4719,7 @@ w32_read_socket (struct terminal *terminal,
         case WM_MOVE:
           f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
 
-          if (f && !f->async_iconified)
+          if (f && !FRAME_ICONIFIED_P (f))
             {
               int x, y;
 
@@ -4649,8 +4767,8 @@ w32_read_socket (struct terminal *terminal,
               switch (msg.msg.wParam)
                 {
                 case SIZE_MINIMIZED:
-                  f->async_visible = 0;
-                  f->async_iconified = 1;
+                  SET_FRAME_VISIBLE (f, 0);
+                  SET_FRAME_ICONIFIED (f, 1);
 
                   inev.kind = ICONIFY_EVENT;
                   XSETFRAME (inev.frame_or_window, f);
@@ -4658,40 +4776,44 @@ w32_read_socket (struct terminal *terminal,
 
                 case SIZE_MAXIMIZED:
                 case SIZE_RESTORED:
-                  f->async_visible = 1;
-                  f->async_iconified = 0;
-
-                  /* wait_reading_process_output will notice this and update
-                     the frame's display structures.  */
-                  SET_FRAME_GARBAGED (f);
+                  {
+                    bool iconified = FRAME_ICONIFIED_P (f);
 
-                  if (f->iconified)
-                    {
-                      int x, y;
+                    SET_FRAME_VISIBLE (f, 1);
+                    SET_FRAME_ICONIFIED (f, 0);
 
-                      /* Reset top and left positions of the Window
-                         here since Windows sends a WM_MOVE message
-                         BEFORE telling us the Window is minimized
-                         when the Window is iconified, with 3000,3000
-                         as the co-ords. */
-                      x_real_positions (f, &x, &y);
-                      f->left_pos = x;
-                      f->top_pos = y;
+                    /* wait_reading_process_output will notice this
+                       and update the frame's display structures.  */
+                    SET_FRAME_GARBAGED (f);
 
-                      inev.kind = DEICONIFY_EVENT;
-                      XSETFRAME (inev.frame_or_window, f);
-                    }
-                  else if (! NILP (Vframe_list)
-                           && ! NILP (XCDR (Vframe_list)))
-                    /* Force a redisplay sooner or later
-                       to update the frame titles
-                       in case this is the second frame.  */
-                    record_asynch_buffer_change ();
+                    if (iconified)
+                      {
+                        int x, y;
+
+                        /* Reset top and left positions of the Window
+                           here since Windows sends a WM_MOVE message
+                           BEFORE telling us the Window is minimized
+                           when the Window is iconified, with 3000,3000
+                           as the co-ords. */
+                        x_real_positions (f, &x, &y);
+                        f->left_pos = x;
+                        f->top_pos = y;
+
+                        inev.kind = DEICONIFY_EVENT;
+                        XSETFRAME (inev.frame_or_window, f);
+                      }
+                    else if (! NILP (Vframe_list)
+                             && ! NILP (XCDR (Vframe_list)))
+                      /* Force a redisplay sooner or later
+                         to update the frame titles
+                         in case this is the second frame.  */
+                      record_asynch_buffer_change ();
+                  }
                   break;
                 }
             }
 
-          if (f && !f->async_iconified && msg.msg.wParam != SIZE_MINIMIZED)
+          if (f && !FRAME_ICONIFIED_P (f) && msg.msg.wParam != SIZE_MINIMIZED)
             {
               RECT rect;
               int rows;
@@ -4836,6 +4958,14 @@ w32_read_socket (struct terminal *terminal,
           check_visibility = 1;
           break;
 
+#ifdef WINDOWSNT
+        case WM_EMACS_FILENOTIFY:
+          f = x_window_to_frame (dpyinfo, msg.msg.hwnd);
+          if (f)
+            queue_notifications (&inev, &msg, f, &count);
+          break;
+#endif
+
         default:
           /* Check for messages registered at runtime.  */
           if (msg.msg.message == msh_mousewheel)
@@ -4911,12 +5041,13 @@ w32_read_socket (struct terminal *terminal,
           continue;
 
         /* Check "visible" frames and mark each as obscured or not.
-           Note that async_visible is nonzero for unobscured and
-           obscured frames, but zero for hidden and iconified frames.  */
-        if (FRAME_W32_P (f) && f->async_visible)
+           Note that visible is nonzero for unobscured and obscured
+           frames, but zero for hidden and iconified frames.  */
+        if (FRAME_W32_P (f) && FRAME_VISIBLE_P (f))
           {
             RECT clipbox;
             HDC  hdc;
+            bool obscured;
 
             enter_crit ();
             /* Query clipping rectangle for the entire window area
@@ -4930,31 +5061,28 @@ w32_read_socket (struct terminal *terminal,
             ReleaseDC (FRAME_W32_WINDOW (f), hdc);
             leave_crit ();
 
-            if (clipbox.right == clipbox.left
-                || clipbox.bottom == clipbox.top)
+            obscured = FRAME_OBSCURED_P (f);
+
+            if (clipbox.right == clipbox.left || clipbox.bottom == clipbox.top)
               {
-                /* Frame has become completely obscured so mark as
-                   such (we do this by setting async_visible to 2 so
-                   that FRAME_VISIBLE_P is still true, but redisplay
-                   will skip it).  */
-                f->async_visible = 2;
+                /* Frame has become completely obscured so mark as such (we
+                   do this by setting visible to 2 so that FRAME_VISIBLE_P
+                   is still true, but redisplay will skip it).  */
+                SET_FRAME_VISIBLE (f, 2);
 
-                if (!FRAME_OBSCURED_P (f))
-                  {
-                    DebPrint (("frame %p (%s) obscured\n", f,
-                               SDATA (f->name)));
-                  }
+                if (!obscured)
+                  DebPrint (("frame %p (%s) obscured\n", f, SDATA (f->name)));
               }
             else
               {
                 /* Frame is not obscured, so mark it as such.  */
-                f->async_visible = 1;
+                SET_FRAME_VISIBLE (f, 1);
 
-                if (FRAME_OBSCURED_P (f))
+                if (obscured)
                   {
                     SET_FRAME_GARBAGED (f);
-                    DebPrint (("obscured frame %p (%s) found to be visible\n", f,
-                               SDATA (f->name)));
+                    DebPrint (("obscured frame %p (%s) found to be visible\n",
+                               f, SDATA (f->name)));
 
                     /* Force a redisplay sooner or later.  */
                     record_asynch_buffer_change ();
@@ -5520,6 +5648,86 @@ x_check_fullscreen (struct frame *f)
     }
 }
 
+static void
+w32fullscreen_hook (FRAME_PTR f)
+{
+  static int normal_width, normal_height;
+
+  if (FRAME_VISIBLE_P (f))
+    {
+      int width, height, top_pos, left_pos, pixel_height, pixel_width;
+      int cur_w = FRAME_COLS (f), cur_h = FRAME_LINES (f);
+      RECT workarea_rect;
+
+      block_input ();
+      if (normal_height <= 0)
+        normal_height = cur_h;
+      if (normal_width <= 0)
+        normal_width = cur_w;
+      x_real_positions (f, &f->left_pos, &f->top_pos);
+      x_fullscreen_adjust (f, &width, &height, &top_pos, &left_pos);
+
+      SystemParametersInfo (SPI_GETWORKAREA, 0, &workarea_rect, 0);
+      pixel_height = workarea_rect.bottom - workarea_rect.top;
+      pixel_width  = workarea_rect.right  - workarea_rect.left;
+
+      switch (f->want_fullscreen)
+        {
+        case FULLSCREEN_MAXIMIZED:
+          PostMessage (FRAME_W32_WINDOW (f), WM_SYSCOMMAND, SC_MAXIMIZE, 0);
+          break;
+        case FULLSCREEN_BOTH:
+          height =
+            FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixel_height)
+            - XINT (Ftool_bar_lines_needed (selected_frame))
+            + (NILP (Vmenu_bar_mode) ? 1 : 0);
+          width  =
+            FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixel_width)
+            - FRAME_SCROLL_BAR_COLS (f);
+          left_pos = workarea_rect.left;
+          top_pos = workarea_rect.top;
+          break;
+        case FULLSCREEN_WIDTH:
+          width  =
+            FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f, pixel_width)
+            - FRAME_SCROLL_BAR_COLS (f);
+          if (normal_height > 0)
+            height = normal_height;
+          left_pos = workarea_rect.left;
+          break;
+        case FULLSCREEN_HEIGHT:
+          height =
+            FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f, pixel_height)
+            - XINT (Ftool_bar_lines_needed (selected_frame))
+            + (NILP (Vmenu_bar_mode) ? 1 : 0);
+          if (normal_width > 0)
+            width = normal_width;
+          top_pos = workarea_rect.top;
+          break;
+        case FULLSCREEN_NONE:
+          if (normal_height > 0)
+            height = normal_height;
+          else
+            normal_height = height;
+          if (normal_width > 0)
+            width = normal_width;
+          else
+            normal_width = width;
+          /* FIXME: Should restore the original position of the frame.  */
+          top_pos = left_pos = 0;
+          break;
+        }
+
+      if (cur_w != width || cur_h != height)
+        {
+          x_set_offset (f, left_pos, top_pos, 1);
+          x_set_window_size (f, 1, width, height);
+          do_pending_window_change (0);
+        }
+      unblock_input ();
+    }
+}
+
 /* Call this to change the size of frame F's x-window.
    If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
    for this size change and subsequent size changes.
@@ -5814,11 +6022,11 @@ x_make_frame_visible (struct frame *f)
          causes unexpected behavior when unminimizing frames that were
          previously maximized.  But only SW_SHOWNORMAL works properly for
          frames that were truely hidden (using make-frame-invisible), so
-         we need it to avoid Bug#5482.  It seems that async_iconified
-         is only set for minimized windows that are still visible, so
-         use that to determine the appropriate flag to pass ShowWindow.  */
+         we need it to avoid Bug#5482.  It seems that iconified is only
+         set for minimized windows that are still visible, so use that to
+         determine the appropriate flag to pass ShowWindow.  */
       my_show_window (f, FRAME_W32_WINDOW (f),
-                      f->async_iconified ? SW_RESTORE : SW_SHOWNORMAL);
+                      FRAME_ICONIFIED_P (f) ? SW_RESTORE : SW_SHOWNORMAL);
     }
 
   /* Synchronize to ensure Emacs knows the frame is visible
@@ -5857,7 +6065,6 @@ x_make_frame_visible (struct frame *f)
             poll_suppress_count = old_poll_suppress_count;
           }
       }
-    FRAME_SAMPLE_VISIBILITY (f);
   }
 }
 
@@ -5881,10 +6088,8 @@ x_make_frame_invisible (struct frame *f)
      So we can't win using the usual strategy of letting
      FRAME_SAMPLE_VISIBILITY set this.  So do it by hand,
      and synchronize with the server to make sure we agree.  */
-  f->visible = 0;
-  FRAME_ICONIFIED_P (f) = 0;
-  f->async_visible = 0;
-  f->async_iconified = 0;
+  SET_FRAME_VISIBLE (f, 0);
+  SET_FRAME_ICONIFIED (f, 0);
 
   unblock_input ();
 }
@@ -5900,7 +6105,7 @@ x_iconify_frame (struct frame *f)
   if (FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame == f)
     FRAME_W32_DISPLAY_INFO (f)->x_highlight_frame = 0;
 
-  if (f->async_iconified)
+  if (FRAME_ICONIFIED_P (f))
     return;
 
   block_input ();
@@ -6210,7 +6415,7 @@ w32_create_terminal (struct w32_display_info *dpyinfo)
   terminal->mouse_position_hook = w32_mouse_position;
   terminal->frame_rehighlight_hook = w32_frame_rehighlight;
   terminal->frame_raise_lower_hook = w32_frame_raise_lower;
-  /* terminal->fullscreen_hook = XTfullscreen_hook; */
+  terminal->fullscreen_hook = w32fullscreen_hook;
   terminal->set_vertical_scroll_bar_hook = w32_set_vertical_scroll_bar;
   terminal->condemn_scroll_bars_hook = w32_condemn_scroll_bars;
   terminal->redeem_scroll_bar_hook = w32_redeem_scroll_bar;
@@ -6503,6 +6708,12 @@ syms_of_w32term (void)
 
   DEFSYM (Qvendor_specific_keysyms, "vendor-specific-keysyms");
 
+  DEFSYM (Qadded, "added");
+  DEFSYM (Qremoved, "removed");
+  DEFSYM (Qmodified, "modified");
+  DEFSYM (Qrenamed_from, "renamed-from");
+  DEFSYM (Qrenamed_to, "renamed-to");
+
   DEFVAR_INT ("w32-num-mouse-buttons",
               w32_num_mouse_buttons,
               doc: /* Number of physical mouse buttons.  */);
diff --git a/src/w32term.h b/src/w32term.h
index af1a79e21c9..7154d549f21 100644
--- a/src/w32term.h
+++ b/src/w32term.h
@@ -1,5 +1,5 @@
 /* Definitions and headers for communication on the Microsoft Windows API.
-   Copyright (C) 1995, 2001-2012 Free Software Foundation, Inc.
+   Copyright (C) 1995, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -602,7 +602,8 @@ do { \
 #define WM_EMACS_PAINT                 (WM_EMACS_START + 20)
 #define WM_EMACS_BRINGTOTOP            (WM_EMACS_START + 21)
 #define WM_EMACS_INPUT_READY           (WM_EMACS_START + 22)
-#define WM_EMACS_END                   (WM_EMACS_START + 23)
+#define WM_EMACS_FILENOTIFY            (WM_EMACS_START + 23)
+#define WM_EMACS_END                   (WM_EMACS_START + 24)
 
 #define WND_FONTWIDTH_INDEX    (0)
 #define WND_LINEHEIGHT_INDEX   (4)
@@ -652,7 +653,7 @@ extern void deselect_palette (struct frame * f, HDC hdc);
 extern HDC get_frame_dc (struct frame * f);
 extern int release_frame_dc (struct frame * f, HDC hDC);
 
-extern void drain_message_queue (void);
+extern int drain_message_queue (void);
 
 extern BOOL get_next_msg (W32Msg *, BOOL);
 extern BOOL post_msg (W32Msg *);
@@ -662,10 +663,17 @@ extern BOOL parse_button (int, int, int *, int *);
 
 extern void w32_sys_ring_bell (struct frame *f);
 extern void x_delete_display (struct w32_display_info *dpyinfo);
+
+extern volatile int notification_buffer_in_use;
+extern BYTE file_notifications[16384];
+extern DWORD notifications_size;
+extern void *notifications_desc;
+extern Lisp_Object w32_get_watch_object (void *);
+extern Lisp_Object lispy_file_action (DWORD);
+
 extern void w32_initialize_display_info (Lisp_Object);
 extern void initialize_w32_display (struct terminal *);
 
-
 /* Keypad command key support.  W32 doesn't have virtual keys defined
    for the function keys on the keypad (they are mapped to the standard
    function keys), so we define our own.  */
@@ -759,6 +767,7 @@ extern void syms_of_w32fns (void);
 
 extern void globals_of_w32menu (void);
 extern void globals_of_w32fns (void);
+extern void globals_of_w32notify (void);
 
 #ifdef CYGWIN
 extern int w32_message_fd;
diff --git a/src/w32uniscribe.c b/src/w32uniscribe.c
index 5d160b9d42f..56931adfac5 100644
--- a/src/w32uniscribe.c
+++ b/src/w32uniscribe.c
@@ -1,5 +1,5 @@
 /* Font backend for the Microsoft W32 Uniscribe API.
-   Copyright (C) 2008-2012 Free Software Foundation, Inc.
+   Copyright (C) 2008-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -435,8 +435,8 @@ uniscribe_shape (Lisp_Object lgstring)
                          are zero.  */
                       || (!attributes[j].fClusterStart && items[i].a.fRTL))
                     {
-                      Lisp_Object vec;
-                      vec = Fmake_vector (make_number (3), Qnil);
+                      Lisp_Object vec = make_uninit_vector (3);
+
                       if (items[i].a.fRTL)
                         {
                           /* Empirically, it looks like Uniscribe
diff --git a/src/w32xfns.c b/src/w32xfns.c
index cb452571665..03611e19768 100644
--- a/src/w32xfns.c
+++ b/src/w32xfns.c
@@ -1,5 +1,6 @@
 /* Functions taken directly from X sources for use with the Microsoft Windows API.
-   Copyright (C) 1989, 1992-1995, 1999, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1989, 1992-1995, 1999, 2001-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -315,16 +316,22 @@ prepend_msg (W32Msg *lpmsg)
   return (TRUE);
 }
 
-/* Process all messages in the current thread's queue.  */
-void
+/* Process all messages in the current thread's queue.  Value is 1 if
+   one of these messages was WM_EMACS_FILENOTIFY, zero otherwise.  */
+int
 drain_message_queue (void)
 {
   MSG msg;
+  int retval = 0;
+
   while (PeekMessage (&msg, NULL, 0, 0, PM_REMOVE))
     {
+      if (msg.message == WM_EMACS_FILENOTIFY)
+        retval = 1;
       TranslateMessage (&msg);
       DispatchMessage (&msg);
     }
+  return retval;
 }
 
 /* x_sync is a no-op on W32.  */
diff --git a/src/widget.c b/src/widget.c
index b4f7335c652..28e9fc29a91 100644
--- a/src/widget.c
+++ b/src/widget.c
@@ -1,5 +1,5 @@
 /* The emacs frame widget.
-   Copyright (C) 1992-1993, 2000-2012  Free Software Foundation, Inc.
+   Copyright (C) 1992-1993, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/widget.h b/src/widget.h
index 03838a01415..e04c31c259b 100644
--- a/src/widget.h
+++ b/src/widget.h
@@ -1,5 +1,5 @@
 /* The emacs frame widget public header file.
-   Copyright (C) 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/widgetprv.h b/src/widgetprv.h
index 00e3eeb1ee1..b617654e7f2 100644
--- a/src/widgetprv.h
+++ b/src/widgetprv.h
@@ -1,5 +1,5 @@
 /* The emacs frame widget private header file.
-   Copyright (C) 1993, 2001-2012  Free Software Foundation, Inc.
+   Copyright (C) 1993, 2001-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/window.c b/src/window.c
index d7c2e8b236e..ea1dd93711c 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1,7 +1,7 @@
 /* Window creation, deletion and examination for GNU Emacs.
    Does not include redisplay.
-   Copyright (C) 1985-1987, 1993-1998, 2000-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1987, 1993-1998, 2000-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -87,6 +87,7 @@ static Lisp_Object window_list_1 (Lisp_Object, Lisp_Object, Lisp_Object);
 static int window_resize_check (struct window *, int);
 static void window_resize_apply (struct window *, int);
 static Lisp_Object select_window (Lisp_Object, Lisp_Object, int);
+static void select_window_1 (Lisp_Object, bool);
 
 /* This is the window in which the terminal's cursor should
    be left when nothing is being done with it.  This must
@@ -115,9 +116,6 @@ Lisp_Object minibuf_selected_window;
 /* Hook run at end of temp_output_buffer_show.  */
 static Lisp_Object Qtemp_buffer_show_hook;
 
-/* Incremented for each window created.  */
-static int sequence_number;
-
 /* Nonzero after init_window_once has finished.  */
 static int window_initialized;
 
@@ -270,6 +268,38 @@ decode_valid_window (register Lisp_Object window)
   return w;
 }
 
+/* Called when W's buffer slot is changed.  ARG -1 means that W is about to
+   cease its buffer, and 1 means that W is about to set up the new one.  */
+
+static void
+adjust_window_count (struct window *w, int arg)
+{
+  eassert (eabs (arg) == 1);
+  if (BUFFERP (w->buffer))
+    {
+      struct buffer *b = XBUFFER (w->buffer);
+
+      if (b->base_buffer)
+        b = b->base_buffer;
+      b->window_count += arg;
+      eassert (b->window_count >= 0);
+      /* These should be recalculated by redisplay code.  */
+      w->window_end_valid = 0;
+      w->base_line_pos = 0;
+    }
+}
+
+/* Set W's buffer slot to VAL and recompute number
+   of windows showing VAL if it is a buffer.  */
+
+void
+wset_buffer (struct window *w, Lisp_Object val)
+{
+  adjust_window_count (w, -1);
+  w->buffer = val;
+  adjust_window_count (w, 1);
+}
+
 /* Build a frequently used 4-integer (X Y W H) list.  */
 
 static Lisp_Object
@@ -458,7 +488,6 @@ static Lisp_Object
 select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
 {
   register struct window *w;
-  register struct window *ow;
   struct frame *sf;
 
   CHECK_LIVE_WINDOW (window);
@@ -494,12 +523,25 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
   else
     fset_selected_window (sf, window);
 
+  select_window_1 (window, inhibit_point_swap);
+
+  bset_last_selected_window (XBUFFER (w->buffer), window);
+  windows_or_buffers_changed++;
+  return window;
+}
+
+/* Select window with a minimum of fuss, i.e. don't record the change anywhere
+   (not even for redisplay's benefit), and assume that the window's frame is
+   already selected.  */
+static void
+select_window_1 (Lisp_Object window, bool inhibit_point_swap)
+{
   /* Store the old selected window's buffer's point in pointm of the old
      selected window.  It belongs to that window, and when the window is
      not selected, must be in the window.  */
   if (!inhibit_point_swap)
     {
-      ow = XWINDOW (selected_window);
+      struct window *ow = XWINDOW (selected_window);
       if (! NILP (ow->buffer))
         set_marker_both (ow->pointm, ow->buffer,
                          BUF_PT (XBUFFER (ow->buffer)),
@@ -507,7 +549,6 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
     }
 
   selected_window = window;
-  bset_last_selected_window (XBUFFER (w->buffer), window);
 
   /* Go to the point recorded in the window.
      This is important when the buffer is in more
@@ -515,7 +556,7 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
      redisplay_window has altered point after scrolling,
      because it makes the change only in the window.  */
   {
-    register ptrdiff_t new_point = marker_position (w->pointm);
+    register ptrdiff_t new_point = marker_position (XWINDOW (window)->pointm);
     if (new_point < BEGV)
       SET_PT (BEGV);
     else if (new_point > ZV)
@@ -523,15 +564,14 @@ select_window (Lisp_Object window, Lisp_Object norecord, int inhibit_point_swap)
     else
       SET_PT (new_point);
   }
-
-  windows_or_buffers_changed++;
-  return window;
 }
 
 DEFUN ("select-window", Fselect_window, Sselect_window, 1, 2, 0,
-       doc: /* Select WINDOW.  Most editing will apply to WINDOW's buffer.
-Also make WINDOW's buffer current and make WINDOW the frame's selected
-window.  Return WINDOW.
+       doc: /* Select WINDOW which must be a live window.
+Also make WINDOW's frame the selected frame and WINDOW that frame's
+selected window.  In addition, make WINDOW's buffer current and set that
+buffer's value of `point' to the value of WINDOW's `window-point'.
+Return WINDOW.
 
 Optional second arg NORECORD non-nil means do not put this buffer at the
 front of the buffer list and do not make this window the most recently
@@ -762,12 +802,12 @@ window_body_cols (struct window *w)
        occupies one column only.  */
     width -= 1;
 
+  /* Display margins cannot be used for normal text.  */
+  width -= WINDOW_LEFT_MARGIN_COLS (w) + WINDOW_RIGHT_MARGIN_COLS (w);
+
   if (FRAME_WINDOW_P (f))
-    /* On window-systems, fringes and display margins cannot be
-       used for normal text.  */
-    width -= (WINDOW_FRINGE_COLS (w)
-              + WINDOW_LEFT_MARGIN_COLS (w)
-              + WINDOW_RIGHT_MARGIN_COLS (w));
+    /* On window-systems, fringes cannot be used for normal text.  */
+    width -= WINDOW_FRINGE_COLS (w);
 
   return width;
 }
@@ -1396,7 +1436,7 @@ window were selected.
 
 Note that, when WINDOW is selected, the value returned is the same as
 that returned by `point' for WINDOW's buffer.  It would be more strictly
-correct to return the `top-level' value of `point', outside of any
+correct to return the top-level value of `point', outside of any
 `save-excursion' forms.  But that is hard to define.  */)
   (Lisp_Object window)
 {
@@ -1449,20 +1489,12 @@ if it isn't already recorded.  */)
   CHECK_BUFFER (buf);
   b = XBUFFER (buf);
 
-#if 0 /* This change broke some things.  We should make it later.  */
-  /* If we don't know the end position, return nil.
-     The user can compute it with vertical-motion if he wants to.
-     It would be nicer to do it automatically,
-     but that's so slow that it would probably bother people.  */
-  if (NILP (w->window_end_valid))
-    return Qnil;
-#endif
-
   if (! NILP (update)
-      && (windows_or_buffers_changed || NILP (w->window_end_valid))
+      && (windows_or_buffers_changed || !w->window_end_valid)
       && !noninteractive)
     {
       struct text_pos startp;
+      ptrdiff_t charpos = marker_position (w->start);
       struct it it;
       struct buffer *old_buffer = NULL;
       void *itdata = NULL;
@@ -1480,9 +1512,9 @@ if it isn't already recorded.  */)
          `-l' containing a call to `rmail' with subsequent other
          commands.  At the end, W->start happened to be BEG, while
          rmail had already narrowed the buffer.  */
-      if (XMARKER (w->start)->charpos < BEGV)
+      if (charpos < BEGV)
         SET_TEXT_POS (startp, BEGV, BEGV_BYTE);
-      else if (XMARKER (w->start)->charpos > ZV)
+      else if (charpos > ZV)
         SET_TEXT_POS (startp, ZV, ZV_BYTE);
       else
         SET_TEXT_POS_FROM_MARKER (startp, w->start);
@@ -1512,7 +1544,7 @@ Return POS.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  CHECK_NUMBER_COERCE_MARKER (pos);
+  /* Type of POS is checked by Fgoto_char or set_marker_restricted ...  */
 
   if (w == XWINDOW (selected_window))
     {
@@ -1522,6 +1554,8 @@ Return POS.  */)
         {
           struct buffer *old_buffer = current_buffer;
 
+          /* ... but here we want to catch type error before buffer change.  */
+          CHECK_NUMBER_COERCE_MARKER (pos);
           set_buffer_internal (XBUFFER (w->buffer));
           Fgoto_char (pos);
           set_buffer_internal (old_buffer);
@@ -1547,9 +1581,8 @@ overriding motion of point in order to display at this exact start.  */)
 {
   register struct window *w = decode_live_window (window);
 
-  CHECK_NUMBER_COERCE_MARKER (pos);
   set_marker_restricted (w->start, pos, w->buffer);
-  /* this is not right, but much easier than doing what is right. */
+  /* This is not right, but much easier than doing what is right.  */
   w->start_at_line_beg = 0;
   if (NILP (noforce))
     w->force_start = 1;
@@ -1605,7 +1638,7 @@ display row, and VPOS is the row number (0-based) containing POS.  */)
   else if (w == XWINDOW (selected_window))
     posint = PT;
   else
-    posint = XMARKER (w->pointm)->charpos;
+    posint = marker_position (w->pointm);
 
   /* If position is above window start or outside buffer boundaries,
      or if window start is out of range, position is not visible.  */
@@ -1665,7 +1698,7 @@ Return nil if window display is not up-to-date.  In that case, use
   b = XBUFFER (w->buffer);
 
   /* Fail if current matrix is not up-to-date.  */
-  if (NILP (w->window_end_valid)
+  if (!w->window_end_valid
       || current_buffer->clip_changed
       || current_buffer->prevent_redisplay_optimizations_p
       || w->last_modified < BUF_MODIFF (b)
@@ -1951,7 +1984,7 @@ unshow_buffer (register struct window *w)
            && EQ (buf, XWINDOW (BVAR (b, last_selected_window))->buffer)))
     temp_set_point_both (b,
                          clip_to_bounds (BUF_BEGV (b),
-                                         XMARKER (w->pointm)->charpos,
+                                         marker_position (w->pointm),
                                          BUF_ZV (b)),
                          clip_to_bounds (BUF_BEGV_BYTE (b),
                                          marker_byte_position (w->pointm),
@@ -1997,7 +2030,7 @@ replace_window (Lisp_Object old, Lisp_Object new, int setflag)
       n->pseudo_window_p = 0;
       wset_window_end_vpos (n, make_number (0));
       wset_window_end_pos (n, make_number (0));
-      wset_window_end_valid (n, Qnil);
+      n->window_end_valid = 0;
       n->frozen_window_start_p = 0;
     }
 
@@ -2197,7 +2230,6 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
     }
   else if (EQ (all_frames, Qvisible))
     {
-      FRAME_SAMPLE_VISIBILITY (f);
       candidate_p = FRAME_VISIBLE_P (f)
         && (FRAME_TERMINAL (XFRAME (w->frame))
             == FRAME_TERMINAL (XFRAME (selected_frame)));
@@ -2205,7 +2237,6 @@ candidate_window_p (Lisp_Object window, Lisp_Object owindow, Lisp_Object minibuf
     }
   else if (INTEGERP (all_frames) && XINT (all_frames) == 0)
     {
-      FRAME_SAMPLE_VISIBILITY (f);
       candidate_p = (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f)
 #ifdef HAVE_X_WINDOWS
                      /* Yuck!!  If we've just created the frame and the
@@ -2932,7 +2963,7 @@ window-start value is reasonable when this function is called.  */)
           pos = *vmotion (startpos, -top, w);
 
           set_marker_both (w->start, w->buffer, pos.bufpos, pos.bytepos);
-          wset_window_end_valid (w, Qnil);
+          w->window_end_valid = 0;
           w->start_at_line_beg = (pos.bytepos == BEGV_BYTE
                                     || FETCH_BYTE (pos.bytepos - 1) == '\n');
           /* We need to do this, so that the window-scroll-functions
@@ -2958,22 +2989,24 @@ replace_buffer_in_windows (Lisp_Object buffer)
   call1 (Qreplace_buffer_in_windows, buffer);
 }
 
-
-/* Safely replace BUFFER with some other buffer in all windows of all
-   frames, even those on other keyboards.  */
+/* If BUFFER is shown in a window, safely replace it with some other
+   buffer in all windows of all frames, even those on other keyboards.  */
 
 void
 replace_buffer_in_windows_safely (Lisp_Object buffer)
 {
-  Lisp_Object tail, frame;
+  if (buffer_window_count (XBUFFER (buffer)))
+    {
+      Lisp_Object tail, frame;
 
-  /* A single call to window_loop won't do the job because it only
-     considers frames on the current keyboard.  So loop manually over
-     frames, and handle each one.  */
-  FOR_EACH_FRAME (tail, frame)
-    window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
+      /* A single call to window_loop won't do the job because it only
+         considers frames on the current keyboard.  So loop manually over
+         frames, and handle each one.  */
+      FOR_EACH_FRAME (tail, frame)
+        window_loop (REPLACE_BUFFER_IN_WINDOWS_SAFELY, buffer, 1, frame);
+    }
 }
-
+
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
@@ -3146,7 +3179,7 @@ set_window_buffer (Lisp_Object window, Lisp_Object buffer, int run_hooks_p, int
   wset_window_end_pos (w, make_number (0));
   wset_window_end_vpos (w, make_number (0));
   memset (&w->last_cursor, 0, sizeof w->last_cursor);
-  wset_window_end_valid (w, Qnil);
+
   if (!(keep_margins_p && samebuf))
     { /* If we're not actually changing the buffer, don't reset hscroll and
          vscroll.  This case happens for example when called from
@@ -3308,11 +3341,11 @@ displaying that buffer.  */)
 
   if (STRINGP (object))
     object = Fget_buffer (object);
-  if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object)))
+  if (BUFFERP (object) && BUFFER_LIVE_P (XBUFFER (object))
+      && buffer_window_count (XBUFFER (object)))
     {
-      /* Walk all windows looking for buffer, and force update
-         of each of those windows.  */
-
+      /* If buffer is live and shown in at least one window, find
+         all windows showing this buffer and force update of them.  */
       object = window_loop (REDISPLAY_BUFFER_WINDOWS, object, 0, Qvisible);
       return NILP (object) ? Qnil : Qt;
     }
@@ -3391,10 +3424,10 @@ make_parent_window (Lisp_Object window, int horflag)
   memcpy ((char *) p + sizeof (struct vectorlike_header),
           (char *) o + sizeof (struct vectorlike_header),
           word_size * VECSIZE (struct window));
+  /* P's buffer slot may change from nil to a buffer.  */
+  adjust_window_count (p, 1);
   XSETWINDOW (parent, p);
 
-  p->sequence_number = ++sequence_number;
-
   replace_window (window, parent, 1);
 
   wset_next (o, Qnil);
@@ -3443,7 +3476,7 @@ make_window (void)
   w->nrows_scale_factor = w->ncols_scale_factor = 1;
   w->phys_cursor_type = -1;
   w->phys_cursor_width = -1;
-  w->sequence_number = ++sequence_number;
+  w->column_number_displayed = -1;
 
   /* Reset window_list.  */
   Vwindow_list = Qnil;
@@ -3913,7 +3946,7 @@ set correctly.  See the code of `split-window' for how this is done.  */)
       wset_next (o, new);
     }
 
-  wset_window_end_valid (n, Qnil);
+  n->window_end_valid = 0;
   memset (&n->last_cursor, 0, sizeof n->last_cursor);
 
   /* Get special geometry settings from reference window.  */
@@ -4583,9 +4616,9 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
         }
 
       /* Set the window start, and set up the window for redisplay.  */
-      set_marker_restricted (w->start, make_number (pos),
-                             w->buffer);
-      bytepos = XMARKER (w->start)->bytepos;
+      set_marker_restricted_both (w->start, w->buffer, IT_CHARPOS (it),
+                                  IT_BYTEPOS (it));
+      bytepos = marker_byte_position (w->start);
       w->start_at_line_beg = (pos == BEGV || FETCH_BYTE (bytepos - 1) == '\n');
       w->update_mode_line = 1;
       w->last_modified = 0;
@@ -5085,6 +5118,7 @@ displayed_window_lines (struct window *w)
 {
   struct it it;
   struct text_pos start;
+  ptrdiff_t charpos = marker_position (w->start);
   int height = window_box_height (w);
   struct buffer *old_buffer;
   int bottom_y;
@@ -5101,9 +5135,9 @@ displayed_window_lines (struct window *w)
   /* In case W->start is out of the accessible range, do something
      reasonable.  This happens in Info mode when Info-scroll-down
      calls (recenter -1) while W->start is 1.  */
-  if (XMARKER (w->start)->charpos < BEGV)
+  if (charpos < BEGV)
     SET_TEXT_POS (start, BEGV, BEGV_BYTE);
-  else if (XMARKER (w->start)->charpos > ZV)
+  else if (charpos > ZV)
     SET_TEXT_POS (start, ZV, ZV_BYTE);
   else
     SET_TEXT_POS_FROM_MARKER (start, w->start);
@@ -5312,8 +5346,8 @@ and redisplay normally--don't erase and redraw the frame.  */)
         iarg += ht;
 
       /* Don't let it get into the margin at either top or bottom.  */
-      iarg = max (iarg, this_scroll_margin);
-      iarg = min (iarg, ht - this_scroll_margin - 1);
+      iarg = clip_to_bounds (this_scroll_margin, iarg,
+                             ht - this_scroll_margin - 1);
 
       pos = *vmotion (PT, - iarg, w);
       charpos = pos.bufpos;
@@ -5322,7 +5356,7 @@ and redisplay normally--don't erase and redraw the frame.  */)
 
   /* Set the new window start.  */
   set_marker_both (w->start, w->buffer, charpos, bytepos);
-  wset_window_end_valid (w, Qnil);
+  w->window_end_valid = 0;
 
   w->optional_new_start = 1;
 
@@ -5531,7 +5565,7 @@ the return value is nil.  Otherwise the value is t.  */)
             && WINDOWP (selected_window)
             && EQ (XWINDOW (selected_window)->buffer, new_current_buffer)
             && !EQ (selected_window, data->current_window))
-          old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
+          old_point = marker_position (XWINDOW (data->current_window)->pointm);
         else
           old_point = PT;
       else
@@ -5546,7 +5580,7 @@ the return value is nil.  Otherwise the value is t.  */)
         if (EQ (XWINDOW (data->current_window)->buffer, new_current_buffer)
             /* If current_window = selected_window, its point is in BUF_PT.  */
             && !EQ (selected_window, data->current_window))
-          old_point = XMARKER (XWINDOW (data->current_window)->pointm)->charpos;
+          old_point = marker_position (XWINDOW (data->current_window)->pointm);
         else
           old_point = BUF_PT (XBUFFER (new_current_buffer));
     }
@@ -5762,8 +5796,7 @@ the return value is nil.  Otherwise the value is t.  */)
              {
                /* Set window markers at start of visible range.  */
                if (XMARKER (w->start)->buffer == 0)
-                 set_marker_restricted (w->start, make_number (0),
-                                        w->buffer);
+                 set_marker_restricted_both (w->start, w->buffer, 0, 0);
                if (XMARKER (w->pointm)->buffer == 0)
                  set_marker_restricted_both
                    (w->pointm, w->buffer,
@@ -5781,10 +5814,8 @@ the return value is nil.  Otherwise the value is t.  */)
               wset_buffer (w, other_buffer_safely (Fcurrent_buffer ()));
               /* This will set the markers to beginning of visible
                  range.  */
-              set_marker_restricted (w->start,
-                                     make_number (0), w->buffer);
-              set_marker_restricted (w->pointm,
-                                     make_number (0), w->buffer);
+              set_marker_restricted_both (w->start, w->buffer, 0, 0);
+              set_marker_restricted_both (w->pointm, w->buffer, 0, 0);
               w->start_at_line_beg = 1;
               if (!NILP (w->dedicated))
                 /* Record this window as dead.  */
@@ -6157,11 +6188,11 @@ saved by this function.  */)
   data->minibuf_selected_window = minibuf_level > 0 ? minibuf_selected_window : Qnil;
   data->root_window = FRAME_ROOT_WINDOW (f);
   data->focus_frame = FRAME_FOCUS_FRAME (f);
-  tem = Fmake_vector (make_number (n_windows), Qnil);
+  tem = make_uninit_vector (n_windows);
   data->saved_windows = tem;
   for (i = 0; i < n_windows; i++)
     ASET (tem, i,
-         Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
+          Fmake_vector (make_number (VECSIZE (struct saved_window)), Qnil));
   save_window_save (FRAME_ROOT_WINDOW (f), XVECTOR (tem), 0);
   XSETWINDOW_CONFIGURATION (tem, data);
   return (tem);
@@ -6273,7 +6304,7 @@ display marginal areas and the text area.  */)
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6343,7 +6374,7 @@ Fourth parameter HORIZONTAL-TYPE is currently unused.  */)
       adjust_window_margins (w);
 
       clear_glyph_matrix (w->current_matrix);
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
 
       ++windows_or_buffers_changed;
       adjust_glyphs (XFRAME (WINDOW_FRAME (w)));
@@ -6747,7 +6778,8 @@ same combination.
 
 Other values are reserved for future use.
 
-This variable takes no effect if `window-combination-limit' is non-nil.  */);
+This variable takes no effect if the variable `window-combination-limit' is
+non-nil.  */);
   Vwindow_combination_resize = Qnil;
 
   DEFVAR_LISP ("window-combination-limit", Vwindow_combination_limit,
diff --git a/src/window.h b/src/window.h
index 2a12226c0aa..dcef37abb4c 100644
--- a/src/window.h
+++ b/src/window.h
@@ -1,6 +1,6 @@
 /* Window definitions for GNU Emacs.
-   Copyright (C) 1985-1986, 1993, 1995, 1997-2012
-                 Free Software Foundation, Inc.
+   Copyright (C) 1985-1986, 1993, 1995, 1997-2013 Free Software
+   Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -175,17 +175,13 @@ struct window
        no scroll bar.  A value of t means use frame value.  */
     Lisp_Object vertical_scroll_bar_type;
 
-    /* Z - the buffer position of the last glyph in the current matrix
-       of W.  Only valid if WINDOW_END_VALID is not nil.  */
+    /* Z - the buffer position of the last glyph in the current
+       matrix of W.  Only valid if window_end_valid is nonzero.  */
     Lisp_Object window_end_pos;
+
     /* Glyph matrix row of the last glyph in the current matrix
-       of W.  Only valid if WINDOW_END_VALID is not nil.  */
+       of W.  Only valid if window_end_valid is nonzero.  */
     Lisp_Object window_end_vpos;
-    /* t if window_end_pos is truly valid.
-       This is nil if nontrivial redisplay is preempted
-       since in that case the frame image that window_end_pos
-       did not get onto the frame.  */
-    Lisp_Object window_end_valid;
 
     /* Display-table to use for displaying chars in this window.
        Nil means use the buffer's own display-table.  */
@@ -196,23 +192,6 @@ struct window
        and Qt, so bitfield can't be used here.  */
     Lisp_Object dedicated;
 
-    /* Line number and position of a line somewhere above the top of the
-       screen.  If this field is nil, it means we don't have a base
-       line.  */
-    Lisp_Object base_line_number;
-    /* If this field is nil, it means we don't have a base line.
-       If it is a buffer, it means don't display the line number
-       as long as the window shows that buffer.  */
-    Lisp_Object base_line_pos;
-
-    /* If we have highlighted the region (or any part of it),
-       this is the mark position that we used, as an integer.  */
-    Lisp_Object region_showing;
-
-    /* The column number currently displayed in this window's mode line,
-       or nil if column numbers are not being displayed.  */
-    Lisp_Object column_number_displayed;
-
     /* If redisplay in this window goes beyond this buffer position,
        must run the redisplay-end-trigger-hook.  */
     Lisp_Object redisplay_end_trigger;
@@ -242,9 +221,6 @@ struct window
     /* Number saying how recently window was selected.  */
     int use_time;
 
-    /* Unique number of window assigned when it was created.  */
-    int sequence_number;
-
     /* Number of columns display within the window is scrolled to the left.  */
     ptrdiff_t hscroll;
 
@@ -261,9 +237,22 @@ struct window
     EMACS_INT last_overlay_modified;
 
     /* Value of point at that time.  Since this is a position in a buffer,
-       it should be positive. */
+       it should be positive.  */
     ptrdiff_t last_point;
 
+    /* Line number and position of a line somewhere above the top of the
+       screen.  If this field is zero, it means we don't have a base line.  */
+    ptrdiff_t base_line_number;
+
+    /* If this field is zero, it means we don't have a base line.
+       If it is -1, it means don't display the line number as long
+       as the window shows its buffer.  */
+    ptrdiff_t base_line_pos;
+
+    /* The column number currently displayed in this window's mode
+       line, or -1 if column numbers are not being displayed.  */
+    ptrdiff_t column_number_displayed;
+
     /* Scaling factor for the glyph_matrix size calculation in this window.
        Used if window contains many small images or uses proportional fonts,
        as the normal  may yield a matrix which is too small.  */
@@ -290,7 +279,7 @@ struct window
     /* Non-zero if this window is a minibuffer window.  */
     unsigned mini : 1;
 
-    /* Non-zero means must regenerate mode line of this window */
+    /* Non-zero means must regenerate mode line of this window.  */
     unsigned update_mode_line : 1;
 
     /* Non-nil if the buffer was "modified" when the window
@@ -339,23 +328,27 @@ struct window
        Otherwise draw them between margin areas and text.  */
     unsigned fringes_outside_margins : 1;
 
+    /* Nonzero if window_end_pos and window_end_vpos are truly valid.
+       This is zero if nontrivial redisplay is preempted since in that case
+       the frame image that window_end_pos did not get onto the frame.  */
+    unsigned window_end_valid : 1;
+
     /* Amount by which lines of this window are scrolled in
        y-direction (smooth scrolling).  */
     int vscroll;
 
-    /* Z_BYTE - the buffer position of the last glyph in the current matrix of W.
-       Should be nonnegative, and only valid if window_end_valid is not nil.  */
+    /* If we have highlighted the region (or any part of it), the mark
+       (region start) position; otherwise zero.  */
+    ptrdiff_t region_showing;
+
+    /* Z_BYTE - buffer position of the last glyph in the current matrix of W.
+       Should be nonnegative, and only valid if window_end_valid is nonzero.  */
     ptrdiff_t window_end_bytepos;
 };
 
 /* Most code should use these functions to set Lisp fields in struct
    window.  */
 WINDOW_INLINE void
-wset_buffer (struct window *w, Lisp_Object val)
-{
-  w->buffer = val;
-}
-WINDOW_INLINE void
 wset_frame (struct window *w, Lisp_Object val)
 {
   w->frame = val;
@@ -406,11 +399,6 @@ wset_window_end_pos (struct window *w, Lisp_Object val)
   w->window_end_pos = val;
 }
 WINDOW_INLINE void
-wset_window_end_valid (struct window *w, Lisp_Object val)
-{
-  w->window_end_valid = val;
-}
-WINDOW_INLINE void
 wset_window_end_vpos (struct window *w, Lisp_Object val)
 {
   w->window_end_vpos = val;
@@ -939,7 +927,7 @@ extern EMACS_INT minibuf_level;
 extern int update_mode_lines;
 
 /* Nonzero if window sizes or contents have changed since last
-   redisplay that finished */
+   redisplay that finished.  */
 
 extern int windows_or_buffers_changed;
 
@@ -947,11 +935,6 @@ extern int windows_or_buffers_changed;
 
 extern int cursor_type_changed;
 
-/* Number of windows displaying the selected buffer.  Normally this is
-   1, but it can be more.  */
-
-extern int buffer_shared;
-
 /* If *ROWS or *COLS are too small a size for FRAME, set them to the
    minimum allowable size.  */
 
@@ -997,6 +980,8 @@ extern int window_body_cols (struct window *w);
 extern void temp_output_buffer_show (Lisp_Object);
 extern void replace_buffer_in_windows (Lisp_Object);
 extern void replace_buffer_in_windows_safely (Lisp_Object);
+/* This looks like a setter, but it is a bit special.  */
+extern void wset_buffer (struct window *, Lisp_Object);
 extern void init_window_once (void);
 extern void init_window (void);
 extern void syms_of_window (void);
diff --git a/src/xdisp.c b/src/xdisp.c
index 9464e87b362..08958f44575 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1,6 +1,7 @@
 /* Display generation from window structure and buffer text.
 
-Copyright (C) 1985-1988, 1993-1995, 1997-2012 Free Software Foundation, Inc.
+Copyright (C) 1985-1988, 1993-1995, 1997-2013 Free Software Foundation,
+Inc.
 
 This file is part of GNU Emacs.
 
@@ -366,28 +367,6 @@ Lisp_Object Qcenter;
 static Lisp_Object Qmargin, Qpointer;
 static Lisp_Object Qline_height;
 
-/* These setters are used only in this file, so they can be private.  */
-static void
-wset_base_line_number (struct window *w, Lisp_Object val)
-{
-  w->base_line_number = val;
-}
-static void
-wset_base_line_pos (struct window *w, Lisp_Object val)
-{
-  w->base_line_pos = val;
-}
-static void
-wset_column_number_displayed (struct window *w, Lisp_Object val)
-{
-  w->column_number_displayed = val;
-}
-static void
-wset_region_showing (struct window *w, Lisp_Object val)
-{
-  w->region_showing = val;
-}
-
 #ifdef HAVE_WINDOW_SYSTEM
 
 /* Test if overflow newline into fringe.  Called with iterator IT
@@ -515,11 +494,6 @@ Lisp_Object Qmenu_bar_update_hook;
 
 static int overlay_arrow_seen;
 
-/* Number of windows showing the buffer of the selected
-   window (or another buffer with the same base buffer).  */
-
-int buffer_shared;
-
 /* Vector containing glyphs for an ellipsis `...'.  */
 
 static Lisp_Object default_invis_vector[3];
@@ -844,17 +818,17 @@ static void ensure_echo_area_buffers (void);
 static Lisp_Object unwind_with_echo_area_buffer (Lisp_Object);
 static Lisp_Object with_echo_area_buffer_unwind_data (struct window *);
 static int with_echo_area_buffer (struct window *, int,
-                                  int (*) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t),
-                                  ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
+                                  int (*) (ptrdiff_t, Lisp_Object),
+                                  ptrdiff_t, Lisp_Object);
 static void clear_garbaged_frames (void);
-static int current_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
+static int current_message_1 (ptrdiff_t, Lisp_Object);
 static void pop_message (void);
-static int truncate_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
-static void set_message (const char *, Lisp_Object, ptrdiff_t, int);
-static int set_message_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
+static int truncate_message_1 (ptrdiff_t, Lisp_Object);
+static void set_message (Lisp_Object);
+static int set_message_1 (ptrdiff_t, Lisp_Object);
 static int display_echo_area (struct window *);
-static int display_echo_area_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
-static int resize_mini_window_1 (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t);
+static int display_echo_area_1 (ptrdiff_t, Lisp_Object);
+static int resize_mini_window_1 (ptrdiff_t, Lisp_Object);
 static Lisp_Object unwind_redisplay (Lisp_Object);
 static int string_char_and_length (const unsigned char *, int *);
 static struct text_pos display_prop_end (struct it *, Lisp_Object,
@@ -874,7 +848,6 @@ static void push_it (struct it *, struct text_pos *);
 static void iterate_out_of_display_property (struct it *);
 static void pop_it (struct it *);
 static void sync_frame_with_window_matrix_rows (struct window *);
-static void select_frame_for_redisplay (Lisp_Object);
 static void redisplay_internal (void);
 static int echo_area_display (int);
 static void redisplay_windows (Lisp_Object);
@@ -937,8 +910,8 @@ static int forward_to_next_line_start (struct it *, int *, struct bidi_it *);
 static struct text_pos string_pos_nchars_ahead (struct text_pos,
                                                 Lisp_Object, ptrdiff_t);
 static struct text_pos string_pos (ptrdiff_t, Lisp_Object);
-static struct text_pos c_string_pos (ptrdiff_t, const char *, int);
-static ptrdiff_t number_of_chars (const char *, int);
+static struct text_pos c_string_pos (ptrdiff_t, const char *, bool);
+static ptrdiff_t number_of_chars (const char *, bool);
 static void compute_stop_pos (struct it *);
 static void compute_string_pos (struct text_pos *, struct text_pos,
                                 Lisp_Object);
@@ -1335,7 +1308,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                            BVAR (current_buffer, header_line_format));
 
   start_display (&it, w, top);
-  move_it_to (&it, charpos, -1, it.last_visible_y-1, -1,
+  move_it_to (&it, charpos, -1, it.last_visible_y - 1, -1,
               (charpos >= 0 ? MOVE_TO_POS : 0) | MOVE_TO_Y);
 
   if (charpos >= 0
@@ -1343,7 +1316,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
            && IT_CHARPOS (it) >= charpos)
           /* When scanning backwards under bidi iteration, move_it_to
              stops at or _before_ CHARPOS, because it stops at or to
-             the _right_ of the character at CHARPOS. */
+             the _right_ of the character at CHARPOS.  */
           || (it.bidi_p && it.bidi_it.scan_dir == -1
               && IT_CHARPOS (it) <= charpos)))
     {
@@ -1419,21 +1392,9 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
               Lisp_Object cpos = make_number (charpos);
               Lisp_Object spec = Fget_char_property (cpos, Qdisplay, Qnil);
               Lisp_Object string = string_from_display_spec (spec);
-              int newline_in_string = 0;
-
-              if (STRINGP (string))
-                {
-                  const char *s = SSDATA (string);
-                  const char *e = s + SBYTES (string);
-                  while (s < e)
-                    {
-                      if (*s++ == '\n')
-                        {
-                          newline_in_string = 1;
-                          break;
-                        }
-                    }
-                }
+              bool newline_in_string
+                = (STRINGP (string)
+                   && memchr (SDATA (string), '\n', SBYTES (string)));
               /* The tricky code below is needed because there's a
                  discrepancy between move_it_to and how we set cursor
                  when the display line ends in a newline from a
@@ -1689,7 +1650,7 @@ string_pos (ptrdiff_t charpos, Lisp_Object string)
    means recognize multibyte characters.  */
 
 static struct text_pos
-c_string_pos (ptrdiff_t charpos, const char *s, int multibyte_p)
+c_string_pos (ptrdiff_t charpos, const char *s, bool multibyte_p)
 {
   struct text_pos pos;
 
@@ -1720,7 +1681,7 @@ c_string_pos (ptrdiff_t charpos, const char *s, int multibyte_p)
    non-zero means recognize multibyte characters.  */
 
 static ptrdiff_t
-number_of_chars (const char *s, int multibyte_p)
+number_of_chars (const char *s, bool multibyte_p)
 {
   ptrdiff_t nchars;
 
@@ -2544,8 +2505,7 @@ check_it (struct it *it)
 static void
 check_window_end (struct window *w)
 {
-  if (!MINI_WINDOW_P (w)
-      && !NILP (w->window_end_valid))
+  if (!MINI_WINDOW_P (w) && w->window_end_valid)
     {
       struct glyph_row *row;
       eassert ((row = MATRIX_ROW (w->current_matrix,
@@ -2564,8 +2524,24 @@ check_window_end (struct window *w)
 
 #endif /* GLYPH_DEBUG and ENABLE_CHECKING */
 
+/* Return mark position if current buffer has the region of non-zero length,
+   or -1 otherwise.  */
+
+static ptrdiff_t
+markpos_of_region (void)
+{
+  if (!NILP (Vtransient_mark_mode)
+      && !NILP (BVAR (current_buffer, mark_active))
+      && XMARKER (BVAR (current_buffer, mark))->buffer != NULL)
+    {
+      ptrdiff_t markpos = XMARKER (BVAR (current_buffer, mark))->charpos;
+
+      if (markpos != PT)
+        return markpos;
+    }
+  return -1;
+}
 
-
 /***********************************************************************
                        Iterator initialization
  ***********************************************************************/
@@ -2594,7 +2570,7 @@ init_iterator (struct it *it, struct window *w,
                ptrdiff_t charpos, ptrdiff_t bytepos,
                struct glyph_row *row, enum face_id base_face_id)
 {
-  int highlight_region_p;
+  ptrdiff_t markpos;
   enum face_id remapped_base_face_id = base_face_id;
 
   /* Some precondition checks.  */
@@ -2697,16 +2673,11 @@ init_iterator (struct it *it, struct window *w,
   /* Are multibyte characters enabled in current_buffer?  */
   it->multibyte_p = !NILP (BVAR (current_buffer, enable_multibyte_characters));
 
-  /* Non-zero if we should highlight the region.  */
-  highlight_region_p
-    = (!NILP (Vtransient_mark_mode)
-       && !NILP (BVAR (current_buffer, mark_active))
-       && XMARKER (BVAR (current_buffer, mark))->buffer != 0);
-
-  /* Set IT->region_beg_charpos and IT->region_end_charpos to the
-     start and end of a visible region in window IT->w.  Set both to
-     -1 to indicate no region.  */
-  if (highlight_region_p
+  /* If visible region is of non-zero length, set IT->region_beg_charpos
+     and IT->region_end_charpos to the start and end of a visible region
+     in window IT->w.  Set both to -1 to indicate no region.  */
+  markpos = markpos_of_region ();
+  if (0 <= markpos
       /* Maybe highlight only in selected window.  */
       && (/* Either show region everywhere.  */
           highlight_nonselected_windows
@@ -2718,7 +2689,6 @@ init_iterator (struct it *it, struct window *w,
               && WINDOWP (minibuf_selected_window)
               && w == XWINDOW (minibuf_selected_window))))
     {
-      ptrdiff_t markpos = marker_position (BVAR (current_buffer, mark));
       it->region_beg_charpos = min (PT, markpos);
       it->region_end_charpos = max (PT, markpos);
     }
@@ -3760,18 +3730,26 @@ handle_face_prop (struct it *it)
       if (new_face_id != it->face_id)
         {
           struct face *new_face = FACE_FROM_ID (it->f, new_face_id);
+          /* If it->face_id is -1, old_face below will be NULL, see
+             the definition of FACE_FROM_ID.  This will happen if this
+             is the initial call that gets the face.  */
+          struct face *old_face = FACE_FROM_ID (it->f, it->face_id);
 
-          /* If new face has a box but old face has not, this is
-             the start of a run of characters with box, i.e. it has
-             a shadow on the left side.  The value of face_id of the
-             iterator will be -1 if this is the initial call that gets
-             the face.  In this case, we have to look in front of IT's
-             position and see whether there is a face != new_face_id.  */
-          it->start_of_box_run_p
-            = (new_face->box != FACE_NO_BOX
-               && (it->face_id >= 0
-                   || IT_CHARPOS (*it) == BEG
-                   || new_face_id != face_before_it_pos (it)));
+          /* If the value of face_id of the iterator is -1, we have to
+             look in front of IT's position and see whether there is a
+             face there that's different from new_face_id.  */
+          if (!old_face && IT_CHARPOS (*it) > BEG)
+            {
+              int prev_face_id = face_before_it_pos (it);
+
+              old_face = FACE_FROM_ID (it->f, prev_face_id);
+            }
+
+          /* If the new face has a box, but the old face does not,
+             this is the start of a run of characters with box face,
+             i.e. this character has a shadow on the left side.  */
+          it->start_of_box_run_p = (new_face->box != FACE_NO_BOX
+                                    && (old_face == NULL || !old_face->box));
           it->face_box_p = new_face->box != FACE_NO_BOX;
         }
     }
@@ -9002,6 +8980,9 @@ move_it_vertically_backward (struct it *it, int dy)
   struct it it2, it3;
   void *it2data = NULL, *it3data = NULL;
   ptrdiff_t start_pos;
+  int nchars_per_row
+    = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
+  ptrdiff_t pos_limit;
 
  move_further_back:
   eassert (dy >= 0);
@@ -9010,9 +8991,15 @@ move_it_vertically_backward (struct it *it, int dy)
 
   /* Estimate how many newlines we must move back.  */
   nlines = max (1, dy / FRAME_LINE_HEIGHT (it->f));
+  if (it->line_wrap == TRUNCATE)
+    pos_limit = BEGV;
+  else
+    pos_limit = max (start_pos - nlines * nchars_per_row, BEGV);
 
-  /* Set the iterator's position that many lines back.  */
-  while (nlines-- && IT_CHARPOS (*it) > BEGV)
+  /* Set the iterator's position that many lines back.  But don't go
+     back more than NLINES full screen lines -- this wins a day with
+     buffers which have very long lines.  */
+  while (nlines-- && IT_CHARPOS (*it) > pos_limit)
     back_to_previous_visible_line_start (it);
 
   /* Reseat the iterator here.  When moving backward, we don't want
@@ -9243,6 +9230,9 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
       struct it it2;
       void *it2data = NULL;
       ptrdiff_t start_charpos, i;
+      int nchars_per_row
+        = (it->last_visible_x - it->first_visible_x) / FRAME_COLUMN_WIDTH (it->f);
+      ptrdiff_t pos_limit;
 
       /* Start at the beginning of the screen line containing IT's
          position.  This may actually move vertically backwards,
@@ -9251,9 +9241,14 @@ move_it_by_lines (struct it *it, ptrdiff_t dvpos)
       move_it_vertically_backward (it, 0);
       dvpos -= it->vpos;
 
-      /* Go back -DVPOS visible lines and reseat the iterator there.  */
+      /* Go back -DVPOS buffer lines, but no farther than -DVPOS full
+         screen lines, and reseat the iterator there.  */
       start_charpos = IT_CHARPOS (*it);
-      for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > BEGV; --i)
+      if (it->line_wrap == TRUNCATE)
+        pos_limit = BEGV;
+      else
+        pos_limit = max (start_charpos + dvpos * nchars_per_row, BEGV);
+      for (i = -dvpos; i > 0 && IT_CHARPOS (*it) > pos_limit; --i)
         back_to_previous_visible_line_start (it);
       reseat (it, it->current.pos, 1);
 
@@ -9362,8 +9357,8 @@ message_log_maybe_newline (void)
 
 
 /* Add a string M of length NBYTES to the message log, optionally
-   terminated with a newline when NLFLAG is non-zero.  MULTIBYTE, if
-   nonzero, means interpret the contents of M as multibyte.  This
+   terminated with a newline when NLFLAG is true.  MULTIBYTE, if
+   true, means interpret the contents of M as multibyte.  This
    function calls low-level routines in order to bypass text property
    hooks, etc. which might not be safe to run.
 
@@ -9371,7 +9366,7 @@ message_log_maybe_newline (void)
    so the buffer M must NOT point to a Lisp string.  */
 
 void
-message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
+message_dolog (const char *m, ptrdiff_t nbytes, bool nlflag, bool multibyte)
 {
   const unsigned char *msg = (const unsigned char *) m;
 
@@ -9385,7 +9380,8 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       int old_windows_or_buffers_changed = windows_or_buffers_changed;
       ptrdiff_t point_at_end = 0;
       ptrdiff_t zv_at_end = 0;
-      Lisp_Object old_deactivate_mark, tem;
+      Lisp_Object old_deactivate_mark;
+      bool shown;
       struct gcpro gcpro1;
 
       old_deactivate_mark = Vdeactivate_mark;
@@ -9394,11 +9390,11 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       bset_undo_list (current_buffer, Qt);
 
       oldpoint = message_dolog_marker1;
-      set_marker_restricted (oldpoint, make_number (PT), Qnil);
+      set_marker_restricted_both (oldpoint, Qnil, PT, PT_BYTE);
       oldbegv = message_dolog_marker2;
-      set_marker_restricted (oldbegv, make_number (BEGV), Qnil);
+      set_marker_restricted_both (oldbegv, Qnil, BEGV, BEGV_BYTE);
       oldzv = message_dolog_marker3;
-      set_marker_restricted (oldzv, make_number (ZV), Qnil);
+      set_marker_restricted_both (oldzv, Qnil, ZV, ZV_BYTE);
       GCPRO1 (old_deactivate_mark);
 
       if (PT == Z)
@@ -9449,13 +9445,14 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
             }
         }
       else if (nbytes)
-        insert_1 (m, nbytes, 1, 0, 0);
+        insert_1_both (m, chars_in_text (msg, nbytes), nbytes, 1, 0, 0);
 
       if (nlflag)
         {
           ptrdiff_t this_bol, this_bol_byte, prev_bol, prev_bol_byte;
           printmax_t dups;
-          insert_1 ("\n", 1, 1, 0, 0);
+
+          insert_1_both ("\n", 1, 1, 1, 0, 0);
 
           scan_newline (Z, Z_BYTE, BEG, BEG_BYTE, -2, 0);
           this_bol = PT;
@@ -9484,7 +9481,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
                          change message_log_check_duplicate.  */
                       int duplen = sprintf (dupstr, " [%"pMd" times]", dups);
                       TEMP_SET_PT_BOTH (Z - 1, Z_BYTE - 1);
-                      insert_1 (dupstr, duplen, 1, 0, 1);
+                      insert_1_both (dupstr, duplen, duplen, 1, 0, 1);
                     }
                 }
             }
@@ -9500,7 +9497,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
               del_range_both (BEG, BEG_BYTE, PT, PT_BYTE, 0);
             }
         }
-      BEGV = XMARKER (oldbegv)->charpos;
+      BEGV = marker_position (oldbegv);
       BEGV_BYTE = marker_byte_position (oldbegv);
 
       if (zv_at_end)
@@ -9510,7 +9507,7 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
         }
       else
         {
-          ZV = XMARKER (oldzv)->charpos;
+          ZV = marker_position (oldzv);
           ZV_BYTE = marker_byte_position (oldzv);
         }
 
@@ -9519,17 +9516,17 @@ message_dolog (const char *m, ptrdiff_t nbytes, int nlflag, int multibyte)
       else
         /* We can't do Fgoto_char (oldpoint) because it will run some
            Lisp code.  */
-        TEMP_SET_PT_BOTH (XMARKER (oldpoint)->charpos,
-                          XMARKER (oldpoint)->bytepos);
+        TEMP_SET_PT_BOTH (marker_position (oldpoint),
+                          marker_byte_position (oldpoint));
 
       UNGCPRO;
       unchain_marker (XMARKER (oldpoint));
       unchain_marker (XMARKER (oldbegv));
       unchain_marker (XMARKER (oldzv));
 
-      tem = Fget_buffer_window (Fcurrent_buffer (), Qt);
+      shown = buffer_window_count (current_buffer) > 0;
       set_buffer_internal (oldbuf);
-      if (NILP (tem))
+      if (!shown)
         windows_or_buffers_changed = old_windows_or_buffers_changed;
       message_log_need_newline = !nlflag;
       Vdeactivate_mark = old_deactivate_mark;
@@ -9554,7 +9551,7 @@ message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
 
   for (i = 0; i < len; i++)
     {
-      if (i >= 3 && p1[i-3] == '.' && p1[i-2] == '.' && p1[i-1] == '.')
+      if (i >= 3 && p1[i - 3] == '.' && p1[i - 2] == '.' && p1[i - 1] == '.')
         seen_dots = 1;
       if (p1[i] != p2[i])
         return seen_dots;
@@ -9567,88 +9564,13 @@ message_log_check_duplicate (ptrdiff_t prev_bol_byte, ptrdiff_t this_bol_byte)
       char *pend;
       intmax_t n = strtoimax ((char *) p1, &pend, 10);
       if (0 < n && n < INTMAX_MAX && strncmp (pend, " times]\n", 8) == 0)
-        return n+1;
+        return n + 1;
     }
   return 0;
 }
 
 
 /* Display an echo area message M with a specified length of NBYTES
-   bytes.  The string may include null characters.  If M is 0, clear
-   out any existing message, and let the mini-buffer text show
-   through.
-
-   This may GC, so the buffer M must NOT point to a Lisp string.  */
-
-void
-message2 (const char *m, ptrdiff_t nbytes, int multibyte)
-{
-  /* First flush out any partial line written with print.  */
-  message_log_maybe_newline ();
-  if (m)
-    message_dolog (m, nbytes, 1, multibyte);
-  message2_nolog (m, nbytes, multibyte);
-}
-
-
-/* The non-logging counterpart of message2.  */
-
-void
-message2_nolog (const char *m, ptrdiff_t nbytes, int multibyte)
-{
-  struct frame *sf = SELECTED_FRAME ();
-  message_enable_multibyte = multibyte;
-
-  if (FRAME_INITIAL_P (sf))
-    {
-      if (noninteractive_need_newline)
-        putc ('\n', stderr);
-      noninteractive_need_newline = 0;
-      if (m)
-        fwrite (m, nbytes, 1, stderr);
-      if (cursor_in_echo_area == 0)
-        fprintf (stderr, "\n");
-      fflush (stderr);
-    }
-  /* A null message buffer means that the frame hasn't really been
-     initialized yet.  Error messages get reported properly by
-     cmd_error, so this must be just an informative message; toss it.  */
-  else if (INTERACTIVE
-           && sf->glyphs_initialized_p
-           && FRAME_MESSAGE_BUF (sf))
-    {
-      Lisp_Object mini_window;
-      struct frame *f;
-
-      /* Get the frame containing the mini-buffer
-         that the selected frame is using.  */
-      mini_window = FRAME_MINIBUF_WINDOW (sf);
-      f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
-
-      FRAME_SAMPLE_VISIBILITY (f);
-      if (FRAME_VISIBLE_P (sf)
-          && ! FRAME_VISIBLE_P (f))
-        Fmake_frame_visible (WINDOW_FRAME (XWINDOW (mini_window)));
-
-      if (m)
-        {
-          set_message (m, Qnil, nbytes, multibyte);
-          if (minibuffer_auto_raise)
-            Fraise_frame  (WINDOW_FRAME (XWINDOW (mini_window)));
-        }
-      else
-        clear_message (1, 1);
-
-      do_pending_window_change (0);
-      echo_area_display (1);
-      do_pending_window_change (0);
-      if (FRAME_TERMINAL (f)->frame_up_to_date_hook)
-        (*FRAME_TERMINAL (f)->frame_up_to_date_hook) (f);
-    }
-}
-
-
-/* Display an echo area message M with a specified length of NBYTES
    bytes.  The string may include null characters.  If M is not a
    string, clear out any existing message, and let the mini-buffer
    text show through.
@@ -9656,7 +9578,7 @@ message2_nolog (const char *m, ptrdiff_t nbytes, int multibyte)
    This function cancels echoing.  */
 
 void
-message3 (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
+message3 (Lisp_Object m)
 {
   struct gcpro gcpro1;
 
@@ -9668,13 +9590,15 @@ message3 (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
   message_log_maybe_newline ();
   if (STRINGP (m))
     {
+      ptrdiff_t nbytes = SBYTES (m);
+      bool multibyte = STRING_MULTIBYTE (m);
       USE_SAFE_ALLOCA;
       char *buffer = SAFE_ALLOCA (nbytes);
       memcpy (buffer, SDATA (m), nbytes);
       message_dolog (buffer, nbytes, 1, multibyte);
       SAFE_FREE ();
     }
-  message3_nolog (m, nbytes, multibyte);
+  message3_nolog (m);
 
   UNGCPRO;
 }
@@ -9686,10 +9610,9 @@ message3 (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
    and make this cancel echoing.  */
 
 void
-message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
+message3_nolog (Lisp_Object m)
 {
   struct frame *sf = SELECTED_FRAME ();
-  message_enable_multibyte = multibyte;
 
   if (FRAME_INITIAL_P (sf))
     {
@@ -9697,36 +9620,28 @@ message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
         putc ('\n', stderr);
       noninteractive_need_newline = 0;
       if (STRINGP (m))
-        fwrite (SDATA (m), nbytes, 1, stderr);
+        fwrite (SDATA (m), SBYTES (m), 1, stderr);
       if (cursor_in_echo_area == 0)
         fprintf (stderr, "\n");
       fflush (stderr);
     }
-  /* A null message buffer means that the frame hasn't really been
-     initialized yet.  Error messages get reported properly by
-     cmd_error, so this must be just an informative message; toss it.  */
-  else if (INTERACTIVE
-           && sf->glyphs_initialized_p
-           && FRAME_MESSAGE_BUF (sf))
+  /* Error messages get reported properly by cmd_error, so this must be just an
+     informative message; if the frame hasn't really been initialized yet, just
+     toss it.  */
+  else if (INTERACTIVE && sf->glyphs_initialized_p)
     {
-      Lisp_Object mini_window;
-      Lisp_Object frame;
-      struct frame *f;
-
       /* Get the frame containing the mini-buffer
          that the selected frame is using.  */
-      mini_window = FRAME_MINIBUF_WINDOW (sf);
-      frame = XWINDOW (mini_window)->frame;
-      f = XFRAME (frame);
+      Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
+      Lisp_Object frame = XWINDOW (mini_window)->frame;
+      struct frame *f = XFRAME (frame);
 
-      FRAME_SAMPLE_VISIBILITY (f);
-      if (FRAME_VISIBLE_P (sf)
-          && !FRAME_VISIBLE_P (f))
+      if (FRAME_VISIBLE_P (sf) && !FRAME_VISIBLE_P (f))
         Fmake_frame_visible (frame);
 
       if (STRINGP (m) && SCHARS (m) > 0)
         {
-          set_message (NULL, m, nbytes, multibyte);
+          set_message (m);
           if (minibuffer_auto_raise)
             Fraise_frame (frame);
           /* Assume we are not echoing.
@@ -9756,7 +9671,7 @@ message3_nolog (Lisp_Object m, ptrdiff_t nbytes, int multibyte)
 void
 message1 (const char *m)
 {
-  message2 (m, (m ? strlen (m) : 0), 0);
+  message3 (m ? make_unibyte_string (m, strlen (m)) : Qnil);
 }
 
 
@@ -9765,7 +9680,7 @@ message1 (const char *m)
 void
 message1_nolog (const char *m)
 {
-  message2_nolog (m, (m ? strlen (m) : 0), 0);
+  message3_nolog (m ? make_unibyte_string (m, strlen (m)) : Qnil);
 }
 
 /* Display a message M which contains a single %s
@@ -9802,10 +9717,10 @@ message_with_string (const char *m, Lisp_Object string, int log)
       mini_window = FRAME_MINIBUF_WINDOW (sf);
       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 
-      /* A null message buffer means that the frame hasn't really been
-         initialized yet.  Error messages get reported properly by
-         cmd_error, so this must be just an informative message; toss it.  */
-      if (FRAME_MESSAGE_BUF (f))
+      /* Error messages get reported properly by cmd_error, so this must be
+         just an informative message; if the frame hasn't really been
+         initialized yet, just toss it.  */
+      if (f->glyphs_initialized_p)
         {
           Lisp_Object args[2], msg;
           struct gcpro gcpro1, gcpro2;
@@ -9818,9 +9733,9 @@ message_with_string (const char *m, Lisp_Object string, int log)
           msg = Fformat (2, args);
 
           if (log)
-            message3 (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
+            message3 (msg);
           else
-            message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
+            message3_nolog (msg);
 
           UNGCPRO;
 
@@ -9864,20 +9779,20 @@ vmessage (const char *m, va_list ap)
       mini_window = FRAME_MINIBUF_WINDOW (sf);
       f = XFRAME (WINDOW_FRAME (XWINDOW (mini_window)));
 
-      /* A null message buffer means that the frame hasn't really been
-         initialized yet.  Error messages get reported properly by
-         cmd_error, so this must be just an informative message; toss
-         it.  */
-      if (FRAME_MESSAGE_BUF (f))
+      /* Error messages get reported properly by cmd_error, so this must be
+         just an informative message; if the frame hasn't really been
+         initialized yet, just toss it.  */
+      if (f->glyphs_initialized_p)
         {
           if (m)
             {
               ptrdiff_t len;
+              ptrdiff_t maxsize = FRAME_MESSAGE_BUF_SIZE (f);
+              char *message_buf = alloca (maxsize + 1);
 
-              len = doprnt (FRAME_MESSAGE_BUF (f),
-                            FRAME_MESSAGE_BUF_SIZE (f), m, (char *)0, ap);
+              len = doprnt (message_buf, maxsize, m, (char *)0, ap);
 
-              message2 (FRAME_MESSAGE_BUF (f), len, 1);
+              message3 (make_string (message_buf, len));
             }
           else
             message1 (0);
@@ -9928,8 +9843,7 @@ update_echo_area (void)
     {
       Lisp_Object string;
       string = Fcurrent_message ();
-      message3 (string, SBYTES (string),
-                !NILP (BVAR (current_buffer, enable_multibyte_characters)));
+      message3 (string);
     }
 }
 
@@ -9965,7 +9879,7 @@ ensure_echo_area_buffers (void)
 }
 
 
-/* Call FN with args A1..A4 with either the current or last displayed
+/* Call FN with args A1..A2 with either the current or last displayed
    echo_area_buffer as current buffer.
 
    WHICH zero means use the current message buffer
@@ -9983,8 +9897,8 @@ ensure_echo_area_buffers (void)
 
 static int
 with_echo_area_buffer (struct window *w, int which,
-                       int (*fn) (ptrdiff_t, Lisp_Object, ptrdiff_t, ptrdiff_t),
-                       ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
+                       int (*fn) (ptrdiff_t, Lisp_Object),
+                       ptrdiff_t a1, Lisp_Object a2)
 {
   Lisp_Object buffer;
   int this_one, the_other, clear_buffer_p, rc;
@@ -10057,7 +9971,7 @@ with_echo_area_buffer (struct window *w, int which,
   eassert (BEGV >= BEG);
   eassert (ZV <= Z && ZV >= BEGV);
 
-  rc = fn (a1, a2, a3, a4);
+  rc = fn (a1, a2);
 
   eassert (BEGV >= BEG);
   eassert (ZV <= Z && ZV >= BEGV);
@@ -10092,8 +10006,8 @@ with_echo_area_buffer_unwind_data (struct window *w)
     {
       XSETWINDOW (tmp, w); ASET (vector, i, tmp); ++i;
       ASET (vector, i, w->buffer); ++i;
-      ASET (vector, i, make_number (XMARKER (w->pointm)->charpos)); ++i;
-      ASET (vector, i, make_number (XMARKER (w->pointm)->bytepos)); ++i;
+      ASET (vector, i, make_number (marker_position (w->pointm))); ++i;
+      ASET (vector, i, make_number (marker_byte_position (w->pointm))); ++i;
     }
   else
     {
@@ -10236,7 +10150,7 @@ display_echo_area (struct window *w)
   window_height_changed_p
     = with_echo_area_buffer (w, display_last_displayed_message_p,
                              display_echo_area_1,
-                             (intptr_t) w, Qnil, 0, 0);
+                             (intptr_t) w, Qnil);
 
   if (no_message_p)
     echo_area_buffer[i] = Qnil;
@@ -10253,7 +10167,7 @@ display_echo_area (struct window *w)
    Value is non-zero if height of W was changed.  */
 
 static int
-display_echo_area_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
+display_echo_area_1 (ptrdiff_t a1, Lisp_Object a2)
 {
   intptr_t i1 = a1;
   struct window *w = (struct window *) i1;
@@ -10298,8 +10212,7 @@ resize_echo_area_exactly (void)
         resize_exactly = Qnil;
 
       resized_p = with_echo_area_buffer (w, 0, resize_mini_window_1,
-                                         (intptr_t) w, resize_exactly,
-                                         0, 0);
+                                         (intptr_t) w, resize_exactly);
       if (resized_p)
         {
           ++windows_or_buffers_changed;
@@ -10317,7 +10230,7 @@ resize_echo_area_exactly (void)
    resize_mini_window returns.  */
 
 static int
-resize_mini_window_1 (ptrdiff_t a1, Lisp_Object exactly, ptrdiff_t a3, ptrdiff_t a4)
+resize_mini_window_1 (ptrdiff_t a1, Lisp_Object exactly)
 {
   intptr_t i1 = a1;
   return resize_mini_window ((struct window *) i1, !NILP (exactly));
@@ -10390,8 +10303,7 @@ resize_mini_window (struct window *w, int exact_p)
         max_height = total_height / 4;
 
       /* Correct that max. height if it's bogus.  */
-      max_height = max (1, max_height);
-      max_height = min (total_height, max_height);
+      max_height = clip_to_bounds (1, max_height, total_height);
 
       /* Find out the height of the text in the window.  */
       if (it.line_wrap == TRUNCATE)
@@ -10487,7 +10399,7 @@ current_message (void)
   else
     {
       with_echo_area_buffer (0, 0, current_message_1,
-                             (intptr_t) &msg, Qnil, 0, 0);
+                             (intptr_t) &msg, Qnil);
       if (NILP (msg))
         echo_area_buffer[0] = Qnil;
     }
@@ -10497,7 +10409,7 @@ current_message (void)
 
 
 static int
-current_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
+current_message_1 (ptrdiff_t a1, Lisp_Object a2)
 {
   intptr_t i1 = a1;
   Lisp_Object *msg = (Lisp_Object *) i1;
@@ -10529,14 +10441,8 @@ push_message (void)
 void
 restore_message (void)
 {
-  Lisp_Object msg;
-
   eassert (CONSP (Vmessage_stack));
-  msg = XCAR (Vmessage_stack);
-  if (STRINGP (msg))
-    message3_nolog (msg, SBYTES (msg), STRING_MULTIBYTE (msg));
-  else
-    message3_nolog (msg, 0, 0);
+  message3_nolog (XCAR (Vmessage_stack));
 }
 
 
@@ -10579,16 +10485,16 @@ truncate_echo_area (ptrdiff_t nchars)
 {
   if (nchars == 0)
     echo_area_buffer[0] = Qnil;
-  /* A null message buffer means that the frame hasn't really been
-     initialized yet.  Error messages get reported properly by
-     cmd_error, so this must be just an informative message; toss it.  */
   else if (!noninteractive
            && INTERACTIVE
            && !NILP (echo_area_buffer[0]))
     {
       struct frame *sf = SELECTED_FRAME ();
-      if (FRAME_MESSAGE_BUF (sf))
-        with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil, 0, 0);
+      /* Error messages get reported properly by cmd_error, so this must be
+         just an informative message; if the frame hasn't really been
+         initialized yet, just toss it.  */
+      if (sf->glyphs_initialized_p)
+        with_echo_area_buffer (0, 0, truncate_message_1, nchars, Qnil);
     }
 }
 
@@ -10597,7 +10503,7 @@ truncate_echo_area (ptrdiff_t nchars)
    message to at most NCHARS characters.  */
 
 static int
-truncate_message_1 (ptrdiff_t nchars, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4)
+truncate_message_1 (ptrdiff_t nchars, Lisp_Object a2)
 {
   if (BEG + nchars < Z)
     del_range (BEG + nchars, Z);
@@ -10606,30 +10512,16 @@ truncate_message_1 (ptrdiff_t nchars, Lisp_Object a2, ptrdiff_t a3, ptrdiff_t a4
   return 0;
 }
 
-/* Set the current message to a substring of S or STRING.
-
-   If STRING is a Lisp string, set the message to the first NBYTES
-   bytes from STRING.  NBYTES zero means use the whole string.  If
-   STRING is multibyte, the message will be displayed multibyte.
-
-   If S is not null, set the message to the first LEN bytes of S.  LEN
-   zero means use the whole string.  MULTIBYTE_P non-zero means S is
-   multibyte.  Display the message multibyte in that case.
-
-   Doesn't GC, as with_echo_area_buffer binds Qinhibit_modification_hooks
-   to t before calling set_message_1 (which calls insert).
-  */
+/* Set the current message to STRING.  */
 
 static void
-set_message (const char *s, Lisp_Object string,
-             ptrdiff_t nbytes, int multibyte_p)
+set_message (Lisp_Object string)
 {
-  message_enable_multibyte
-    = ((s && multibyte_p)
-       || (STRINGP (string) && STRING_MULTIBYTE (string)));
+  eassert (STRINGP (string));
+
+  message_enable_multibyte = STRING_MULTIBYTE (string);
 
-  with_echo_area_buffer (0, -1, set_message_1,
-                         (intptr_t) s, string, nbytes, multibyte_p);
+  with_echo_area_buffer (0, -1, set_message_1, 0, string);
   message_buf_print = 0;
   help_echo_showing_p = 0;
 
@@ -10639,18 +10531,14 @@ set_message (const char *s, Lisp_Object string,
 }
 
 
-/* Helper function for set_message.  Arguments have the same meaning
-   as there, with A1 corresponding to S and A2 corresponding to STRING
-   This function is called with the echo area buffer being
-   current.  */
+/* Helper function for set_message.  First argument is ignored and second
+   argument has the same meaning as for set_message.
+   This function is called with the echo area buffer being current.  */
 
 static int
-set_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t nbytes, ptrdiff_t multibyte_p)
+set_message_1 (ptrdiff_t a1, Lisp_Object string)
 {
-  intptr_t i1 = a1;
-  const char *s = (const char *) i1;
-  const unsigned char *msg = (const unsigned char *) s;
-  Lisp_Object string = a2;
+  eassert (STRINGP (string));
 
   /* Change multibyteness of the echo buffer appropriately.  */
   if (message_enable_multibyte
@@ -10664,61 +10552,10 @@ set_message_1 (ptrdiff_t a1, Lisp_Object a2, ptrdiff_t nbytes, ptrdiff_t multiby
   /* Insert new message at BEG.  */
   TEMP_SET_PT_BOTH (BEG, BEG_BYTE);
 
-  if (STRINGP (string))
-    {
-      ptrdiff_t nchars;
-
-      if (nbytes == 0)
-        nbytes = SBYTES (string);
-      nchars = string_byte_to_char (string, nbytes);
-
-      /* This function takes care of single/multibyte conversion.  We
-         just have to ensure that the echo area buffer has the right
-         setting of enable_multibyte_characters.  */
-      insert_from_string (string, 0, 0, nchars, nbytes, 1);
-    }
-  else if (s)
-    {
-      if (nbytes == 0)
-        nbytes = strlen (s);
-
-      if (multibyte_p && NILP (BVAR (current_buffer, enable_multibyte_characters)))
-        {
-          /* Convert from multi-byte to single-byte.  */
-          ptrdiff_t i;
-          int c, n;
-          char work[1];
-
-          /* Convert a multibyte string to single-byte.  */
-          for (i = 0; i < nbytes; i += n)
-            {
-              c = string_char_and_length (msg + i, &n);
-              work[0] = (ASCII_CHAR_P (c)
-                         ? c
-                         : multibyte_char_to_unibyte (c));
-              insert_1_both (work, 1, 1, 1, 0, 0);
-            }
-        }
-      else if (!multibyte_p
-               && !NILP (BVAR (current_buffer, enable_multibyte_characters)))
-        {
-          /* Convert from single-byte to multi-byte.  */
-          ptrdiff_t i;
-          int c, n;
-          unsigned char str[MAX_MULTIBYTE_LENGTH];
-
-          /* Convert a single-byte string to multibyte.  */
-          for (i = 0; i < nbytes; i++)
-            {
-              c = msg[i];
-              MAKE_CHAR_MULTIBYTE (c);
-              n = CHAR_STRING (c, str);
-              insert_1_both ((char *) str, 1, n, 1, 0, 0);
-            }
-        }
-      else
-        insert_1 (s, nbytes, 1, 0, 0);
-    }
+  /* This function takes care of single/multibyte conversion.
+     We just have to ensure that the echo area buffer has the right
+     setting of enable_multibyte_characters.  */
+  insert_from_string (string, 0, 0, SCHARS (string), SBYTES (string), 1);
 
   return 0;
 }
@@ -10894,9 +10731,8 @@ echo_area_display (int update_frame_p)
 static int
 buffer_shared_and_changed (void)
 {
-  /* The variable buffer_shared is set in redisplay_window and
-     indicates that we redisplay a buffer in different windows. */
-  return (buffer_shared > 1 && UNCHANGED_MODIFIED < MODIFF);
+  return (buffer_window_count (current_buffer) > 1
+          && UNCHANGED_MODIFIED < MODIFF);
 }
 
 /* Nonzero if W doesn't reflect the actual state of current buffer due
@@ -10906,7 +10742,7 @@ buffer_shared_and_changed (void)
 static int
 window_outdated (struct window *w)
 {
-  return (w->last_modified < MODIFF 
+  return (w->last_modified < MODIFF
           || w->last_overlay_modified < OVERLAY_MODIFF);
 }
 
@@ -10922,7 +10758,7 @@ window_buffer_changed (struct window *w)
 
   return (((BUF_SAVE_MODIFF (b) < BUF_MODIFF (b)) != w->last_had_star)
           || ((!NILP (Vtransient_mark_mode) && !NILP (BVAR (b, mark_active)))
-              != !NILP (w->region_showing)));
+              != (w->region_showing != 0)));
 }
 
 /* Nonzero if W has %c in its mode line and mode line should be updated.  */
@@ -10930,9 +10766,9 @@ window_buffer_changed (struct window *w)
 static int
 mode_line_update_needed (struct window *w)
 {
-  return (!NILP (w->column_number_displayed)
+  return (w->column_number_displayed != -1
           && !(PT == w->last_point && !window_outdated (w))
-          && (XFASTINT (w->column_number_displayed) != current_column ()));
+          && (w->column_number_displayed != current_column ()));
 }
 
 /***********************************************************************
@@ -12494,11 +12330,7 @@ hscroll_window_tree (Lisp_Object window)
               if (w == XWINDOW (selected_window))
                 pt = PT;
               else
-                {
-                  pt = marker_position (w->pointm);
-                  pt = max (BEGV, pt);
-                  pt = min (ZV, pt);
-                }
+                pt = clip_to_bounds (BEGV, marker_position (w->pointm), ZV);
 
               /* Move iterator to pt starting at cursor_row->start in
                  a line with infinite width.  */
@@ -12914,10 +12746,10 @@ static void
 reconsider_clip_changes (struct window *w, struct buffer *b)
 {
   if (b->clip_changed
-           && !NILP (w->window_end_valid)
-           && w->current_matrix->buffer == b
-           && w->current_matrix->zv == BUF_ZV (b)
-           && w->current_matrix->begv == BUF_BEGV (b))
+      && w->window_end_valid
+      && w->current_matrix->buffer == b
+      && w->current_matrix->zv == BUF_ZV (b)
+      && w->current_matrix->begv == BUF_BEGV (b))
     b->clip_changed = 0;
 
   /* If display wasn't paused, and W is not a tool bar window, see if
@@ -12925,8 +12757,7 @@ reconsider_clip_changes (struct window *w, struct buffer *b)
      we set b->clip_changed to 1 to force updating the screen.  If
      b->clip_changed has already been set to 1, we can skip this
      check.  */
-  if (!b->clip_changed
-      && BUFFERP (w->buffer) && !NILP (w->window_end_valid))
+  if (!b->clip_changed && BUFFERP (w->buffer) && w->window_end_valid)
     {
       ptrdiff_t pt;
 
@@ -12945,46 +12776,6 @@ reconsider_clip_changes (struct window *w, struct buffer *b)
 }
 
 
-/* Select FRAME to forward the values of frame-local variables into C
-   variables so that the redisplay routines can access those values
-   directly.  */
-
-static void
-select_frame_for_redisplay (Lisp_Object frame)
-{
-  Lisp_Object tail, tem;
-  Lisp_Object old = selected_frame;
-  struct Lisp_Symbol *sym;
-
-  eassert (FRAMEP (frame) && FRAME_LIVE_P (XFRAME (frame)));
-
-  selected_frame = frame;
-
-  do {
-    for (tail = XFRAME (frame)->param_alist;
-         CONSP (tail); tail = XCDR (tail))
-      if (CONSP (XCAR (tail))
-          && (tem = XCAR (XCAR (tail)),
-              SYMBOLP (tem))
-          && (sym = indirect_variable (XSYMBOL (tem)),
-              sym->redirect == SYMBOL_LOCALIZED)
-          && sym->val.blv->frame_local)
-        /* Use find_symbol_value rather than Fsymbol_value
-           to avoid an error if it is void.  */
-        find_symbol_value (tem);
-  } while (!EQ (frame, old) && (frame = old, 1));
-}
-
-/* Make sure that previously selected OLD_FRAME is selected unless it has been
-   deleted (by an X connection failure during redisplay, for example).  */
-
-static void
-ensure_selected_frame (Lisp_Object old_frame)
-{
-  if (!EQ (old_frame, selected_frame) && FRAME_LIVE_P (XFRAME (old_frame)))
-    select_frame_for_redisplay (old_frame);
-}
-
 #define STOP_POLLING                                    \
 do { if (! polling_stopped_here) stop_polling ();       \
        polling_stopped_here = 1; } while (0)
@@ -13010,7 +12801,7 @@ redisplay_internal (void)
   ptrdiff_t count, count1;
   struct frame *sf;
   int polling_stopped_here = 0;
-  Lisp_Object tail, frame, old_frame = selected_frame;
+  Lisp_Object tail, frame;
   struct backtrace backtrace;
 
   /* Non-zero means redisplay has to consider all windows on all
@@ -13069,12 +12860,6 @@ redisplay_internal (void)
   /* Remember the currently selected window.  */
   sw = w;
 
-  /* When running redisplay, we play a bit fast-and-loose and allow e.g.
-     selected_frame and selected_window to be temporarily out-of-sync so
-     when we come back here via `goto retry', we need to resync because we
-     may need to run Elisp code (via prepare_menu_bars).  */
-  ensure_selected_frame (old_frame);
-
   pending = 0;
   reconsider_clip_changes (w, current_buffer);
   last_escape_glyph_frame = NULL;
@@ -13120,7 +12905,6 @@ redisplay_internal (void)
     {
       struct frame *f = XFRAME (frame);
 
-      FRAME_SAMPLE_VISIBILITY (f);
       if (FRAME_VISIBLE_P (f))
         ++number_of_visible_frames;
       clear_desired_matrices (f);
@@ -13237,16 +13021,15 @@ redisplay_internal (void)
       clear_garbaged_frames ();
     }
 
-
   /* If showing the region, and mark has changed, we must redisplay
      the whole window.  The assignment to this_line_start_pos prevents
      the optimization directly below this if-statement.  */
   if (((!NILP (Vtransient_mark_mode)
         && !NILP (BVAR (XBUFFER (w->buffer), mark_active)))
-       != !NILP (w->region_showing))
-      || (!NILP (w->region_showing)
-          && !EQ (w->region_showing,
-                  Fmarker_position (BVAR (XBUFFER (w->buffer), mark)))))
+       != (w->region_showing > 0))
+      || (w->region_showing
+          && w->region_showing
+          != XINT (Fmarker_position (BVAR (XBUFFER (w->buffer), mark)))))
     CHARPOS (this_line_start_pos) = 0;
 
   /* Optimize the case that only the line containing the cursor in the
@@ -13366,7 +13149,7 @@ redisplay_internal (void)
               else if (XFASTINT (w->window_end_vpos) == this_line_vpos
                        && this_line_vpos > 0)
                 wset_window_end_vpos (w, make_number (this_line_vpos - 1));
-              wset_window_end_valid (w, Qnil);
+              w->window_end_valid = 0;
 
               /* Update hint: No need to try to scroll in update_window.  */
               w->desired_matrix->no_scrolling_p = 1;
@@ -13412,7 +13195,7 @@ redisplay_internal (void)
                && (EQ (selected_window,
                        BVAR (current_buffer, last_selected_window))
                    || highlight_nonselected_windows)
-               && NILP (w->region_showing)
+               && !w->region_showing
                && NILP (Vshow_trailing_whitespace)
                && !cursor_in_echo_area)
         {
@@ -13470,10 +13253,6 @@ redisplay_internal (void)
       FOR_EACH_FRAME (tail, frame)
         XFRAME (frame)->updated_p = 0;
 
-      /* Recompute # windows showing selected buffer.  This will be
-         incremented each time such a window is displayed.  */
-      buffer_shared = 0;
-
       FOR_EACH_FRAME (tail, frame)
         {
           struct frame *f = XFRAME (frame);
@@ -13486,11 +13265,6 @@ redisplay_internal (void)
 
           if (FRAME_WINDOW_P (f) || FRAME_TERMCAP_P (f) || f == sf)
             {
-              if (! EQ (frame, selected_frame))
-                /* Select the frame, for the sake of frame-local
-                   variables.  */
-                select_frame_for_redisplay (frame);
-
               /* Mark all the scroll bars to be removed; we'll redeem
                  the ones we want when we redisplay their windows.  */
               if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
@@ -13540,10 +13314,6 @@ redisplay_internal (void)
             }
         }
 
-      /* We played a bit fast-and-loose above and allowed selected_frame
-         and selected_window to be temporarily out-of-sync but let's make
-         sure this stays contained.  */
-      ensure_selected_frame (old_frame);
       eassert (EQ (XFRAME (selected_frame)->selected_window, selected_window));
 
       if (!pending)
@@ -13681,9 +13451,6 @@ redisplay_internal (void)
 
           if (XFRAME (frame)->visible)
             this_is_visible = 1;
-          FRAME_SAMPLE_VISIBILITY (XFRAME (frame));
-          if (XFRAME (frame)->visible)
-            this_is_visible = 1;
 
           if (this_is_visible)
             new_count++;
@@ -13769,55 +13536,47 @@ static Lisp_Object
 unwind_redisplay (Lisp_Object old_frame)
 {
   redisplaying_p = 0;
-  ensure_selected_frame (old_frame);
   return Qnil;
 }
 
 
-/* Mark the display of window W as accurate or inaccurate.  If
-   ACCURATE_P is non-zero mark display of W as accurate.  If
-   ACCURATE_P is zero, arrange for W to be redisplayed the next time
-   redisplay_internal is called.  */
+/* Mark the display of leaf window W as accurate or inaccurate.
+   If ACCURATE_P is non-zero mark display of W as accurate.  If
+   ACCURATE_P is zero, arrange for W to be redisplayed the next
+   time redisplay_internal is called.  */
 
 static void
 mark_window_display_accurate_1 (struct window *w, int accurate_p)
 {
-  if (BUFFERP (w->buffer))
-    {
-      struct buffer *b = XBUFFER (w->buffer);
+  struct buffer *b = XBUFFER (w->buffer);
 
-      w->last_modified = accurate_p ? BUF_MODIFF(b) : 0;
-      w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF(b) : 0;
-      w->last_had_star
-        = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
+  w->last_modified = accurate_p ? BUF_MODIFF (b) : 0;
+  w->last_overlay_modified = accurate_p ? BUF_OVERLAY_MODIFF (b) : 0;
+  w->last_had_star = BUF_MODIFF (b) > BUF_SAVE_MODIFF (b);
 
-      if (accurate_p)
-        {
-          b->clip_changed = 0;
-          b->prevent_redisplay_optimizations_p = 0;
+  if (accurate_p)
+    {
+      b->clip_changed = 0;
+      b->prevent_redisplay_optimizations_p = 0;
 
-          BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
-          BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
-          BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
-          BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
+      BUF_UNCHANGED_MODIFIED (b) = BUF_MODIFF (b);
+      BUF_OVERLAY_UNCHANGED_MODIFIED (b) = BUF_OVERLAY_MODIFF (b);
+      BUF_BEG_UNCHANGED (b) = BUF_GPT (b) - BUF_BEG (b);
+      BUF_END_UNCHANGED (b) = BUF_Z (b) - BUF_GPT (b);
 
-          w->current_matrix->buffer = b;
-          w->current_matrix->begv = BUF_BEGV (b);
-          w->current_matrix->zv = BUF_ZV (b);
+      w->current_matrix->buffer = b;
+      w->current_matrix->begv = BUF_BEGV (b);
+      w->current_matrix->zv = BUF_ZV (b);
 
-          w->last_cursor = w->cursor;
-          w->last_cursor_off_p = w->cursor_off_p;
+      w->last_cursor = w->cursor;
+      w->last_cursor_off_p = w->cursor_off_p;
 
-          if (w == XWINDOW (selected_window))
-            w->last_point = BUF_PT (b);
-          else
-            w->last_point = XMARKER (w->pointm)->charpos;
-        }
-    }
+      if (w == XWINDOW (selected_window))
+        w->last_point = BUF_PT (b);
+      else
+        w->last_point = marker_position (w->pointm);
 
-  if (accurate_p)
-    {
-      wset_window_end_valid (w, w->buffer);
+      w->window_end_valid = 1;
       w->update_mode_line = 0;
     }
 }
@@ -13836,25 +13595,21 @@ mark_window_display_accurate (Lisp_Object window, int accurate_p)
   for (; !NILP (window); window = w->next)
     {
       w = XWINDOW (window);
-      mark_window_display_accurate_1 (w, accurate_p);
-
       if (!NILP (w->vchild))
         mark_window_display_accurate (w->vchild, accurate_p);
-      if (!NILP (w->hchild))
+      else if (!NILP (w->hchild))
         mark_window_display_accurate (w->hchild, accurate_p);
+      else if (BUFFERP (w->buffer))
+        mark_window_display_accurate_1 (w, accurate_p);
     }
 
   if (accurate_p)
-    {
-      update_overlay_arrows (1);
-    }
+    update_overlay_arrows (1);
   else
-    {
-      /* Force a thorough redisplay the next time by setting
-         last_arrow_position and last_arrow_string to t, which is
-         unequal to any useful value of Voverlay_arrow_...  */
-      update_overlay_arrows (-1);
-    }
+    /* Force a thorough redisplay the next time by setting
+       last_arrow_position and last_arrow_string to t, which is
+       unequal to any useful value of Voverlay_arrow_...  */
+    update_overlay_arrows (-1);
 }
 
 
@@ -14242,7 +13997,12 @@ set_cursor_from_row (struct window *w, struct glyph_row *row,
          CHARPOS is zero or negative.  */
       int empty_line_p =
         (row->reversed_p ? glyph > glyphs_end : glyph < glyphs_end)
-        && INTEGERP (glyph->object) && glyph->charpos > 0;
+        && INTEGERP (glyph->object) && glyph->charpos > 0
+        /* On a TTY, continued and truncated rows also have a glyph at
+           their end whose OBJECT is zero and whose CHARPOS is
+           positive (the continuation and truncation glyphs), but such
+           rows are obviously not "empty".  */
+        && !(row->continued_p || row->truncated_on_right_p);
 
       if (row->ends_in_ellipsis_p && pos_after == last_pos)
         {
@@ -14844,14 +14604,24 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
   else
     {
       struct text_pos scroll_margin_pos = startp;
+      int y_offset = 0;
 
       /* See if point is inside the scroll margin at the top of the
          window.  */
       if (this_scroll_margin)
         {
+          int y_start;
+
           start_display (&it, w, startp);
+          y_start = it.current_y;
           move_it_vertically (&it, this_scroll_margin);
           scroll_margin_pos = it.current.pos;
+          /* If we didn't move enough before hitting ZV, request
+             additional amount of scroll, to move point out of the
+             scroll margin.  */
+          if (IT_CHARPOS (it) == ZV
+              && it.current_y - y_start < this_scroll_margin)
+            y_offset = this_scroll_margin - (it.current_y - y_start);
         }
 
       if (PT < CHARPOS (scroll_margin_pos))
@@ -14878,6 +14648,9 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
               || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
             return SCROLLING_FAILED;
 
+          /* Additional scroll for when ZV was too close to point.  */
+          dy += y_offset;
+
           /* Compute new window start.  */
           start_display (&it, w, startp);
 
@@ -14932,7 +14705,7 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
       if (!just_this_one_p
           || current_buffer->clip_changed
           || BEG_UNCHANGED < CHARPOS (startp))
-        wset_base_line_number (w, Qnil);
+        w->base_line_number = 0;
 
       /* If cursor ends up on a partially visible line,
          treat that as being off the bottom of the screen.  */
@@ -14985,7 +14758,7 @@ compute_window_start_on_continuation_line (struct window *w)
         SET_TEXT_POS (start_pos, ZV, ZV_BYTE);
 
       /* Find the start of the continued line.  This should be fast
-         because scan_buffer is fast (newline cache).  */
+         because find_newline is fast (newline cache).  */
       row = w->desired_matrix->rows + (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0);
       init_iterator (&it, w, CHARPOS (start_pos), BYTEPOS (start_pos),
                      row, DEFAULT_FACE_ID);
@@ -15080,9 +14853,8 @@ try_cursor_movement (Lisp_Object window, struct text_pos startp, int *scroll_ste
       /* Can't use this case if highlighting a region.  When a
          region exists, cursor movement has to do more than just
          set the cursor.  */
-      && !(!NILP (Vtransient_mark_mode)
-           && !NILP (BVAR (current_buffer, mark_active)))
-      && NILP (w->region_showing)
+      && markpos_of_region () < 0
+      && !w->region_showing
       && NILP (Vshow_trailing_whitespace)
       /* This code is not used for mini-buffer for the sake of the case
          of redisplaying to replace an echo area message; since in
@@ -15519,7 +15291,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   set_buffer_internal_1 (XBUFFER (w->buffer));
 
   current_matrix_up_to_date_p
-    = (!NILP (w->window_end_valid)
+    = (w->window_end_valid
        && !current_buffer->clip_changed
        && !current_buffer->prevent_redisplay_optimizations_p
        && !window_outdated (w));
@@ -15542,7 +15314,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   specbind (Qinhibit_point_motion_hooks, Qt);
 
   buffer_unchanged_p
-    = (!NILP (w->window_end_valid)
+    = (w->window_end_valid
        && !current_buffer->clip_changed
        && !window_outdated (w));
 
@@ -15555,7 +15327,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
       if (XMARKER (w->start)->buffer == current_buffer)
         compute_window_start_on_continuation_line (w);
 
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
     }
 
   /* Some sanity checks.  */
@@ -15568,26 +15340,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   if (mode_line_update_needed (w))
     update_mode_line = 1;
 
-  /* Count number of windows showing the selected buffer.  An indirect
-     buffer counts as its base buffer.  */
-  if (!just_this_one_p)
-    {
-      struct buffer *current_base, *window_base;
-      current_base = current_buffer;
-      window_base = XBUFFER (XWINDOW (selected_window)->buffer);
-      if (current_base->base_buffer)
-        current_base = current_base->base_buffer;
-      if (window_base->base_buffer)
-        window_base = window_base->base_buffer;
-      if (current_base == window_base)
-        buffer_shared++;
-    }
-
   /* Point refers normally to the selected window.  For any other
      window, set up appropriate value.  */
   if (!EQ (window, selected_window))
     {
-      ptrdiff_t new_pt = XMARKER (w->pointm)->charpos;
+      ptrdiff_t new_pt = marker_position (w->pointm);
       ptrdiff_t new_pt_byte = marker_byte_position (w->pointm);
       if (new_pt < BEGV)
         {
@@ -15659,11 +15416,11 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
       w->force_start = 0;
       w->vscroll = 0;
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
 
       /* Forget any recorded base line for line number display.  */
       if (!buffer_unchanged_p)
-        wset_base_line_number (w, Qnil);
+        w->base_line_number = 0;
 
       /* Redisplay the mode line.  Select the buffer properly for that.
          Also, run the hook window-scroll-functions
@@ -15718,7 +15475,6 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
           /* Some people insist on not letting point enter the scroll
              margin, even though this part handles windows that didn't
              scroll at all.  */
-          struct frame *f = XFRAME (w->frame);
           int margin = min (scroll_margin, WINDOW_TOTAL_LINES (w) / 4);
           int pixel_margin = margin * FRAME_LINE_HEIGHT (f);
           bool header_line = WINDOW_WANTS_HEADER_LINE_P (w);
@@ -15765,8 +15521,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
 
           /* If we are highlighting the region, then we just changed
              the region, so redisplay to show it.  */
-          if (!NILP (Vtransient_mark_mode)
-              && !NILP (BVAR (current_buffer, mark_active)))
+          if (0 <= markpos_of_region ())
             {
               clear_glyph_matrix (w->desired_matrix);
               if (!try_window (window, startp, 0))
@@ -15905,7 +15660,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
               || current_buffer->clip_changed
               || BEG_UNCHANGED < CHARPOS (startp))
             /* Forget any recorded base line for line number display.  */
-            wset_base_line_number (w, Qnil);
+            w->base_line_number = 0;
 
           if (!cursor_row_fully_visible_p (w, 1, 0))
             {
@@ -15972,11 +15727,9 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
   debug_method_add (w, "recenter");
 #endif
 
-  /* w->vscroll = 0; */
-
   /* Forget any previously recorded base line for line number display.  */
   if (!buffer_unchanged_p)
-    wset_base_line_number (w, Qnil);
+    w->base_line_number = 0;
 
   /* Determine the window start relative to point.  */
   init_iterator (&it, w, PT, PT_BYTE, NULL, DEFAULT_FACE_ID);
@@ -16110,8 +15863,7 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
      line.)  */
   if (w->cursor.vpos < 0)
     {
-      if (!NILP (w->window_end_valid)
-          && PT >= Z - XFASTINT (w->window_end_pos))
+      if (w->window_end_valid && PT >= Z - XFASTINT (w->window_end_pos))
         {
           clear_glyph_matrix (w->desired_matrix);
           move_it_by_lines (&it, 1);
@@ -16197,10 +15949,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
            && !FRAME_WINDOW_P (f)
            && !WINDOW_FULL_WIDTH_P (w))
        /* Line number to display.  */
-       || INTEGERP (w->base_line_pos)
+       || w->base_line_pos > 0
        /* Column number is displayed and different from the one displayed.  */
-       || (!NILP (w->column_number_displayed)
-           && (XFASTINT (w->column_number_displayed) != current_column ())))
+       || (w->column_number_displayed != -1
+           && (w->column_number_displayed != current_column ())))
       /* This means that the window has a mode line.  */
       && (WINDOW_WANTS_MODELINE_P (w)
           || WINDOW_WANTS_HEADER_LINE_P (w)))
@@ -16231,11 +15983,10 @@ redisplay_window (Lisp_Object window, int just_this_one_p)
         goto need_larger_matrices;
     }
 
-  if (!line_number_displayed
-      && !BUFFERP (w->base_line_pos))
+  if (!line_number_displayed && w->base_line_pos != -1)
     {
-      wset_base_line_pos (w, Qnil);
-      wset_base_line_number (w, Qnil);
+      w->base_line_pos = 0;
+      w->base_line_number = 0;
     }
 
  finish_menu_bars:
@@ -16428,7 +16179,7 @@ try_window (Lisp_Object window, struct text_pos pos, int flags)
     }
 
   /* But that is not valid info until redisplay finishes.  */
-  wset_window_end_valid (w, Qnil);
+  w->window_end_valid = 0;
   return 1;
 }
 
@@ -16471,9 +16222,8 @@ try_window_reusing_current_matrix (struct window *w)
     return 0;
 
   /* Can't do this if region may have changed.  */
-  if ((!NILP (Vtransient_mark_mode)
-       && !NILP (BVAR (current_buffer, mark_active)))
-      || !NILP (w->region_showing)
+  if (0 <= markpos_of_region ()
+      || w->region_showing
       || !NILP (Vshow_trailing_whitespace))
     return 0;
 
@@ -16676,7 +16426,7 @@ try_window_reusing_current_matrix (struct window *w)
           wset_window_end_pos (w, make_number (Z - ZV));
           wset_window_end_vpos (w, make_number (0));
         }
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
 
       /* Update hint: don't try scrolling again in update_window.  */
       w->desired_matrix->no_scrolling_p = 1;
@@ -16874,7 +16624,7 @@ try_window_reusing_current_matrix (struct window *w)
             (w, make_number (XFASTINT (w->window_end_vpos) - nrows_scrolled));
         }
 
-      wset_window_end_valid (w, Qnil);
+      w->window_end_valid = 0;
       w->desired_matrix->no_scrolling_p = 1;
 
 #ifdef GLYPH_DEBUG
@@ -17007,7 +16757,7 @@ find_first_unchanged_at_end_row (struct window *w,
 
   /* Display must not have been paused, otherwise the current matrix
      is not up to date.  */
-  eassert (!NILP (w->window_end_valid));
+  eassert (w->window_end_valid);
 
   /* A value of window_end_pos >= END_UNCHANGED means that the window
      end is in the range of changed text.  If so, there is no
@@ -17191,7 +16941,7 @@ row_containing_pos (struct window *w, ptrdiff_t charpos,
 
 /* Try to redisplay window W by reusing its existing display.  W's
    current matrix must be up to date when this function is called,
-   i.e. window_end_valid must not be nil.
+   i.e. window_end_valid must be nonzero.
 
    Value is
 
@@ -17299,13 +17049,12 @@ try_window_id (struct window *w)
     GIVE_UP (7);
 
   /* Verify that display wasn't paused.  */
-  if (NILP (w->window_end_valid))
+  if (!w->window_end_valid)
     GIVE_UP (8);
 
   /* Can't use this if highlighting a region because a cursor movement
      will do more than just set the cursor.  */
-  if (!NILP (Vtransient_mark_mode)
-      && !NILP (BVAR (current_buffer, mark_active)))
+  if (0 <= markpos_of_region ())
     GIVE_UP (9);
 
   /* Likewise if highlighting trailing whitespace.  */
@@ -17313,7 +17062,7 @@ try_window_id (struct window *w)
     GIVE_UP (11);
 
   /* Likewise if showing a region.  */
-  if (!NILP (w->region_showing))
+  if (w->region_showing)
     GIVE_UP (10);
 
   /* Can't use this if overlay arrow position and/or string have
@@ -17951,7 +17700,7 @@ try_window_id (struct window *w)
             debug_end_vpos = XFASTINT (w->window_end_vpos));
 
   /* Record that display has not been completed.  */
-  wset_window_end_valid (w, Qnil);
+  w->window_end_valid = 0;
   w->desired_matrix->no_scrolling_p = 1;
   return 3;
 
@@ -17992,18 +17741,23 @@ dump_glyph_matrix (struct glyph_matrix *matrix, int glyphs)
 void
 dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
 {
-  if (glyph->type == CHAR_GLYPH)
+  if (glyph->type == CHAR_GLYPH
+      || glyph->type == GLYPHLESS_GLYPH)
     {
       fprintf (stderr,
-               "  %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
+               "  %5"pD"d     %c %9"pI"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
                glyph - row->glyphs[TEXT_AREA],
-               'C',
+               (glyph->type == CHAR_GLYPH
+                ? 'C'
+                : 'G'),
                glyph->charpos,
                (BUFFERP (glyph->object)
                 ? 'B'
                 : (STRINGP (glyph->object)
                    ? 'S'
-                   : '-')),
+                   : (INTEGERP (glyph->object)
+                      ? '0'
+                      : '-'))),
                glyph->pixel_width,
                glyph->u.ch,
                (glyph->u.ch < 0x80 && glyph->u.ch >= ' '
@@ -18016,7 +17770,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
   else if (glyph->type == STRETCH_GLYPH)
     {
       fprintf (stderr,
-               "  %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
+               "  %5"pD"d     %c %9"pI"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
                glyph - row->glyphs[TEXT_AREA],
                'S',
                glyph->charpos,
@@ -18024,10 +17778,12 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                 ? 'B'
                 : (STRINGP (glyph->object)
                    ? 'S'
-                   : '-')),
+                   : (INTEGERP (glyph->object)
+                      ? '0'
+                      : '-'))),
                glyph->pixel_width,
                0,
-               '.',
+               ' ',
                glyph->face_id,
                glyph->left_box_line_p,
                glyph->right_box_line_p);
@@ -18035,7 +17791,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
   else if (glyph->type == IMAGE_GLYPH)
     {
       fprintf (stderr,
-               "  %5td %4c %6"pI"d %c %3d 0x%05x %c %4d %1.1d%1.1d\n",
+               "  %5"pD"d     %c %9"pI"d   %c %3d 0x%06x      %c %4d %1.1d%1.1d\n",
                glyph - row->glyphs[TEXT_AREA],
                'I',
                glyph->charpos,
@@ -18043,7 +17799,9 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                 ? 'B'
                 : (STRINGP (glyph->object)
                    ? 'S'
-                   : '-')),
+                   : (INTEGERP (glyph->object)
+                      ? '0'
+                      : '-'))),
                glyph->pixel_width,
                glyph->u.img_id,
                '.',
@@ -18054,7 +17812,7 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
   else if (glyph->type == COMPOSITE_GLYPH)
     {
       fprintf (stderr,
-               "  %5td %4c %6"pI"d %c %3d 0x%05x",
+               "  %5"pD"d     %c %9"pI"d   %c %3d 0x%06x",
                glyph - row->glyphs[TEXT_AREA],
                '+',
                glyph->charpos,
@@ -18062,7 +17820,9 @@ dump_glyph (struct glyph_row *row, struct glyph *glyph, int area)
                 ? 'B'
                 : (STRINGP (glyph->object)
                    ? 'S'
-                   : '-')),
+                   : (INTEGERP (glyph->object)
+                      ? '0'
+                      : '-'))),
                glyph->pixel_width,
                glyph->u.cmp.id);
       if (glyph->u.cmp.automatic)
@@ -18087,10 +17847,10 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
 {
   if (glyphs != 1)
     {
-      fprintf (stderr, "Row Start   End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n");
-      fprintf (stderr, "======================================================================\n");
+      fprintf (stderr, "Row     Start       End Used oE><\\CTZFesm     X    Y    W    H    V    A    P\n");
+      fprintf (stderr, "==============================================================================\n");
 
-      fprintf (stderr, "%3d %5"pI"d %5"pI"d %4d %1.1d%1.1d%1.1d%1.1d\
+      fprintf (stderr, "%3d %9"pI"d %9"pI"d %4d %1.1d%1.1d%1.1d%1.1d\
 %1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d%1.1d  %4d %4d %4d %4d %4d %4d %4d\n",
                vpos,
                MATRIX_ROW_START_CHARPOS (row),
@@ -18115,13 +17875,14 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
                row->visible_height,
                row->ascent,
                row->phys_ascent);
-      fprintf (stderr, "%9"pD"d %5"pD"d\t%5d\n", row->start.overlay_string_index,
+      /* The next 3 lines should align to "Start" in the header.  */
+      fprintf (stderr, "    %9"pD"d %9"pD"d\t%5d\n", row->start.overlay_string_index,
                row->end.overlay_string_index,
                row->continuation_lines_width);
-      fprintf (stderr, "%9"pI"d %5"pI"d\n",
+      fprintf (stderr, "    %9"pI"d %9"pI"d\n",
                CHARPOS (row->start.string_pos),
                CHARPOS (row->end.string_pos));
-      fprintf (stderr, "%9d %5d\n", row->start.dpvec_index,
+      fprintf (stderr, "    %9d %9d\n", row->start.dpvec_index,
                row->end.dpvec_index);
     }
 
@@ -18139,7 +17900,7 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
             ++glyph_end;
 
           if (glyph < glyph_end)
-            fprintf (stderr, "  Glyph    Type Pos   O W    Code C Face LR\n");
+            fprintf (stderr, " Glyph#  Type       Pos   O   W     Code      C Face LR\n");
 
           for (; glyph < glyph_end; ++glyph)
             dump_glyph (row, glyph, area);
@@ -18151,15 +17912,24 @@ dump_glyph_row (struct glyph_row *row, int vpos, int glyphs)
 
       for (area = LEFT_MARGIN_AREA; area < LAST_AREA; ++area)
         {
-          char *s = alloca (row->used[area] + 1);
+          char *s = alloca (row->used[area] + 4);
           int i;
 
           for (i = 0; i < row->used[area]; ++i)
             {
               struct glyph *glyph = row->glyphs[area] + i;
-              if (glyph->type == CHAR_GLYPH
-                  && glyph->u.ch < 0x80
-                  && glyph->u.ch >= ' ')
+              if (i == row->used[area] - 1
+                  && area == TEXT_AREA
+                  && INTEGERP (glyph->object)
+                  && glyph->type == CHAR_GLYPH
+                  && glyph->u.ch == ' ')
+                {
+                  strcpy (&s[i], "[\\n]");
+                  i += 4;
+                }
+              else if (glyph->type == CHAR_GLYPH
+                       && glyph->u.ch < 0x80
+                       && glyph->u.ch >= ' ')
                 s[i] = glyph->u.ch;
               else
                 s[i] = '.';
@@ -18294,7 +18064,7 @@ get_overlay_arrow_glyph_row (struct window *w, Lisp_Object overlay_arrow_string)
   const unsigned char *arrow_end = arrow_string + arrow_len;
   const unsigned char *p;
   struct it it;
-  int multibyte_p;
+  bool multibyte_p;
   int n_glyphs_before;
 
   set_buffer_temp (buffer);
@@ -18638,6 +18408,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           int saved_char_to_display = it->char_to_display;
           int saved_x = it->current_x;
           int saved_face_id = it->face_id;
+          int saved_box_end = it->end_of_box_run_p;
           struct text_pos saved_pos;
           Lisp_Object saved_object;
           struct face *face;
@@ -18659,6 +18430,16 @@ append_space_for_newline (struct it *it, int default_face_p)
             it->face_id = it->saved_face_id;
           face = FACE_FROM_ID (it->f, it->face_id);
           it->face_id = FACE_FOR_CHAR (it->f, face, 0, -1, Qnil);
+          /* In R2L rows, we will prepend a stretch glyph that will
+             have the end_of_box_run_p flag set for it, so there's no
+             need for the appended newline glyph to have that flag
+             set.  */
+          if (it->glyph_row->reversed_p
+              /* But if the appended newline glyph goes all the way to
+                 the end of the row, there will be no stretch glyph,
+                 so leave the box flag set.  */
+              && saved_x + FRAME_COLUMN_WIDTH (it->f) < it->last_visible_x)
+            it->end_of_box_run_p = 0;
 
           PRODUCE_GLYPHS (it);
 
@@ -18672,6 +18453,7 @@ append_space_for_newline (struct it *it, int default_face_p)
           it->len = saved_len;
           it->c = saved_c;
           it->char_to_display = saved_char_to_display;
+          it->end_of_box_run_p = saved_box_end;
           return 1;
         }
     }
@@ -18761,7 +18543,7 @@ extend_face_to_end_of_line (struct it *it)
           struct glyph *g;
           int row_width, stretch_ascent, stretch_width;
           struct text_pos saved_pos;
-          int saved_face_id, saved_avoid_cursor;
+          int saved_face_id, saved_avoid_cursor, saved_box_start;
 
           for (row_width = 0, g = row_start; g < row_end; g++)
             row_width += g->pixel_width;
@@ -18776,6 +18558,7 @@ extend_face_to_end_of_line (struct it *it)
               saved_avoid_cursor = it->avoid_cursor_p;
               it->avoid_cursor_p = 1;
               saved_face_id = it->face_id;
+              saved_box_start = it->start_of_box_run_p;
               /* The last row's stretch glyph should get the default
                  face, to avoid painting the rest of the window with
                  the region face, if the region ends at ZV.  */
@@ -18783,11 +18566,13 @@ extend_face_to_end_of_line (struct it *it)
                 it->face_id = default_face->id;
               else
                 it->face_id = face->id;
+              it->start_of_box_run_p = 0;
               append_stretch_glyph (it, make_number (0), stretch_width,
                                     it->ascent + it->descent, stretch_ascent);
               it->position = saved_pos;
               it->avoid_cursor_p = saved_avoid_cursor;
               it->face_id = saved_face_id;
+              it->start_of_box_run_p = saved_box_start;
             }
         }
 #endif  /* HAVE_WINDOW_SYSTEM */
@@ -19364,7 +19149,7 @@ display_line (struct it *it)
     }
 
   /* Is IT->w showing the region?  */
-  wset_region_showing (it->w, it->region_beg_charpos > 0 ? Qt : Qnil);
+  it->w->region_showing = it->region_beg_charpos > 0 ? it->region_beg_charpos : 0;
 
   /* Clear the result glyph row and enable it.  */
   prepare_desired_row (row);
@@ -20354,17 +20139,21 @@ redisplay_mode_lines (Lisp_Object window, int force)
 static int
 display_mode_lines (struct window *w)
 {
-  Lisp_Object old_selected_window, old_selected_frame;
+  Lisp_Object old_selected_window = selected_window;
+  Lisp_Object old_selected_frame = selected_frame;
+  Lisp_Object new_frame = w->frame;
+  Lisp_Object old_frame_selected_window = XFRAME (new_frame)->selected_window;
   int n = 0;
 
-  old_selected_frame = selected_frame;
-  selected_frame = w->frame;
-  old_selected_window = selected_window;
+  selected_frame = new_frame;
+  /* FIXME: If we were to allow the mode-line's computation changing the buffer
+     or window's point, then we'd need select_window_1 here as well.  */
   XSETWINDOW (selected_window, w);
+  XFRAME (new_frame)->selected_window = selected_window;
 
   /* These will be set while the mode line specs are processed.  */
   line_number_displayed = 0;
-  wset_column_number_displayed (w, Qnil);
+  w->column_number_displayed = -1;
 
   if (WINDOW_WANTS_MODELINE_P (w))
     {
@@ -20383,6 +20172,7 @@ display_mode_lines (struct window *w)
       ++n;
     }
 
+  XFRAME (new_frame)->selected_window = old_frame_selected_window;
   selected_frame = old_selected_frame;
   selected_window = old_selected_window;
   return n;
@@ -20705,7 +20495,7 @@ display_mode_element (struct it *it, int depth, int field_width, int precision,
                                              risky);
                 else if (c != 0)
                   {
-                    int multibyte;
+                    bool multibyte;
                     ptrdiff_t bytepos, charpos;
                     const char *spec;
                     Lisp_Object string;
@@ -21310,7 +21100,7 @@ static char *
 decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_flag)
 {
   Lisp_Object val;
-  int multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
+  bool multibyte = !NILP (BVAR (current_buffer, enable_multibyte_characters));
   const unsigned char *eol_str;
   int eol_str_len;
   /* The EOL conversion we are using.  */
@@ -21386,8 +21176,7 @@ decode_mode_spec_coding (Lisp_Object coding_system, register char *buf, int eol_
    returned with spaces to that value.  Return a Lisp string in
    *STRING if the resulting string is taken from that Lisp string.
 
-   Note we operate on the current buffer for most purposes,
-   the exception being w->base_line_pos.  */
+   Note we operate on the current buffer for most purposes.  */
 
 static char lots_of_dashes[] = "--------------------------------------------------------------------------------------------------------------------------------------------";
 
@@ -21468,8 +21257,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         register int i;
 
         /* Let lots_of_dashes be a string of infinite length.  */
-        if (mode_line_target == MODE_LINE_NOPROP ||
-            mode_line_target == MODE_LINE_STRING)
+        if (mode_line_target == MODE_LINE_NOPROP
+            || mode_line_target == MODE_LINE_STRING)
           return "--";
         if (field_width <= 0
             || field_width > sizeof (lots_of_dashes))
@@ -21498,7 +21287,7 @@ decode_mode_spec (struct window *w, register int c, int field_width,
       else
         {
           ptrdiff_t col = current_column ();
-          wset_column_number_displayed (w, make_number (col));
+          w->column_number_displayed = col;
           pint2str (decode_mode_spec_buf, width, col);
           return decode_mode_spec_buf;
         }
@@ -21551,33 +21340,30 @@ decode_mode_spec (struct window *w, register int c, int field_width,
         if (mode_line_target == MODE_LINE_TITLE)
           return "";
 
-        startpos = XMARKER (w->start)->charpos;
+        startpos = marker_position (w->start);
         startpos_byte = marker_byte_position (w->start);
         height = WINDOW_TOTAL_LINES (w);
 
         /* If we decided that this buffer isn't suitable for line numbers,
            don't forget that too fast.  */
-        if (EQ (w->base_line_pos, w->buffer))
+        if (w->base_line_pos == -1)
           goto no_value;
-        /* But do forget it, if the window shows a different buffer now.  */
-        else if (BUFFERP (w->base_line_pos))
-          wset_base_line_pos (w, Qnil);
 
         /* If the buffer is very big, don't waste time.  */
         if (INTEGERP (Vline_number_display_limit)
             && BUF_ZV (b) - BUF_BEGV (b) > XINT (Vline_number_display_limit))
           {
-            wset_base_line_pos (w, Qnil);
-            wset_base_line_number (w, Qnil);
+            w->base_line_pos = 0;
+            w->base_line_number = 0;
             goto no_value;
           }
 
-        if (INTEGERP (w->base_line_number)
-            && INTEGERP (w->base_line_pos)
-            && XFASTINT (w->base_line_pos) <= startpos)
+        if (w->base_line_number > 0
+            && w->base_line_pos > 0
+            && w->base_line_pos <= startpos)
           {
-            line = XFASTINT (w->base_line_number);
-            linepos = XFASTINT (w->base_line_pos);
+            line = w->base_line_number;
+            linepos = w->base_line_pos;
             linepos_byte = buf_charpos_to_bytepos (b, linepos);
           }
         else
@@ -21600,8 +21386,8 @@ decode_mode_spec (struct window *w, register int c, int field_width,
            go back past it.  */
         if (startpos == BUF_BEGV (b))
           {
-            wset_base_line_number (w, make_number (topline));
-            wset_base_line_pos (w, make_number (BUF_BEGV (b)));
+            w->base_line_number = topline;
+            w->base_line_pos = BUF_BEGV (b);
           }
         else if (nlines < height + 25 || nlines > height * 3 + 50
                  || linepos == BUF_BEGV (b))
@@ -21627,13 +21413,13 @@ decode_mode_spec (struct window *w, register int c, int field_width,
                give up on line numbers for this window.  */
             if (position == limit_byte && limit == startpos - distance)
               {
-                wset_base_line_pos (w, w->buffer);
-                wset_base_line_number (w, Qnil);
+                w->base_line_pos = -1;
+                w->base_line_number = 0;
                 goto no_value;
               }
 
-            wset_base_line_number (w, make_number (topline - nlines));
-            wset_base_line_pos (w, make_number (BYTE_TO_CHAR (position)));
+            w->base_line_number = topline - nlines;
+            w->base_line_pos = BYTE_TO_CHAR (position);
           }
 
         /* Now count lines from the start pos to point.  */
@@ -21755,9 +21541,6 @@ decode_mode_spec (struct window *w, register int c, int field_width,
           return "@";
       }
 
-    case 't':                   /* indicate TEXT or BINARY */
-      return "T";
-
     case 'z':
       /* coding-system (not including end-of-line format) */
     case 'Z':
@@ -21807,11 +21590,15 @@ decode_mode_spec (struct window *w, register int c, int field_width,
 }
 
 
-/* Count up to COUNT lines starting from START_BYTE.
-   But don't go beyond LIMIT_BYTE.
-   Return the number of lines thus found (always nonnegative).
+/* Count up to COUNT lines starting from START_BYTE.  COUNT negative
+   means count lines back from START_BYTE.  But don't go beyond
+   LIMIT_BYTE.  Return the number of lines thus found (always
+   nonnegative).
 
-   Set *BYTE_POS_PTR to 1 if we found COUNT lines, 0 if we hit LIMIT.  */
+   Set *BYTE_POS_PTR to the byte position where we stopped.  This is
+   either the position COUNT lines after/before START_BYTE, if we
+   found COUNT lines, or LIMIT_BYTE if we hit the limit before finding
+   COUNT lines.  */
 
 static ptrdiff_t
 display_count_lines (ptrdiff_t start_byte,
@@ -21838,31 +21625,36 @@ display_count_lines (ptrdiff_t start_byte,
           ceiling = min (limit_byte - 1, ceiling);
           ceiling_addr = BYTE_POS_ADDR (ceiling) + 1;
           base = (cursor = BYTE_POS_ADDR (start_byte));
-          while (1)
+
+          do
             {
               if (selective_display)
-                while (*cursor != '\n' && *cursor != 015 && ++cursor != ceiling_addr)
-                  ;
+                {
+                  while (*cursor != '\n' && *cursor != 015
+                         && ++cursor != ceiling_addr)
+                    continue;
+                  if (cursor == ceiling_addr)
+                    break;
+                }
               else
-                while (*cursor != '\n' && ++cursor != ceiling_addr)
-                  ;
+                {
+                  cursor = memchr (cursor, '\n', ceiling_addr - cursor);
+                  if (! cursor)
+                    break;
+                }
 
-              if (cursor != ceiling_addr)
+              cursor++;
+
+              if (--count == 0)
                 {
-                  if (--count == 0)
-                    {
-                      start_byte += cursor - base + 1;
-                      *byte_pos_ptr = start_byte;
-                      return orig_count;
-                    }
-                  else
-                    if (++cursor == ceiling_addr)
-                      break;
+                  start_byte += cursor - base;
+                  *byte_pos_ptr = start_byte;
+                  return orig_count;
                 }
-              else
-                break;
             }
-          start_byte += cursor - base;
+          while (cursor < ceiling_addr);
+
+          start_byte += ceiling_addr - base;
         }
     }
   else
@@ -21871,35 +21663,35 @@ display_count_lines (ptrdiff_t start_byte,
         {
           ceiling = BUFFER_FLOOR_OF (start_byte - 1);
           ceiling = max (limit_byte, ceiling);
-          ceiling_addr = BYTE_POS_ADDR (ceiling) - 1;
+          ceiling_addr = BYTE_POS_ADDR (ceiling);
           base = (cursor = BYTE_POS_ADDR (start_byte - 1) + 1);
           while (1)
             {
               if (selective_display)
-                while (--cursor != ceiling_addr
-                       && *cursor != '\n' && *cursor != 015)
-                  ;
+                {
+                  while (--cursor >= ceiling_addr
+                         && *cursor != '\n' && *cursor != 015)
+                    continue;
+                  if (cursor < ceiling_addr)
+                    break;
+                }
               else
-                while (--cursor != ceiling_addr && *cursor != '\n')
-                  ;
+                {
+                  cursor = memrchr (ceiling_addr, '\n', cursor - ceiling_addr);
+                  if (! cursor)
+                    break;
+                }
 
-              if (cursor != ceiling_addr)
+              if (++count == 0)
                 {
-                  if (++count == 0)
-                    {
-                      start_byte += cursor - base + 1;
-                      *byte_pos_ptr = start_byte;
-                      /* When scanning backwards, we should
-                         not count the newline posterior to which we stop.  */
-                      return - orig_count - 1;
-                    }
+                  start_byte += cursor - base + 1;
+                  *byte_pos_ptr = start_byte;
+                  /* When scanning backwards, we should
+                     not count the newline posterior to which we stop.  */
+                  return - orig_count - 1;
                 }
-              else
-                break;
             }
-          /* Here we add 1 to compensate for the last decrement
-             of CURSOR, which took it past the valid range.  */
-          start_byte += cursor - base + 1;
+          start_byte += ceiling_addr - base;
         }
     }
 
@@ -23487,8 +23279,7 @@ draw_glyphs (struct window *w, int x, struct glyph_row *row,
 
   /* Let's rather be paranoid than getting a SEGV.  */
   end = min (end, row->used[area]);
-  start = max (0, start);
-  start = min (end, start);
+  start = clip_to_bounds (0, start, end);
 
   /* Translate X to frame coordinates.  Set last_x to the right
      end of the drawing area.  */
@@ -23767,8 +23558,18 @@ append_glyph (struct it *it)
       glyph->type = CHAR_GLYPH;
       glyph->avoid_cursor_p = it->avoid_cursor_p;
       glyph->multibyte_p = it->multibyte_p;
-      glyph->left_box_line_p = it->start_of_box_run_p;
-      glyph->right_box_line_p = it->end_of_box_run_p;
+      if (it->glyph_row->reversed_p && area == TEXT_AREA)
+        {
+          /* In R2L rows, the left and the right box edges need to be
+             drawn in reverse direction.  */
+          glyph->right_box_line_p = it->start_of_box_run_p;
+          glyph->left_box_line_p = it->end_of_box_run_p;
+        }
+      else
+        {
+          glyph->left_box_line_p = it->start_of_box_run_p;
+          glyph->right_box_line_p = it->end_of_box_run_p;
+        }
       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
                                       || it->phys_descent > it->descent);
       glyph->glyph_not_available_p = it->glyph_not_available_p;
@@ -23842,8 +23643,18 @@ append_composite_glyph (struct it *it)
         }
       glyph->avoid_cursor_p = it->avoid_cursor_p;
       glyph->multibyte_p = it->multibyte_p;
-      glyph->left_box_line_p = it->start_of_box_run_p;
-      glyph->right_box_line_p = it->end_of_box_run_p;
+      if (it->glyph_row->reversed_p && area == TEXT_AREA)
+        {
+          /* In R2L rows, the left and the right box edges need to be
+             drawn in reverse direction.  */
+          glyph->right_box_line_p = it->start_of_box_run_p;
+          glyph->left_box_line_p = it->end_of_box_run_p;
+        }
+      else
+        {
+          glyph->left_box_line_p = it->start_of_box_run_p;
+          glyph->right_box_line_p = it->end_of_box_run_p;
+        }
       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
                                       || it->phys_descent > it->descent);
       glyph->padding_p = 0;
@@ -24020,8 +23831,18 @@ produce_image_glyph (struct it *it)
           glyph->type = IMAGE_GLYPH;
           glyph->avoid_cursor_p = it->avoid_cursor_p;
           glyph->multibyte_p = it->multibyte_p;
-          glyph->left_box_line_p = it->start_of_box_run_p;
-          glyph->right_box_line_p = it->end_of_box_run_p;
+          if (it->glyph_row->reversed_p && area == TEXT_AREA)
+            {
+              /* In R2L rows, the left and the right box edges need to be
+                 drawn in reverse direction.  */
+              glyph->right_box_line_p = it->start_of_box_run_p;
+              glyph->left_box_line_p = it->end_of_box_run_p;
+            }
+          else
+            {
+              glyph->left_box_line_p = it->start_of_box_run_p;
+              glyph->right_box_line_p = it->end_of_box_run_p;
+            }
           glyph->overlaps_vertically_p = 0;
           glyph->padding_p = 0;
           glyph->glyph_not_available_p = 0;
@@ -24080,8 +23901,18 @@ append_stretch_glyph (struct it *it, Lisp_Object object,
       glyph->type = STRETCH_GLYPH;
       glyph->avoid_cursor_p = it->avoid_cursor_p;
       glyph->multibyte_p = it->multibyte_p;
-      glyph->left_box_line_p = it->start_of_box_run_p;
-      glyph->right_box_line_p = it->end_of_box_run_p;
+      if (it->glyph_row->reversed_p && area == TEXT_AREA)
+        {
+          /* In R2L rows, the left and the right box edges need to be
+             drawn in reverse direction.  */
+          glyph->right_box_line_p = it->start_of_box_run_p;
+          glyph->left_box_line_p = it->end_of_box_run_p;
+        }
+      else
+        {
+          glyph->left_box_line_p = it->start_of_box_run_p;
+          glyph->right_box_line_p = it->end_of_box_run_p;
+        }
       glyph->overlaps_vertically_p = 0;
       glyph->padding_p = 0;
       glyph->glyph_not_available_p = 0;
@@ -24533,8 +24364,18 @@ append_glyphless_glyph (struct it *it, int face_id, int for_no_font, int len,
       glyph->slice.glyphless.lower_yoff = lower_yoff;
       glyph->avoid_cursor_p = it->avoid_cursor_p;
       glyph->multibyte_p = it->multibyte_p;
-      glyph->left_box_line_p = it->start_of_box_run_p;
-      glyph->right_box_line_p = it->end_of_box_run_p;
+      if (it->glyph_row->reversed_p && area == TEXT_AREA)
+        {
+          /* In R2L rows, the left and the right box edges need to be
+             drawn in reverse direction.  */
+          glyph->right_box_line_p = it->start_of_box_run_p;
+          glyph->left_box_line_p = it->end_of_box_run_p;
+        }
+      else
+        {
+          glyph->left_box_line_p = it->start_of_box_run_p;
+          glyph->right_box_line_p = it->end_of_box_run_p;
+        }
       glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
                                       || it->phys_descent > it->descent);
       glyph->padding_p = 0;
@@ -27770,7 +27611,7 @@ note_mouse_highlight (struct frame *f, int x, int y)
      And verify the buffer's text has not changed.  */
   b = XBUFFER (w->buffer);
   if (part == ON_TEXT
-      && EQ (w->window_end_valid, w->buffer)
+      && w->window_end_valid
       && w->last_modified == BUF_MODIFF (b)
       && w->last_overlay_modified == BUF_OVERLAY_MODIFF (b))
     {
@@ -28403,6 +28244,9 @@ x_draw_vertical_border (struct window *w)
   if (FRAME_HAS_VERTICAL_SCROLL_BARS (XFRAME (w->frame)))
     return;
 
+  /* Note: It is necessary to redraw bot the left and the right
+     borders, for when only this single window W is being
+     redisplayed.  */
   if (!WINDOW_RIGHTMOST_P (w)
       && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w))
     {
@@ -28416,8 +28260,8 @@ x_draw_vertical_border (struct window *w)
 
       FRAME_RIF (f)->draw_vertical_window_border (w, x1, y0, y1);
     }
-  else if (!WINDOW_LEFTMOST_P (w)
-           && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
+  if (!WINDOW_LEFTMOST_P (w)
+      && !WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w))
     {
       int x0, x1, y0, y1;
 
diff --git a/src/xfaces.c b/src/xfaces.c
index 1e27d5cc043..71709446c1d 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1,6 +1,6 @@
 /* xfaces.c -- "Face" primitives.
 
-Copyright (C) 1993-1994, 1998-2012  Free Software Foundation, Inc.
+Copyright (C) 1993-1994, 1998-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1585,7 +1585,7 @@ the face font sort order.  */)
   for (i = nfonts - 1; i >= 0; --i)
     {
       Lisp_Object font = AREF (vec, i);
-      Lisp_Object v = Fmake_vector (make_number (8), Qnil);
+      Lisp_Object v = make_uninit_vector (8);
       int point;
       Lisp_Object spacing;
 
@@ -4877,6 +4877,8 @@ tty_supports_face_attributes_p (struct frame *f,
     {
       if (STRINGP (val))
         return 0;               /* ttys can't use colored underlines */
+      else if (EQ (CAR_SAFE (val), QCstyle) && EQ (CAR_SAFE (CDR_SAFE (val)), Qwave))
+        return 0;               /* ttys can't use wave underlines */
       else if (face_attr_equal_p (val, def_attrs[LFACE_UNDERLINE_INDEX]))
         return 0;               /* same as default */
       else
@@ -6150,7 +6152,7 @@ face_at_string_position (struct window *w, Lisp_Object string,
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   Lisp_Object attrs[LFACE_VECTOR_SIZE];
   struct face *base_face;
-  int multibyte_p = STRING_MULTIBYTE (string);
+  bool multibyte_p = STRING_MULTIBYTE (string);
   Lisp_Object prop_name = mouse_p ? Qmouse_face : Qface;
 
   /* Get the value of the face property at the current position within
diff --git a/src/xfns.c b/src/xfns.c
index 7e832c3a95f..f01983fea4d 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1,6 +1,6 @@
 /* Functions for the X window system.
 
-Copyright (C) 1989, 1992-2012  Free Software Foundation, Inc.
+Copyright (C) 1989, 1992-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -5292,8 +5292,7 @@ file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 static Lisp_Object
 clean_up_file_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  Widget dialog = (Widget) p->pointer;
+  Widget dialog = XSAVE_POINTER (arg, 0);
 
   /* Clean up.  */
   block_input ();
@@ -5417,7 +5416,7 @@ Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.  */)
       XmStringFree (default_xmstring);
     }
 
-  record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
+  record_unwind_protect (clean_up_file_dialog, make_save_pointer (dialog));
 
   /* Process events until the user presses Cancel or OK.  */
   x_menu_set_in_use (1);
diff --git a/src/xfont.c b/src/xfont.c
index 2d493088b0b..9978aba76de 100644
--- a/src/xfont.c
+++ b/src/xfont.c
@@ -1,5 +1,5 @@
 /* xfont.c -- X core font driver.
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
diff --git a/src/xftfont.c b/src/xftfont.c
index 181a1da9b38..166a70acd85 100644
--- a/src/xftfont.c
+++ b/src/xftfont.c
@@ -1,5 +1,5 @@
 /* xftfont.c -- XFT font driver.
-   Copyright (C) 2006-2012 Free Software Foundation, Inc.
+   Copyright (C) 2006-2013 Free Software Foundation, Inc.
    Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011
      National Institute of Advanced Industrial Science and Technology (AIST)
      Registration Number H13PRO009
diff --git a/src/xgselect.c b/src/xgselect.c
index c161564a322..db7dce10ad0 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -1,6 +1,6 @@
 /* Function for handling the GLib event loop.
 
-Copyright (C) 2009-2012  Free Software Foundation, Inc.
+Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xgselect.h b/src/xgselect.h
index 5509e23c5c0..f142e85d877 100644
--- a/src/xgselect.h
+++ b/src/xgselect.h
@@ -1,6 +1,6 @@
 /* Header for xg_select.
 
-Copyright (C) 2009-2012  Free Software Foundation, Inc.
+Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xmenu.c b/src/xmenu.c
index b585df2125b..958cd220393 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1,7 +1,7 @@
 /* X Communication module for terminals which understand the X protocol.
 
-Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2012
-  Free Software Foundation, Inc.
+Copyright (C) 1986, 1988, 1993-1994, 1996, 1999-2013 Free Software
+Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1411,11 +1411,9 @@ popup_selection_callback (GtkWidget *widget, gpointer client_data)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-
   popup_activated_flag = 0;
   block_input ();
-  gtk_widget_destroy (GTK_WIDGET (p->pointer));
+  gtk_widget_destroy (GTK_WIDGET (XSAVE_POINTER (arg, 0)));
   unblock_input ();
   return Qnil;
 }
@@ -1479,7 +1477,7 @@ create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv, int x, int y,
   gtk_menu_popup (GTK_MENU (menu), 0, 0, pos_func, &popup_x_y, i,
                   timestamp ? timestamp : gtk_get_current_event_time ());
 
-  record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
+  record_unwind_protect (pop_down_menu, make_save_pointer (menu));
 
   if (gtk_widget_get_mapped (menu))
     {
@@ -1612,11 +1610,7 @@ create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
 static Lisp_Object
 cleanup_widget_value_tree (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  widget_value *wv = p->pointer;
-
-  free_menubar_widget_value_tree (wv);
-
+  free_menubar_widget_value_tree (XSAVE_POINTER (arg, 0));
   return Qnil;
 }
 
@@ -1832,7 +1826,7 @@ xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
   /* Make sure to free the widget_value objects we used to specify the
      contents even with longjmp.  */
   record_unwind_protect (cleanup_widget_value_tree,
-                         make_save_value (first_wv, 0));
+                         make_save_pointer (first_wv));
 
   /* Actually create and show the menu until popped down.  */
   create_and_show_popup_menu (f, first_wv, x, y, for_click, timestamp);
@@ -1931,7 +1925,7 @@ create_and_show_dialog (FRAME_PTR f, widget_value *first_wv)
   if (menu)
     {
       ptrdiff_t specpdl_count = SPECPDL_INDEX ();
-      record_unwind_protect (pop_down_menu, make_save_value (menu, 0));
+      record_unwind_protect (pop_down_menu, make_save_pointer (menu));
 
       /* Display the menu.  */
       gtk_widget_show_all (menu);
@@ -2142,7 +2136,7 @@ xdialog_show (FRAME_PTR f,
   /* Make sure to free the widget_value objects we used to specify the
      contents even with longjmp.  */
   record_unwind_protect (cleanup_widget_value_tree,
-                         make_save_value (first_wv, 0));
+                         make_save_pointer (first_wv));
 
   /* Actually create and show the dialog.  */
   create_and_show_dialog (f, first_wv);
@@ -2242,11 +2236,8 @@ menu_help_callback (char const *help_string, int pane, int item)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p1 = XSAVE_VALUE (Fcar (arg));
-  struct Lisp_Save_Value *p2 = XSAVE_VALUE (Fcdr (arg));
-
-  FRAME_PTR f = p1->pointer;
-  XMenu *menu = p2->pointer;
+  FRAME_PTR f = XSAVE_POINTER (arg, 0);
+  XMenu *menu = XSAVE_POINTER (arg, 1);
 
   block_input ();
 #ifndef MSDOS
@@ -2488,8 +2479,7 @@ xmenu_show (FRAME_PTR f, int x, int y, bool for_click, bool keymaps,
 #endif
 
   record_unwind_protect (pop_down_menu,
-                         Fcons (make_save_value (f, 0),
-                                make_save_value (menu, 0)));
+                         make_save_value ("pp", f, menu));
 
   /* Help display under X won't work because XMenuActivate contains
      a loop that doesn't give Emacs a chance to process it.  */
diff --git a/src/xml.c b/src/xml.c
index a0c4fe17fc4..4b466dc1bca 100644
--- a/src/xml.c
+++ b/src/xml.c
@@ -1,5 +1,5 @@
 /* Interface to libxml2.
-   Copyright (C) 2010-2012 Free Software Foundation, Inc.
+   Copyright (C) 2010-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -93,7 +93,7 @@ init_libxml2_functions (void)
 
       if (!(library = w32_delayed_load (Qlibxml2_dll)))
         {
-          message ("%s", "libxml2 library not found");
+          message1 ("libxml2 library not found");
           return 0;
         }
 
@@ -180,8 +180,7 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
   xmlDoc *doc;
   Lisp_Object result = Qnil;
   const char *burl = "";
-  ptrdiff_t bytes;
-  ptrdiff_t istart, iend;
+  ptrdiff_t istart, iend, istart_byte, iend_byte;
 
   fn_xmlCheckVersion (LIBXML_VERSION);
 
@@ -189,9 +188,11 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
 
   istart = XINT (start);
   iend = XINT (end);
+  istart_byte = CHAR_TO_BYTE (istart);
+  iend_byte = CHAR_TO_BYTE (iend);
 
   if (istart < GPT && GPT < iend)
-    move_gap (iend);
+    move_gap_both (iend, iend_byte);
 
   if (! NILP (base_url))
     {
@@ -199,17 +200,15 @@ parse_region (Lisp_Object start, Lisp_Object end, Lisp_Object base_url, int html
       burl = SSDATA (base_url);
     }
 
-  bytes = CHAR_TO_BYTE (iend) - CHAR_TO_BYTE (istart);
-
   if (htmlp)
-    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                             bytes, burl, "utf-8",
+    doc = fn_htmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                             iend_byte - istart_byte, burl, "utf-8",
                              HTML_PARSE_RECOVER|HTML_PARSE_NONET|
                              HTML_PARSE_NOWARNING|HTML_PARSE_NOERROR|
                              HTML_PARSE_NOBLANKS);
   else
-    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (CHAR_TO_BYTE (istart)),
-                            bytes, burl, "utf-8",
+    doc = fn_xmlReadMemory ((char *) BYTE_POS_ADDR (istart_byte),
+                            iend_byte - istart_byte, burl, "utf-8",
                             XML_PARSE_NONET|XML_PARSE_NOWARNING|
                             XML_PARSE_NOBLANKS |XML_PARSE_NOERROR);
 
diff --git a/src/xrdb.c b/src/xrdb.c
index 59b0876ebf8..c25c25d6f33 100644
--- a/src/xrdb.c
+++ b/src/xrdb.c
@@ -1,5 +1,6 @@
 /* Deal with the X Resource Manager.
-   Copyright (C) 1990, 1993-1994, 2000-2012 Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993-1994, 2000-2013 Free Software Foundation,
+   Inc.
 
 Author: Joseph Arceneaux
 Created: 4/90
diff --git a/src/xselect.c b/src/xselect.c
index 64c64fa0c76..decea696bfd 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1,5 +1,5 @@
 /* X Selection processing for Emacs.
-   Copyright (C) 1993-1997, 2000-2012 Free Software Foundation, Inc.
+   Copyright (C) 1993-1997, 2000-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -1120,7 +1120,7 @@ unexpect_property_change (struct prop_location *location)
 static Lisp_Object
 wait_for_property_change_unwind (Lisp_Object loc)
 {
-  struct prop_location *location = XSAVE_VALUE (loc)->pointer;
+  struct prop_location *location = XSAVE_POINTER (loc, 0);
 
   unexpect_property_change (location);
   if (location == property_change_reply_object)
@@ -1141,7 +1141,7 @@ wait_for_property_change (struct prop_location *location)
 
   /* Make sure to do unexpect_property_change if we quit or err.  */
   record_unwind_protect (wait_for_property_change_unwind,
-                         make_save_value (location, 0));
+                         make_save_pointer (location));
 
   XSETCAR (property_change_reply, Qnil);
   property_change_reply_object = location;
@@ -1670,11 +1670,10 @@ selection_data_to_lisp_data (Display *display, const unsigned char *data,
         return x_atom_to_symbol (display, (Atom) idata[0]);
       else
         {
-          Lisp_Object v = Fmake_vector (make_number (size / sizeof (int)),
-                                        make_number (0));
+          Lisp_Object v = make_uninit_vector (size / sizeof (int));
+
           for (i = 0; i < size / sizeof (int); i++)
-            Faset (v, make_number (i),
-                   x_atom_to_symbol (display, (Atom) idata[i]));
+            ASET (v, i, x_atom_to_symbol (display, (Atom) idata[i]));
           return v;
         }
     }
@@ -1694,24 +1693,24 @@ selection_data_to_lisp_data (Display *display, const unsigned char *data,
   else if (format == 16)
     {
       ptrdiff_t i;
-      Lisp_Object v;
-      v = Fmake_vector (make_number (size / 2), make_number (0));
+      Lisp_Object v = make_uninit_vector (size / 2);
+
       for (i = 0; i < size / 2; i++)
         {
           short j = ((short *) data) [i];
-          Faset (v, make_number (i), make_number (j));
+          ASET (v, i, make_number (j));
         }
       return v;
     }
   else
     {
       ptrdiff_t i;
-      Lisp_Object v = Fmake_vector (make_number (size / X_LONG_SIZE),
-                                    make_number (0));
+      Lisp_Object v = make_uninit_vector (size / X_LONG_SIZE);
+
       for (i = 0; i < size / X_LONG_SIZE; i++)
         {
           int j = ((int *) data) [i];
-          Faset (v, make_number (i), INTEGER_TO_CONS (j));
+          ASET (v, i, INTEGER_TO_CONS (j));
         }
       return v;
     }
diff --git a/src/xsettings.c b/src/xsettings.c
index d23070791d8..576a5032eac 100644
--- a/src/xsettings.c
+++ b/src/xsettings.c
@@ -1,6 +1,6 @@
 /* Functions for handling font and other changes dynamically.
 
-Copyright (C) 2009-2012  Free Software Foundation, Inc.
+Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xsettings.h b/src/xsettings.h
index 10dc7ef926a..e3738c593bd 100644
--- a/src/xsettings.h
+++ b/src/xsettings.h
@@ -1,6 +1,6 @@
 /* Functions for handle font changes dynamically.
 
-Copyright (C) 2009-2012  Free Software Foundation, Inc.
+Copyright (C) 2009-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xsmfns.c b/src/xsmfns.c
index 289aac8492b..fe2dfbaf83e 100644
--- a/src/xsmfns.c
+++ b/src/xsmfns.c
@@ -1,7 +1,7 @@
 /* Session management module for systems which understand the X Session
    management protocol.
 
-Copyright (C) 2002-2012  Free Software Foundation, Inc.
+Copyright (C) 2002-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
diff --git a/src/xterm.c b/src/xterm.c
index e9e99574663..b5274992293 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -1,6 +1,6 @@
 /* X Communication module for terminals which understand the X protocol.
 
-Copyright (C) 1989, 1993-2012 Free Software Foundation, Inc.
+Copyright (C) 1989, 1993-2013 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -2236,8 +2236,7 @@ x_draw_image_foreground (struct glyph_string *s)
              nothing here for mouse-face.  */
           if (s->hl == DRAW_CURSOR)
             {
-              int relief = s->img->relief;
-              if (relief < 0) relief = -relief;
+              int relief = eabs (s->img->relief);
               XDrawRectangle (s->display, s->window, s->gc,
                               x - relief, y - relief,
                               s->slice.width + relief*2 - 1,
@@ -2368,8 +2367,7 @@ x_draw_image_foreground_1 (struct glyph_string *s, Pixmap pixmap)
              nothing here for mouse-face.  */
           if (s->hl == DRAW_CURSOR)
             {
-              int r = s->img->relief;
-              if (r < 0) r = -r;
+              int r = eabs (s->img->relief);
               XDrawRectangle (s->display, s->window, s->gc, x - r, y - r,
                               s->slice.width + r*2 - 1,
                               s->slice.height + r*2 - 1);
@@ -2633,14 +2631,14 @@ x_draw_stretch_glyph_string (struct glyph_string *s)
 static void
 x_draw_underwave (struct glyph_string *s)
 {
-  int wave_height = 2, wave_length = 3;
+  int wave_height = 3, wave_length = 2;
   int dx, dy, x0, y0, width, x1, y1, x2, y2, odd, xmax;
   XRectangle wave_clip, string_clip, final_clip;
 
   dx = wave_length;
   dy = wave_height - 1;
   x0 = s->x;
-  y0 = s->ybase + 1;
+  y0 = s->ybase - wave_height + 3;
   width = s->width;
   xmax = x0 + width;
 
@@ -2802,7 +2800,8 @@ x_draw_glyph_string (struct glyph_string *s)
               unsigned long thickness, position;
               int y;
 
-              if (s->prev && s->prev->face->underline_p)
+              if (s->prev && s->prev->face->underline_p
+                  && s->prev->face->underline_type == FACE_UNDER_LINE)
                 {
                   /* We use the same underline style as the previous one.  */
                   thickness = s->prev->underline_thickness;
@@ -4803,21 +4802,24 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
 
 #ifdef USE_MOTIF
 
-  /* We use an estimate of 30 chars per line rather than the real
-     `portion' value.  This has the disadvantage that the thumb size
-     is not very representative, but it makes our life a lot easier.
-     Otherwise, we have to constantly adjust the thumb size, which
-     we can't always do quickly enough: while dragging, the size of
-     the thumb might prevent the user from dragging the thumb all the
-     way to the end.  but Motif and some versions of Xaw3d don't allow
-     updating the thumb size while dragging.  Also, even if we can update
-     its size, the update will often happen too late.
-     If you don't believe it, check out revision 1.650 of xterm.c to see
-     what hoops we were going through and the still poor behavior we got.  */
-  portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
-  /* When the thumb is at the bottom, position == whole.
-     So we need to increase `whole' to make space for the thumb.  */
-  whole += portion;
+  if (scroll_bar_adjust_thumb_portion_p)
+    {
+      /* We use an estimate of 30 chars per line rather than the real
+         `portion' value.  This has the disadvantage that the thumb size
+         is not very representative, but it makes our life a lot easier.
+         Otherwise, we have to constantly adjust the thumb size, which
+         we can't always do quickly enough: while dragging, the size of
+         the thumb might prevent the user from dragging the thumb all the
+         way to the end.  but Motif and some versions of Xaw3d don't allow
+         updating the thumb size while dragging.  Also, even if we can update
+         its size, the update will often happen too late.
+         If you don't believe it, check out revision 1.650 of xterm.c to see
+         what hoops we were going through and the still poor behavior we got.  */
+      portion = WINDOW_TOTAL_LINES (XWINDOW (bar->window)) * 30;
+      /* When the thumb is at the bottom, position == whole.
+         So we need to increase `whole' to make space for the thumb.  */
+      whole += portion;
+    }
 
   if (whole <= 0)
     top = 0, shown = 1;
@@ -4834,9 +4836,7 @@ x_set_toolkit_scroll_bar_thumb (struct scroll_bar *bar, int portion, int positio
       /* Slider size.  Must be in the range [1 .. MAX - MIN] where MAX
          is the scroll bar's maximum and MIN is the scroll bar's minimum
          value.  */
-      size = shown * XM_SB_MAX;
-      size = min (size, XM_SB_MAX);
-      size = max (size, 1);
+      size = clip_to_bounds (1, shown * XM_SB_MAX, XM_SB_MAX);
 
       /* Position.  Must be in the range [MIN .. MAX - SLIDER_SIZE].  */
       value = top * XM_SB_MAX;
@@ -6102,16 +6102,15 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
       last_user_time = event.xproperty.time;
       f = x_top_window_to_frame (dpyinfo, event.xproperty.window);
       if (f && event.xproperty.atom == dpyinfo->Xatom_net_wm_state)
-        if (x_handle_net_wm_state (f, &event.xproperty) && f->iconified
-            && f->output_data.x->net_wm_state_hidden_seen)
+        if (x_handle_net_wm_state (f, &event.xproperty)
+            && FRAME_ICONIFIED_P (f)
+            && f->output_data.x->net_wm_state_hidden_seen)
           {
-            /* Gnome shell does not iconify us when C-z is pressed.  It hides
-               the frame.  So if our state says we aren't hidden anymore,
-               treat it as deiconified.  */
-            if (! f->async_iconified)
-              SET_FRAME_GARBAGED (f);
-            f->async_visible = 1;
-            f->async_iconified = 0;
+            /* Gnome shell does not iconify us when C-z is pressed.
+               It hides the frame.  So if our state says we aren't
+               hidden anymore, treat it as deiconified.  */
+            SET_FRAME_VISIBLE (f, 1);
+            SET_FRAME_ICONIFIED (f, 0);
             f->output_data.x->has_been_visible = 1;
             f->output_data.x->net_wm_state_hidden_seen = 0;
             inev.ie.kind = DEICONIFY_EVENT;
@@ -6152,10 +6151,10 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
                         event.xexpose.width, event.xexpose.height,
                         FALSE);
 #endif
-          if (f->async_visible == 0)
+          if (!FRAME_VISIBLE_P (f))
             {
-              f->async_visible = 1;
-              f->async_iconified = 0;
+              SET_FRAME_VISIBLE (f, 1);
+              SET_FRAME_ICONIFIED (f, 0);
               f->output_data.x->has_been_visible = 1;
               SET_FRAME_GARBAGED (f);
             }
@@ -6232,20 +6231,20 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
       if (f)            /* F may no longer exist if
                            the frame was deleted.  */
         {
+          bool visible = FRAME_VISIBLE_P (f);
           /* While a frame is unmapped, display generation is
              disabled; you don't want to spend time updating a
              display that won't ever be seen.  */
-          f->async_visible = 0;
+          SET_FRAME_VISIBLE (f, 0);
           /* We can't distinguish, from the event, whether the window
              has become iconified or invisible.  So assume, if it
              was previously visible, than now it is iconified.
              But x_make_frame_invisible clears both
              the visible flag and the iconified flag;
              and that way, we know the window is not iconified now.  */
-          if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
+          if (visible || FRAME_ICONIFIED_P (f))
             {
-              f->async_iconified = 1;
-
+              SET_FRAME_ICONIFIED (f, 1);
               inev.ie.kind = ICONIFY_EVENT;
               XSETFRAME (inev.ie.frame_or_window, f);
             }
@@ -6264,13 +6263,14 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
       f = x_top_window_to_frame (dpyinfo, event.xmap.window);
       if (f)
         {
+          bool iconified = FRAME_ICONIFIED_P (f);
           /* wait_reading_process_output will notice this and update
              the frame's display structures.
              If we where iconified, we should not set garbaged,
              because that stops redrawing on Expose events.  This looks
              bad if we are called from a recursive event loop
              (x_dispatch_event), for example when a dialog is up.  */
-          if (! f->async_iconified)
+          if (!iconified)
             SET_FRAME_GARBAGED (f);
 
           /* Check if fullscreen was specified before we where mapped the
@@ -6278,20 +6278,18 @@ handle_one_xevent (struct x_display_info *dpyinfo, XEvent *eventptr,
           if (!f->output_data.x->has_been_visible)
             x_check_fullscreen (f);
 
-          f->async_visible = 1;
-          f->async_iconified = 0;
+          SET_FRAME_VISIBLE (f, 1);
+          SET_FRAME_ICONIFIED (f, 0);
           f->output_data.x->has_been_visible = 1;
 
-          if (f->iconified)
+          if (iconified)
             {
               inev.ie.kind = DEICONIFY_EVENT;
               XSETFRAME (inev.ie.frame_or_window, f);
             }
-          else if (! NILP (Vframe_list)
-                   && ! NILP (XCDR (Vframe_list)))
-            /* Force a redisplay sooner or later
-               to update the frame titles
-               in case this is the second frame.  */
+          else if (! NILP (Vframe_list) && ! NILP (XCDR (Vframe_list)))
+            /* Force a redisplay sooner or later to update the
+               frame titles in case this is the second frame.  */
             record_asynch_buffer_change ();
 
 #ifdef USE_GTK
@@ -8417,7 +8415,7 @@ get_current_wm_state (struct frame *f,
       if (tmp_data) XFree (tmp_data);
       x_uncatch_errors ();
       unblock_input ();
-      return ! f->iconified;
+      return !FRAME_ICONIFIED_P (f);
     }
 
   x_uncatch_errors ();
@@ -8529,7 +8527,7 @@ do_ewmh_fullscreen (struct frame *f)
 static void
 XTfullscreen_hook (FRAME_PTR f)
 {
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     {
       block_input ();
       x_check_fullscreen (f);
@@ -8793,7 +8791,7 @@ x_set_window_size_1 (struct frame *f, int change_gravity, int cols, int rows)
   /* But the ConfigureNotify may in fact never arrive, and then this is
      not right if the frame is visible.  Instead wait (with timeout)
      for the ConfigureNotify.  */
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     x_wait_for_event (f, ConfigureNotify);
   else
     {
@@ -8905,9 +8903,8 @@ void
 x_raise_frame (struct frame *f)
 {
   block_input ();
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
-
   XFlush (FRAME_X_DISPLAY (f));
   unblock_input ();
 }
@@ -8917,7 +8914,7 @@ x_raise_frame (struct frame *f)
 static void
 x_lower_frame (struct frame *f)
 {
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     {
       block_input ();
       XLowerWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f));
@@ -8933,7 +8930,7 @@ xembed_request_focus (FRAME_PTR f)
 {
   /* See XEmbed Protocol Specification at
      http://freedesktop.org/wiki/Specifications/xembed-spec  */
-  if (f->async_visible)
+  if (FRAME_VISIBLE_P (f))
     xembed_send_message (f, CurrentTime,
                          XEMBED_REQUEST_FOCUS, 0, 0, 0);
 }
@@ -8947,7 +8944,8 @@ x_ewmh_activate_frame (FRAME_PTR f)
      http://freedesktop.org/wiki/Specifications/wm-spec  */
 
   struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
-  if (f->async_visible && wm_supports (f, dpyinfo->Xatom_net_active_window))
+
+  if (FRAME_VISIBLE_P (f) && wm_supports (f, dpyinfo->Xatom_net_active_window))
     {
       Lisp_Object frame;
       XSETFRAME (frame, f);
@@ -9159,9 +9157,6 @@ x_make_frame_visible (struct frame *f)
             poll_for_input_1 ();
             poll_suppress_count = old_poll_suppress_count;
           }
-
-        /* See if a MapNotify event has been processed.  */
-        FRAME_SAMPLE_VISIBILITY (f);
       }
 
     /* 2000-09-28: In
@@ -9229,10 +9224,8 @@ x_make_frame_invisible (struct frame *f)
      So we can't win using the usual strategy of letting
      FRAME_SAMPLE_VISIBILITY set this.  So do it by hand,
      and synchronize with the server to make sure we agree.  */
-  f->visible = 0;
-  FRAME_ICONIFIED_P (f) = 0;
-  f->async_visible = 0;
-  f->async_iconified = 0;
+  SET_FRAME_VISIBLE (f, 0);
+  SET_FRAME_ICONIFIED (f, 0);
 
   x_sync (f);
 
@@ -9253,13 +9246,11 @@ x_iconify_frame (struct frame *f)
   if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
     FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
 
-  if (f->async_iconified)
+  if (FRAME_ICONIFIED_P (f))
     return;
 
   block_input ();
 
-  FRAME_SAMPLE_VISIBILITY (f);
-
   type = x_icon_type (f);
   if (!NILP (type))
     x_bitmap_icon (f, type);
@@ -9271,10 +9262,8 @@ x_iconify_frame (struct frame *f)
         gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f));
 
       gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)));
-      f->iconified = 1;
-      f->visible = 1;
-      f->async_iconified = 1;
-      f->async_visible = 0;
+      SET_FRAME_VISIBLE (f, 0);
+      SET_FRAME_ICONIFIED (f, 1);
       unblock_input ();
       return;
     }
@@ -9291,10 +9280,8 @@ x_iconify_frame (struct frame *f)
       /* The server won't give us any event to indicate
          that an invisible frame was changed to an icon,
          so we have to record it here.  */
-      f->iconified = 1;
-      f->visible = 1;
-      f->async_iconified = 1;
-      f->async_visible = 0;
+      SET_FRAME_VISIBLE (f, 0);
+      SET_FRAME_ICONIFIED (f, 1);
       unblock_input ();
       return;
     }
@@ -9307,9 +9294,8 @@ x_iconify_frame (struct frame *f)
   if (!result)
     error ("Can't notify window manager of iconification");
 
-  f->async_iconified = 1;
-  f->async_visible = 0;
-
+  SET_FRAME_ICONIFIED (f, 1);
+  SET_FRAME_VISIBLE (f, 0);
 
   block_input ();
   XFlush (FRAME_X_DISPLAY (f));
@@ -9358,8 +9344,8 @@ x_iconify_frame (struct frame *f)
       XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
     }
 
-  f->async_iconified = 1;
-  f->async_visible = 0;
+  SET_FRAME_ICONIFIED (f, 1);
+  SET_FRAME_VISIBLE (f, 0);
 
   XFlush (FRAME_X_DISPLAY (f));
   unblock_input ();
diff --git a/src/xterm.h b/src/xterm.h
index d63ed1c4583..b241ff23559 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -1,5 +1,6 @@
 /* Definitions and headers for communication with X protocol.
-   Copyright (C) 1989, 1993-1994, 1998-2012 Free Software Foundation, Inc.
+   Copyright (C) 1989, 1993-1994, 1998-2013 Free Software Foundation,
+   Inc.
 
 This file is part of GNU Emacs.
 
@@ -473,12 +474,13 @@ struct x_output
   GtkWidget *menubar_widget;
   /* The tool bar in this frame  */
   GtkWidget *toolbar_widget;
-  /* The handle box that makes the tool bar detachable.  */
+#ifdef HAVE_GTK_HANDLE_BOX_NEW
+/* The handle box that makes the tool bar detachable.  */
   GtkWidget *handlebox_widget;
-  /* Non-zero if the tool bar is detached.  */
-  int toolbar_detached;
+#endif
   /* Non-zero if tool bar is packed into the hbox widget (i.e. vertical).  */
-  int toolbar_in_hbox;
+  bool toolbar_in_hbox;
+  bool toolbar_is_packed;
 
   /* The last size hints set.  */
   GdkGeometry size_hints;