Merge from trunk.

author: Paul Eggert 2012-05-25 11:19:24 -0700
committer: Paul Eggert 2012-05-25 11:19:24 -0700
commit: 42b2a986d9d4b7040fb20c90ec0efeffb78e761a (patch)
tree: d38e7bf5307837f2f38982757f088100de18a64e /src
parent: e4d81efc58695c19154d5f6733d91172b4c3e5b7 (diff)
parent: a8d3cbf75d219d7a249fc0623219511179e959da (diff)
download: emacs-42b2a986d9d4b7040fb20c90ec0efeffb78e761a.tar.gz
emacs-42b2a986d9d4b7040fb20c90ec0efeffb78e761a.zip
80 files changed, 2269 insertions, 3057 deletions
diff --git a/src/.gdbinit b/src/.gdbinit
index 7cd828733b1..8f8508f291f 100644
--- a/src/.gdbinit
+++ b/src/.gdbinit
@@ -54,7 +54,7 @@ end
 define xgetint
  set $bugfix = $arg0
-  set $int = gdb_use_union ? $bugfix.s.val : (gdb_use_lsb ? $bugfix : $bugfix << gdb_gctypebits) >> gdb_gctypebits
+  set $int = gdb_use_union ? $bugfix.s.val : (gdb_use_lsb ? $bugfix >> (gdb_gctypebits - 1) : $bugfix << gdb_gctypebits) >> gdb_gctypebits
 end
 define xgettype
@@ -703,60 +703,6 @@ Print $ as a misc free-cell pointer.
 This command assumes that $ is an Emacs Lisp Misc value.
 end
-define xintfwd
-  xgetptr $
-  print (struct Lisp_Intfwd *) $ptr
-end
-document xintfwd
-Print $ as an integer forwarding pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
-define xboolfwd
-  xgetptr $
-  print (struct Lisp_Boolfwd *) $ptr
-end
-document xboolfwd
-Print $ as a boolean forwarding pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
-define xobjfwd
-  xgetptr $
-  print (struct Lisp_Objfwd *) $ptr
-end
-document xobjfwd
-Print $ as an object forwarding pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
-define xbufobjfwd
-  xgetptr $
-  print (struct Lisp_Buffer_Objfwd *) $ptr
-end
-document xbufobjfwd
-Print $ as a buffer-local object forwarding pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
-define xkbobjfwd
-  xgetptr $
-  print (struct Lisp_Kboard_Objfwd *) $ptr
-end
-document xkbobjfwd
-Print $ as a kboard-local object forwarding pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
-define xbuflocal
-  xgetptr $
-  print (struct Lisp_Buffer_Local_Value *) $ptr
-end
-document xbuflocal
-Print $ as a buffer-local-value pointer.
-This command assumes that $ is an Emacs Lisp Misc value.
-end
 define xsymbol
  set $sym = $
  xgetptr $sym
@@ -1003,8 +949,15 @@ end
 define xpr
  xtype
-  if $type == Lisp_Int
+  if gdb_use_union
-    xint
+    if $type == Lisp_Int
+      xint
+    end
+  end
+  if !gdb_use_union
+    if $type == Lisp_Int0 || $type == Lisp_Int1
+      xint
+    end
  end
  if $type == Lisp_Symbol
    xsymbol
@@ -1023,36 +976,12 @@ define xpr
    if $misc == Lisp_Misc_Free
      xmiscfree
    end
-    if $misc == Lisp_Misc_Boolfwd
-      xboolfwd
-    end
    if $misc == Lisp_Misc_Marker
      xmarker
    end
-    if $misc == Lisp_Misc_Intfwd
-      xintfwd
-    end
-    if $misc == Lisp_Misc_Boolfwd
-      xboolfwd
-    end
-    if $misc == Lisp_Misc_Objfwd
-      xobjfwd
-    end
-    if $misc == Lisp_Misc_Buffer_Objfwd
-      xbufobjfwd
-    end
-    if $misc == Lisp_Misc_Buffer_Local_Value
-      xbuflocal
-    end
-#    if $misc == Lisp_Misc_Some_Buffer_Local_Value
-#      xvalue
-#    end
    if $misc == Lisp_Misc_Overlay
      xoverlay
    end
-    if $misc == Lisp_Misc_Kboard_Objfwd
-      xkbobjfwd
-    end
 #    if $misc == Lisp_Misc_Save_Value
 #      xsavevalue
 #    end
diff --git a/src/ChangeLog b/src/ChangeLog
index bdc70f54f29..6217560409d 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,9 +1,8 @@
-2012-04-22  Paul Eggert  <eggert@cs.ucla.edu>
+2012-05-25  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix integer width and related bugs (Bug#9874).
        * process.h (struct Lisp_Process): Members tick and update_tick
        are now of type EMACS_INT, not int.
-        Fix integer width and related bugs (Bug#9874).
        * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp):
        (allocate_vectorlike, buffer_memory_full, struct sdata, SDATA_SIZE)
        (string_bytes, check_sblock, allocate_string_data):
@@ -47,12 +46,6 @@
        (Foverlays_at, Fnext_overlay_change, Fprevious_overlay_change):
        Omit pointer cast, which isn't needed anyway, and doesn't work
        after the EMACS_INT -> ptrdiff_t change.
-        (Fmove_overlay): Delete an evaporating overlay
-        if it becomes empty after its bounds are adjusted to fit within
-        its buffer.  Without this fix, in a nonempty buffer (let ((o
-        (make-overlay 1 2))) (overlay-put o 'evaporate t) (move-overlay o 0 1))
-        yields an empty overlay that has the evaporate property, which is
-        not supposed to happen.  (Bug#9642)
        * buffer.h: Adjust decls to match defn changes elsewhere.
        (struct buffer_text, struct buffer):
        Use ptrdiff_t, not EMACS_INT, where ptrdiff_t is wide enough.
@@ -218,6 +211,7 @@
        (Frem): Don't assume arg is nonnegative.
        * dbusbind.c (xd_append_arg): Check for integers out of range.
        (Fdbus_call_method): Don't overflow the timeout int.
+        (extract_signed, extract_unsigned): New functions.
        * dired.c (directory_files_internal, file_name_completion, scmp)
        (file_name_completion_stat):
        Use ptrdiff_t, not int, to avoid needless 32-bit limit on 64-bit hosts.
@@ -796,6 +790,539 @@
        rather than rolling our own approximation.
        (SCROLL_BAR_VEC_SIZE): Remove; not used.
+2012-05-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * fileio.c, character.h: Minor style tweaks.
+2012-05-24  Dmitry Antipov  <dmantipov@yandex.ru>
+        * window.h (clip_changed): Remove useless declaration.
+2012-05-22  Juanma Barranquero  <lekktu@gmail.com>
+        * makefile.w32-in: Follow-up to 2012-05-22T16:20:27Z!eggert@cs.ucla.edu.
+        (TAGS, TAGS-gmake, CONFIG_H): Remove further references to m/intel386.h.
+2012-05-22  Paul Eggert  <eggert@cs.ucla.edu>
+        Remove src/m/*.
+        This directory predates autoconf and is no longer needed nowadays.
+        Move its few remaining bits of functionality to where they're needed.
+        * m/README, m/alpha.h, m/amdx86-64.h, m/ia64.h, m/ibmrs6000.h:
+        * m/ibms390x.h, m/intel386.h, m/m68k.h, m/macppc.h, m/sparc.h:
+        * m/template.h: Remove.
+        * Makefile.in (M_FILE): Remove.  All uses removed.
+        * alloc.c (POINTERS_MIGHT_HIDE_IN_OBJECTS):
+        * lisp.h (USE_LSB_TAG):
+        * mem-limits.h (EXCEEDS_LISP_PTR):
+        Use VAL_MAX, not VALBITS, in #if.
+        * lisp.h (EMACS_INT_MAX): New macro, useful in #if.
+        (EMACS_UINT): Define unconditionally now.
+        (BITS_PER_CHAR, BITS_PER_SHORT, BITS_PER_INT, BITS_PER_LONG)
+        (BITS_PER_EMACS_INT): New constants, replacing
+        what used to be in config.h, but not useful in #if.
+        (GCTYPEBITS, VALBITS): Define unconditionally, since m/* files don't
+        define them any more.
+        (VAL_MAX): New macro.
+        (VALMASK): Use it.
+        * puresize.h (PURESIZE_RATIO): Use EMACS_INT_MAX, not
+        BITS_PER_EMACS_INT, in #if.
+        * s/aix4-2.h (BROKEN_FIONREAD, BROKEN_SIGAIO, BROKEN_SIGPTY)
+        (BROKEN_SIGPOLL): Move here from m/ibmrs6000.h, which was removed.
+        * s/gnu-linux.h (ULIMIT_BREAK_VALUE) [__i386__]:
+        * s/ms-w32.h (DATA_START):
+        Move here from removed file m/intel386.h.
+        * s/gnu.h (NLIST_STRUCT): Remove undef; 'configure' does this.
+        * s/irix6-5.h (_LP64): Remove; lisp.h no longer needs this.
+2012-05-21  Paul Eggert  <eggert@cs.ucla.edu>
+        Assume C89 or later.
+        * alloc.c, buffer.c, lisp.h: Replace POINTER_TYPE with void.
+        * alloc.c (overrun_check_malloc, overrun_check_realloc, xmalloc)
+        (xrealloc):
+        * buffer.c (mmap_free_1, mmap_enlarge): Omit needless casts.
+        * editfns.c, fns.c, gmalloc.c, insdel.c, sysdep.c, termcap.c (NULL):
+        * textprop.c, tparam.c (NULL): Remove.
+        * ralloc.c, vm-limit.c (POINTER): Assume void * works.
+        * regex.c (SIGN_EXTEND_CHAR): Assume signed char works.
+        * regex.h (_RE_ARGS): Remove.  All uses rewritten to use prototypes.
+        * unexelf.c (ElfBitsW): Assume c89 preprocessor or better.
+        * xterm.c (input_signal_count): Assume volatile works.
+2012-05-21  Ken Brown  <kbrown@cornell.edu>
+        * xgselect.c (xg_select): Fix first argument in call to 'select'
+        (bug#11508).
+2012-05-20  Ken Brown  <kbrown@cornell.edu>
+        * gmalloc.c (_free_internal_nolock, _realloc_internal_nolock)
+        [CYGWIN]: Cast ptr to (char *) before comparing to _heapbase.
+2012-05-19  Ken Brown  <kbrown@cornell.edu>
+        * xfns.c (x_in_use): Remove `static' qualifier.
+        * xterm.h (x_in_use): Declare.
+        * xgselect.c: Include xterm.h.
+        (xg_select): Test `x_in_use' instead of `inhibit_window_system'
+        and `display_arg' (bug#9754).
+2012-05-19  Paul Eggert  <eggert@cs.ucla.edu>
+        * s/ms-w32.h (HAVE_GETDOMAINNAME): Remove; not needed.
+        * m/vax.h: Remove; no longer needed since HAVE_FTIME is being removed.
+        * s/ms-w32.h (HAVE_FTIME): Remove; not needed.
+2012-05-18  Eli Zaretskii  <eliz@gnu.org>
+        Fix compilation with -DGLYPH_DEBUG=1 on MS-Windows.
+        * w32term.c [GLYPH_DEBUG]: Add prototype for x_check_font.
+        (x_check_font) [GLYPH_DEBUG]: New function, copied from xterm.c
+        * w32fns.c (unwind_create_frame) [GLYPH_DEBUG]: Fix broken
+        reference to image_cache->refcount.
+        (x_create_tip_frame): Fix broken use of FRAME_IMAGE_CACHE.
+2012-05-17  Juri Linkov  <juri@jurta.org>
+        * search.c (Fword_search_regexp, Fword_search_backward)
+        (Fword_search_forward, Fword_search_backward_lax)
+        (Fword_search_forward_lax): Move functions to isearch.el
+        (bug#10145, bug#11381).
+2012-05-16  Paul Eggert  <eggert@cs.ucla.edu>
+        * xgselect.c (xg_select): Just invoke 'select' if -nw (Bug#9754).
+2012-05-15  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * lread.c (init_obarray): Declare Qt and Qnil as special.
+2012-05-14  Glenn Morris  <rgm@gnu.org>
+        * nsterm.m (ns_init_paths): Fix typo ("libexec" not "lib-exec").
+        Put "libexec" before "bin", for the sake of init_callproc_1.
+2012-05-14  Paul Eggert  <eggert@cs.ucla.edu>
+        * keyboard.c (kbd_buffer_get_event) [!HAVE_DBUS]: Omit unused local.
+        * unexaix.c: Port to more-recent AIX compilers.
+        (report_error, report_error_1, make_hdr, copy_sym)
+        (mark_x, adjust_lnnoptrs, unrelocate_symbols):
+        Make arguments const char *, not char *, to avoid violations of C
+        standard and to fix some AIX warnings reported by Gilles Pion.
+2012-05-14  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (handle_stop): Don't call get_overlay_strings_1 if we
+        already have overlays loaded.
+        (handle_single_display_spec): Before returning without displaying
+        fringe bitmap, synchronize the bidi iterator with the main display
+        iterator, by calling iterate_out_of_display_property.
+        (iterate_out_of_display_property): Detect buffer iteration by
+        testing that it->string is a Lisp string.
+        (get_next_display_element): When the current object is exhausted,
+        and there's something on it->stack, call set_iterator_to_next to
+        proceed with what's on the stack, instead of returning zero.
+        (set_iterator_to_next): If called at the end of a Lisp string,
+        proceed to consider_string_end without incrementing string
+        position.  Don't increment display vector index past the end of
+        the display vector.  (Bug#11417)
+        (pos_visible_p): Don't report a position visible when move_it_to
+        stopped at the last line of window, which happens to be scanned
+        backwards by the bidi iteration.  (Bug#11464)
+2012-05-14  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (handle_single_display_spec): Return 1 for left-margin
+        and right-margin display specs even if the spec is invalid or we
+        are on a TTY, and thus unable to display on the fringes.  That's
+        because the text with the property will not be displayed anyway,
+        so we need to signal to the caller that this is a "replacing"
+        display spec.  This fixes display when the spec is invalid or we
+        are on a TTY.
+2012-05-14  Paul Eggert  <eggert@cs.ucla.edu>
+        * unexaix.c (make_hdr): Fix typo in prototype.
+        This bug broke the build on AIX.  Problem reported by Gilles Pion.
+2012-05-14  Michael Albinus  <michael.albinus@gmx.de>
+        * keyboard.c (kbd_buffer_get_event): Read special events also in
+        batch mode.  (Bug#11415)
+2012-05-12  Glenn Morris  <rgm@gnu.org>
+        * ns.mk: Update for ns_appbindir no longer having trailing "/".
+2012-05-12  Eli Zaretskii  <eliz@gnu.org>
+        * lisp.mk (lisp): Add newcomment.elc.
+2012-05-12  Glenn Morris  <rgm@gnu.org>
+        * Makefile.in (MKDIR_P): New, set by configure.
+        * ns.mk (${ns_appdir}, ${ns_appbindir}Emacs): Use $MKDIR_P.
+2012-05-11  Paul Eggert  <eggert@cs.ucla.edu>
+        Remove unused function hourglass_started.
+        * dispextern.h (hourglass_started):
+        * w32fns.c (hourglass_started):
+        * xdisp.c (hourglass_started): Remove.
+2012-05-10  Juanma Barranquero  <lekktu@gmail.com>
+        * makefile.w32-in ($(BLD)/gmalloc.$(O), $(BLD)/w32menu.$(O)):
+        Update dependencies.
+2012-05-10  Paul Eggert  <eggert@cs.ucla.edu>
+        * xgselect.c (xg_select): Put maxfds+1 into a var.
+        This is slightly clearer, and pacifies Ubuntu 12.04 gcc.
+        * sound.c (DEFAULT_ALSA_SOUND_DEVICE): Define only if HAVE_ALSA.
+2012-05-10  Dave Abrahams  <dave@boostpro.com>
+        * filelock.c (syms_of_filelock): New boolean create-lockfiles.
+        (lock_file): If create_lockfiles is 0, do nothing.  (Bug#11227)
+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.
+        (syms_of_dbusbind): Remove declaration of Vdbus_registered_buses.
+        Initialize xd_registered_buses.
+2012-05-09  Paul Eggert  <eggert@cs.ucla.edu>
+        Untag more efficiently if USE_LSB_TAG.
+        This is based on a proposal by YAMAMOTO Mitsuharu in
+        <http://lists.gnu.org/archive/html/emacs-devel/2008-01/msg01876.html>.
+        For an admittedly artificial (nth 8000 longlist) benchmark on
+        Fedora 15 x86-64, this yields a 25% CPU speedup.  Also, it shrinks
+        Emacs's overall text size by 1%.
+        * lisp.h (XUNTAG): New macro.
+        (XCONS, XVECTOR, XSTRING, XSYMBOL, XFLOAT, XMISC, XPROCESS, XWINDOW)
+        (XTERMINAL, XSUBR, XBUFFER, XCHAR_TABLE, XSUB_CHAR_TABLE, XBOOL_VECTOR)
+        (XSETTYPED_PSEUDOVECTOR, XHASH_TABLE, TYPED_PSEUDOVECTORP): Use it.
+        * eval.c (Fautoload):
+        * font.h (XFONT_SPEC, XFONT_ENTITY, XFONT_OBJECT):
+        * frame.h (XFRAME): Use XUNTAG.
+        Port recent dbusbind.c changes to 32-bit --with-wide-int.
+        * dbusbind.c (xd_append_arg, xd_retrieve_arg, Fdbus_message_internal):
+        Remove unportable assumptions about print widths of types like
+        dbus_uint32_t.
+        (xd_get_connection_address, Fdbus_init_bus): Cast Emacs integer to
+        intptr_t when converting between pointer and integer, to avoid GCC
+        warnings about wrong width.
+2012-05-09  Eli Zaretskii  <eliz@gnu.org>
+        * w32proc.c (new_child): Force Windows to reserve only 64KB of
+        stack for each reader_thread, instead of defaulting to 8MB
+        determined by the linker.  This avoids failures in creating
+        subprocesses on Windows 7, see the discussion in this thread:
+        http://lists.gnu.org/archive/html/emacs-devel/2012-03/msg00119.html.
+2012-05-07  Jérémy Compostella  <jeremy.compostella@gmail.com>
+        Fix up display of the *Minibuf-0* buffer in the mini window.
+        * keyboard.c (read_char): Don't clear the echo area if there's no
+        message to clear.
+        * xdisp.c (redisplay_internal): Redisplay the mini window (with the
+        contents of *Minibuf-0*) if there's no message displayed in its stead.
+2012-05-07  Michael Albinus  <michael.albinus@gmx.de>
+        * dbusbind.c (XD_DEBUG_MESSAGE): Don't print message twice in
+        batch mode.
+2012-05-06  Chong Yidong  <cyd@gnu.org>
+        * lisp.mk (lisp): Update.
+2012-05-05  Jim Meyering  <meyering@redhat.com>
+        * w32font.c (fill_in_logfont): NUL-terminate a string (Bug#11372).
+2012-05-04  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * data.c (PUT_ERROR): New macro.
+        (syms_of_data): Use it.  Add new error type `user-error'.
+        * undo.c (user_error): New function.
+        (Fprimitive_undo): Use it.
+        * print.c (print_error_message): Adjust print style for `user-error'.
+        * keyboard.c (user_error): New function.
+        (Fexit_recursive_edit, Fabort_recursive_edit): Use it.
+2012-05-03  Paul Eggert  <eggert@cs.ucla.edu>
+        Do not limit current-time-string to years 1000..9999.
+        * editfns.c (TM_YEAR_IN_ASCTIME_RANGE): Remove.
+        (Fcurrent_time_string): Support any year that is supported by the
+        underlying localtime representation.  Don't use asctime, as it
+        has undefined behavior for years outside the range -999..9999.
+2012-05-02  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix race conditions involving setenv, gmtime, localtime, asctime.
+        Without this fix, interrupts could mess up code that uses these
+        nonreentrant functions, since setting TZ invalidates existing
+        tm_zone or tzname values, and since most of these functions return
+        pointers to static storage.
+        * editfns.c (format_time_string, Fdecode_time, Fencode_time)
+        (Fcurrent_time_string, Fcurrent_time_zone, Fset_time_zone_rule):
+        Grow the critical sections to include not just invoking
+        localtime/gmtime, but also accessing these functions' results
+        including their tm_zone values if any, and any related TZ setting.
+        (format_time_string): Last arg is now struct tm *, not struct tm **,
+        so that the struct tm is saved in the critical section.
+        All callers changed.  Simplify allocation of initial buffer, partly
+        motivated by the fact that memory allocation needs to be outside
+        the critical section.
+2012-05-02  Dmitry Antipov  <dmantipov@yandex.ru>
+        * intervals.c (adjust_intervals_for_insertion): Initialize `newi'
+        with RESET_INTERVAL.
+        * buffer.c (Fget_buffer_create, Fmake_indirect_buffer):
+        Remove duplicated buffer name initialization.
+2012-05-02  Jim Meyering  <jim@meyering.net>
+        * xterm.c (x_term_init): Use memcpy instead of strncpy (Bug#11373).
+        * xfns.c (x_window): Use xstrdup (Bug#11375).
+2012-05-02  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (pos_visible_p): If already at a newline from the
+        display string before the 'while' loop, don't walk back the glyphs
+        from it3.glyph_row.  Solves assertion violation when the display
+        string begins with a newline (egg.el).  (Bug#11367)
+2012-05-01  Stefan Monnier  <monnier@iro.umontreal.ca>
+        * keyboard.c (Fexecute_extended_command, Vsuggest_key_bindings):
+        Move to simple.el.
+2012-05-01  Glenn Morris  <rgm@gnu.org>
+        * syssignal.h: Remove reference to BROKEN_SIGINFO (last used in
+        s/ptx4.h), BROKEN_SIGTSTP (last used in m/ustation.h, m/dpx2.h),
+        and BROKEN_SIGURG (was in s/gnu-linux.h prior to 2008-02-10).
+        All were removed before 23.1.
+        * dispnew.c: Remove HAVE_LIBNCURSES test;
+        it is always true on relevant platforms.
+        * Makefile.in (LD_SWITCH_X_SITE_RPATH):
+        Rename from LD_SWITCH_X_SITE_AUX_RPATH.
+        * Makefile.in (LD_SWITCH_X_SITE_AUX): Remove; no longer used.
+2012-04-30  Andreas Schwab  <schwab@linux-m68k.org>
+        * .gdbinit (xpr): Remove checks for no longer existing misc types.
+        (xintfwd, xboolfwd, xobjfwd, xbufobjfwd, xkbobjfwd, xbuflocal):
+        Remove.
+2012-04-28  Paul Eggert  <eggert@cs.ucla.edu>
+        Do not avoid creating empty evaporating overlays (Bug#9642).
+        * buffer.c (Fmove_overlay): Revert the change of 2012-04-23.
+        That is, do not delete an evaporating overlay if it becomes
+        empty after its bounds are adjusted to fit within its buffer.
+        This fix caused other problems, and I'm reverting it until we get
+        to the bottom of them.
+2012-04-27  Chong Yidong  <cyd@gnu.org>
+        * xselect.c (x_convert_selection): Initialize a pointer (Bug#11315).
+2012-04-27  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (pos_visible_p): If the window start position is beyond
+        ZV, start the display from buffer beginning.  Prevents assertion
+        violation in init_iterator when the minibuffer window is scrolled
+        via the scroll bar.
+        * window.c (window_scroll_pixel_based): Likewise.
+2012-04-27  Chong Yidong  <cyd@gnu.org>
+        * keymap.c (where_is_internal): Doc fix (Bug#10872).
+2012-04-27  Glenn Morris  <rgm@gnu.org>
+        * fileio.c (Fcopy_file, Fset_file_selinux_context):
+        Ignore ENOTSUP failures from setfilecon functions.  (Bug#11245)
+2012-04-27  Eli Zaretskii  <eliz@gnu.org>
+        * dispnew.c (swap_glyph_pointers, copy_row_except_pointers):
+        Don't overrun array limits of glyph row's used[] array.  (Bug#11288)
+2012-04-26  Eli Zaretskii  <eliz@gnu.org>
+        * xdisp.c (IT_DISPLAYING_WHITESPACE): In addition to the loaded
+        display element, check also the underlying string or buffer
+        character.  (Bug#11341)
+        * w32menu.c: Include w32heap.h.
+        (add_menu_item): If the call to AppendMenuW (via
+        unicode_append_menu) fails, disable Unicode menus only if we are
+        running on Windows 9X/Me.
+2012-04-24  Andreas Schwab  <schwab@linux-m68k.org>
+        * .gdbinit (xpr): Handle USE_2_TAGS_FOR_INTS.
+        (xgetint): Add missing shift for LSB tags.
+2012-04-24  Martin Rudalics  <rudalics@gmx.at>
+        * keyboard.c (read_char): Don't wipe echo area for select window
+        events: These might get delayed via `mouse-autoselect-window'
+        (Bug#11304).
+2012-04-24  Juanma Barranquero  <lekktu@gmail.com>
+        * gnutls.c (init_gnutls_functions): Protect against (unlikely)
+        manipulation of :loaded-from data.
+2012-04-23  Juanma Barranquero  <lekktu@gmail.com>
+        * gnutls.c (init_gnutls_functions): The value of :loaded-from is
+        now a cons (bug#11311).
+2012-04-23  Paul Eggert  <eggert@cs.ucla.edu>
+        Do not create empty overlays with the evaporate property (Bug#9642).
+        * buffer.c (Fmove_overlay): Delete an evaporating overlay
+        if it becomes empty after its bounds are adjusted to fit within
+        its buffer.  Without this fix, in a nonempty buffer (let ((o
+        (make-overlay 1 2))) (overlay-put o 'evaporate t) (move-overlay o 0 1))
+        yields an empty overlay that has the evaporate property, which is
+        not supposed to happen.
+        Fix minor GTK3 problems found by static checking.
+        * emacsgtkfixed.c (EMACS_TYPE_FIXED, EMACS_FIXED, EmacsFixed)
+        (EmacsFixedPrivate, EmacsFixedClass, struct _EmacsFixed)
+        (struct _EmacsFixedClass, emacs_fixed_get_type):
+        Move decls here from emacsgtkfixed.h, since they needn't be public.
+        (emacs_fixed_get_type): Now static.
+        (emacs_fixed_class_init): Omit unused local.
+        (emacs_fixed_child_type): Remove; unused.
+        * emacsgtkfixed.h (EMACS_TYPE_FIXED, EMACS_FIXED, EmacsFixed)
+        (EmacsFixedPrivate, EmacsFixedClass, struct _EmacsFixed)
+        (struct _EmacsFixedClass): Move to emacsgtkfixed.c.
+        (EMACS_FIXED_CLASS, EMACS_IS_FIXED, EMACS_IS_FIXED_CLASS)
+        (EMACS_FIXED_GET_CLASS): Remove; unused.
+        * gtkutil.c (xg_create_frame_widgets) [!HAVE_GTK3]: Omit unused local.
+        * keyboard.c (handle_async_input): Define only if SYNC_INPUT || SIGIO.
+        Problem reported by Juanma Barranquero for Windows -Wunused-function.
+2012-04-22  Paul Eggert  <eggert@cs.ucla.edu>
+        Modernize and clean up gmalloc.c to assume C89 (Bug#9119).
+        * gmalloc.c (_MALLOC_INTERNAL, _MALLOC_H, _PP, __ptr_t)
+        (__malloc_size_t, __malloc_ptrdiff_t):
+        Remove.  All uses removed, replaced by the definiens if needed,
+        since we can assume C89 or better now.
+        Include <stdint.h>, for PTRDIFF_MAX, uintptr_t.
+        (protect_malloc_state, align, get_contiguous_space)
+        (malloc_atfork_handler_prepare, malloc_atfork_handler_parent)
+        (malloc_atfork_handler_child, malloc_enable_thread)
+        (malloc_initialize_1, __malloc_initialize, morecore_nolock)
+        (_malloc_internal_nolock, _malloc_internal, malloc, _malloc)
+        (_free, _realloc, _free_internal_nolock, _free_internal, free, cfree)
+        (special_realloc, _realloc_internal_nolock, _realloc_internal)
+        (realloc, calloc, __default_morecore, memalign, valloc, checkhdr)
+        (freehook, mallochook, reallochook, mabort, mcheck, mprobe):
+        Define using prototypes, not old style.
+        (align, _malloc_internal_nolock, _free_internal_nolock, memalign):
+        Don't assume ptrdiff_t and uintptr_t are no wider than unsigned long.
+        (align): Don't assume that signed integer overflow wraps around.
+        Omit unused local var.
+        (malloc_initialize_1, morecore_nolock, _malloc_internal_nolock)
+        (_free_internal_nolock, memalign, mallochook, reallochook):
+        Omit no-longer-needed casts.
+        (valloc): Use getpagesize, not __getpagesize.
+        (MAGICWORD, MAGICFREE): Now randomish size_t values, not 32-bit.
+        (struct hdr): The 'magic' member is now size_t, not unsigned long.
+        * dbusbind.c (XD_DBUS_VALIDATE_OBJECT): Define only if needed.
+2012-04-22  Michael Albinus  <michael.albinus@gmx.de>
+        Move functions from C to Lisp.  Make non-blocking method calls
+        the default.  Implement further D-Bus standard interfaces.
+        * dbusbind.c (DBUS_NUM_MESSAGE_TYPES): Declare.
+        (QCdbus_request_name_allow_replacement)
+        (QCdbus_request_name_replace_existing)
+        (QCdbus_request_name_do_not_queue)
+        (QCdbus_request_name_reply_primary_owner)
+        (QCdbus_request_name_reply_in_queue)
+        (QCdbus_request_name_reply_exists)
+        (QCdbus_request_name_reply_already_owner): Move to dbus.el.
+        (QCdbus_registered_serial, QCdbus_registered_method)
+        (QCdbus_registered_signal): New Lisp objects.
+        (XD_DEBUG_MESSAGE): Use sizeof.
+        (XD_MESSAGE_TYPE_TO_STRING, XD_OBJECT_TO_STRING)
+        (XD_DBUS_VALIDATE_BUS_ADDRESS, XD_DBUS_VALIDATE_OBJECT)
+        (XD_DBUS_VALIDATE_BUS_NAME, XD_DBUS_VALIDATE_PATH)
+        (XD_DBUS_VALIDATE_INTERFACE, XD_DBUS_VALIDATE_MEMBER): New macros.
+        (XD_CHECK_DBUS_SERIAL): Rename from CHECK_DBUS_SERIAL_GET_SERIAL.
+        (xd_signature, xd_append_arg): Allow float for integer types.
+        (xd_get_connection_references): New function.
+        (xd_get_connection_address): Rename from xd_initialize.
+        Return cached address.
+        (xd_remove_watch): Do not unset $DBUS_SESSION_BUS_ADDRESS.
+        (xd_close_bus): Rename from Fdbus_close_bus.  Not needed on Lisp
+        level.
+        (Fdbus_init_bus): New optional arg PRIVATE.  Cache address.
+        Return number of refcounts.
+        (Fdbus_get_unique_name): Make stronger parameter check.
+        (Fdbus_message_internal): New defun.
+        (Fdbus_call_method, Fdbus_call_method_asynchronously)
+        (Fdbus_method_return_internal, Fdbus_method_error_internal)
+        (Fdbus_send_signal, Fdbus_register_service)
+        (Fdbus_register_signal, Fdbus_register_method): Move to dbus.el.
+        (xd_read_message_1): Obey new structure of Vdbus_registered_objects.
+        (xd_read_queued_messages): Obey new structure of Vdbus_registered_buses.
+        (Vdbus_compiled_version, Vdbus_runtime_version)
+        (Vdbus_message_type_invalid, Vdbus_message_type_method_call)
+        (Vdbus_message_type_method_return, Vdbus_message_type_error)
+        (Vdbus_message_type_signal): New defvars.
+        (Vdbus_registered_buses, Vdbus_registered_objects_table):
+        Adapt docstring.
+2012-04-22  Paul Eggert  <eggert@cs.ucla.edu>
+        Fix GC_MALLOC_CHECK debugging output on 64-bit hosts.
+        * alloc.c (emacs_blocked_malloc) [GC_MALLOC_CHECK]:
+        Do not assume ptrdiff_t is the same width as 'int'.
+        * alloc.c: Handle unusual debugging option combinations.
+        (GC_CHECK_MARKED_OBJECTS): Undef if ! GC_MARK_STACK,
+        since the two debugging options are incompatible.
+        (GC_MALLOC_CHECK): Similarly, undef if GC_CHECK_MARKED_OBJECTS
+        is defined.
+        (mem_init, mem_insert, mem_insert_fixup):
+        Define if GC_MARK_STACK || GC_MALLOC_CHECK.
+        (NEED_MEM_INSERT): Remove; no longer needed.
 2012-04-22  Leo Liu  <sdl.web@gmail.com>
        * sysdep.c (list_system_processes): Support Darwin (Bug#5725).
@@ -809,8 +1336,8 @@
 2012-04-21  Eduard Wiebe  <usenet@pusto.de>
-        * sysdep.c (list_system_processes, system_process_attributes): Add
+        * sysdep.c (list_system_processes, system_process_attributes):
-        implementation for FreeBSD (Bug#5243).
+        Add implementation for FreeBSD (Bug#5243).
 2012-04-21  Andreas Schwab  <schwab@linux-m68k.org>
diff --git a/src/Makefile.in b/src/Makefile.in
index 37480f8269d..27199578fc0 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -40,6 +40,7 @@ version = @version@
 # Substitute an assignment for the MAKE variable, because
 # BSD doesn't have it as a default.
 @SET_MAKE@
+MKDIR_P = @MKDIR_P@
 # Don't use LIBS.  configure puts stuff in it that either shouldn't be
 # linked with Emacs or is duplicated by the other stuff below.
 # LIBS = @LIBS@
@@ -55,9 +56,8 @@ lwlibdir = ../lwlib
 lispdir = ../lisp
 # Configuration files for .o files to depend on.
-M_FILE = @M_FILE@
 S_FILE = @S_FILE@
-config_h = config.h $(M_FILE) $(S_FILE)
+config_h = config.h $(S_FILE)
 bootstrap_exe = $(abs_builddir)/bootstrap-emacs$(EXEEXT)
@@ -94,11 +94,9 @@ C_SWITCH_X_SITE=@C_SWITCH_X_SITE@
 ## substituted in this or any other Makefile. Cf C_SWITCH_X_SITE.
 LD_SWITCH_X_SITE=
-## Next two must come before LD_SWITCH_SYSTEM.
+## This must come before LD_SWITCH_SYSTEM.
-## If needed, a -R option that says where to find X windows at run time.
+## If needed, a -rpath option that says where to find X windows at run time.
-LD_SWITCH_X_SITE_AUX=@LD_SWITCH_X_SITE_AUX@
+LD_SWITCH_X_SITE_RPATH=@LD_SWITCH_X_SITE_RPATH@
-## As above, but using -rpath instead.
-LD_SWITCH_X_SITE_AUX_RPATH=@LD_SWITCH_X_SITE_AUX_RPATH@
 ## System-specific LDFLAGS.
 LD_SWITCH_SYSTEM=@LD_SWITCH_SYSTEM@
@@ -286,7 +284,7 @@ CANNOT_DUMP=@CANNOT_DUMP@
 DEPDIR=deps
 ## -MMD -MF $(DEPDIR)/$*.d if AUTO_DEPEND; else empty.
 DEPFLAGS=@DEPFLAGS@
-## test -d $(DEPDIR) || mkdir $(DEPDIR) (if AUTO_DEPEND); else ':'.
+## ${MKDIR_P} ${DEPDIR} (if AUTO_DEPEND); else ':'.
 MKDEPDIR=@MKDEPDIR@
 ## DO NOT use -R.  There is a special hack described in lastfile.c
@@ -535,10 +533,10 @@ extraclean: distclean
 ctagsfiles1 = [xyzXYZ]*.[hcm]
 ctagsfiles2 = [a-wA-W]*.[hcm]
-TAGS: $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(M_FILE) $(S_FILE)
+TAGS: $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(S_FILE)
        ../lib-src/etags --include=TAGS-LISP --include=$(lwlibdir)/TAGS \
          --regex='/[   ]*DEFVAR_[A-Z_  (]+"\([^"]+\)"/' \
-          $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(M_FILE) $(S_FILE)
+          $(srcdir)/$(ctagsfiles1) $(srcdir)/$(ctagsfiles2) $(S_FILE)
 frc:
 TAGS-LISP: frc
        $(MAKE) -f $(lispdir)/Makefile TAGS-LISP ETAGS=../lib-src/etags
diff --git a/src/alloc.c b/src/alloc.c
index c07d5c929f9..05d2db274da 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -49,16 +49,24 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <setjmp.h>
 #include <verify.h>
+/* GC_CHECK_MARKED_OBJECTS means do sanity checks on allocated objects.
+   Doable only if GC_MARK_STACK.  */
+#if ! GC_MARK_STACK
+# undef GC_CHECK_MARKED_OBJECTS
+#endif
 /* GC_MALLOC_CHECK defined means perform validity checks of malloc'd
-   memory.  Can do this only if using gmalloc.c.  */
+   memory.  Can do this only if using gmalloc.c and if not checking
+   marked objects.  */
-#if defined SYSTEM_MALLOC || defined DOUG_LEA_MALLOC
+#if (defined SYSTEM_MALLOC || defined DOUG_LEA_MALLOC \
+     || defined GC_CHECK_MARKED_OBJECTS)
 #undef GC_MALLOC_CHECK
 #endif
 #include <unistd.h>
 #ifndef HAVE_UNISTD_H
-extern POINTER_TYPE *sbrk ();
+extern void *sbrk ();
 #endif
 #include <fcntl.h>
@@ -298,7 +306,7 @@ enum mem_type
  MEM_TYPE_VECTORLIKE
 };
-static POINTER_TYPE *lisp_malloc (size_t, enum mem_type);
+static void *lisp_malloc (size_t, enum mem_type);
 #if GC_MARK_STACK || defined GC_MALLOC_CHECK
@@ -380,7 +388,7 @@ static struct mem_node mem_z;
 #define MEM_NIL &mem_z
 static struct Lisp_Vector *allocate_vectorlike (ptrdiff_t);
-static void lisp_free (POINTER_TYPE *);
+static void lisp_free (void *);
 static void mark_stack (void);
 static int live_vector_p (struct mem_node *, void *);
 static int live_buffer_p (struct mem_node *, void *);
@@ -391,11 +399,8 @@ static int live_float_p (struct mem_node *, void *);
 static int live_misc_p (struct mem_node *, void *);
 static void mark_maybe_object (Lisp_Object);
 static void mark_memory (void *, void *);
+#if GC_MARK_STACK || defined GC_MALLOC_CHECK
 static void mem_init (void);
-#if (defined GC_MALLOC_CHECK                         \
-     ? !defined SYSTEM_MALLOC && !defined SYNC_INPUT \
-     : GC_MARK_STACK)
-# define NEED_MEM_INSERT
 static struct mem_node *mem_insert (void *, void *, enum mem_type);
 static void mem_insert_fixup (struct mem_node *);
 #endif
@@ -430,15 +435,15 @@ static Lisp_Object *staticvec[NSTATICS] = {&Vpurify_flag};
 static int staticidx = 0;
-static POINTER_TYPE *pure_alloc (size_t, int);
+static void *pure_alloc (size_t, int);
 /* Value is SZ rounded up to the next multiple of ALIGNMENT.
   ALIGNMENT must be a power of 2.  */
 #define ALIGN(ptr, ALIGNMENT) \
-  ((POINTER_TYPE *) ((((uintptr_t) (ptr)) + (ALIGNMENT) - 1) \
+  ((void *) (((uintptr_t) (ptr) + (ALIGNMENT) - 1) \
-                     & ~((ALIGNMENT) - 1)))
+             & ~ ((ALIGNMENT) - 1)))
@@ -599,7 +604,7 @@ static ptrdiff_t check_depth;
 /* Like malloc, but wraps allocated block with header and trailer.  */
-static POINTER_TYPE *
+static void *
 overrun_check_malloc (size_t size)
 {
  register unsigned char *val;
@@ -617,15 +622,15 @@ overrun_check_malloc (size_t size)
              XMALLOC_OVERRUN_CHECK_SIZE);
    }
  --check_depth;
-  return (POINTER_TYPE *)val;
+  return val;
 }
 /* Like realloc, but checks old block for overrun, and wraps new block
   with header and trailer.  */
-static POINTER_TYPE *
+static void *
-overrun_check_realloc (POINTER_TYPE *block, size_t size)
+overrun_check_realloc (void *block, size_t size)
 {
  register unsigned char *val = (unsigned char *) block;
  int overhead = ++check_depth == 1 ? XMALLOC_OVERRUN_CHECK_OVERHEAD : 0;
@@ -647,7 +652,7 @@ overrun_check_realloc (POINTER_TYPE *block, size_t size)
      memset (val, 0, XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE);
    }
-  val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + overhead);
+  val = realloc (val, size + overhead);
  if (val && check_depth == 1)
    {
@@ -658,13 +663,13 @@ overrun_check_realloc (POINTER_TYPE *block, size_t size)
              XMALLOC_OVERRUN_CHECK_SIZE);
    }
  --check_depth;
-  return (POINTER_TYPE *)val;
+  return val;
 }
 /* Like free, but checks block for overrun.  */
 static void
-overrun_check_free (POINTER_TYPE *block)
+overrun_check_free (void *block)
 {
  unsigned char *val = (unsigned char *) block;
@@ -713,13 +718,13 @@ overrun_check_free (POINTER_TYPE *block)
 /* Like malloc but check for no memory and block interrupt input..  */
-POINTER_TYPE *
+void *
 xmalloc (size_t size)
 {
-  register POINTER_TYPE *val;
+  void *val;
  MALLOC_BLOCK_INPUT;
-  val = (POINTER_TYPE *) malloc (size);
+  val = malloc (size);
  MALLOC_UNBLOCK_INPUT;
  if (!val && size)
@@ -730,18 +735,18 @@ xmalloc (size_t size)
 /* Like realloc but check for no memory and block interrupt input..  */
-POINTER_TYPE *
+void *
-xrealloc (POINTER_TYPE *block, size_t size)
+xrealloc (void *block, size_t size)
 {
-  register POINTER_TYPE *val;
+  void *val;
  MALLOC_BLOCK_INPUT;
  /* We must call malloc explicitly when BLOCK is 0, since some
     reallocs don't do this.  */
  if (! block)
-    val = (POINTER_TYPE *) malloc (size);
+    val = malloc (size);
  else
-    val = (POINTER_TYPE *) realloc (block, size);
+    val = realloc (block, size);
  MALLOC_UNBLOCK_INPUT;
  if (!val && size)
@@ -753,7 +758,7 @@ xrealloc (POINTER_TYPE *block, size_t size)
 /* Like free but block interrupt input.  */
 void
-xfree (POINTER_TYPE *block)
+xfree (void *block)
 {
  if (!block)
    return;
@@ -888,7 +893,7 @@ safe_alloca_unwind (Lisp_Object arg)
 static void *lisp_malloc_loser;
 #endif
-static POINTER_TYPE *
+static void *
 lisp_malloc (size_t nbytes, enum mem_type type)
 {
  register void *val;
@@ -933,7 +938,7 @@ lisp_malloc (size_t nbytes, enum mem_type type)
   call to lisp_malloc.  */
 static void
-lisp_free (POINTER_TYPE *block)
+lisp_free (void *block)
 {
  MALLOC_BLOCK_INPUT;
  free (block);
@@ -1029,7 +1034,7 @@ static struct ablock *free_ablock;
 /* Allocate an aligned block of nbytes.
   Alignment is on a multiple of BLOCK_ALIGN and `nbytes' has to be
   smaller or equal to BLOCK_BYTES.  */
-static POINTER_TYPE *
+static void *
 lisp_align_malloc (size_t nbytes, enum mem_type type)
 {
  void *base, *val;
@@ -1136,7 +1141,7 @@ lisp_align_malloc (size_t nbytes, enum mem_type type)
 }
 static void
-lisp_align_free (POINTER_TYPE *block)
+lisp_align_free (void *block)
 {
  struct ablock *ablock = block;
  struct ablocks *abase = ABLOCK_ABASE (ablock);
@@ -1309,7 +1314,7 @@ emacs_blocked_malloc (size_t size, const void *ptr)
      {
        fprintf (stderr, "Malloc returned %p which is already in use\n",
                 value);
-        fprintf (stderr, "Region in use is %p...%p, %u bytes, type %d\n",
+        fprintf (stderr, "Region in use is %p...%p, %td bytes, type %d\n",
                 m->start, m->end, (char *) m->end - (char *) m->start,
                 m->type);
        abort ();
@@ -3579,8 +3584,6 @@ mem_find (void *start)
 }
-#ifdef NEED_MEM_INSERT
 /* Insert a new node into the tree for a block of memory with start
   address START, end address END, and type TYPE.  Value is a
   pointer to the node that was inserted.  */
@@ -3728,8 +3731,6 @@ mem_insert_fixup (struct mem_node *x)
  mem_root->color = MEM_BLACK;
 }
-#endif /* NEED_MEM_INSERT */
 /*   (x)                   (y)
     / \                   / \
@@ -4297,8 +4298,8 @@ mark_maybe_pointer (void *p)
   wider than a pointer might allocate a Lisp_Object in non-adjacent halves.
   If USE_LSB_TAG, the bottom half is not a valid pointer, but it should
   suffice to widen it to to a Lisp_Object and check it that way.  */
-#if defined USE_LSB_TAG || UINTPTR_MAX >> VALBITS != 0
+#if defined USE_LSB_TAG || VAL_MAX < UINTPTR_MAX
-# if !defined USE_LSB_TAG && UINTPTR_MAX >> VALBITS >> GCTYPEBITS != 0
+# if !defined USE_LSB_TAG && VAL_MAX < UINTPTR_MAX >> GCTYPEBITS
  /* If tag bits straddle pointer-word boundaries, neither mark_maybe_pointer
     nor mark_maybe_object can follow the pointers.  This should not occur on
     any practical porting target.  */
@@ -4722,10 +4723,10 @@ valid_lisp_object_p (Lisp_Object obj)
   pointer to it.  TYPE is the Lisp type for which the memory is
   allocated.  TYPE < 0 means it's not used for a Lisp object.  */
-static POINTER_TYPE *
+static void *
 pure_alloc (size_t size, int type)
 {
-  POINTER_TYPE *result;
+  void *result;
 #ifdef USE_LSB_TAG
  size_t alignment = (1 << GCTYPEBITS);
 #else
@@ -5838,7 +5839,7 @@ mark_buffer (Lisp_Object buf)
 }
 /* Mark the Lisp pointers in the terminal objects.
-   Called by the Fgarbage_collector.  */
+   Called by Fgarbage_collect.  */
 static void
 mark_terminals (void)
diff --git a/src/buffer.c b/src/buffer.c
index d3d5bd268a2..dbaa9f0cc82 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -392,7 +392,6 @@ even if it is dead.  The return value is never nil.  */)
  BVAR (b, mark) = Fmake_marker ();
  BUF_MARKERS (b) = NULL;
-  BVAR (b, name) = name;
  /* Put this in the alist of all live buffers.  */
  XSETBUFFER (buffer, b);
@@ -612,7 +611,6 @@ CLONE nil means the indirect buffer's state is reset to default values.  */)
  Vbuffer_alist = nconc2 (Vbuffer_alist, Fcons (Fcons (name, buf), Qnil));
  BVAR (b, mark) = Fmake_marker ();
-  BVAR (b, name) = name;
  /* The multibyte status belongs to the base buffer.  */
  BVAR (b, enable_multibyte_characters) = BVAR (b->base_buffer, enable_multibyte_characters);
@@ -2052,10 +2050,10 @@ DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
  eassert (current_buffer->text == &current_buffer->own_text);
  eassert (other_buffer->text == &other_buffer->own_text);
 #ifdef REL_ALLOC
-  r_alloc_reset_variable ((POINTER_TYPE **) &current_buffer->own_text.beg,
+  r_alloc_reset_variable ((void **) &current_buffer->own_text.beg,
-                          (POINTER_TYPE **) &other_buffer->own_text.beg);
+                          (void **) &other_buffer->own_text.beg);
-  r_alloc_reset_variable ((POINTER_TYPE **) &other_buffer->own_text.beg,
+  r_alloc_reset_variable ((void **) &other_buffer->own_text.beg,
-                          (POINTER_TYPE **) &current_buffer->own_text.beg);
+                          (void **) &current_buffer->own_text.beg);
 #endif /* REL_ALLOC */
  swapfield (pt, ptrdiff_t);
@@ -4384,7 +4382,7 @@ struct mmap_region
  /* Pointer to the location holding the address of the memory
     allocated with the mmap'd block.  The variable actually points
     after this structure.  */
-  POINTER_TYPE **var;
+  void **var;
  /* Next and previous in list of all mmap'd regions.  */
  struct mmap_region *next, *prev;
@@ -4431,7 +4429,7 @@ static int mmap_initialized_p;
   to the start of the user-visible part of the region.  */
 #define MMAP_USER_AREA(P) \
-     ((POINTER_TYPE *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
+     ((void *) ((char *) (P) + MMAP_REGION_STRUCT_SIZE))
 #define MEM_ALIGN       sizeof (double)
@@ -4480,7 +4478,7 @@ mmap_init (void)
   is at END - 1.  */
 static struct mmap_region *
-mmap_find (POINTER_TYPE *start, POINTER_TYPE *end)
+mmap_find (void *start, void *end)
 {
  struct mmap_region *r;
  char *s = (char *) start, *e = (char *) end;
@@ -4518,7 +4516,7 @@ mmap_free_1 (struct mmap_region *r)
  else
    mmap_regions = r->next;
-  if (munmap ((POINTER_TYPE *) r, r->nbytes_mapped) == -1)
+  if (munmap (r, r->nbytes_mapped) == -1)
    {
      fprintf (stderr, "munmap: %s\n", emacs_strerror (errno));
      return 0;
@@ -4560,13 +4558,13 @@ mmap_enlarge (struct mmap_region *r, int npages)
         I'm not sure this is worth doing, let's see.  */
      if (!MMAP_ALLOCATED_P (region_end, region_end + nbytes))
        {
-          POINTER_TYPE *p;
+          void *p;
          p = mmap (region_end, nbytes, PROT_READ | PROT_WRITE,
                    MAP_ANON | MAP_PRIVATE | MAP_FIXED, mmap_fd, 0);
          if (p == MAP_FAILED)
            ; /* fprintf (stderr, "mmap: %s\n", emacs_strerror (errno)); */
-          else if (p != (POINTER_TYPE *) region_end)
+          else if (p != region_end)
            {
              /* Kernels are free to choose a different address.  In
                 that case, unmap what we've mapped above; we have
@@ -4628,8 +4626,8 @@ mmap_set_vars (int restore_p)
   If we can't allocate the necessary memory, set *VAR to null, and
   return null.  */
-static POINTER_TYPE *
+static void *
-mmap_alloc (POINTER_TYPE **var, size_t nbytes)
+mmap_alloc (void **var, size_t nbytes)
 {
  void *p;
  size_t map;
@@ -4670,7 +4668,7 @@ mmap_alloc (POINTER_TYPE **var, size_t nbytes)
   PTR.  Store 0 in *PTR to show there's no block allocated.  */
 static void
-mmap_free (POINTER_TYPE **var)
+mmap_free (void **var)
 {
  mmap_init ();
@@ -4687,10 +4685,10 @@ mmap_free (POINTER_TYPE **var)
   and return this value.  If more memory cannot be allocated, then
   leave *VAR unchanged, and return null.  */
-static POINTER_TYPE *
+static void *
-mmap_realloc (POINTER_TYPE **var, size_t nbytes)
+mmap_realloc (void **var, size_t nbytes)
 {
-  POINTER_TYPE *result;
+  void *result;
  mmap_init ();
@@ -4709,7 +4707,7 @@ mmap_realloc (POINTER_TYPE **var, size_t nbytes)
      if (room < nbytes)
        {
          /* Must enlarge.  */
-          POINTER_TYPE *old_ptr = *var;
+          void *old_ptr = *var;
          /* Try to map additional pages at the end of the region.
             If that fails, allocate a new region,  copy data
@@ -4771,13 +4769,13 @@ mmap_realloc (POINTER_TYPE **var, size_t nbytes)
 static void
 alloc_buffer_text (struct buffer *b, ptrdiff_t nbytes)
 {
-  POINTER_TYPE *p;
+  void *p;
  BLOCK_INPUT;
 #if defined USE_MMAP_FOR_BUFFERS
-  p = mmap_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+  p = mmap_alloc ((void **) &b->text->beg, nbytes);
 #elif defined REL_ALLOC
-  p = r_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+  p = r_alloc ((void **) &b->text->beg, nbytes);
 #else
  p = xmalloc (nbytes);
 #endif
@@ -4798,14 +4796,14 @@ alloc_buffer_text (struct buffer *b, ptrdiff_t nbytes)
 void
 enlarge_buffer_text (struct buffer *b, ptrdiff_t delta)
 {
-  POINTER_TYPE *p;
+  void *p;
  ptrdiff_t nbytes = (BUF_Z_BYTE (b) - BUF_BEG_BYTE (b) + BUF_GAP_SIZE (b) + 1
                      + delta);
  BLOCK_INPUT;
 #if defined USE_MMAP_FOR_BUFFERS
-  p = mmap_realloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+  p = mmap_realloc ((void **) &b->text->beg, nbytes);
 #elif defined REL_ALLOC
-  p = r_re_alloc ((POINTER_TYPE **) &b->text->beg, nbytes);
+  p = r_re_alloc ((void **) &b->text->beg, nbytes);
 #else
  p = xrealloc (b->text->beg, nbytes);
 #endif
@@ -4829,9 +4827,9 @@ free_buffer_text (struct buffer *b)
  BLOCK_INPUT;
 #if defined USE_MMAP_FOR_BUFFERS
-  mmap_free ((POINTER_TYPE **) &b->text->beg);
+  mmap_free ((void **) &b->text->beg);
 #elif defined REL_ALLOC
-  r_alloc_free ((POINTER_TYPE **) &b->text->beg);
+  r_alloc_free ((void **) &b->text->beg);
 #else
  xfree (b->text->beg);
 #endif
diff --git a/src/character.h b/src/character.h
index 8a0f2d4c3f6..a64b48d896c 100644
--- a/src/character.h
+++ b/src/character.h
@@ -434,7 +434,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
          unsigned char *chp = BYTE_POS_ADDR (BYTEIDX);         \
          int chlen;                                            \
                                                                \
-          OUTPUT= STRING_CHAR_AND_LENGTH (chp, chlen);          \
+          OUTPUT = STRING_CHAR_AND_LENGTH (chp, chlen);         \
          BYTEIDX += chlen;                                     \
        }                                                       \
      else                                                      \
diff --git a/src/data.c b/src/data.c
index 7c0d1830344..11660a2483d 100644
--- a/src/data.c
+++ b/src/data.c
@@ -51,7 +51,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 Lisp_Object Qnil, Qt, Qquote, Qlambda, Qunbound;
 static Lisp_Object Qsubr;
 Lisp_Object Qerror_conditions, Qerror_message, Qtop_level;
-Lisp_Object Qerror, Qquit, Qargs_out_of_range;
+Lisp_Object Qerror, Quser_error, Qquit, Qargs_out_of_range;
 static Lisp_Object Qwrong_type_argument;
 Lisp_Object Qvoid_variable, Qvoid_function;
 static Lisp_Object Qcyclic_function_indirection;
@@ -2938,6 +2938,7 @@ syms_of_data (void)
  DEFSYM (Qtop_level, "top-level");
  DEFSYM (Qerror, "error");
+  DEFSYM (Quser_error, "user-error");
  DEFSYM (Qquit, "quit");
  DEFSYM (Qwrong_type_argument, "wrong-type-argument");
  DEFSYM (Qargs_out_of_range, "args-out-of-range");
@@ -3005,102 +3006,42 @@ syms_of_data (void)
  Fput (Qerror, Qerror_message,
        make_pure_c_string ("error"));
-  Fput (Qquit, Qerror_conditions,
+#define PUT_ERROR(sym, tail, msg)                       \
-        pure_cons (Qquit, Qnil));
+  Fput (sym, Qerror_conditions, pure_cons (sym, tail)); \
-  Fput (Qquit, Qerror_message,
+  Fput (sym, Qerror_message, make_pure_c_string (msg))
-        make_pure_c_string ("Quit"));
+  PUT_ERROR (Qquit, Qnil, "Quit");
-  Fput (Qwrong_type_argument, Qerror_conditions,
-        pure_cons (Qwrong_type_argument, error_tail));
+  PUT_ERROR (Quser_error, error_tail, "");
-  Fput (Qwrong_type_argument, Qerror_message,
+  PUT_ERROR (Qwrong_type_argument, error_tail, "Wrong type argument");
-        make_pure_c_string ("Wrong type argument"));
+  PUT_ERROR (Qargs_out_of_range, error_tail, "Args out of range");
+  PUT_ERROR (Qvoid_function, error_tail,
-  Fput (Qargs_out_of_range, Qerror_conditions,
+             "Symbol's function definition is void");
-        pure_cons (Qargs_out_of_range, error_tail));
+  PUT_ERROR (Qcyclic_function_indirection, error_tail,
-  Fput (Qargs_out_of_range, Qerror_message,
+             "Symbol's chain of function indirections contains a loop");
-        make_pure_c_string ("Args out of range"));
+  PUT_ERROR (Qcyclic_variable_indirection, error_tail,
+             "Symbol's chain of variable indirections contains a loop");
-  Fput (Qvoid_function, Qerror_conditions,
-        pure_cons (Qvoid_function, error_tail));
-  Fput (Qvoid_function, Qerror_message,
-        make_pure_c_string ("Symbol's function definition is void"));
-  Fput (Qcyclic_function_indirection, Qerror_conditions,
-        pure_cons (Qcyclic_function_indirection, error_tail));
-  Fput (Qcyclic_function_indirection, Qerror_message,
-        make_pure_c_string ("Symbol's chain of function indirections contains a loop"));
-  Fput (Qcyclic_variable_indirection, Qerror_conditions,
-        pure_cons (Qcyclic_variable_indirection, error_tail));
-  Fput (Qcyclic_variable_indirection, Qerror_message,
-        make_pure_c_string ("Symbol's chain of variable indirections contains a loop"));
  DEFSYM (Qcircular_list, "circular-list");
-  Fput (Qcircular_list, Qerror_conditions,
+  PUT_ERROR (Qcircular_list, error_tail, "List contains a loop");
-        pure_cons (Qcircular_list, error_tail));
+  PUT_ERROR (Qvoid_variable, error_tail, "Symbol's value as variable is void");
-  Fput (Qcircular_list, Qerror_message,
+  PUT_ERROR (Qsetting_constant, error_tail,
-        make_pure_c_string ("List contains a loop"));
+             "Attempt to set a constant symbol");
+  PUT_ERROR (Qinvalid_read_syntax, error_tail, "Invalid read syntax");
-  Fput (Qvoid_variable, Qerror_conditions,
+  PUT_ERROR (Qinvalid_function, error_tail, "Invalid function");
-        pure_cons (Qvoid_variable, error_tail));
+  PUT_ERROR (Qwrong_number_of_arguments, error_tail,
-  Fput (Qvoid_variable, Qerror_message,
+             "Wrong number of arguments");
-        make_pure_c_string ("Symbol's value as variable is void"));
+  PUT_ERROR (Qno_catch, error_tail, "No catch for tag");
+  PUT_ERROR (Qend_of_file, error_tail, "End of file during parsing");
-  Fput (Qsetting_constant, Qerror_conditions,
-        pure_cons (Qsetting_constant, error_tail));
-  Fput (Qsetting_constant, Qerror_message,
-        make_pure_c_string ("Attempt to set a constant symbol"));
-  Fput (Qinvalid_read_syntax, Qerror_conditions,
-        pure_cons (Qinvalid_read_syntax, error_tail));
-  Fput (Qinvalid_read_syntax, Qerror_message,
-        make_pure_c_string ("Invalid read syntax"));
-  Fput (Qinvalid_function, Qerror_conditions,
-        pure_cons (Qinvalid_function, error_tail));
-  Fput (Qinvalid_function, Qerror_message,
-        make_pure_c_string ("Invalid function"));
-  Fput (Qwrong_number_of_arguments, Qerror_conditions,
-        pure_cons (Qwrong_number_of_arguments, error_tail));
-  Fput (Qwrong_number_of_arguments, Qerror_message,
-        make_pure_c_string ("Wrong number of arguments"));
-  Fput (Qno_catch, Qerror_conditions,
-        pure_cons (Qno_catch, error_tail));
-  Fput (Qno_catch, Qerror_message,
-        make_pure_c_string ("No catch for tag"));
-  Fput (Qend_of_file, Qerror_conditions,
-        pure_cons (Qend_of_file, error_tail));
-  Fput (Qend_of_file, Qerror_message,
-        make_pure_c_string ("End of file during parsing"));
  arith_tail = pure_cons (Qarith_error, error_tail);
-  Fput (Qarith_error, Qerror_conditions,
+  Fput (Qarith_error, Qerror_conditions, arith_tail);
-        arith_tail);
+  Fput (Qarith_error, Qerror_message, make_pure_c_string ("Arithmetic error"));
-  Fput (Qarith_error, Qerror_message,
-        make_pure_c_string ("Arithmetic error"));
+  PUT_ERROR (Qbeginning_of_buffer, error_tail, "Beginning of buffer");
+  PUT_ERROR (Qend_of_buffer, error_tail, "End of buffer");
-  Fput (Qbeginning_of_buffer, Qerror_conditions,
+  PUT_ERROR (Qbuffer_read_only, error_tail, "Buffer is read-only");
-        pure_cons (Qbeginning_of_buffer, error_tail));
+  PUT_ERROR (Qtext_read_only, pure_cons (Qbuffer_read_only, error_tail),
-  Fput (Qbeginning_of_buffer, Qerror_message,
+             "Text is read-only");
-        make_pure_c_string ("Beginning of buffer"));
-  Fput (Qend_of_buffer, Qerror_conditions,
-        pure_cons (Qend_of_buffer, error_tail));
-  Fput (Qend_of_buffer, Qerror_message,
-        make_pure_c_string ("End of buffer"));
-  Fput (Qbuffer_read_only, Qerror_conditions,
-        pure_cons (Qbuffer_read_only, error_tail));
-  Fput (Qbuffer_read_only, Qerror_message,
-        make_pure_c_string ("Buffer is read-only"));
-  Fput (Qtext_read_only, Qerror_conditions,
-        pure_cons (Qtext_read_only, error_tail));
-  Fput (Qtext_read_only, Qerror_message,
-        make_pure_c_string ("Text is read-only"));
  DEFSYM (Qrange_error, "range-error");
  DEFSYM (Qdomain_error, "domain-error");
@@ -3108,30 +3049,17 @@ syms_of_data (void)
  DEFSYM (Qoverflow_error, "overflow-error");
  DEFSYM (Qunderflow_error, "underflow-error");
-  Fput (Qdomain_error, Qerror_conditions,
+  PUT_ERROR (Qdomain_error, arith_tail, "Arithmetic domain error");
-        pure_cons (Qdomain_error, arith_tail));
-  Fput (Qdomain_error, Qerror_message,
+  PUT_ERROR (Qrange_error, arith_tail, "Arithmetic range error");
-        make_pure_c_string ("Arithmetic domain error"));
+  PUT_ERROR (Qsingularity_error, Fcons (Qdomain_error, arith_tail),
-  Fput (Qrange_error, Qerror_conditions,
+             "Arithmetic singularity error");
-        pure_cons (Qrange_error, arith_tail));
-  Fput (Qrange_error, Qerror_message,
+  PUT_ERROR (Qoverflow_error, Fcons (Qdomain_error, arith_tail),
-        make_pure_c_string ("Arithmetic range error"));
+             "Arithmetic overflow error");
+  PUT_ERROR (Qunderflow_error, Fcons (Qdomain_error, arith_tail),
-  Fput (Qsingularity_error, Qerror_conditions,
+             "Arithmetic underflow error");
-        pure_cons (Qsingularity_error, Fcons (Qdomain_error, arith_tail)));
-  Fput (Qsingularity_error, Qerror_message,
-        make_pure_c_string ("Arithmetic singularity error"));
-  Fput (Qoverflow_error, Qerror_conditions,
-        pure_cons (Qoverflow_error, Fcons (Qdomain_error, arith_tail)));
-  Fput (Qoverflow_error, Qerror_message,
-        make_pure_c_string ("Arithmetic overflow error"));
-  Fput (Qunderflow_error, Qerror_conditions,
-        pure_cons (Qunderflow_error, Fcons (Qdomain_error, arith_tail)));
-  Fput (Qunderflow_error, Qerror_message,
-        make_pure_c_string ("Arithmetic underflow error"));
  staticpro (&Qnil);
  staticpro (&Qt);
diff --git a/src/dbusbind.c b/src/dbusbind.c
index c4e57dad98a..2ed7369c9dc 100644
--- a/src/dbusbind.c
+++ b/src/dbusbind.c
@@ -28,19 +28,15 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "keyboard.h"
 #include "process.h"
+#ifndef DBUS_NUM_MESSAGE_TYPES
+#define DBUS_NUM_MESSAGE_TYPES 5
+#endif
 /* Subroutines.  */
 static Lisp_Object Qdbus_init_bus;
-static Lisp_Object Qdbus_close_bus;
 static Lisp_Object Qdbus_get_unique_name;
-static Lisp_Object Qdbus_call_method;
+static Lisp_Object Qdbus_message_internal;
-static Lisp_Object Qdbus_call_method_asynchronously;
-static Lisp_Object Qdbus_method_return_internal;
-static Lisp_Object Qdbus_method_error_internal;
-static Lisp_Object Qdbus_send_signal;
-static Lisp_Object Qdbus_register_service;
-static Lisp_Object Qdbus_register_signal;
-static Lisp_Object Qdbus_register_method;
 /* D-Bus error symbol.  */
 static Lisp_Object Qdbus_error;
@@ -51,17 +47,6 @@ static Lisp_Object QCdbus_system_bus, QCdbus_session_bus;
 /* Lisp symbol for method call timeout.  */
 static Lisp_Object QCdbus_timeout;
-/* Lisp symbols for name request flags.  */
-static Lisp_Object QCdbus_request_name_allow_replacement;
-static Lisp_Object QCdbus_request_name_replace_existing;
-static Lisp_Object QCdbus_request_name_do_not_queue;
-/* Lisp symbols for name request replies.  */
-static Lisp_Object QCdbus_request_name_reply_primary_owner;
-static Lisp_Object QCdbus_request_name_reply_in_queue;
-static Lisp_Object QCdbus_request_name_reply_exists;
-static Lisp_Object QCdbus_request_name_reply_already_owner;
 /* Lisp symbols of D-Bus types.  */
 static Lisp_Object QCdbus_type_byte, QCdbus_type_boolean;
 static Lisp_Object QCdbus_type_int16, QCdbus_type_uint16;
@@ -75,6 +60,15 @@ static Lisp_Object QCdbus_type_unix_fd;
 static Lisp_Object QCdbus_type_array, QCdbus_type_variant;
 static Lisp_Object QCdbus_type_struct, QCdbus_type_dict_entry;
+/* Lisp symbols of objects in `dbus-registered-objects-table'.  */
+static Lisp_Object QCdbus_registered_serial, QCdbus_registered_method;
+static Lisp_Object QCdbus_registered_signal;
+/* Alist of D-Bus buses we are polling for messages.
+   The key is the symbol or string of the bus, and the value is the
+   connection address.  */
+static Lisp_Object xd_registered_buses;
 /* Whether we are reading a D-Bus event.  */
 static int xd_in_read_queued_messages = 0;
@@ -120,14 +114,15 @@ static int xd_in_read_queued_messages = 0;
  } while (0)
 /* Macros for debugging.  In order to enable them, build with
-   "MYCPPFLAGS='-DDBUS_DEBUG -Wall' make".  */
+   "env MYCPPFLAGS='-DDBUS_DEBUG -Wall' make".  */
 #ifdef DBUS_DEBUG
-#define XD_DEBUG_MESSAGE(...)           \
+#define XD_DEBUG_MESSAGE(...)                                           \
-  do {                                  \
+  do {                                                                  \
-    char s[1024];                       \
+    char s[1024];                                                       \
-    snprintf (s, sizeof s, __VA_ARGS__); \
+    snprintf (s, sizeof s, __VA_ARGS__);                                \
-    printf ("%s: %s\n", __func__, s);   \
+    if (!noninteractive)                                                \
-    message ("%s: %s", __func__, s);    \
+      printf ("%s: %s\n", __func__, s);                                 \
+    message ("%s: %s", __func__, s);                                    \
  } while (0)
 #define XD_DEBUG_VALID_LISP_OBJECT_P(object)                            \
  do {                                                                  \
@@ -144,7 +139,7 @@ static int xd_in_read_queued_messages = 0;
    if (!NILP (Vdbus_debug))                                            \
      {                                                                 \
        char s[1024];                                                   \
-        snprintf (s, 1023, __VA_ARGS__);                                \
+        snprintf (s, sizeof s, __VA_ARGS__);                            \
        message ("%s: %s", __func__, s);                                \
      }                                                                 \
  } while (0)
@@ -241,23 +236,115 @@ xd_symbol_to_dbus_type (Lisp_Object object)
 #define XD_NEXT_VALUE(object)                                           \
  ((XD_DBUS_TYPE_P (CAR_SAFE (object))) ? CDR_SAFE (object) : object)
+/* Transform the message type to its string representation for debug
+   messages.  */
+#define XD_MESSAGE_TYPE_TO_STRING(mtype)                                \
+  ((mtype == DBUS_MESSAGE_TYPE_INVALID)                                 \
+  ? "DBUS_MESSAGE_TYPE_INVALID"                                         \
+  : (mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)                            \
+  ? "DBUS_MESSAGE_TYPE_METHOD_CALL"                                     \
+  : (mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)                          \
+  ? "DBUS_MESSAGE_TYPE_METHOD_RETURN"                                   \
+  : (mtype == DBUS_MESSAGE_TYPE_ERROR)                                  \
+   ? "DBUS_MESSAGE_TYPE_ERROR"                                          \
+   : "DBUS_MESSAGE_TYPE_SIGNAL")
+/* Transform the object to its string representation for debug
+   messages.  */
+#define XD_OBJECT_TO_STRING(object)                                     \
+  SDATA (format2 ("%s", object, Qnil))
 /* Check whether X is a valid dbus serial number.  If valid, set
   SERIAL to its value.  Otherwise, signal an error. */
-#define CHECK_DBUS_SERIAL_GET_SERIAL(x, serial)                         \
+#define XD_CHECK_DBUS_SERIAL(x, serial)                                 \
-  do                                                                    \
+  do {                                                                  \
-    {                                                                   \
+    dbus_uint32_t DBUS_SERIAL_MAX = -1;                                 \
-      dbus_uint32_t DBUS_SERIAL_MAX = -1;                               \
+    if (NATNUMP (x) && XINT (x) <= DBUS_SERIAL_MAX)                     \
-      if (NATNUMP (x) && XINT (x) <= DBUS_SERIAL_MAX)                   \
+      serial = XINT (x);                                                \
-        serial = XINT (x);                                              \
+    else if (MOST_POSITIVE_FIXNUM < DBUS_SERIAL_MAX                     \
-      else if (MOST_POSITIVE_FIXNUM < DBUS_SERIAL_MAX                   \
+             && FLOATP (x)                                              \
-               && FLOATP (x)                                            \
+             && 0 <= XFLOAT_DATA (x)                                    \
-               && 0 <= XFLOAT_DATA (x)                                  \
+             && XFLOAT_DATA (x) <= DBUS_SERIAL_MAX)                     \
-               && XFLOAT_DATA (x) <= DBUS_SERIAL_MAX)                   \
+      serial = XFLOAT_DATA (x);                                         \
-        serial = XFLOAT_DATA (x);                                       \
+    else                                                                \
-      else                                                              \
+      XD_SIGNAL2 (build_string ("Invalid dbus serial"), x);             \
-        XD_SIGNAL2 (build_string ("Invalid dbus serial"), x);           \
+  } while (0)
-    }                                                                   \
-  while (0)
+#define XD_DBUS_VALIDATE_BUS_ADDRESS(bus)                               \
+  do {                                                                  \
+    if (STRINGP (bus))                                                  \
+      {                                                                 \
+        DBusAddressEntry **entries;                                     \
+        int len;                                                        \
+        DBusError derror;                                               \
+        dbus_error_init (&derror);                                      \
+        if (!dbus_parse_address (SSDATA (bus), &entries, &len, &derror)) \
+          XD_ERROR (derror);                                            \
+        /* Cleanup.  */                                                 \
+        dbus_error_free (&derror);                                      \
+        dbus_address_entries_free (entries);                            \
+      }                                                                 \
+                                                                        \
+    else                                                                \
+      {                                                                 \
+        CHECK_SYMBOL (bus);                                             \
+        if (!(EQ (bus, QCdbus_system_bus) || EQ (bus, QCdbus_session_bus))) \
+          XD_SIGNAL2 (build_string ("Wrong bus name"), bus);            \
+        /* We do not want to have an autolaunch for the session bus.  */ \
+        if (EQ (bus, QCdbus_session_bus)                                \
+            && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL)             \
+          XD_SIGNAL2 (build_string ("No connection to bus"), bus);      \
+      }                                                                 \
+  } while (0)
+#if (HAVE_DBUS_VALIDATE_BUS_NAME || HAVE_DBUS_VALIDATE_PATH \
+     || XD_DBUS_VALIDATE_OBJECT || HAVE_DBUS_VALIDATE_MEMBER)
+#define XD_DBUS_VALIDATE_OBJECT(object, func)                           \
+  do {                                                                  \
+    if (!NILP (object))                                                 \
+      {                                                                 \
+        DBusError derror;                                               \
+        CHECK_STRING (object);                                          \
+        dbus_error_init (&derror);                                      \
+        if (!func (SSDATA (object), &derror))                           \
+          XD_ERROR (derror);                                            \
+        /* Cleanup.  */                                                 \
+        dbus_error_free (&derror);                                      \
+      }                                                                 \
+  } while (0)
+#endif
+#if HAVE_DBUS_VALIDATE_BUS_NAME
+#define XD_DBUS_VALIDATE_BUS_NAME(bus_name)                             \
+  XD_DBUS_VALIDATE_OBJECT(bus_name, dbus_validate_bus_name);
+#else
+#define XD_DBUS_VALIDATE_BUS_NAME(bus_name)                             \
+  if (!NILP (bus_name)) CHECK_STRING (bus_name);
+#endif
+#if HAVE_DBUS_VALIDATE_PATH
+#define XD_DBUS_VALIDATE_PATH(path)                                     \
+  XD_DBUS_VALIDATE_OBJECT(path, dbus_validate_path);
+#else
+#define XD_DBUS_VALIDATE_PATH(path)                                     \
+  if (!NILP (path)) CHECK_STRING (path);
+#endif
+#if HAVE_DBUS_VALIDATE_INTERFACE
+#define XD_DBUS_VALIDATE_INTERFACE(interface)                           \
+  XD_DBUS_VALIDATE_OBJECT(interface, dbus_validate_interface);
+#else
+#define XD_DBUS_VALIDATE_INTERFACE(interface)                           \
+  if (!NILP (interface)) CHECK_STRING (interface);
+#endif
+#if HAVE_DBUS_VALIDATE_MEMBER
+#define XD_DBUS_VALIDATE_MEMBER(member)                                 \
+  XD_DBUS_VALIDATE_OBJECT(member, dbus_validate_member);
+#else
+#define XD_DBUS_VALIDATE_MEMBER(member)                                 \
+  if (!NILP (member)) CHECK_STRING (member);
+#endif
 /* Append to SIGNATURE a copy of X, making sure SIGNATURE does
   not become too long.  */
@@ -293,11 +380,6 @@ xd_signature (char *signature, unsigned int dtype, unsigned int parent_type, Lis
    {
    case DBUS_TYPE_BYTE:
    case DBUS_TYPE_UINT16:
-    case DBUS_TYPE_UINT32:
-    case DBUS_TYPE_UINT64:
-#ifdef DBUS_TYPE_UNIX_FD
-    case DBUS_TYPE_UNIX_FD:
-#endif
      CHECK_NATNUM (object);
      sprintf (signature, "%c", dtype);
      break;
@@ -309,14 +391,19 @@ xd_signature (char *signature, unsigned int dtype, unsigned int parent_type, Lis
      break;
    case DBUS_TYPE_INT16:
-    case DBUS_TYPE_INT32:
-    case DBUS_TYPE_INT64:
      CHECK_NUMBER (object);
      sprintf (signature, "%c", dtype);
      break;
+    case DBUS_TYPE_UINT32:
+    case DBUS_TYPE_UINT64:
+#ifdef DBUS_TYPE_UNIX_FD
+    case DBUS_TYPE_UNIX_FD:
+#endif
+    case DBUS_TYPE_INT32:
+    case DBUS_TYPE_INT64:
    case DBUS_TYPE_DOUBLE:
-      CHECK_FLOAT (object);
+      CHECK_NUMBER_OR_FLOAT (object);
      sprintf (signature, "%c", dtype);
      break;
@@ -352,8 +439,8 @@ xd_signature (char *signature, unsigned int dtype, unsigned int parent_type, Lis
        }
      /* If the element type is DBUS_TYPE_SIGNATURE, and this is the
-         only element, the value of this element is used as he array's
+         only element, the value of this element is used as the
-         element signature.  */
+         array's element signature.  */
      if ((subtype == DBUS_TYPE_SIGNATURE)
          && STRINGP (CAR_SAFE (XD_NEXT_VALUE (elt)))
          && NILP (CDR_SAFE (XD_NEXT_VALUE (elt))))
@@ -451,6 +538,54 @@ xd_signature (char *signature, unsigned int dtype, unsigned int parent_type, Lis
  XD_DEBUG_MESSAGE ("%s", signature);
 }
+/* Convert X to a signed integer with bounds LO and HI.  */
+static intmax_t
+extract_signed (Lisp_Object x, intmax_t lo, intmax_t hi)
+{
+  CHECK_NUMBER_OR_FLOAT (x);
+  if (INTEGERP (x))
+    {
+      if (lo <= XINT (x) && XINT (x) <= hi)
+        return XINT (x);
+    }
+  else
+    {
+      double d = XFLOAT_DATA (x);
+      if (lo <= d && d <= hi)
+        {
+          intmax_t n = d;
+          if (n == d)
+            return n;
+        }
+    }
+  args_out_of_range_3 (x,
+                       make_fixnum_or_float (lo),
+                       make_fixnum_or_float (hi));
+}
+/* Convert X to an unsigned integer with bounds 0 and HI.  */
+static uintmax_t
+extract_unsigned (Lisp_Object x, uintmax_t hi)
+{
+  CHECK_NUMBER_OR_FLOAT (x);
+  if (INTEGERP (x))
+    {
+      if (0 <= XINT (x) && XINT (x) <= hi)
+        return XINT (x);
+    }
+  else
+    {
+      double d = XFLOAT_DATA (x);
+      if (0 <= d && d <= hi)
+        {
+          uintmax_t n = d;
+          if (n == d)
+            return n;
+        }
+    }
+  args_out_of_range_2 (x, make_fixnum_or_float (hi));
+}
 /* Append C value, extracted from Lisp OBJECT, to iteration ITER.
   DTYPE must be a valid DBusType.  It is used to convert Lisp
   objects, being arguments of `dbus-call-method' or
@@ -469,7 +604,7 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
        CHECK_NATNUM (object);
        {
          unsigned char val = XFASTINT (object) & 0xFF;
-          XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+          XD_DEBUG_MESSAGE ("%c %u", dtype, val);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
@@ -488,7 +623,8 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
        CHECK_TYPE_RANGED_INTEGER (dbus_int16_t, object);
        {
          dbus_int16_t val = XINT (object);
-          XD_DEBUG_MESSAGE ("%c %d", dtype, (int) val);
+          int pval = val;
+          XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
@@ -498,17 +634,20 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
        CHECK_TYPE_RANGED_INTEGER (dbus_uint16_t, object);
        {
          dbus_uint16_t val = XFASTINT (object);
-          XD_DEBUG_MESSAGE ("%c %u", dtype, (unsigned int) val);
+          unsigned int pval = val;
+          XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
        }
      case DBUS_TYPE_INT32:
-        CHECK_TYPE_RANGED_INTEGER (dbus_int32_t, object);
        {
-          dbus_int32_t val = XINT (object);
+          dbus_int32_t val = extract_signed (object,
-          XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+                                             TYPE_MINIMUM (dbus_int32_t),
+                                             TYPE_MAXIMUM (dbus_int32_t));
+          int pval = val;
+          XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
@@ -518,39 +657,43 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
 #ifdef DBUS_TYPE_UNIX_FD
      case DBUS_TYPE_UNIX_FD:
 #endif
-        CHECK_TYPE_RANGED_INTEGER (dbus_uint32_t, object);
        {
-          dbus_uint32_t val = XFASTINT (object);
+          dbus_uint32_t val = extract_unsigned (object,
-          XD_DEBUG_MESSAGE ("%c %u", dtype, val);
+                                                TYPE_MAXIMUM (dbus_uint32_t));
+          unsigned int pval = val;
+          XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
        }
      case DBUS_TYPE_INT64:
-        CHECK_NUMBER (object);
+        CHECK_TYPE_RANGED_INTEGER_OR_FLOAT (dbus_int64_t, object);
        {
-          dbus_int64_t val = XINT (object);
+          dbus_int64_t val = extract_signed (object,
-          XD_DEBUG_MESSAGE ("%c %d", dtype, (int) val);
+                                             TYPE_MINIMUM (dbus_int64_t),
+                                             TYPE_MAXIMUM (dbus_int64_t));
+          printmax_t pval = val;
+          XD_DEBUG_MESSAGE ("%c %"pMd, dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
        }
      case DBUS_TYPE_UINT64:
-        CHECK_TYPE_RANGED_INTEGER (dbus_uint64_t, object);
        {
-          dbus_uint64_t val = XFASTINT (object);
+          dbus_uint64_t val = extract_unsigned (object,
-          XD_DEBUG_MESSAGE ("%c %"pI"d", dtype, XFASTINT (object));
+                                                TYPE_MAXIMUM (dbus_uint64_t));
+          uprintmax_t pval = val;
+          XD_DEBUG_MESSAGE ("%c %"pMu, dtype, pval);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
          return;
        }
      case DBUS_TYPE_DOUBLE:
-        CHECK_FLOAT (object);
        {
-          double val = XFLOAT_DATA (object);
+          double val = extract_float (object);
          XD_DEBUG_MESSAGE ("%c %f", dtype, val);
          if (!dbus_message_iter_append_basic (iter, dtype, &val))
            XD_SIGNAL2 (build_string ("Unable to append argument"), object);
@@ -614,7 +757,7 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
                            dtype, CAR_SAFE (XD_NEXT_VALUE (object)));
          XD_DEBUG_MESSAGE ("%c %s %s", dtype, signature,
-                            SDATA (format2 ("%s", object, Qnil)));
+                            XD_OBJECT_TO_STRING (object));
          if (!dbus_message_iter_open_container (iter, dtype,
                                                 signature, &subiter))
            XD_SIGNAL3 (build_string ("Cannot open container"),
@@ -627,7 +770,7 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
                        dtype, CAR_SAFE (XD_NEXT_VALUE (object)));
          XD_DEBUG_MESSAGE ("%c %s %s", dtype, signature,
-                            SDATA (format2 ("%s", object, Qnil)));
+                            XD_OBJECT_TO_STRING (object));
          if (!dbus_message_iter_open_container (iter, dtype,
                                                 signature, &subiter))
            XD_SIGNAL3 (build_string ("Cannot open container"),
@@ -637,8 +780,7 @@ xd_append_arg (unsigned int dtype, Lisp_Object object, DBusMessageIter *iter)
        case DBUS_TYPE_STRUCT:
        case DBUS_TYPE_DICT_ENTRY:
          /* These containers do not require a signature.  */
-          XD_DEBUG_MESSAGE ("%c %s", dtype,
+          XD_DEBUG_MESSAGE ("%c %s", dtype, XD_OBJECT_TO_STRING (object));
-                            SDATA (format2 ("%s", object, Qnil)));
          if (!dbus_message_iter_open_container (iter, dtype, NULL, &subiter))
            XD_SIGNAL2 (build_string ("Cannot open container"),
                        make_number (dtype));
@@ -678,7 +820,7 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
        unsigned int val;
        dbus_message_iter_get_basic (iter, &val);
        val = val & 0xFF;
-        XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+        XD_DEBUG_MESSAGE ("%c %u", dtype, val);
        return make_number (val);
      }
@@ -693,24 +835,30 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
    case DBUS_TYPE_INT16:
      {
        dbus_int16_t val;
+        int pval;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
        return make_number (val);
      }
    case DBUS_TYPE_UINT16:
      {
        dbus_uint16_t val;
+        int pval;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
        return make_number (val);
      }
    case DBUS_TYPE_INT32:
      {
        dbus_int32_t val;
+        int pval;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %d", dtype, pval);
        return make_fixnum_or_float (val);
      }
@@ -720,24 +868,30 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
 #endif
      {
        dbus_uint32_t val;
+        unsigned int pval = val;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %u", dtype, pval);
        return make_fixnum_or_float (val);
      }
    case DBUS_TYPE_INT64:
      {
        dbus_int64_t val;
+        printmax_t pval;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, (int) val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %"pMd, dtype, pval);
        return make_fixnum_or_float (val);
      }
    case DBUS_TYPE_UINT64:
      {
        dbus_uint64_t val;
+        uprintmax_t pval;
        dbus_message_iter_get_basic (iter, &val);
-        XD_DEBUG_MESSAGE ("%c %d", dtype, (int) val);
+        pval = val;
+        XD_DEBUG_MESSAGE ("%c %"pMd, dtype, pval);
        return make_fixnum_or_float (val);
      }
@@ -777,7 +931,7 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
            result = Fcons (xd_retrieve_arg (subtype, &subiter), result);
            dbus_message_iter_next (&subiter);
          }
-        XD_DEBUG_MESSAGE ("%c %s", dtype, SDATA (format2 ("%s", result, Qnil)));
+        XD_DEBUG_MESSAGE ("%c %s", dtype, XD_OBJECT_TO_STRING (result));
        RETURN_UNGCPRO (Fnreverse (result));
      }
@@ -787,85 +941,37 @@ xd_retrieve_arg (unsigned int dtype, DBusMessageIter *iter)
    }
 }
-/* Initialize D-Bus connection.  BUS is either a Lisp symbol, :system
+/* Return the number of references of the shared CONNECTION.  */
-   or :session, or a string denoting the bus address.  It tells which
+static int
-   D-Bus to initialize.  If RAISE_ERROR is non-zero, signal an error
+xd_get_connection_references (DBusConnection *connection)
-   when the connection cannot be initialized.  */
+{
+  ptrdiff_t *refcount;
+  /* We cannot access the DBusConnection structure, it is not public.
+     But we know, that the reference counter is the first field in
+     that structure.  */
+  refcount = (void *) &connection;
+  refcount =  (void *) *refcount;
+  return *refcount;
+}
+/* Return D-Bus connection address.  BUS is either a Lisp symbol,
+   :system or :session, or a string denoting the bus address.  */
 static DBusConnection *
-xd_initialize (Lisp_Object bus, int raise_error)
+xd_get_connection_address (Lisp_Object bus)
 {
  DBusConnection *connection;
-  DBusError derror;
+  Lisp_Object val;
-  /* Parameter check.  */
-  if (!STRINGP (bus))
-    {
-      CHECK_SYMBOL (bus);
-      if (!(EQ (bus, QCdbus_system_bus) || EQ (bus, QCdbus_session_bus)))
-        {
-          if (raise_error)
-            XD_SIGNAL2 (build_string ("Wrong bus name"), bus);
-          else
-            return NULL;
-        }
-      /* We do not want to have an autolaunch for the session bus.  */
+  val = CDR_SAFE (Fassoc (bus, xd_registered_buses));
-      if (EQ (bus, QCdbus_session_bus)
+  if (NILP (val))
-          && getenv ("DBUS_SESSION_BUS_ADDRESS") == NULL)
+    XD_SIGNAL2 (build_string ("No connection to bus"), bus);
-        {
-          if (raise_error)
-            XD_SIGNAL2 (build_string ("No connection to bus"), bus);
-          else
-            return NULL;
-        }
-    }
-  /* Open a connection to the bus.  */
-  dbus_error_init (&derror);
-  if (STRINGP (bus))
-      connection = dbus_connection_open (SSDATA (bus), &derror);
  else
-    if (EQ (bus, QCdbus_system_bus))
+    connection = (DBusConnection *) (intptr_t) XFASTINT (val);
-      connection = dbus_bus_get (DBUS_BUS_SYSTEM, &derror);
-    else
-      connection = dbus_bus_get (DBUS_BUS_SESSION, &derror);
-  if (dbus_error_is_set (&derror))
-    {
-      if (raise_error)
-        XD_ERROR (derror);
-      else
-        connection = NULL;
-    }
-  /* If it is not the system or session bus, we must register
+  if (!dbus_connection_get_is_connected (connection))
-     ourselves.  Otherwise, we have called dbus_bus_get, which has
-     configured us to exit if the connection closes - we undo this
-     setting.  */
-  if (connection != NULL)
-    {
-      if (STRINGP (bus))
-        dbus_bus_register (connection, &derror);
-      else
-        dbus_connection_set_exit_on_disconnect (connection, FALSE);
-    }
-  if (dbus_error_is_set (&derror))
-    {
-      if (raise_error)
-        XD_ERROR (derror);
-      else
-        connection = NULL;
-    }
-  if (connection == NULL && raise_error)
    XD_SIGNAL2 (build_string ("No connection to bus"), bus);
-  /* Cleanup.  */
-  dbus_error_free (&derror);
-  /* Return the result.  */
  return connection;
 }
@@ -896,8 +1002,8 @@ xd_add_watch (DBusWatch *watch, void *data)
  int fd = xd_find_watch_fd (watch);
  XD_DEBUG_MESSAGE ("fd %d, write %d, enabled %d",
-                    fd, flags & DBUS_WATCH_WRITABLE,
+                    fd, flags & DBUS_WATCH_WRITABLE,
-                    dbus_watch_get_enabled (watch));
+                    dbus_watch_get_enabled (watch));
  if (fd == -1)
    return FALSE;
@@ -929,8 +1035,8 @@ xd_remove_watch (DBusWatch *watch, void *data)
  /* Unset session environment.  */
  if (XSYMBOL (QCdbus_session_bus) == data)
    {
-      XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
+      //      XD_DEBUG_MESSAGE ("unsetenv DBUS_SESSION_BUS_ADDRESS");
-      unsetenv ("DBUS_SESSION_BUS_ADDRESS");
+      //      unsetenv ("DBUS_SESSION_BUS_ADDRESS");
    }
  if (flags & DBUS_WATCH_WRITABLE)
@@ -949,23 +1055,111 @@ xd_toggle_watch (DBusWatch *watch, void *data)
    xd_remove_watch (watch, data);
 }
-DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
+/* Close connection to D-Bus BUS.  */
-       doc: /* Initialize connection to D-Bus BUS.  */)
+static void
-  (Lisp_Object bus)
+xd_close_bus (Lisp_Object bus)
+{
+  DBusConnection *connection;
+  Lisp_Object val;
+  /* Check whether we are connected.  */
+  val = Fassoc (bus, xd_registered_buses);
+  if (NILP (val))
+    return;
+  /* Retrieve bus address.  */
+  connection = xd_get_connection_address (bus);
+  /* Close connection, if there isn't another shared application.  */
+  if (xd_get_connection_references (connection) == 1)
+    {
+      XD_DEBUG_MESSAGE ("Close connection to bus %s",
+                        XD_OBJECT_TO_STRING (bus));
+      dbus_connection_close (connection);
+    }
+  /* Decrement reference count.  */
+  dbus_connection_unref (connection);
+  /* Remove bus from list of registered buses.  */
+  xd_registered_buses = Fdelete (val, xd_registered_buses);
+  /* Return.  */
+  return;
+}
+DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 2, 0,
+       doc: /* Establish the connection to D-Bus BUS.
+BUS can be either the symbol `:system' or the symbol `:session', or it
+can be a string denoting the address of the corresponding bus.  For
+the system and session buses, this function is called when loading
+`dbus.el', there is no need to call it again.
+The function returns a number, which counts the connections this Emacs
+session has established to the BUS under the same unique name (see
+`dbus-get-unique-name').  It depends on the libraries Emacs is linked
+with, and on the environment Emacs is running.  For example, if Emacs
+is linked with the gtk toolkit, and it runs in a GTK-aware environment
+like Gnome, another connection might already be established.
+When PRIVATE is non-nil, a new connection is established instead of
+reusing an existing one.  It results in a new unique name at the bus.
+This can be used, if it is necessary to distinguish from another
+connection used in the same Emacs process, like the one established by
+GTK+.  It should be used with care for at least the `:system' and
+`:session' buses, because other Emacs Lisp packages might already use
+this connection to those buses.  */)
+  (Lisp_Object bus, Lisp_Object private)
 {
  DBusConnection *connection;
-  void *busp;
+  DBusError derror;
+  Lisp_Object val;
+  int refcount;
  /* Check parameter.  */
-  if (SYMBOLP (bus))
+  XD_DBUS_VALIDATE_BUS_ADDRESS (bus);
-    busp = XSYMBOL (bus);
-  else if (STRINGP (bus))
+  /* Close bus if it is already open.  */
-    busp = XSTRING (bus);
+  xd_close_bus (bus);
+  /* Initialize.  */
+  dbus_error_init (&derror);
+  /* Open the connection.  */
+  if (STRINGP (bus))
+    if (NILP (private))
+      connection = dbus_connection_open (SSDATA (bus), &derror);
+    else
+      connection = dbus_connection_open_private (SSDATA (bus), &derror);
+  else
+    if (NILP (private))
+      connection = dbus_bus_get (EQ (bus, QCdbus_system_bus)
+                                 ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION,
+                                 &derror);
+    else
+      connection = dbus_bus_get_private (EQ (bus, QCdbus_system_bus)
+                                         ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION,
+                                         &derror);
+  if (dbus_error_is_set (&derror))
+    XD_ERROR (derror);
+  if (connection == NULL)
+    XD_SIGNAL2 (build_string ("No connection to bus"), bus);
+  /* If it is not the system or session bus, we must register
+     ourselves.  Otherwise, we have called dbus_bus_get, which has
+     configured us to exit if the connection closes - we undo this
+     setting.  */
+  if (STRINGP (bus))
+    dbus_bus_register (connection, &derror);
  else
-    wrong_type_argument (intern ("D-Bus"), bus);
+    dbus_connection_set_exit_on_disconnect (connection, FALSE);
-  /* Open a connection to the bus.  */
+  if (dbus_error_is_set (&derror))
-  connection = xd_initialize (bus, TRUE);
+    XD_ERROR (derror);
  /* Add the watch functions.  We pass also the bus as data, in order
     to distinguish between the buses in xd_remove_watch.  */
@@ -973,36 +1167,27 @@ DEFUN ("dbus-init-bus", Fdbus_init_bus, Sdbus_init_bus, 1, 1, 0,
                                            xd_add_watch,
                                            xd_remove_watch,
                                            xd_toggle_watch,
-                                            busp, NULL))
+                                            SYMBOLP (bus)
+                                            ? (void *) XSYMBOL (bus)
+                                            : (void *) XSTRING (bus),
+                                            NULL))
    XD_SIGNAL1 (build_string ("Cannot add watch functions"));
  /* Add bus to list of registered buses.  */
-  Vdbus_registered_buses =  Fcons (bus, Vdbus_registered_buses);
+  XSETFASTINT (val, (intptr_t) connection);
+  xd_registered_buses = Fcons (Fcons (bus, val), xd_registered_buses);
  /* We do not want to abort.  */
  putenv ((char *) "DBUS_FATAL_WARNINGS=0");
-  /* Return.  */
+  /* Cleanup.  */
-  return Qnil;
+  dbus_error_free (&derror);
-}
-DEFUN ("dbus-close-bus", Fdbus_close_bus, Sdbus_close_bus, 1, 1, 0,
-       doc: /* Close connection to D-Bus BUS.  */)
-  (Lisp_Object bus)
-{
-  DBusConnection *connection;
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Decrement reference count to the bus.  */
-  dbus_connection_unref (connection);
-  /* Remove bus from list of registered buses.  */
-  Vdbus_registered_buses = Fdelete (bus, Vdbus_registered_buses);
-  /* Return.  */
+  /* Return reference counter.  */
-  return Qnil;
+  refcount = xd_get_connection_references (connection);
+  XD_DEBUG_MESSAGE ("Bus %s, Reference counter %d",
+                    XD_OBJECT_TO_STRING (bus), refcount);
+  return make_number (refcount);
 }
 DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
@@ -1013,8 +1198,11 @@ DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
  DBusConnection *connection;
  const char *name;
-  /* Open a connection to the bus.  */
+  /* Check parameter.  */
-  connection = xd_initialize (bus, TRUE);
+  XD_DBUS_VALIDATE_BUS_ADDRESS (bus);
+  /* Retrieve bus address.  */
+  connection = xd_get_connection_address (bus);
  /* Request the name.  */
  name = dbus_bus_get_unique_name (connection);
@@ -1025,341 +1213,243 @@ DEFUN ("dbus-get-unique-name", Fdbus_get_unique_name, Sdbus_get_unique_name,
  return build_string (name);
 }
-DEFUN ("dbus-call-method", Fdbus_call_method, Sdbus_call_method, 5, MANY, 0,
+DEFUN ("dbus-message-internal", Fdbus_message_internal, Sdbus_message_internal,
-       doc: /* Call METHOD on the D-Bus BUS.
+       4, MANY, 0,
+       doc: /* Send a D-Bus message.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
+This is an internal function, it shall not be used outside dbus.el.
-denoting the bus address.
+The following usages are expected:
-SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
-object path SERVICE is registered at.  INTERFACE is an interface
+`dbus-call-method', `dbus-call-method-asynchronously':
-offered by SERVICE.  It must provide METHOD.
+  \(dbus-message-internal
+    dbus-message-type-method-call BUS SERVICE PATH INTERFACE METHOD HANDLER
-If the parameter `:timeout' is given, the following integer TIMEOUT
+    &optional :timeout TIMEOUT &rest ARGS)
-specifies the maximum number of milliseconds the method call must
-return.  The default value is 25,000.  If the method call doesn't
+`dbus-send-signal':
-return in time, a D-Bus error is raised.
+  \(dbus-message-internal
+    dbus-message-type-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)
-All other arguments ARGS are passed to METHOD as arguments.  They are
-converted into D-Bus types via the following rules:
+`dbus-method-return-internal':
+  \(dbus-message-internal
-  t and nil => DBUS_TYPE_BOOLEAN
+    dbus-message-type-method-return BUS SERVICE SERIAL &rest ARGS)
-  number    => DBUS_TYPE_UINT32
-  integer   => DBUS_TYPE_INT32
+`dbus-method-error-internal':
-  float     => DBUS_TYPE_DOUBLE
+  \(dbus-message-internal
-  string    => DBUS_TYPE_STRING
+    dbus-message-type-error BUS SERVICE SERIAL &rest ARGS)
-  list      => DBUS_TYPE_ARRAY
+usage: (dbus-message-internal &rest REST)  */)
-All arguments can be preceded by a type symbol.  For details about
-type symbols, see Info node `(dbus)Type Conversion'.
-`dbus-call-method' returns the resulting values of METHOD as a list of
-Lisp objects.  The type conversion happens the other direction as for
-input arguments.  It follows the mapping rules:
-  DBUS_TYPE_BOOLEAN     => t or nil
-  DBUS_TYPE_BYTE        => number
-  DBUS_TYPE_UINT16      => number
-  DBUS_TYPE_INT16       => integer
-  DBUS_TYPE_UINT32      => number or float
-  DBUS_TYPE_UNIX_FD     => number or float
-  DBUS_TYPE_INT32       => integer or float
-  DBUS_TYPE_UINT64      => number or float
-  DBUS_TYPE_INT64       => integer or float
-  DBUS_TYPE_DOUBLE      => float
-  DBUS_TYPE_STRING      => string
-  DBUS_TYPE_OBJECT_PATH => string
-  DBUS_TYPE_SIGNATURE   => string
-  DBUS_TYPE_ARRAY       => list
-  DBUS_TYPE_VARIANT     => list
-  DBUS_TYPE_STRUCT      => list
-  DBUS_TYPE_DICT_ENTRY  => list
-Example:
-\(dbus-call-method
-  :session "org.gnome.seahorse" "/org/gnome/seahorse/keys/openpgp"
-  "org.gnome.seahorse.Keys" "GetKeyField"
-  "openpgp:657984B8C7A966DD" "simple-name")
-  => (t ("Philip R. Zimmermann"))
-If the result of the METHOD call is just one value, the converted Lisp
-object is returned instead of a list containing this single Lisp object.
-\(dbus-call-method
-  :system "org.freedesktop.Hal" "/org/freedesktop/Hal/devices/computer"
-  "org.freedesktop.Hal.Device" "GetPropertyString"
-  "system.kernel.machine")
-  => "i686"
-usage: (dbus-call-method BUS SERVICE PATH INTERFACE METHOD &optional :timeout TIMEOUT &rest ARGS)  */)
  (ptrdiff_t nargs, Lisp_Object *args)
 {
-  Lisp_Object bus, service, path, interface, method;
+  Lisp_Object message_type, bus, service, handler;
+  Lisp_Object path = Qnil;
+  Lisp_Object interface = Qnil;
+  Lisp_Object member = Qnil;
  Lisp_Object result;
-  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
+  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
  DBusConnection *connection;
  DBusMessage *dmessage;
-  DBusMessage *reply;
  DBusMessageIter iter;
-  DBusError derror;
  unsigned int dtype;
+  unsigned int mtype;
+  dbus_uint32_t serial = 0;
+  unsigned int ui_serial;
  int timeout = -1;
-  ptrdiff_t i = 5;
+  ptrdiff_t count;
  char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
+  /* Initialize parameters.  */
+  message_type = args[0];
+  bus = args[1];
+  service = args[2];
+  handler = Qnil;
+  CHECK_NATNUM (message_type);
+  mtype = XFASTINT (message_type);
+  if ((mtype <= DBUS_MESSAGE_TYPE_INVALID) || (mtype >= DBUS_NUM_MESSAGE_TYPES))
+    XD_SIGNAL2 (build_string ("Invalid message type"), message_type);
+  if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
+      || (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
+    {
+      path = args[3];
+      interface = args[4];
+      member = args[5];
+      if (mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
+        handler = args[6];
+      count = (mtype == DBUS_MESSAGE_TYPE_METHOD_CALL) ? 7 : 6;
+    }
+  else /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
+    {
+      XD_CHECK_DBUS_SERIAL (args[3], serial);
+      count = 4;
+    }
  /* Check parameters.  */
-  bus = args[0];
+  XD_DBUS_VALIDATE_BUS_ADDRESS (bus);
-  service = args[1];
+  XD_DBUS_VALIDATE_BUS_NAME (service);
-  path = args[2];
+  if (nargs < count)
-  interface = args[3];
+    xsignal2 (Qwrong_number_of_arguments,
-  method = args[4];
+              Qdbus_message_internal,
+              make_number (nargs));
-  CHECK_STRING (service);
-  CHECK_STRING (path);
+  if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
-  CHECK_STRING (interface);
+      || (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
-  CHECK_STRING (method);
+    {
-  GCPRO5 (bus, service, path, interface, method);
+      XD_DBUS_VALIDATE_PATH (path);
+      XD_DBUS_VALIDATE_INTERFACE (interface);
-  XD_DEBUG_MESSAGE ("%s %s %s %s",
+      XD_DBUS_VALIDATE_MEMBER (member);
-                    SDATA (service),
+      if (!NILP (handler) && (!FUNCTIONP (handler)))
-                    SDATA (path),
+        wrong_type_argument (Qinvalid_function, handler);
-                    SDATA (interface),
+    }
-                    SDATA (method));
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Create the message.  */
-  dmessage = dbus_message_new_method_call (SSDATA (service),
-                                           SSDATA (path),
-                                           SSDATA (interface),
-                                           SSDATA (method));
-  UNGCPRO;
-  if (dmessage == NULL)
-    XD_SIGNAL1 (build_string ("Unable to create a new message"));
-  /* Check for timeout parameter.  */
+  /* Protect Lisp variables.  */
-  if ((i+2 <= nargs) && (EQ ((args[i]), QCdbus_timeout)))
+  GCPRO6 (bus, service, path, interface, member, handler);
+  /* Trace parameters.  */
+  switch (mtype)
    {
-      CHECK_NATNUM (args[i+1]);
+    case DBUS_MESSAGE_TYPE_METHOD_CALL:
-      timeout = min (XFASTINT (args[i+1]), INT_MAX);
+      XD_DEBUG_MESSAGE ("%s %s %s %s %s %s %s",
-      i = i+2;
+                        XD_MESSAGE_TYPE_TO_STRING (mtype),
+                        XD_OBJECT_TO_STRING (bus),
+                        XD_OBJECT_TO_STRING (service),
+                        XD_OBJECT_TO_STRING (path),
+                        XD_OBJECT_TO_STRING (interface),
+                        XD_OBJECT_TO_STRING (member),
+                        XD_OBJECT_TO_STRING (handler));
+      break;
+    case DBUS_MESSAGE_TYPE_SIGNAL:
+      XD_DEBUG_MESSAGE ("%s %s %s %s %s %s",
+                        XD_MESSAGE_TYPE_TO_STRING (mtype),
+                        XD_OBJECT_TO_STRING (bus),
+                        XD_OBJECT_TO_STRING (service),
+                        XD_OBJECT_TO_STRING (path),
+                        XD_OBJECT_TO_STRING (interface),
+                        XD_OBJECT_TO_STRING (member));
+      break;
+    default: /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
+      ui_serial = serial;
+      XD_DEBUG_MESSAGE ("%s %s %s %u",
+                        XD_MESSAGE_TYPE_TO_STRING (mtype),
+                        XD_OBJECT_TO_STRING (bus),
+                        XD_OBJECT_TO_STRING (service),
+                        ui_serial);
    }
-  /* Initialize parameter list of message.  */
+  /* Retrieve bus address.  */
-  dbus_message_iter_init_append (dmessage, &iter);
+  connection = xd_get_connection_address (bus);
-  /* Append parameters to the message.  */
+  /* Create the D-Bus message.  */
-  for (; i < nargs; ++i)
+  dmessage = dbus_message_new (mtype);
+  if (dmessage == NULL)
    {
-      dtype = XD_OBJECT_TO_DBUS_TYPE (args[i]);
+      UNGCPRO;
-      if (XD_DBUS_TYPE_P (args[i]))
+      XD_SIGNAL1 (build_string ("Unable to create a new message"));
+    }
+  if (STRINGP (service))
+    {
+      if (mtype != DBUS_MESSAGE_TYPE_SIGNAL)
+        /* Set destination.  */
        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
+          if (!dbus_message_set_destination (dmessage, SSDATA (service)))
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
+            {
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
+              UNGCPRO;
-                            SDATA (format2 ("%s", args[i], Qnil)),
+              XD_SIGNAL2 (build_string ("Unable to set the destination"),
-                            SDATA (format2 ("%s", args[i+1], Qnil)));
+                          service);
-          ++i;
+            }
        }
      else
+        /* Set destination for unicast signals.  */
        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
+          Lisp_Object uname;
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
-                            SDATA (format2 ("%s", args[i], Qnil)));
-        }
-      /* Check for valid signature.  We use DBUS_TYPE_INVALID as
+          /* If it is the same unique name as we are registered at the
-         indication that there is no parent type.  */
+             bus or an unknown name, we regard it as broadcast message
-      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[i]);
+             due to backward compatibility.  */
+          if (dbus_bus_name_has_owner (connection, SSDATA (service), NULL))
+            uname = call2 (intern ("dbus-get-name-owner"), bus, service);
+          else
+            uname = Qnil;
-      xd_append_arg (dtype, args[i], &iter);
+          if (STRINGP (uname)
+              && (strcmp (dbus_bus_get_unique_name (connection), SSDATA (uname))
+                  != 0)
+              && (!dbus_message_set_destination (dmessage, SSDATA (service))))
+            {
+              UNGCPRO;
+              XD_SIGNAL2 (build_string ("Unable to set signal destination"),
+                          service);
+            }
+        }
    }
-  /* Send the message.  */
+  /* Set message parameters.  */
-  dbus_error_init (&derror);
+  if ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
-  reply = dbus_connection_send_with_reply_and_block (connection,
+      || (mtype == DBUS_MESSAGE_TYPE_SIGNAL))
-                                                     dmessage,
-                                                     timeout,
-                                                     &derror);
-  if (dbus_error_is_set (&derror))
-    XD_ERROR (derror);
-  if (reply == NULL)
-    XD_SIGNAL1 (build_string ("No reply"));
-  XD_DEBUG_MESSAGE ("Message sent");
-  /* Collect the results.  */
-  result = Qnil;
-  GCPRO1 (result);
-  if (dbus_message_iter_init (reply, &iter))
    {
-      /* Loop over the parameters of the D-Bus reply message.  Construct a
+      if ((!dbus_message_set_path (dmessage, SSDATA (path)))
-         Lisp list, which is returned by `dbus-call-method'.  */
+          || (!dbus_message_set_interface (dmessage, SSDATA (interface)))
-      while ((dtype = dbus_message_iter_get_arg_type (&iter))
+          || (!dbus_message_set_member (dmessage, SSDATA (member))))
-             != DBUS_TYPE_INVALID)
        {
-          result = Fcons (xd_retrieve_arg (dtype, &iter), result);
+          UNGCPRO;
-          dbus_message_iter_next (&iter);
+          XD_SIGNAL1 (build_string ("Unable to set the message parameter"));
        }
    }
-  else
-    {
-      /* No arguments: just return nil.  */
-    }
-  /* Cleanup.  */
-  dbus_error_free (&derror);
-  dbus_message_unref (dmessage);
-  dbus_message_unref (reply);
-  /* Return the result.  If there is only one single Lisp object,
-     return it as-it-is, otherwise return the reversed list.  */
-  if (XFASTINT (Flength (result)) == 1)
-    RETURN_UNGCPRO (CAR_SAFE (result));
-  else
-    RETURN_UNGCPRO (Fnreverse (result));
-}
-DEFUN ("dbus-call-method-asynchronously", Fdbus_call_method_asynchronously,
-       Sdbus_call_method_asynchronously, 6, MANY, 0,
-       doc: /* Call METHOD on the D-Bus BUS asynchronously.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
-denoting the bus address.
-SERVICE is the D-Bus service name to be used.  PATH is the D-Bus
-object path SERVICE is registered at.  INTERFACE is an interface
-offered by SERVICE.  It must provide METHOD.
-HANDLER is a Lisp function, which is called when the corresponding
-return message has arrived.  If HANDLER is nil, no return message will
-be expected.
-If the parameter `:timeout' is given, the following integer TIMEOUT
-specifies the maximum number of milliseconds the method call must
-return.  The default value is 25,000.  If the method call doesn't
-return in time, a D-Bus error is raised.
-All other arguments ARGS are passed to METHOD as arguments.  They are
-converted into D-Bus types via the following rules:
-  t and nil => DBUS_TYPE_BOOLEAN
-  number    => DBUS_TYPE_UINT32
-  integer   => DBUS_TYPE_INT32
-  float     => DBUS_TYPE_DOUBLE
-  string    => DBUS_TYPE_STRING
-  list      => DBUS_TYPE_ARRAY
-All arguments can be preceded by a type symbol.  For details about
-type symbols, see Info node `(dbus)Type Conversion'.
-Unless HANDLER is nil, the function returns a key into the hash table
+  else /* DBUS_MESSAGE_TYPE_METHOD_RETURN, DBUS_MESSAGE_TYPE_ERROR  */
-`dbus-registered-objects-table'.  The corresponding entry in the hash
+    {
-table is removed, when the return message has been arrived, and
+      if (!dbus_message_set_reply_serial (dmessage, serial))
-HANDLER is called.
+        {
+          UNGCPRO;
-Example:
+          XD_SIGNAL1 (build_string ("Unable to create a return message"));
+        }
-\(dbus-call-method-asynchronously
-  :system "org.freedesktop.Hal" "/org/freedesktop/Hal/devices/computer"
-  "org.freedesktop.Hal.Device" "GetPropertyString" 'message
-  "system.kernel.machine")
-  => (:system 2)
-  -| i686
-usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLER &optional :timeout TIMEOUT &rest ARGS)  */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service, path, interface, method, handler;
-  Lisp_Object result;
-  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
-  DBusConnection *connection;
-  DBusMessage *dmessage;
-  DBusMessageIter iter;
-  unsigned int dtype;
-  dbus_uint32_t serial;
-  int timeout = -1;
-  ptrdiff_t i = 6;
-  char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
-  /* Check parameters.  */
+      if ((mtype == DBUS_MESSAGE_TYPE_ERROR)
-  bus = args[0];
+          && (!dbus_message_set_error_name (dmessage, DBUS_ERROR_FAILED)))
-  service = args[1];
+        {
-  path = args[2];
+          UNGCPRO;
-  interface = args[3];
+          XD_SIGNAL1 (build_string ("Unable to create a error message"));
-  method = args[4];
+        }
-  handler = args[5];
+    }
-  CHECK_STRING (service);
-  CHECK_STRING (path);
-  CHECK_STRING (interface);
-  CHECK_STRING (method);
-  if (!NILP (handler) && !FUNCTIONP (handler))
-    wrong_type_argument (Qinvalid_function, handler);
-  GCPRO6 (bus, service, path, interface, method, handler);
-  XD_DEBUG_MESSAGE ("%s %s %s %s",
-                    SDATA (service),
-                    SDATA (path),
-                    SDATA (interface),
-                    SDATA (method));
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Create the message.  */
-  dmessage = dbus_message_new_method_call (SSDATA (service),
-                                           SSDATA (path),
-                                           SSDATA (interface),
-                                           SSDATA (method));
-  if (dmessage == NULL)
-    XD_SIGNAL1 (build_string ("Unable to create a new message"));
  /* Check for timeout parameter.  */
-  if ((i+2 <= nargs) && (EQ ((args[i]), QCdbus_timeout)))
+  if ((count+2 <= nargs) && (EQ ((args[count]), QCdbus_timeout)))
    {
-      CHECK_NATNUM (args[i+1]);
+      CHECK_NATNUM (args[count+1]);
-      timeout = min (XFASTINT (args[i+1]), INT_MAX);
+      timeout = min (XFASTINT (args[count+1]), INT_MAX);
-      i = i+2;
+      count = count+2;
    }
  /* Initialize parameter list of message.  */
  dbus_message_iter_init_append (dmessage, &iter);
  /* Append parameters to the message.  */
-  for (; i < nargs; ++i)
+  for (; count < nargs; ++count)
    {
-      dtype = XD_OBJECT_TO_DBUS_TYPE (args[i]);
+      dtype = XD_OBJECT_TO_DBUS_TYPE (args[count]);
-      if (XD_DBUS_TYPE_P (args[i]))
+      if (XD_DBUS_TYPE_P (args[count]))
        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
+          XD_DEBUG_VALID_LISP_OBJECT_P (args[count]);
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
+          XD_DEBUG_VALID_LISP_OBJECT_P (args[count+1]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
+          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", count - 4,
-                            SDATA (format2 ("%s", args[i], Qnil)),
+                            XD_OBJECT_TO_STRING (args[count]),
-                            SDATA (format2 ("%s", args[i+1], Qnil)));
+                            XD_OBJECT_TO_STRING (args[count+1]));
-          ++i;
+          ++count;
        }
      else
        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
+          XD_DEBUG_VALID_LISP_OBJECT_P (args[count]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
+          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", count - 4,
-                            SDATA (format2 ("%s", args[i], Qnil)));
+                            XD_OBJECT_TO_STRING (args[count]));
        }
      /* Check for valid signature.  We use DBUS_TYPE_INVALID as
         indication that there is no parent type.  */
-      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[i]);
+      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[count]);
-      xd_append_arg (dtype, args[i], &iter);
+      xd_append_arg (dtype, args[count], &iter);
    }
  if (!NILP (handler))
@@ -1368,11 +1458,15 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
         message queue.  */
      if (!dbus_connection_send_with_reply (connection, dmessage,
                                            NULL, timeout))
-        XD_SIGNAL1 (build_string ("Cannot send message"));
+        {
+          UNGCPRO;
+          XD_SIGNAL1 (build_string ("Cannot send message"));
+        }
      /* The result is the key in Vdbus_registered_objects_table.  */
      serial = dbus_message_get_serial (dmessage);
-      result = list2 (bus, make_fixnum_or_float (serial));
+      result = list3 (QCdbus_registered_serial,
+                      bus, make_fixnum_or_float (serial));
      /* Create a hash table entry.  */
      Fputhash (result, handler, Vdbus_registered_objects_table);
@@ -1382,12 +1476,15 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
      /* Send the message.  The message is just added to the outgoing
         message queue.  */
      if (!dbus_connection_send (connection, dmessage, NULL))
-        XD_SIGNAL1 (build_string ("Cannot send message"));
+        {
+          UNGCPRO;
+          XD_SIGNAL1 (build_string ("Cannot send message"));
+        }
      result = Qnil;
    }
-  XD_DEBUG_MESSAGE ("Message sent");
+  XD_DEBUG_MESSAGE ("Message sent: %s", XD_OBJECT_TO_STRING (result));
  /* Cleanup.  */
  dbus_message_unref (dmessage);
@@ -1396,300 +1493,6 @@ usage: (dbus-call-method-asynchronously BUS SERVICE PATH INTERFACE METHOD HANDLE
  RETURN_UNGCPRO (result);
 }
-DEFUN ("dbus-method-return-internal", Fdbus_method_return_internal,
-       Sdbus_method_return_internal,
-       3, MANY, 0,
-       doc: /* Return for message SERIAL on the D-Bus BUS.
-This is an internal function, it shall not be used outside dbus.el.
-usage: (dbus-method-return-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service;
-  struct gcpro gcpro1, gcpro2;
-  DBusConnection *connection;
-  DBusMessage *dmessage;
-  DBusMessageIter iter;
-  dbus_uint32_t serial;
-  unsigned int ui_serial, dtype;
-  ptrdiff_t i;
-  char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
-  /* Check parameters.  */
-  bus = args[0];
-  service = args[2];
-  CHECK_DBUS_SERIAL_GET_SERIAL (args[1], serial);
-  CHECK_STRING (service);
-  GCPRO2 (bus, service);
-  ui_serial = serial;
-  XD_DEBUG_MESSAGE ("%u %s ", ui_serial, SSDATA (service));
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Create the message.  */
-  dmessage = dbus_message_new (DBUS_MESSAGE_TYPE_METHOD_RETURN);
-  if ((dmessage == NULL)
-      || (!dbus_message_set_reply_serial (dmessage, serial))
-      || (!dbus_message_set_destination (dmessage, SSDATA (service))))
-    {
-      UNGCPRO;
-      XD_SIGNAL1 (build_string ("Unable to create a return message"));
-    }
-  UNGCPRO;
-  /* Initialize parameter list of message.  */
-  dbus_message_iter_init_append (dmessage, &iter);
-  /* Append parameters to the message.  */
-  for (i = 3; i < nargs; ++i)
-    {
-      dtype = XD_OBJECT_TO_DBUS_TYPE (args[i]);
-      if (XD_DBUS_TYPE_P (args[i]))
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2,
-                            SDATA (format2 ("%s", args[i], Qnil)),
-                            SDATA (format2 ("%s", args[i+1], Qnil)));
-          ++i;
-        }
-      else
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2,
-                            SDATA (format2 ("%s", args[i], Qnil)));
-        }
-      /* Check for valid signature.  We use DBUS_TYPE_INVALID as
-         indication that there is no parent type.  */
-      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[i]);
-      xd_append_arg (dtype, args[i], &iter);
-    }
-  /* Send the message.  The message is just added to the outgoing
-     message queue.  */
-  if (!dbus_connection_send (connection, dmessage, NULL))
-    XD_SIGNAL1 (build_string ("Cannot send message"));
-  XD_DEBUG_MESSAGE ("Message sent");
-  /* Cleanup.  */
-  dbus_message_unref (dmessage);
-  /* Return.  */
-  return Qt;
-}
-DEFUN ("dbus-method-error-internal", Fdbus_method_error_internal,
-       Sdbus_method_error_internal,
-       3, MANY, 0,
-       doc: /* Return error message for message SERIAL on the D-Bus BUS.
-This is an internal function, it shall not be used outside dbus.el.
-usage: (dbus-method-error-internal BUS SERIAL SERVICE &rest ARGS)  */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service;
-  struct gcpro gcpro1, gcpro2;
-  DBusConnection *connection;
-  DBusMessage *dmessage;
-  DBusMessageIter iter;
-  dbus_uint32_t serial;
-  unsigned int ui_serial, dtype;
-  ptrdiff_t i;
-  char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
-  /* Check parameters.  */
-  bus = args[0];
-  service = args[2];
-  CHECK_DBUS_SERIAL_GET_SERIAL (args[1], serial);
-  CHECK_STRING (service);
-  GCPRO2 (bus, service);
-  ui_serial = serial;
-  XD_DEBUG_MESSAGE ("%u %s ", ui_serial, SSDATA (service));
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Create the message.  */
-  dmessage = dbus_message_new (DBUS_MESSAGE_TYPE_ERROR);
-  if ((dmessage == NULL)
-      || (!dbus_message_set_error_name (dmessage, DBUS_ERROR_FAILED))
-      || (!dbus_message_set_reply_serial (dmessage, serial))
-      || (!dbus_message_set_destination (dmessage, SSDATA (service))))
-    {
-      UNGCPRO;
-      XD_SIGNAL1 (build_string ("Unable to create a error message"));
-    }
-  UNGCPRO;
-  /* Initialize parameter list of message.  */
-  dbus_message_iter_init_append (dmessage, &iter);
-  /* Append parameters to the message.  */
-  for (i = 3; i < nargs; ++i)
-    {
-      dtype = XD_OBJECT_TO_DBUS_TYPE (args[i]);
-      if (XD_DBUS_TYPE_P (args[i]))
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 2,
-                            SDATA (format2 ("%s", args[i], Qnil)),
-                            SDATA (format2 ("%s", args[i+1], Qnil)));
-          ++i;
-        }
-      else
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 2,
-                            SDATA (format2 ("%s", args[i], Qnil)));
-        }
-      /* Check for valid signature.  We use DBUS_TYPE_INVALID as
-         indication that there is no parent type.  */
-      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[i]);
-      xd_append_arg (dtype, args[i], &iter);
-    }
-  /* Send the message.  The message is just added to the outgoing
-     message queue.  */
-  if (!dbus_connection_send (connection, dmessage, NULL))
-    XD_SIGNAL1 (build_string ("Cannot send message"));
-  XD_DEBUG_MESSAGE ("Message sent");
-  /* Cleanup.  */
-  dbus_message_unref (dmessage);
-  /* Return.  */
-  return Qt;
-}
-DEFUN ("dbus-send-signal", Fdbus_send_signal, Sdbus_send_signal, 5, MANY, 0,
-       doc: /* Send signal SIGNAL on the D-Bus BUS.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
-denoting the bus address.
-SERVICE is the D-Bus service name SIGNAL is sent from.  PATH is the
-D-Bus object path SERVICE is registered at.  INTERFACE is an interface
-offered by SERVICE.  It must provide signal SIGNAL.
-All other arguments ARGS are passed to SIGNAL as arguments.  They are
-converted into D-Bus types via the following rules:
-  t and nil => DBUS_TYPE_BOOLEAN
-  number    => DBUS_TYPE_UINT32
-  integer   => DBUS_TYPE_INT32
-  float     => DBUS_TYPE_DOUBLE
-  string    => DBUS_TYPE_STRING
-  list      => DBUS_TYPE_ARRAY
-All arguments can be preceded by a type symbol.  For details about
-type symbols, see Info node `(dbus)Type Conversion'.
-Example:
-\(dbus-send-signal
-  :session "org.gnu.Emacs" "/org/gnu/Emacs"
-  "org.gnu.Emacs.FileManager" "FileModified" "/home/albinus/.emacs")
-usage: (dbus-send-signal BUS SERVICE PATH INTERFACE SIGNAL &rest ARGS)  */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service, path, interface, signal;
-  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5;
-  DBusConnection *connection;
-  DBusMessage *dmessage;
-  DBusMessageIter iter;
-  unsigned int dtype;
-  ptrdiff_t i;
-  char signature[DBUS_MAXIMUM_SIGNATURE_LENGTH];
-  /* Check parameters.  */
-  bus = args[0];
-  service = args[1];
-  path = args[2];
-  interface = args[3];
-  signal = args[4];
-  CHECK_STRING (service);
-  CHECK_STRING (path);
-  CHECK_STRING (interface);
-  CHECK_STRING (signal);
-  GCPRO5 (bus, service, path, interface, signal);
-  XD_DEBUG_MESSAGE ("%s %s %s %s",
-                    SDATA (service),
-                    SDATA (path),
-                    SDATA (interface),
-                    SDATA (signal));
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Create the message.  */
-  dmessage = dbus_message_new_signal (SSDATA (path),
-                                      SSDATA (interface),
-                                      SSDATA (signal));
-  UNGCPRO;
-  if (dmessage == NULL)
-    XD_SIGNAL1 (build_string ("Unable to create a new message"));
-  /* Initialize parameter list of message.  */
-  dbus_message_iter_init_append (dmessage, &iter);
-  /* Append parameters to the message.  */
-  for (i = 5; i < nargs; ++i)
-    {
-      dtype = XD_OBJECT_TO_DBUS_TYPE (args[i]);
-      if (XD_DBUS_TYPE_P (args[i]))
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i+1]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s %s", i - 4,
-                            SDATA (format2 ("%s", args[i], Qnil)),
-                            SDATA (format2 ("%s", args[i+1], Qnil)));
-          ++i;
-        }
-      else
-        {
-          XD_DEBUG_VALID_LISP_OBJECT_P (args[i]);
-          XD_DEBUG_MESSAGE ("Parameter%"pD"d %s", i - 4,
-                            SDATA (format2 ("%s", args[i], Qnil)));
-        }
-      /* Check for valid signature.  We use DBUS_TYPE_INVALID as
-         indication that there is no parent type.  */
-      xd_signature (signature, dtype, DBUS_TYPE_INVALID, args[i]);
-      xd_append_arg (dtype, args[i], &iter);
-    }
-  /* Send the message.  The message is just added to the outgoing
-     message queue.  */
-  if (!dbus_connection_send (connection, dmessage, NULL))
-    XD_SIGNAL1 (build_string ("Cannot send message"));
-  XD_DEBUG_MESSAGE ("Signal sent");
-  /* Cleanup.  */
-  dbus_message_unref (dmessage);
-  /* Return.  */
-  return Qt;
-}
 /* Read one queued incoming message of the D-Bus BUS.
   BUS is either a Lisp symbol, :system or :session, or a string denoting
   the bus address.  */
@@ -1702,7 +1505,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
  DBusMessage *dmessage;
  DBusMessageIter iter;
  unsigned int dtype;
-  int mtype;
+  unsigned int mtype;
  dbus_uint32_t serial;
  unsigned int ui_serial;
  const char *uname, *path, *interface, *member;
@@ -1744,23 +1547,19 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
  member = dbus_message_get_member (dmessage);
  XD_DEBUG_MESSAGE ("Event received: %s %u %s %s %s %s %s",
-                    (mtype == DBUS_MESSAGE_TYPE_INVALID)
+                    XD_MESSAGE_TYPE_TO_STRING (mtype),
-                    ? "DBUS_MESSAGE_TYPE_INVALID"
-                    : (mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
-                    ? "DBUS_MESSAGE_TYPE_METHOD_CALL"
-                    : (mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
-                    ? "DBUS_MESSAGE_TYPE_METHOD_RETURN"
-                    : (mtype == DBUS_MESSAGE_TYPE_ERROR)
-                    ? "DBUS_MESSAGE_TYPE_ERROR"
-                    : "DBUS_MESSAGE_TYPE_SIGNAL",
                    ui_serial, uname, path, interface, member,
-                    SDATA (format2 ("%s", args, Qnil)));
+                    XD_OBJECT_TO_STRING (args));
+  if (mtype == DBUS_MESSAGE_TYPE_INVALID)
+    goto cleanup;
-  if ((mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
+  else if ((mtype == DBUS_MESSAGE_TYPE_METHOD_RETURN)
-      || (mtype == DBUS_MESSAGE_TYPE_ERROR))
+           || (mtype == DBUS_MESSAGE_TYPE_ERROR))
    {
      /* Search for a registered function of the message.  */
-      key = list2 (bus, make_fixnum_or_float (serial));
+      key = list3 (QCdbus_registered_serial, bus,
+                   make_fixnum_or_float (serial));
      value = Fgethash (key, Vdbus_registered_objects_table, Qnil);
      /* There shall be exactly one entry.  Construct an event.  */
@@ -1777,7 +1576,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
      event.arg = Fcons (value, args);
    }
-  else /* (mtype != DBUS_MESSAGE_TYPE_METHOD_RETURN)  */
+  else /* DBUS_MESSAGE_TYPE_METHOD_CALL, DBUS_MESSAGE_TYPE_SIGNAL.  */
    {
      /* Vdbus_registered_objects_table requires non-nil interface and
         member.  */
@@ -1785,7 +1584,10 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
        goto cleanup;
      /* Search for a registered function of the message.  */
-      key = list3 (bus, build_string (interface), build_string (member));
+      key = list4 ((mtype == DBUS_MESSAGE_TYPE_METHOD_CALL)
+                   ? QCdbus_registered_method
+                   : QCdbus_registered_signal,
+                   bus, build_string (interface), build_string (member));
      value = Fgethash (key, Vdbus_registered_objects_table, Qnil);
      /* Loop over the registered functions.  Construct an event.  */
@@ -1835,8 +1637,7 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
  /* Store it into the input event queue.  */
  kbd_buffer_store_event (&event);
-  XD_DEBUG_MESSAGE ("Event stored: %s",
+  XD_DEBUG_MESSAGE ("Event stored: %s", XD_OBJECT_TO_STRING (event.arg));
-                    SDATA (format2 ("%s", event.arg, Qnil)));
  /* Cleanup.  */
 cleanup:
@@ -1851,8 +1652,8 @@ xd_read_message_1 (DBusConnection *connection, Lisp_Object bus)
 static Lisp_Object
 xd_read_message (Lisp_Object bus)
 {
-  /* Open a connection to the bus.  */
+  /* Retrieve bus address.  */
-  DBusConnection *connection = xd_initialize (bus, TRUE);
+  DBusConnection *connection = xd_get_connection_address (bus);
  /* Non blocking read of the next available message.  */
  dbus_connection_read_write (connection, 0);
@@ -1867,16 +1668,18 @@ xd_read_message (Lisp_Object bus)
 static void
 xd_read_queued_messages (int fd, void *data, int for_read)
 {
-  Lisp_Object busp = Vdbus_registered_buses;
+  Lisp_Object busp = xd_registered_buses;
  Lisp_Object bus = Qnil;
+  Lisp_Object key;
  /* Find bus related to fd.  */
  if (data != NULL)
    while (!NILP (busp))
      {
-        if ((SYMBOLP (CAR_SAFE (busp)) && XSYMBOL (CAR_SAFE (busp)) == data)
+        key = CAR_SAFE (CAR_SAFE (busp));
-            || (STRINGP (CAR_SAFE (busp)) && XSTRING (CAR_SAFE (busp)) == data))
+        if ((SYMBOLP (key) && XSYMBOL (key) == data)
-          bus = CAR_SAFE (busp);
+            || (STRINGP (key) && XSTRING (key) == data))
+          bus = key;
        busp = CDR_SAFE (busp);
      }
@@ -1889,327 +1692,6 @@ xd_read_queued_messages (int fd, void *data, int for_read)
  xd_in_read_queued_messages = 0;
 }
-DEFUN ("dbus-register-service", Fdbus_register_service, Sdbus_register_service,
-       2, MANY, 0,
-       doc: /* Register known name SERVICE on the D-Bus BUS.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
-denoting the bus address.
-SERVICE is the D-Bus service name that should be registered.  It must
-be a known name.
-FLAGS are keywords, which control how the service name is registered.
-The following keywords are recognized:
-`:allow-replacement': Allow another service to become the primary
-owner if requested.
-`:replace-existing': Request to replace the current primary owner.
-`:do-not-queue': If we can not become the primary owner do not place
-us in the queue.
-The function returns a keyword, indicating the result of the
-operation.  One of the following keywords is returned:
-`:primary-owner': Service has become the primary owner of the
-requested name.
-`:in-queue': Service could not become the primary owner and has been
-placed in the queue.
-`:exists': Service is already in the queue.
-`:already-owner': Service is already the primary owner.
-Example:
-\(dbus-register-service :session dbus-service-emacs)
-  => :primary-owner.
-\(dbus-register-service
-  :session "org.freedesktop.TextEditor"
-  dbus-service-allow-replacement dbus-service-replace-existing)
-  => :already-owner.
-usage: (dbus-register-service BUS SERVICE &rest FLAGS)  */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service;
-  DBusConnection *connection;
-  ptrdiff_t i;
-  unsigned int value;
-  unsigned int flags = 0;
-  int result;
-  DBusError derror;
-  bus = args[0];
-  service = args[1];
-  /* Check parameters.  */
-  CHECK_STRING (service);
-  /* Process flags.  */
-  for (i = 2; i < nargs; ++i) {
-    value = ((EQ (args[i], QCdbus_request_name_replace_existing))
-             ? DBUS_NAME_FLAG_REPLACE_EXISTING
-             : (EQ (args[i], QCdbus_request_name_allow_replacement))
-             ? DBUS_NAME_FLAG_ALLOW_REPLACEMENT
-             : (EQ (args[i], QCdbus_request_name_do_not_queue))
-             ? DBUS_NAME_FLAG_DO_NOT_QUEUE
-             : -1);
-    if (value == -1)
-      XD_SIGNAL2 (build_string ("Unrecognized name request flag"), args[i]);
-    flags |= value;
-  }
-  /* Open a connection to the bus.  */
-  connection = xd_initialize (bus, TRUE);
-  /* Request the known name from the bus.  */
-  dbus_error_init (&derror);
-  result = dbus_bus_request_name (connection, SSDATA (service), flags,
-                                  &derror);
-  if (dbus_error_is_set (&derror))
-    XD_ERROR (derror);
-  /* Cleanup.  */
-  dbus_error_free (&derror);
-  /* Return object.  */
-  switch (result)
-    {
-    case DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER:
-      return QCdbus_request_name_reply_primary_owner;
-    case DBUS_REQUEST_NAME_REPLY_IN_QUEUE:
-      return QCdbus_request_name_reply_in_queue;
-    case DBUS_REQUEST_NAME_REPLY_EXISTS:
-      return QCdbus_request_name_reply_exists;
-    case DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER:
-      return QCdbus_request_name_reply_already_owner;
-    default:
-      /* This should not happen.  */
-      XD_SIGNAL2 (build_string ("Could not register service"), service);
-    }
-}
-DEFUN ("dbus-register-signal", Fdbus_register_signal, Sdbus_register_signal,
-       6, MANY, 0,
-       doc: /* Register for signal SIGNAL on the D-Bus BUS.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
-denoting the bus address.
-SERVICE is the D-Bus service name used by the sending D-Bus object.
-It can be either a known name or the unique name of the D-Bus object
-sending the signal.  When SERVICE is nil, related signals from all
-D-Bus objects shall be accepted.
-PATH is the D-Bus object path SERVICE is registered.  It can also be
-nil if the path name of incoming signals shall not be checked.
-INTERFACE is an interface offered by SERVICE.  It must provide SIGNAL.
-HANDLER is a Lisp function to be called when the signal is received.
-It must accept as arguments the values SIGNAL is sending.
-All other arguments ARGS, if specified, must be strings.  They stand
-for the respective arguments of the signal in their order, and are
-used for filtering as well.  A nil argument might be used to preserve
-the order.
-INTERFACE, SIGNAL and HANDLER must not be nil.  Example:
-\(defun my-signal-handler (device)
-  (message "Device %s added" device))
-\(dbus-register-signal
-  :system "org.freedesktop.Hal" "/org/freedesktop/Hal/Manager"
-  "org.freedesktop.Hal.Manager" "DeviceAdded" 'my-signal-handler)
-  => ((:system "org.freedesktop.Hal.Manager" "DeviceAdded")
-      ("org.freedesktop.Hal" "/org/freedesktop/Hal/Manager" my-signal-handler))
-`dbus-register-signal' returns an object, which can be used in
-`dbus-unregister-object' for removing the registration.
-usage: (dbus-register-signal BUS SERVICE PATH INTERFACE SIGNAL HANDLER &rest ARGS) */)
-  (ptrdiff_t nargs, Lisp_Object *args)
-{
-  Lisp_Object bus, service, path, interface, signal, handler;
-  struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
-  Lisp_Object uname, key, key1, value;
-  DBusConnection *connection;
-  ptrdiff_t i;
-  char rule[DBUS_MAXIMUM_MATCH_RULE_LENGTH];
-  int rulelen;
-  DBusError derror;
-  /* Check parameters.  */
-  bus = args[0];
-  service = args[1];
-  path = args[2];
-  interface = args[3];
-  signal = args[4];
-  handler = args[5];
-  if (!NILP (service)) CHECK_STRING (service);
-  if (!NILP (path)) CHECK_STRING (path);
-  CHECK_STRING (interface);
-  CHECK_STRING (signal);
-  if (!FUNCTIONP (handler))
-    wrong_type_argument (Qinvalid_function, handler);
-  GCPRO6 (bus, service, path, interface, signal, handler);
-  /* Retrieve unique name of service.  If service is a known name, we
-     will register for the corresponding unique name, if any.  Signals
-     are sent always with the unique name as sender.  Note: the unique
-     name of "org.freedesktop.DBus" is that string itself.  */
-  if ((STRINGP (service))
-      && (SBYTES (service) > 0)
-      && (strcmp (SSDATA (service), DBUS_SERVICE_DBUS) != 0)
-      && (strncmp (SSDATA (service), ":", 1) != 0))
-    uname = call2 (intern ("dbus-get-name-owner"), bus, service);
-  else
-    uname = service;
-  /* Create a matching rule if the unique name exists (when no
-     wildcard).  */
-  if (NILP (uname) || (SBYTES (uname) > 0))
-    {
-      /* Open a connection to the bus.  */
-      connection = xd_initialize (bus, TRUE);
-      /* Create a rule to receive related signals.  */
-      rulelen = snprintf (rule, sizeof rule,
-                          "type='signal',interface='%s',member='%s'",
-                          SDATA (interface),
-                          SDATA (signal));
-      if (! (0 <= rulelen && rulelen < sizeof rule))
-        string_overflow ();
-      /* Add unique name and path to the rule if they are non-nil.  */
-      if (!NILP (uname))
-        {
-          int len = snprintf (rule + rulelen, sizeof rule - rulelen,
-                              ",sender='%s'", SDATA (uname));
-          if (! (0 <= len && len < sizeof rule - rulelen))
-            string_overflow ();
-          rulelen += len;
-        }
-      if (!NILP (path))
-        {
-          int len = snprintf (rule + rulelen, sizeof rule - rulelen,
-                              ",path='%s'", SDATA (path));
-          if (! (0 <= len && len < sizeof rule - rulelen))
-            string_overflow ();
-          rulelen += len;
-        }
-      /* Add arguments to the rule if they are non-nil.  */
-      for (i = 6; i < nargs; ++i)
-        if (!NILP (args[i]))
-          {
-            int len;
-            CHECK_STRING (args[i]);
-            len = snprintf (rule + rulelen, sizeof rule - rulelen,
-                            ",arg%"pD"d='%s'", i - 6, SDATA (args[i]));
-            if (! (0 <= len && len < sizeof rule - rulelen))
-              string_overflow ();
-            rulelen += len;
-          }
-      /* Add the rule to the bus.  */
-      dbus_error_init (&derror);
-      dbus_bus_add_match (connection, rule, &derror);
-      if (dbus_error_is_set (&derror))
-        {
-          UNGCPRO;
-          XD_ERROR (derror);
-        }
-      /* Cleanup.  */
-      dbus_error_free (&derror);
-      XD_DEBUG_MESSAGE ("Matching rule \"%s\" created", rule);
-    }
-  /* Create a hash table entry.  */
-  key = list3 (bus, interface, signal);
-  key1 = list5 (uname, service, path, handler, build_string (rule));
-  value = Fgethash (key, Vdbus_registered_objects_table, Qnil);
-  if (NILP (Fmember (key1, value)))
-    Fputhash (key, Fcons (key1, value), Vdbus_registered_objects_table);
-  /* Return object.  */
-  RETURN_UNGCPRO (list2 (key, list3 (service, path, handler)));
-}
-DEFUN ("dbus-register-method", Fdbus_register_method, Sdbus_register_method,
-       6, 7, 0,
-       doc: /* Register for method METHOD on the D-Bus BUS.
-BUS is either a Lisp symbol, `:system' or `:session', or a string
-denoting the bus address.
-SERVICE is the D-Bus service name of the D-Bus object METHOD is
-registered for.  It must be a known name (See discussion of
-DONT-REGISTER-SERVICE below).
-PATH is the D-Bus object path SERVICE is registered (See discussion of
-DONT-REGISTER-SERVICE below).  INTERFACE is the interface offered by
-SERVICE.  It must provide METHOD.
-HANDLER is a Lisp function to be called when a method call is
-received.  It must accept the input arguments of METHOD.  The return
-value of HANDLER is used for composing the returning D-Bus message.
-In case HANDLER shall return a reply message with an empty argument
-list, HANDLER must return the symbol `:ignore'.
-When DONT-REGISTER-SERVICE is non-nil, the known name SERVICE is not
-registered.  This means that other D-Bus clients have no way of
-noticing the newly registered method.  When interfaces are constructed
-incrementally by adding single methods or properties at a time,
-DONT-REGISTER-SERVICE can be used to prevent other clients from
-discovering the still incomplete interface.*/)
-  (Lisp_Object bus, Lisp_Object service, Lisp_Object path,
-   Lisp_Object interface, Lisp_Object method, Lisp_Object handler,
-   Lisp_Object dont_register_service)
-{
-  Lisp_Object key, key1, value;
-  Lisp_Object args[2] = { bus, service };
-  /* Check parameters.  */
-  CHECK_STRING (service);
-  CHECK_STRING (path);
-  CHECK_STRING (interface);
-  CHECK_STRING (method);
-  if (!FUNCTIONP (handler))
-    wrong_type_argument (Qinvalid_function, handler);
-  /* TODO: We must check for a valid service name, otherwise there is
-     a segmentation fault.  */
-  /* Request the name.  */
-  if (NILP (dont_register_service))
-    Fdbus_register_service (2, args);
-  /* Create a hash table entry.  We use nil for the unique name,
-     because the method might be called from anybody.  */
-  key = list3 (bus, interface, method);
-  key1 = list4 (Qnil, service, path, handler);
-  value = Fgethash (key, Vdbus_registered_objects_table, Qnil);
-  if (NILP (Fmember (key1, value)))
-    Fputhash (key, Fcons (key1, value), Vdbus_registered_objects_table);
-  /* Return object.  */
-  return list2 (key, list3 (service, path, handler));
-}
 void
 syms_of_dbusbind (void)
@@ -2218,35 +1700,11 @@ syms_of_dbusbind (void)
  DEFSYM (Qdbus_init_bus, "dbus-init-bus");
  defsubr (&Sdbus_init_bus);
-  DEFSYM (Qdbus_close_bus, "dbus-close-bus");
-  defsubr (&Sdbus_close_bus);
  DEFSYM (Qdbus_get_unique_name, "dbus-get-unique-name");
  defsubr (&Sdbus_get_unique_name);
-  DEFSYM (Qdbus_call_method, "dbus-call-method");
+  DEFSYM (Qdbus_message_internal, "dbus-message-internal");
-  defsubr (&Sdbus_call_method);
+  defsubr (&Sdbus_message_internal);
-  DEFSYM (Qdbus_call_method_asynchronously, "dbus-call-method-asynchronously");
-  defsubr (&Sdbus_call_method_asynchronously);
-  DEFSYM (Qdbus_method_return_internal, "dbus-method-return-internal");
-  defsubr (&Sdbus_method_return_internal);
-  DEFSYM (Qdbus_method_error_internal, "dbus-method-error-internal");
-  defsubr (&Sdbus_method_error_internal);
-  DEFSYM (Qdbus_send_signal, "dbus-send-signal");
-  defsubr (&Sdbus_send_signal);
-  DEFSYM (Qdbus_register_service, "dbus-register-service");
-  defsubr (&Sdbus_register_service);
-  DEFSYM (Qdbus_register_signal, "dbus-register-signal");
-  defsubr (&Sdbus_register_signal);
-  DEFSYM (Qdbus_register_method, "dbus-register-method");
-  defsubr (&Sdbus_register_method);
  DEFSYM (Qdbus_error, "dbus-error");
  Fput (Qdbus_error, Qerror_conditions,
@@ -2256,13 +1714,6 @@ syms_of_dbusbind (void)
  DEFSYM (QCdbus_system_bus, ":system");
  DEFSYM (QCdbus_session_bus, ":session");
-  DEFSYM (QCdbus_request_name_allow_replacement, ":allow-replacement");
-  DEFSYM (QCdbus_request_name_replace_existing, ":replace-existing");
-  DEFSYM (QCdbus_request_name_do_not_queue, ":do-not-queue");
-  DEFSYM (QCdbus_request_name_reply_primary_owner, ":primary-owner");
-  DEFSYM (QCdbus_request_name_reply_exists, ":exists");
-  DEFSYM (QCdbus_request_name_reply_in_queue, ":in-queue");
-  DEFSYM (QCdbus_request_name_reply_already_owner, ":already-owner");
  DEFSYM (QCdbus_timeout, ":timeout");
  DEFSYM (QCdbus_type_byte, ":byte");
  DEFSYM (QCdbus_type_boolean, ":boolean");
@@ -2276,20 +1727,66 @@ syms_of_dbusbind (void)
  DEFSYM (QCdbus_type_string, ":string");
  DEFSYM (QCdbus_type_object_path, ":object-path");
  DEFSYM (QCdbus_type_signature, ":signature");
 #ifdef DBUS_TYPE_UNIX_FD
  DEFSYM (QCdbus_type_unix_fd, ":unix-fd");
 #endif
  DEFSYM (QCdbus_type_array, ":array");
  DEFSYM (QCdbus_type_variant, ":variant");
  DEFSYM (QCdbus_type_struct, ":struct");
  DEFSYM (QCdbus_type_dict_entry, ":dict-entry");
+  DEFSYM (QCdbus_registered_serial, ":serial");
+  DEFSYM (QCdbus_registered_method, ":method");
+  DEFSYM (QCdbus_registered_signal, ":signal");
+  DEFVAR_LISP ("dbus-compiled-version",
+               Vdbus_compiled_version,
+    doc: /* The version of D-Bus Emacs is compiled against.  */);
+#ifdef DBUS_VERSION_STRING
+  Vdbus_compiled_version = make_pure_c_string (DBUS_VERSION_STRING);
+#else
+  Vdbus_compiled_version = Qnil;
+#endif
+  DEFVAR_LISP ("dbus-runtime-version",
+               Vdbus_runtime_version,
+    doc: /* The version of D-Bus Emacs runs with.  */);
+  {
+#ifdef DBUS_VERSION
+    int major, minor, micro;
+    char s[1024];
+    dbus_get_version (&major, &minor, &micro);
+    snprintf (s, sizeof s, "%d.%d.%d", major, minor, micro);
+    Vdbus_runtime_version = make_string (s, strlen (s));
+#else
+    Vdbus_runtime_version = Qnil;
+#endif
+  }
+  DEFVAR_LISP ("dbus-message-type-invalid",
+               Vdbus_message_type_invalid,
+    doc: /* This value is never a valid message type.  */);
+  Vdbus_message_type_invalid = make_number (DBUS_MESSAGE_TYPE_INVALID);
-  DEFVAR_LISP ("dbus-registered-buses",
+  DEFVAR_LISP ("dbus-message-type-method-call",
-               Vdbus_registered_buses,
+               Vdbus_message_type_method_call,
-    doc: /* List of D-Bus buses we are polling for messages.  */);
+    doc: /* Message type of a method call message.  */);
-  Vdbus_registered_buses = Qnil;
+  Vdbus_message_type_method_call = make_number (DBUS_MESSAGE_TYPE_METHOD_CALL);
+  DEFVAR_LISP ("dbus-message-type-method-return",
+               Vdbus_message_type_method_return,
+    doc: /* Message type of a method return message.  */);
+  Vdbus_message_type_method_return
+    = make_number (DBUS_MESSAGE_TYPE_METHOD_RETURN);
+  DEFVAR_LISP ("dbus-message-type-error",
+               Vdbus_message_type_error,
+    doc: /* Message type of an error reply message.  */);
+  Vdbus_message_type_error = make_number (DBUS_MESSAGE_TYPE_ERROR);
+  DEFVAR_LISP ("dbus-message-type-signal",
+               Vdbus_message_type_signal,
+    doc: /* Message type of a signal message.  */);
+  Vdbus_message_type_signal = make_number (DBUS_MESSAGE_TYPE_SIGNAL);
  DEFVAR_LISP ("dbus-registered-objects-table",
               Vdbus_registered_objects_table,
@@ -2299,27 +1796,28 @@ There are two different uses of the hash table: for accessing
 registered interfaces properties, targeted by signals or method calls,
 and for calling handlers in case of non-blocking method call returns.
-In the first case, the key in the hash table is the list (BUS
+In the first case, the key in the hash table is the list (TYPE BUS
-INTERFACE MEMBER).  BUS is either a Lisp symbol, `:system' or
+INTERFACE MEMBER).  TYPE is one of the Lisp symbols `:method',
+`:signal' or `:property'.  BUS is either a Lisp symbol, `:system' or
 `:session', or a string denoting the bus address.  INTERFACE is a
 string which denotes a D-Bus interface, and MEMBER, also a string, is
 either a method, a signal or a property INTERFACE is offering.  All
 arguments but BUS must not be nil.
-The value in the hash table is a list of quadruple lists
+The value in the hash table is a list of quadruple lists \((UNAME
-\((UNAME SERVICE PATH OBJECT) (UNAME SERVICE PATH OBJECT) ...).
+SERVICE PATH OBJECT [RULE]) ...).  SERVICE is the service name as
-SERVICE is the service name as registered, UNAME is the corresponding
+registered, UNAME is the corresponding unique name.  In case of
-unique name.  In case of registered methods and properties, UNAME is
+registered methods and properties, UNAME is nil.  PATH is the object
-nil.  PATH is the object path of the sending object.  All of them can
+path of the sending object.  All of them can be nil, which means a
-be nil, which means a wildcard then.  OBJECT is either the handler to
+wildcard then.  OBJECT is either the handler to be called when a D-Bus
-be called when a D-Bus message, which matches the key criteria,
+message, which matches the key criteria, arrives (TYPE `:method' and
-arrives (methods and signals), or a cons cell containing the value of
+`:signal'), or a cons cell containing the value of the property (TYPE
-the property.
+`:property').
-For signals, there is also a fifth element RULE, which keeps the match
+For entries of type `:signal', there is also a fifth element RULE,
-string the signal is registered with.
+which keeps the match string the signal is registered with.
-In the second case, the key in the hash table is the list (BUS
+In the second case, the key in the hash table is the list (:serial BUS
 SERIAL).  BUS is either a Lisp symbol, `:system' or `:session', or a
 string denoting the bus address.  SERIAL is the serial number of the
 non-blocking method call, a reply is expected.  Both arguments must
@@ -2343,6 +1841,10 @@ be called when the D-Bus reply message arrives.  */);
  Vdbus_debug = Qnil;
 #endif
+  /* Initialize internal objects.  */
+  xd_registered_buses = Qnil;
+  staticpro (&xd_registered_buses);
  Fprovide (intern_c_string ("dbusbind"), Qnil);
 }
diff --git a/src/dispextern.h b/src/dispextern.h
index 93611403649..979ade70bfc 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -3243,7 +3243,6 @@ extern Window tip_window;
 EXFUN (Fx_hide_tip, 0);
 extern void start_hourglass (void);
 extern void cancel_hourglass (void);
-extern int hourglass_started (void);
 extern int hourglass_shown_p;
 struct atimer;                  /* Defined in atimer.h.  */
 /* If non-null, an asynchronous timer that, when it expires, displays
diff --git a/src/dispnew.c b/src/dispnew.c
index 41e6e5b8df6..d8808de3caa 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1,5 +1,6 @@
 /* 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-2012 Free Software Foundation, Inc.
 This file is part of GNU Emacs.
@@ -87,7 +88,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 #endif /* not __GNU_LIBRARY__ */
-#if defined (HAVE_TERM_H) && defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
+#if defined (HAVE_TERM_H) && defined (GNU_LINUX)
 #include <term.h>               /* for tgetent */
 #endif
@@ -1085,12 +1086,16 @@ swap_glyph_pointers (struct glyph_row *a, struct glyph_row *b)
  for (i = 0; i < LAST_AREA + 1; ++i)
    {
      struct glyph *temp = a->glyphs[i];
-      short used_tem = a->used[i];
      a->glyphs[i] = b->glyphs[i];
      b->glyphs[i] = temp;
-      a->used[i] = b->used[i];
+      if (i < LAST_AREA)
-      b->used[i] = used_tem;
+        {
+          short used_tem = a->used[i];
+          a->used[i] = b->used[i];
+          b->used[i] = used_tem;
+        }
    }
  a->hash = b->hash;
  b->hash = hash_tem;
@@ -1105,7 +1110,7 @@ static inline void
 copy_row_except_pointers (struct glyph_row *to, struct glyph_row *from)
 {
  struct glyph *pointers[1 + LAST_AREA];
-  short used[1 + LAST_AREA];
+  short used[LAST_AREA];
  unsigned hashval;
  /* Save glyph pointers of TO.  */
@@ -6308,7 +6313,7 @@ init_display (void)
 #ifdef HAVE_X11
      Vwindow_system_version = make_number (11);
 #endif
-#if defined (GNU_LINUX) && defined (HAVE_LIBNCURSES)
+#ifdef GNU_LINUX
      /* In some versions of ncurses,
         tputs crashes if we have not called tgetent.
         So call tgetent.  */
diff --git a/src/editfns.c b/src/editfns.c
index 7e7f82c5992..6d59b89513c 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -59,10 +59,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "window.h"
 #include "blockinput.h"
-#ifndef NULL
-#define NULL 0
-#endif
 #ifndef USER_FULL_NAME
 #define USER_FULL_NAME pw->pw_gecos
 #endif
@@ -73,20 +69,13 @@ extern char **environ;
 #define TM_YEAR_BASE 1900
-/* Nonzero if TM_YEAR is a struct tm's tm_year value that causes
-   asctime to have well-defined behavior.  */
-#ifndef TM_YEAR_IN_ASCTIME_RANGE
-# define TM_YEAR_IN_ASCTIME_RANGE(tm_year) \
-    (1000 - TM_YEAR_BASE <= (tm_year) && (tm_year) <= 9999 - TM_YEAR_BASE)
-#endif
 #ifdef WINDOWSNT
 extern Lisp_Object w32_get_internal_run_time (void);
 #endif
 static void time_overflow (void) NO_RETURN;
 static Lisp_Object format_time_string (char const *, ptrdiff_t, Lisp_Object,
-                                       int, time_t *, struct tm **);
+                                       int, time_t *, struct tm *);
 static int tm_diff (struct tm *, struct tm *);
 static void update_buffer_properties (ptrdiff_t, ptrdiff_t);
@@ -1691,7 +1680,7 @@ usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL)  */)
  (Lisp_Object format_string, Lisp_Object timeval, Lisp_Object universal)
 {
  time_t t;
-  struct tm *tm;
+  struct tm tm;
  CHECK_STRING (format_string);
  format_string = code_convert_string_norecord (format_string,
@@ -1702,53 +1691,54 @@ usage: (format-time-string FORMAT-STRING &optional TIME UNIVERSAL)  */)
 static Lisp_Object
 format_time_string (char const *format, ptrdiff_t formatlen,
-                    Lisp_Object timeval, int ut, time_t *tval, struct tm **tmp)
+                    Lisp_Object timeval, int ut, time_t *tval, struct tm *tmp)
 {
-  ptrdiff_t size;
+  char buffer[4000];
+  char *buf = buffer;
+  size_t size = sizeof buffer;
+  size_t len;
+  Lisp_Object bufstring;
  int usec;
  int ns;
  struct tm *tm;
+  USE_SAFE_ALLOCA;
  if (! lisp_time_argument (timeval, tval, &usec))
    error ("Invalid time specification");
  ns = usec * 1000;
-  /* This is probably enough.  */
-  size = formatlen;
-  if (size <= (STRING_BYTES_BOUND - 50) / 6)
-    size = size * 6 + 50;
-  BLOCK_INPUT;
-  tm = ut ? gmtime (tval) : localtime (tval);
-  UNBLOCK_INPUT;
-  if (! tm)
-    time_overflow ();
-  *tmp = tm;
-  synchronize_system_time_locale ();
  while (1)
    {
-      char *buf = (char *) alloca (size + 1);
+      BLOCK_INPUT;
-      size_t result;
+      synchronize_system_time_locale ();
+      tm = ut ? gmtime (tval) : localtime (tval);
+      if (! tm)
+        {
+          UNBLOCK_INPUT;
+          time_overflow ();
+        }
+      *tmp = *tm;
      buf[0] = '\1';
-      BLOCK_INPUT;
+      len = emacs_nmemftime (buf, size, format, formatlen, tm, ut, ns);
-      result = emacs_nmemftime (buf, size, format, formatlen, tm, ut, ns);
+      if ((0 < len && len < size) || (len == 0 && buf[0] == '\0'))
-      UNBLOCK_INPUT;
+        break;
-      if ((result > 0 && result < size) || (result == 0 && buf[0] == '\0'))
-        return code_convert_string_norecord (make_unibyte_string (buf, result),
-                                             Vlocale_coding_system, 0);
-      /* If buffer was too small, make it bigger and try again.  */
+      /* Buffer was too small, so make it bigger and try again.  */
-      BLOCK_INPUT;
+      len = emacs_nmemftime (NULL, SIZE_MAX, format, formatlen, tm, ut, ns);
-      result = emacs_nmemftime (NULL, (size_t) -1, format, formatlen,
-                                tm, ut, ns);
      UNBLOCK_INPUT;
-      if (STRING_BYTES_BOUND <= result)
+      if (STRING_BYTES_BOUND <= len)
        string_overflow ();
-      size = result + 1;
+      size = len + 1;
+      SAFE_ALLOCA (buf, char *, size);
    }
+  UNBLOCK_INPUT;
+  bufstring = make_unibyte_string (buf, len);
+  SAFE_FREE ();
+  return code_convert_string_norecord (bufstring, Vlocale_coding_system, 0);
 }
 DEFUN ("decode-time", Fdecode_time, Sdecode_time, 0, 1, 0,
@@ -1778,31 +1768,32 @@ DOW and ZONE.)  */)
  BLOCK_INPUT;
  decoded_time = localtime (&time_spec);
+  /* Make a copy, in case a signal handler modifies TZ or the struct.  */
+  if (decoded_time)
+    save_tm = *decoded_time;
  UNBLOCK_INPUT;
  if (! (decoded_time
-         && MOST_NEGATIVE_FIXNUM - TM_YEAR_BASE <= decoded_time->tm_year
+         && MOST_NEGATIVE_FIXNUM - TM_YEAR_BASE <= save_tm.tm_year
-         && decoded_time->tm_year <= MOST_POSITIVE_FIXNUM - TM_YEAR_BASE))
+         && save_tm.tm_year <= MOST_POSITIVE_FIXNUM - TM_YEAR_BASE))
    time_overflow ();
-  XSETFASTINT (list_args[0], decoded_time->tm_sec);
+  XSETFASTINT (list_args[0], save_tm.tm_sec);
-  XSETFASTINT (list_args[1], decoded_time->tm_min);
+  XSETFASTINT (list_args[1], save_tm.tm_min);
-  XSETFASTINT (list_args[2], decoded_time->tm_hour);
+  XSETFASTINT (list_args[2], save_tm.tm_hour);
-  XSETFASTINT (list_args[3], decoded_time->tm_mday);
+  XSETFASTINT (list_args[3], save_tm.tm_mday);
-  XSETFASTINT (list_args[4], decoded_time->tm_mon + 1);
+  XSETFASTINT (list_args[4], save_tm.tm_mon + 1);
  /* On 64-bit machines an int is narrower than EMACS_INT, thus the
     cast below avoids overflow in int arithmetics.  */
-  XSETINT (list_args[5], TM_YEAR_BASE + (EMACS_INT) decoded_time->tm_year);
+  XSETINT (list_args[5], TM_YEAR_BASE + (EMACS_INT) save_tm.tm_year);
-  XSETFASTINT (list_args[6], decoded_time->tm_wday);
+  XSETFASTINT (list_args[6], save_tm.tm_wday);
-  list_args[7] = (decoded_time->tm_isdst)? Qt : Qnil;
+  list_args[7] = save_tm.tm_isdst ? Qt : Qnil;
-  /* Make a copy, in case gmtime modifies the struct.  */
-  save_tm = *decoded_time;
  BLOCK_INPUT;
  decoded_time = gmtime (&time_spec);
-  UNBLOCK_INPUT;
  if (decoded_time == 0)
    list_args[8] = Qnil;
  else
    XSETINT (list_args[8], tm_diff (&save_tm, decoded_time));
+  UNBLOCK_INPUT;
  return Flist (9, list_args);
 }
@@ -1887,21 +1878,23 @@ usage: (encode-time SECOND MINUTE HOUR DAY MONTH YEAR &optional ZONE)  */)
      else
        error ("Invalid time zone specification");
+      BLOCK_INPUT;
      /* Set TZ before calling mktime; merely adjusting mktime's returned
         value doesn't suffice, since that would mishandle leap seconds.  */
      set_time_zone_rule (tzstring);
-      BLOCK_INPUT;
      value = mktime (&tm);
-      UNBLOCK_INPUT;
      /* Restore TZ to previous value.  */
      newenv = environ;
      environ = oldenv;
-      xfree (newenv);
 #ifdef LOCALTIME_CACHE
      tzset ();
 #endif
+      UNBLOCK_INPUT;
+      xfree (newenv);
    }
  if (value == (time_t) -1)
@@ -1928,24 +1921,37 @@ but this is considered obsolete.  */)
 {
  time_t value;
  struct tm *tm;
-  register char *tem;
+  char buf[sizeof "Mon Apr 30 12:49:17 " + INT_STRLEN_BOUND (int) + 1];
+  int len IF_LINT (= 0);
  if (! lisp_time_argument (specified_time, &value, NULL))
    error ("Invalid time specification");
-  /* Convert to a string, checking for out-of-range time stamps.
+  /* Convert to a string in ctime format, except without the trailing
-     Don't use 'ctime', as that might dump core if VALUE is out of
+     newline, and without the 4-digit year limit.  Don't use asctime
-     range.  */
+     or ctime, as they might dump core if the year is outside the
+     range -999 .. 9999.  */
  BLOCK_INPUT;
  tm = localtime (&value);
+  if (tm)
+    {
+      static char const wday_name[][4] =
+        { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };
+      static char const mon_name[][4] =
+        { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+          "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
+      printmax_t year_base = TM_YEAR_BASE;
+      len = sprintf (buf, "%s %s%3d %02d:%02d:%02d %"pMd,
+                     wday_name[tm->tm_wday], mon_name[tm->tm_mon], tm->tm_mday,
+                     tm->tm_hour, tm->tm_min, tm->tm_sec,
+                     tm->tm_year + year_base);
+    }
  UNBLOCK_INPUT;
-  if (! (tm && TM_YEAR_IN_ASCTIME_RANGE (tm->tm_year) && (tem = asctime (tm))))
+  if (! tm)
    time_overflow ();
-  /* Remove the trailing newline.  */
+  return make_unibyte_string (buf, len);
-  tem[strlen (tem) - 1] = '\0';
-  return build_string (tem);
 }
 /* Yield A - B, measured in seconds.
@@ -1989,22 +1995,22 @@ the data it can't find.  */)
  (Lisp_Object specified_time)
 {
  time_t value;
+  int offset;
  struct tm *t;
  struct tm localtm;
-  struct tm *localt;
  Lisp_Object zone_offset, zone_name;
  zone_offset = Qnil;
  zone_name = format_time_string ("%Z", sizeof "%Z" - 1, specified_time,
-                                  0, &value, &localt);
+                                  0, &value, &localtm);
-  localtm = *localt;
  BLOCK_INPUT;
  t = gmtime (&value);
+  if (t)
+    offset = tm_diff (&localtm, t);
  UNBLOCK_INPUT;
  if (t)
    {
-      int offset = tm_diff (&localtm, t);
      zone_offset = make_number (offset);
      if (SCHARS (zone_name) == 0)
        {
@@ -2042,9 +2048,16 @@ only the former.  */)
  (Lisp_Object tz)
 {
  const char *tzstring;
+  char **old_environbuf;
+  if (! (NILP (tz) || EQ (tz, Qt)))
+    CHECK_STRING (tz);
+  BLOCK_INPUT;
  /* When called for the first time, save the original TZ.  */
-  if (!environbuf)
+  old_environbuf = environbuf;
+  if (!old_environbuf)
    initial_tz = (char *) getenv ("TZ");
  if (NILP (tz))
@@ -2052,15 +2065,14 @@ only the former.  */)
  else if (EQ (tz, Qt))
    tzstring = "UTC0";
  else
-    {
+    tzstring = SSDATA (tz);
-      CHECK_STRING (tz);
-      tzstring = SSDATA (tz);
-    }
  set_time_zone_rule (tzstring);
-  xfree (environbuf);
  environbuf = environ;
+  UNBLOCK_INPUT;
+  xfree (old_environbuf);
  return Qnil;
 }
diff --git a/src/emacsgtkfixed.c b/src/emacsgtkfixed.c
index fba672ff74d..1a62b59b7af 100644
--- a/src/emacsgtkfixed.c
+++ b/src/emacsgtkfixed.c
@@ -28,6 +28,27 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "frame.h"
 #include "xterm.h"
+#define EMACS_TYPE_FIXED emacs_fixed_get_type ()
+#define EMACS_FIXED(obj) \
+  G_TYPE_CHECK_INSTANCE_CAST (obj, EMACS_TYPE_FIXED, EmacsFixed)
+typedef struct _EmacsFixed EmacsFixed;
+typedef struct _EmacsFixedPrivate EmacsFixedPrivate;
+typedef struct _EmacsFixedClass EmacsFixedClass;
+struct _EmacsFixed
+{
+  GtkFixed container;
+  /*< private >*/
+  EmacsFixedPrivate *priv;
+};
+struct _EmacsFixedClass
+{
+  GtkFixedClass parent_class;
+};
 struct _EmacsFixedPrivate
 {
  struct frame *f;
@@ -40,28 +61,21 @@ static void emacs_fixed_get_preferred_width  (GtkWidget *widget,
 static void emacs_fixed_get_preferred_height (GtkWidget *widget,
                                              gint      *minimum,
                                              gint      *natural);
+static GType emacs_fixed_get_type (void);
 G_DEFINE_TYPE (EmacsFixed, emacs_fixed, GTK_TYPE_FIXED)
 static void
 emacs_fixed_class_init (EmacsFixedClass *klass)
 {
  GtkWidgetClass *widget_class;
-  GtkFixedClass *fixed_class;
  widget_class = (GtkWidgetClass*) klass;
-  fixed_class = (GtkFixedClass*) klass;
  widget_class->get_preferred_width = emacs_fixed_get_preferred_width;
  widget_class->get_preferred_height = emacs_fixed_get_preferred_height;
  g_type_class_add_private (klass, sizeof (EmacsFixedPrivate));
 }
-static GType
-emacs_fixed_child_type (GtkFixed *container)
-{
-  return GTK_TYPE_WIDGET;
-}
 static void
 emacs_fixed_init (EmacsFixed *fixed)
 {
diff --git a/src/emacsgtkfixed.h b/src/emacsgtkfixed.h
index 90fb37e521b..3fa294aa41e 100644
--- a/src/emacsgtkfixed.h
+++ b/src/emacsgtkfixed.h
@@ -27,33 +27,7 @@ G_BEGIN_DECLS
 struct frame;
-#define EMACS_TYPE_FIXED                  (emacs_fixed_get_type ())
-#define EMACS_FIXED(obj)                  (G_TYPE_CHECK_INSTANCE_CAST ((obj), EMACS_TYPE_FIXED, EmacsFixed))
-#define EMACS_FIXED_CLASS(klass)          (G_TYPE_CHECK_CLASS_CAST ((klass), EMACS_TYPE_FIXED, EmacsFixedClass))
-#define EMACS_IS_FIXED(obj)               (G_TYPE_CHECK_INSTANCE_TYPE ((obj), EMACS_TYPE_FIXED))
-#define EMACS_IS_FIXED_CLASS(klass)       (G_TYPE_CHECK_CLASS_TYPE ((klass), EMACS_TYPE_FIXED))
-#define EMACS_FIXED_GET_CLASS(obj)        (G_TYPE_INSTANCE_GET_CLASS ((obj), EMACS_TYPE_FIXED, EmacsFixedClass))
-typedef struct _EmacsFixed              EmacsFixed;
-typedef struct _EmacsFixedPrivate       EmacsFixedPrivate;
-typedef struct _EmacsFixedClass         EmacsFixedClass;
-struct _EmacsFixed
-{
-  GtkFixed container;
-  /*< private >*/
-  EmacsFixedPrivate *priv;
-};
-struct _EmacsFixedClass
-{
-  GtkFixedClass parent_class;
-};
 extern GtkWidget *emacs_fixed_new (struct frame *f);
-extern GType emacs_fixed_get_type (void);
 G_END_DECLS
diff --git a/src/eval.c b/src/eval.c
index d266d995c4b..e44b7e32915 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2020,7 +2020,7 @@ this does nothing and returns nil.  */)
       We used to use 0 here, but that leads to accidental sharing in
       purecopy's hash-consing, so we use a (hopefully) unique integer
       instead.  */
-    docstring = make_number (XPNTR (function));
+    docstring = make_number (XUNTAG (function, Lisp_Symbol));
  return Ffset (function,
                Fpurecopy (list5 (Qautoload, file, docstring,
                                  interactive, type)));
diff --git a/src/fileio.c b/src/fileio.c
index c5442d560fd..c6e2eea5089 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-2012 Free Software Foundation, Inc.
 This file is part of GNU Emacs.
@@ -87,17 +87,17 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define FILE_SYSTEM_CASE(filename)  (filename)
 #endif
-/* Nonzero during writing of auto-save files */
+/* Nonzero during writing of auto-save files.  */
 static int auto_saving;
-/* Nonzero umask during creation of auto-save directories */
+/* Nonzero umask during creation of auto-save directories.  */
 static int auto_saving_dir_umask;
 /* Set by auto_save_1 to mode of original file so Fwrite_region will create
-   a new file with the same mode as the original */
+   a new file with the same mode as the original.  */
 static int auto_save_mode_bits;
-/* Set by auto_save_1 if an error occurred during the last auto-save. */
+/* Set by auto_save_1 if an error occurred during the last auto-save.  */
 static int auto_save_error_occurred;
 /* The symbol bound to coding-system-for-read when
@@ -111,7 +111,7 @@ static Lisp_Object Qauto_save_coding;
   which gives a list of operations it handles..  */
 static Lisp_Object Qoperations;
-/* Lisp functions for translating file formats */
+/* Lisp functions for translating file formats.  */
 static Lisp_Object Qformat_decode, Qformat_annotate_function;
 /* Lisp function for setting buffer-file-coding-system and the
@@ -877,7 +877,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
        }
    }
-  /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below. */
+  /* Make a local copy of nm[] to protect it from GC in DECODE_FILE below.  */
  nm = (char *) alloca (SBYTES (name) + 1);
  memcpy (nm, SSDATA (name), SBYTES (name) + 1);
@@ -905,7 +905,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
  if (drive && IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
    nm++;
-  /* Discard any previous drive specifier if nm is now in UNC format. */
+  /* Discard any previous drive specifier if nm is now in UNC format.  */
  if (IS_DIRECTORY_SEP (nm[0]) && IS_DIRECTORY_SEP (nm[1]))
    {
      drive = 0;
@@ -970,7 +970,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
            }
          else
 #endif
-          /* drive must be set, so this is okay */
+          /* Drive must be set, so this is okay.  */
          if (strcmp (nm - 2, SSDATA (name)) != 0)
            {
              char temp[] = " :";
@@ -1016,7 +1016,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
          if (!(newdir = egetenv ("HOME")))
            newdir = "";
          nm++;
-          /* egetenv may return a unibyte string, which will bite us since
+          /* `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))
@@ -1058,7 +1058,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
     use the drive's current directory as the prefix if needed.  */
  if (!newdir && drive)
    {
-      /* Get default directory if needed to make nm absolute. */
+      /* Get default directory if needed to make nm absolute.  */
      char *adir = NULL;
      if (!IS_DIRECTORY_SEP (nm[0]))
        {
@@ -1068,7 +1068,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
        }
      if (!adir)
        {
-          /* Either nm starts with /, or drive isn't mounted. */
+          /* Either nm starts with /, or drive isn't mounted.  */
          adir = alloca (4);
          adir[0] = DRIVE_LETTER (drive);
          adir[1] = ':';
@@ -1080,11 +1080,11 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #endif /* DOS_NT */
  /* Finally, if no prefix has been specified and nm is not absolute,
-     then it must be expanded relative to default_directory. */
+     then it must be expanded relative to default_directory.  */
  if (1
 #ifndef DOS_NT
-      /* /... alone is not absolute on DOS and Windows. */
+      /* /... alone is not absolute on DOS and Windows.  */
      && !IS_DIRECTORY_SEP (nm[0])
 #endif
 #ifdef WINDOWSNT
@@ -1106,7 +1106,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
 #ifdef DOS_NT
  if (newdir)
    {
-      /* First ensure newdir is an absolute name. */
+      /* First ensure newdir is an absolute name.  */
      if (
          /* Detect MSDOS file names with drive specifiers.  */
          ! (IS_DRIVE (newdir[0])
@@ -1121,7 +1121,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
             Because of the admonition against calling expand-file-name
             when we have pointers into lisp strings, we accomplish this
             indirectly by prepending newdir to nm if necessary, and using
-             cwd (or the wd of newdir's drive) as the new newdir. */
+             cwd (or the wd of newdir's drive) as the new newdir.  */
          char *adir;
          if (IS_DRIVE (newdir[0]) && IS_DEVICE_SEP (newdir[1]))
            {
@@ -1146,7 +1146,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
          newdir = adir;
        }
-      /* Strip off drive name from prefix, if present. */
+      /* Strip off drive name from prefix, if present.  */
      if (IS_DRIVE (newdir[0]) && IS_DEVICE_SEP (newdir[1]))
        {
          drive = newdir[0];
@@ -1196,7 +1196,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
  else
    tlen = 0;
-  /* Now concatenate the directory and name to new space in the stack frame */
+  /* Now concatenate the directory and name to new space in the stack frame.  */
  tlen += strlen (nm) + 1;
 #ifdef DOS_NT
  /* Reserve space for drive specifier and escape prefix, since either
@@ -1292,7 +1292,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
      }
 #ifdef DOS_NT
-    /* At last, set drive name. */
+    /* At last, set drive name.  */
 #ifdef WINDOWSNT
    /* Except for network file name.  */
    if (!(IS_DIRECTORY_SEP (target[0]) && IS_DIRECTORY_SEP (target[1])))
@@ -1320,7 +1320,7 @@ filesystem tree, not (expand-file-name ".."  dirname).  */)
     and perhaps call the corresponding file handler.  This is needed
     for filenames such as "/foo/../user@host:/bar/../baz".  Expanding
     the ".." component gives us "/user@host:/bar/../baz" which needs
-     to be expanded again. */
+     to be expanded again.  */
  handler = Ffind_file_name_handler (result, Qexpand_file_name);
  if (!NILP (handler))
    {
@@ -1396,7 +1396,7 @@ See also the function `substitute-in-file-name'.")
        }
    }
-  /* Now determine directory to start with and put it in NEWDIR */
+  /* Now determine directory to start with and put it in NEWDIR.  */
  newdir = 0;
@@ -1409,17 +1409,17 @@ See also the function `substitute-in-file-name'.")
      }
    else  /* ~user/filename */
      {
-        /* Get past ~ to user */
+        /* Get past ~ to user.  */
        unsigned char *user = nm + 1;
-        /* Find end of name. */
+        /* Find end of name.  */
        unsigned char *ptr = (unsigned char *) strchr (user, '/');
        ptrdiff_t len = ptr ? ptr - user : strlen (user);
-        /* Copy the user name into temp storage. */
+        /* Copy the user name into temp storage.  */
        o = (unsigned char *) alloca (len + 1);
        memcpy (o, user, len);
        o[len] = 0;
-        /* Look up the user name. */
+        /* Look up the user name.  */
        BLOCK_INPUT;
        pw = (struct passwd *) getpwnam (o + 1);
        UNBLOCK_INPUT;
@@ -1440,7 +1440,7 @@ See also the function `substitute-in-file-name'.")
      newdir = SDATA (defalt);
    }
-  /* Now concatenate the directory and name to new space in the stack frame */
+  /* Now concatenate the directory and name to new space in the stack frame.  */
  tlen = (newdir ? strlen (newdir) + 1 : 0) + strlen (nm) + 1;
  target = (unsigned char *) alloca (tlen);
@@ -1456,7 +1456,7 @@ See also the function `substitute-in-file-name'.")
  strcat (target, nm);
-  /* Now canonicalize by removing /. and /foo/.. if they appear */
+  /* Now canonicalize by removing /. and /foo/.. if they appear.  */
  p = target;
  o = target;
@@ -1528,7 +1528,7 @@ search_embedded_absfilename (char *nm, char *endp)
              )
        {
          for (s = p; *s && (!IS_DIRECTORY_SEP (*s)); s++);
-          if (p[0] == '~' && s > p + 1) /* we've got "/~something/" */
+          if (p[0] == '~' && s > p + 1) /* We've got "/~something/".  */
            {
              char *o = alloca (s - p + 1);
              struct passwd *pw;
@@ -1612,7 +1612,7 @@ those `/' is discarded.  */)
      (make_specified_string (p, -1, endp - p, multibyte));
  /* See if any variables are substituted into the string
-     and find the total length of their values in `total' */
+     and find the total length of their values in `total'.  */
  for (p = nm; p != endp;)
    if (*p != '$')
@@ -1624,7 +1624,7 @@ those `/' is discarded.  */)
          goto badsubst;
        else if (*p == '$')
          {
-            /* "$$" means a single "$" */
+            /* "$$" means a single "$".  */
            p++;
            total -= 1;
            substituted = 1;
@@ -1644,7 +1644,7 @@ those `/' is discarded.  */)
            s = p;
          }
-        /* Copy out the variable name */
+        /* Copy out the variable name.  */
        target = (char *) alloca (s - o + 1);
        strncpy (target, o, s - o);
        target[s - o] = 0;
@@ -1652,7 +1652,7 @@ those `/' is discarded.  */)
        strupr (target); /* $home == $HOME etc.  */
 #endif /* DOS_NT */
-        /* Get variable value */
+        /* Get variable value.  */
        o = egetenv (target);
        if (o)
          {
@@ -1674,12 +1674,12 @@ those `/' is discarded.  */)
  if (!substituted)
    return filename;
-  /* If substitution required, recopy the string and do it */
+  /* If substitution required, recopy the string and do it.  */
-  /* Make space in stack frame for the new copy */
+  /* Make space in stack frame for the new copy.  */
  xnm = (char *) alloca (SBYTES (filename) + total + 1);
  x = xnm;
-  /* Copy the rest of the name through, replacing $ constructs with values */
+  /* Copy the rest of the name through, replacing $ constructs with values.  */
  for (p = nm; *p;)
    if (*p != '$')
      *x++ = *p++;
@@ -1707,7 +1707,7 @@ those `/' is discarded.  */)
            s = p;
          }
-        /* Copy out the variable name */
+        /* Copy out the variable name.  */
        target = (char *) alloca (s - o + 1);
        strncpy (target, o, s - o);
        target[s - o] = 0;
@@ -1715,7 +1715,7 @@ those `/' is discarded.  */)
        strupr (target); /* $home == $HOME etc.  */
 #endif /* DOS_NT */
-        /* Get variable value */
+        /* Get variable value.  */
        o = egetenv (target);
        if (!o)
          {
@@ -1777,7 +1777,7 @@ expand_and_dir_to_file (Lisp_Object filename, Lisp_Object defdir)
     stat behaves differently depending!  */
  if (SCHARS (absname) > 1
      && IS_DIRECTORY_SEP (SREF (absname, SBYTES (absname) - 1))
-      && !IS_DEVICE_SEP (SREF (absname, SBYTES (absname)-2)))
+      && !IS_DEVICE_SEP (SREF (absname, SBYTES (absname) - 2)))
    /* We cannot take shortcuts; they might be wrong for magic file names.  */
    absname = Fdirectory_file_name (absname);
  return absname;
@@ -1805,7 +1805,7 @@ barf_or_query_if_file_exists (Lisp_Object absname, const char *querystring,
  encoded_filename = ENCODE_FILE (absname);
-  /* stat is a good way to tell whether the file exists,
+  /* `stat' is a good way to tell whether the file exists,
     regardless of what access permissions it has.  */
  if (lstat (SSDATA (encoded_filename), &statbuf) >= 0)
    {
@@ -2044,9 +2044,10 @@ on the system, we copy the SELinux context of FILE to NEWNAME.  */)
 #if HAVE_LIBSELINUX
  if (conlength > 0)
    {
-      /* Set the modified context back to the file. */
+      /* Set the modified context back to the file.  */
      fail = fsetfilecon (ofd, con);
-      if (fail)
+      /* See http://debbugs.gnu.org/11245 for ENOTSUP.  */
+      if (fail && errno != ENOTSUP)
        report_file_error ("Doing fsetfilecon", Fcons (newname, Qnil));
      freecon (con);
@@ -2917,10 +2918,11 @@ compiled with SELinux support.  */)
                error ("Doing context_range_set");
            }
-          /* Set the modified context back to the file. */
+          /* Set the modified context back to the file.  */
          fail = lsetfilecon (SSDATA (encoded_absname),
                              context_str (parsed_con));
-          if (fail)
+          /* See http://debbugs.gnu.org/11245 for ENOTSUP.  */
+          if (fail && errno != ENOTSUP)
            report_file_error ("Doing lsetfilecon", Fcons (absname, Qnil));
          context_free (parsed_con);
diff --git a/src/filelock.c b/src/filelock.c
index 2613eec4aca..d8914c73328 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -550,6 +550,10 @@ lock_file (Lisp_Object fn)
  struct gcpro gcpro1;
  USE_SAFE_ALLOCA;
+  /* Don't do locking if the user has opted out.  */
+  if (! create_lockfiles)
+    return;
  /* Don't do locking while dumping Emacs.
     Uncompressing wtmp files uses call-process, which does not work
     in an uninitialized Emacs.  */
@@ -722,6 +726,10 @@ syms_of_filelock (void)
               doc: /* The directory for writing temporary files.  */);
  Vtemporary_file_directory = Qnil;
+  DEFVAR_BOOL ("create-lockfiles", create_lockfiles,
+               doc: /* Non-nil means use lockfiles to avoid editing collisions.  */);
+  create_lockfiles = 1;
 #ifdef CLASH_DETECTION
  defsubr (&Sunlock_buffer);
  defsubr (&Slock_buffer);
diff --git a/src/fns.c b/src/fns.c
index 6c7c1b21045..676e53ccbd8 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -42,10 +42,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #endif
 #endif /* HAVE_MENUS */
-#ifndef NULL
-#define NULL ((POINTER_TYPE *)0)
-#endif
 Lisp_Object Qstring_lessp;
 static Lisp_Object Qprovide, Qrequire;
 static Lisp_Object Qyes_or_no_p_history;
diff --git a/src/font.h b/src/font.h
index 89f6b29ca9d..b058be67aa3 100644
--- a/src/font.h
+++ b/src/font.h
@@ -469,11 +469,12 @@ struct font_bitmap
  } while (0)
 #define XFONT_SPEC(p)   \
-  (eassert (FONT_SPEC_P(p)), (struct font_spec *) XPNTR (p))
+  (eassert (FONT_SPEC_P (p)), (struct font_spec *) XUNTAG (p, Lisp_Vectorlike))
 #define XFONT_ENTITY(p) \
-  (eassert (FONT_ENTITY_P(p)), (struct font_entity *) XPNTR (p))
+  (eassert (FONT_ENTITY_P (p)), \
+   (struct font_entity *) XUNTAG (p, Lisp_Vectorlike))
 #define XFONT_OBJECT(p) \
-  (eassert (FONT_OBJECT_P(p)), (struct font *) XPNTR (p))
+  (eassert (FONT_OBJECT_P (p)), (struct font *) XUNTAG (p, Lisp_Vectorlike))
 #define XSETFONT(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FONT))
 /* Number of pt per inch (from the TeXbook).  */
diff --git a/src/frame.h b/src/frame.h
index e058a101462..1a8bff7c3e7 100644
--- a/src/frame.h
+++ b/src/frame.h
@@ -501,7 +501,8 @@ struct frame
 typedef struct frame *FRAME_PTR;
-#define XFRAME(p) (eassert (FRAMEP(p)),(struct frame *) XPNTR (p))
+#define XFRAME(p) \
+  (eassert (FRAMEP (p)), (struct frame *) XUNTAG (p, Lisp_Vectorlike))
 #define XSETFRAME(a, b) (XSETPSEUDOVECTOR (a, b, PVEC_FRAME))
 /* Given a window, return its frame as a Lisp_Object.  */
diff --git a/src/gmalloc.c b/src/gmalloc.c
index 7b5e6df009b..0df050e127a 100644
--- a/src/gmalloc.c
+++ b/src/gmalloc.c
@@ -1,9 +1,3 @@
-/* This file is no longer automatically generated from libc.  */
-#define _MALLOC_INTERNAL
-/* The malloc headers and source files from the C library follow here.  */
 /* Declarations for `malloc' and friends.
   Copyright (C) 1990, 1991, 1992, 1993, 1995, 1996, 1999, 2002, 2003, 2004,
                 2005, 2006, 2007 Free Software Foundation, Inc.
@@ -27,12 +21,6 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifndef _MALLOC_H
-#define _MALLOC_H       1
-#ifdef _MALLOC_INTERNAL
 #ifdef  HAVE_CONFIG_H
 #include <config.h>
 #endif
@@ -41,62 +29,44 @@ Fifth Floor, Boston, MA 02110-1301, USA.
 #define USE_PTHREAD
 #endif
-#undef  PP
-#define PP(args)        args
-#undef  __ptr_t
-#define __ptr_t         void *
 #include <string.h>
 #include <limits.h>
+#include <stdint.h>
 #include <unistd.h>
 #ifdef USE_PTHREAD
 #include <pthread.h>
 #endif
-#endif  /* _MALLOC_INTERNAL.  */
 #ifdef  __cplusplus
 extern "C"
 {
 #endif
 #include <stddef.h>
-#define __malloc_size_t         size_t
-#define __malloc_ptrdiff_t      ptrdiff_t
 /* Allocate SIZE bytes of memory.  */
-extern __ptr_t malloc PP ((__malloc_size_t __size));
+extern void *malloc (size_t size);
 /* Re-allocate the previously allocated block
-   in __ptr_t, making the new block SIZE bytes long.  */
+   in ptr, making the new block SIZE bytes long.  */
-extern __ptr_t realloc PP ((__ptr_t __ptr, __malloc_size_t __size));
+extern void *realloc (void *ptr, size_t size);
 /* Allocate NMEMB elements of SIZE bytes each, all initialized to 0.  */
-extern __ptr_t calloc PP ((__malloc_size_t __nmemb, __malloc_size_t __size));
+extern void *calloc (size_t nmemb, size_t size);
 /* Free a block allocated by `malloc', `realloc' or `calloc'.  */
-extern void free PP ((__ptr_t __ptr));
+extern void free (void *ptr);
 /* Allocate SIZE bytes allocated to ALIGNMENT bytes.  */
-#if !defined (_MALLOC_INTERNAL) || defined (MSDOS) /* Avoid conflict.  */
+#ifdef MSDOS
-extern __ptr_t memalign PP ((__malloc_size_t __alignment,
+extern void *memalign (size_t, size_t);
-                             __malloc_size_t __size));
+extern int posix_memalign (void **, size_t, size_t);
-extern int posix_memalign PP ((__ptr_t *, __malloc_size_t,
-                               __malloc_size_t size));
-#endif
-/* Allocate SIZE bytes on a page boundary.  */
-#if ! (defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC))
-extern __ptr_t valloc PP ((__malloc_size_t __size));
 #endif
 #ifdef USE_PTHREAD
 /* Set up mutexes and make malloc etc. thread-safe.  */
-extern void malloc_enable_thread PP ((void));
+extern void malloc_enable_thread (void);
 #endif
-#ifdef _MALLOC_INTERNAL
 /* The allocator divides the heap into blocks of fixed size; large
   requests receive one or more whole blocks, and small requests
   receive a fragment of a block.  Fragment sizes are powers of two,
@@ -128,22 +98,22 @@ typedef union
          {
            struct
              {
-                __malloc_size_t nfree; /* Free frags in a fragmented block.  */
+                size_t nfree; /* Free frags in a fragmented block.  */
-                __malloc_size_t first; /* First free fragment of the block.  */
+                size_t first; /* First free fragment of the block.  */
              } frag;
            /* For a large object, in its first block, this has the number
               of blocks in the object.  In the other blocks, this has a
               negative number which says how far back the first block is.  */
-            __malloc_ptrdiff_t size;
+            ptrdiff_t size;
          } info;
      } busy;
    /* Heap information for a free block
       (that may be the first of a free cluster).  */
    struct
      {
-        __malloc_size_t size;   /* Size (in blocks) of a free cluster.  */
+        size_t size;    /* Size (in blocks) of a free cluster.  */
-        __malloc_size_t next;   /* Index of next free cluster.  */
+        size_t next;    /* Index of next free cluster.  */
-        __malloc_size_t prev;   /* Index of previous free cluster.  */
+        size_t prev;    /* Index of previous free cluster.  */
      } free;
  } malloc_info;
@@ -155,13 +125,13 @@ extern malloc_info *_heapinfo;
 /* Address to block number and vice versa.  */
 #define BLOCK(A)        (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
-#define ADDRESS(B)      ((__ptr_t) (((B) - 1) * BLOCKSIZE + _heapbase))
+#define ADDRESS(B)      ((void *) (((B) - 1) * BLOCKSIZE + _heapbase))
 /* Current search index for the heap table.  */
-extern __malloc_size_t _heapindex;
+extern size_t _heapindex;
 /* Limit of valid info table indices.  */
-extern __malloc_size_t _heaplimit;
+extern size_t _heaplimit;
 /* Doubly linked lists of free fragments.  */
 struct list
@@ -177,26 +147,26 @@ extern struct list _fraghead[];
 struct alignlist
  {
    struct alignlist *next;
-    __ptr_t aligned;            /* The address that memaligned returned.  */
+    void *aligned;              /* The address that memaligned returned.  */
-    __ptr_t exact;              /* The address that malloc returned.  */
+    void *exact;                /* The address that malloc returned.  */
  };
 extern struct alignlist *_aligned_blocks;
 /* Instrumentation.  */
-extern __malloc_size_t _chunks_used;
+extern size_t _chunks_used;
-extern __malloc_size_t _bytes_used;
+extern size_t _bytes_used;
-extern __malloc_size_t _chunks_free;
+extern size_t _chunks_free;
-extern __malloc_size_t _bytes_free;
+extern size_t _bytes_free;
 /* Internal versions of `malloc', `realloc', and `free'
   used when these functions need to call each other.
   They are the same but don't call the hooks.  */
-extern __ptr_t _malloc_internal PP ((__malloc_size_t __size));
+extern void *_malloc_internal (size_t);
-extern __ptr_t _realloc_internal PP ((__ptr_t __ptr, __malloc_size_t __size));
+extern void *_realloc_internal (void *, size_t);
-extern void _free_internal PP ((__ptr_t __ptr));
+extern void _free_internal (void *);
-extern __ptr_t _malloc_internal_nolock PP ((__malloc_size_t __size));
+extern void *_malloc_internal_nolock (size_t);
-extern __ptr_t _realloc_internal_nolock PP ((__ptr_t __ptr, __malloc_size_t __size));
+extern void *_realloc_internal_nolock (void *, size_t);
-extern void _free_internal_nolock PP ((__ptr_t __ptr));
+extern void _free_internal_nolock (void *);
 #ifdef USE_PTHREAD
 extern pthread_mutex_t _malloc_mutex, _aligned_blocks_mutex;
@@ -228,39 +198,36 @@ extern int _malloc_thread_enabled_p;
 #define UNLOCK_ALIGNED_BLOCKS()
 #endif
-#endif /* _MALLOC_INTERNAL.  */
 /* Given an address in the middle of a malloc'd object,
   return the address of the beginning of the object.  */
-extern __ptr_t malloc_find_object_address PP ((__ptr_t __ptr));
+extern void *malloc_find_object_address (void *ptr);
 /* Underlying allocation function; successive calls should
   return contiguous pieces of memory.  */
-extern __ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size));
+extern void *(*__morecore) (ptrdiff_t size);
 /* Default value of `__morecore'.  */
-extern __ptr_t __default_morecore PP ((__malloc_ptrdiff_t __size));
+extern void *__default_morecore (ptrdiff_t size);
 /* If not NULL, this function is called after each time
   `__morecore' is called to increase the data size.  */
-extern void (*__after_morecore_hook) PP ((void));
+extern void (*__after_morecore_hook) (void);
 /* Number of extra blocks to get each time we ask for more core.
   This reduces the frequency of calling `(*__morecore)'.  */
-extern __malloc_size_t __malloc_extra_blocks;
+extern size_t __malloc_extra_blocks;
 /* Nonzero if `malloc' has been called and done its initialization.  */
 extern int __malloc_initialized;
 /* Function called to initialize malloc data structures.  */
-extern int __malloc_initialize PP ((void));
+extern int __malloc_initialize (void);
 /* Hooks for debugging versions.  */
-extern void (*__malloc_initialize_hook) PP ((void));
+extern void (*__malloc_initialize_hook) (void);
-extern void (*__free_hook) PP ((__ptr_t __ptr));
+extern void (*__free_hook) (void *ptr);
-extern __ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
+extern void *(*__malloc_hook) (size_t size);
-extern __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size));
+extern void *(*__realloc_hook) (void *ptr, size_t size);
-extern __ptr_t (*__memalign_hook) PP ((__malloc_size_t __size,
+extern void *(*__memalign_hook) (size_t size, size_t alignment);
-                                       __malloc_size_t __alignment));
 /* Return values for `mprobe': these are the kinds of inconsistencies that
   `mcheck' enables detection of.  */
@@ -277,52 +244,37 @@ enum mcheck_status
   before `malloc' is ever called.  ABORTFUNC is called with an error code
   (see enum above) when an inconsistency is detected.  If ABORTFUNC is
   null, the standard function prints on stderr and then calls `abort'.  */
-extern int mcheck PP ((void (*__abortfunc) PP ((enum mcheck_status))));
+extern int mcheck (void (*abortfunc) (enum mcheck_status));
 /* Check for aberrations in a particular malloc'd block.  You must have
   called `mcheck' already.  These are the same checks that `mcheck' does
   when you free or reallocate a block.  */
-extern enum mcheck_status mprobe PP ((__ptr_t __ptr));
+extern enum mcheck_status mprobe (void *ptr);
 /* Activate a standard collection of tracing hooks.  */
-extern void mtrace PP ((void));
+extern void mtrace (void);
-extern void muntrace PP ((void));
+extern void muntrace (void);
 /* Statistics available to the user.  */
 struct mstats
  {
-    __malloc_size_t bytes_total; /* Total size of the heap. */
+    size_t bytes_total; /* Total size of the heap. */
-    __malloc_size_t chunks_used; /* Chunks allocated by the user. */
+    size_t chunks_used; /* Chunks allocated by the user. */
-    __malloc_size_t bytes_used; /* Byte total of user-allocated chunks. */
+    size_t bytes_used;  /* Byte total of user-allocated chunks. */
-    __malloc_size_t chunks_free; /* Chunks in the free list. */
+    size_t chunks_free; /* Chunks in the free list. */
-    __malloc_size_t bytes_free; /* Byte total of chunks in the free list. */
+    size_t bytes_free;  /* Byte total of chunks in the free list. */
  };
 /* Pick up the current statistics. */
-extern struct mstats mstats PP ((void));
+extern struct mstats mstats (void);
 /* Call WARNFUN with a warning message when memory usage is high.  */
-extern void memory_warnings PP ((__ptr_t __start,
+extern void memory_warnings (void *start, void (*warnfun) (const char *));
-                                 void (*__warnfun) PP ((const char *))));
-/* Relocating allocator.  */
-/* Allocate SIZE bytes, and store the address in *HANDLEPTR.  */
-extern __ptr_t r_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size));
-/* Free the storage allocated in HANDLEPTR.  */
-extern void r_alloc_free PP ((__ptr_t *__handleptr));
-/* Adjust the block at HANDLEPTR to be SIZE bytes long.  */
-extern __ptr_t r_re_alloc PP ((__ptr_t *__handleptr, __malloc_size_t __size));
 #ifdef  __cplusplus
 }
 #endif
-#endif /* malloc.h  */
 /* Memory allocator `malloc'.
   Copyright 1990, 1991, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
                  Written May 1989 by Mike Haertel.
@@ -345,10 +297,6 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 #include <errno.h>
 /* On Cygwin there are two heaps.  temacs uses the static heap
@@ -362,15 +310,15 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   this is changed in the future, we'll have to similarly deal with
   reinitializing ralloc. */
 #ifdef CYGWIN
-extern __ptr_t bss_sbrk PP ((ptrdiff_t __size));
+extern void *bss_sbrk (ptrdiff_t size);
 extern int bss_sbrk_did_unexec;
 char *bss_sbrk_heapbase;        /* _heapbase for static heap */
 malloc_info *bss_sbrk_heapinfo; /* _heapinfo for static heap */
 #endif
-__ptr_t (*__morecore) PP ((__malloc_ptrdiff_t __size)) = __default_morecore;
+void *(*__morecore) (ptrdiff_t size) = __default_morecore;
 /* Debugging hook for `malloc'.  */
-__ptr_t (*__malloc_hook) PP ((__malloc_size_t __size));
+void *(*__malloc_hook) (size_t size);
 /* Pointer to the base of the first block.  */
 char *_heapbase;
@@ -379,30 +327,30 @@ char *_heapbase;
 malloc_info *_heapinfo;
 /* Number of info entries.  */
-static __malloc_size_t heapsize;
+static size_t heapsize;
 /* Search index in the info table.  */
-__malloc_size_t _heapindex;
+size_t _heapindex;
 /* Limit of valid info table indices.  */
-__malloc_size_t _heaplimit;
+size_t _heaplimit;
 /* Free lists for each fragment size.  */
 struct list _fraghead[BLOCKLOG];
 /* Instrumentation.  */
-__malloc_size_t _chunks_used;
+size_t _chunks_used;
-__malloc_size_t _bytes_used;
+size_t _bytes_used;
-__malloc_size_t _chunks_free;
+size_t _chunks_free;
-__malloc_size_t _bytes_free;
+size_t _bytes_free;
 /* Are you experienced?  */
 int __malloc_initialized;
-__malloc_size_t __malloc_extra_blocks;
+size_t __malloc_extra_blocks;
-void (*__malloc_initialize_hook) PP ((void));
+void (*__malloc_initialize_hook) (void);
-void (*__after_morecore_hook) PP ((void));
+void (*__after_morecore_hook) (void);
 #if defined GC_MALLOC_CHECK && defined GC_PROTECT_MALLOC_STATE
@@ -419,12 +367,11 @@ void (*__after_morecore_hook) PP ((void));
 #include <sys/mman.h>
 static int state_protected_p;
-static __malloc_size_t last_state_size;
+static size_t last_state_size;
 static malloc_info *last_heapinfo;
 void
-protect_malloc_state (protect_p)
+protect_malloc_state (int protect_p)
-     int protect_p;
 {
  /* If _heapinfo has been relocated, make sure its old location
     isn't left read-only; it will be reused by malloc.  */
@@ -453,29 +400,25 @@ protect_malloc_state (protect_p)
 /* Aligned allocation.  */
-static __ptr_t align PP ((__malloc_size_t));
+static void *
-static __ptr_t
+align (size_t size)
-align (size)
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
-  unsigned long int adj;
+  ptrdiff_t adj;
  /* align accepts an unsigned argument, but __morecore accepts a
-     signed one.  This could lead to trouble if SIZE overflows a
+     signed one.  This could lead to trouble if SIZE overflows the
-     signed int type accepted by __morecore.  We just punt in that
+     ptrdiff_t type accepted by __morecore.  We just punt in that
     case, since they are requesting a ludicrous amount anyway.  */
-  if ((__malloc_ptrdiff_t)size < 0)
+  if (PTRDIFF_MAX < size)
    result = 0;
  else
    result = (*__morecore) (size);
-  adj = (unsigned long int) ((unsigned long int) ((char *) result -
+  adj = (uintptr_t) result % BLOCKSIZE;
-                                                  (char *) NULL)) % BLOCKSIZE;
  if (adj != 0)
    {
-      __ptr_t new;
      adj = BLOCKSIZE - adj;
-      new = (*__morecore) (adj);
+      (*__morecore) (adj);
      result = (char *) result + adj;
    }
@@ -488,14 +431,11 @@ align (size)
 /* Get SIZE bytes, if we can get them starting at END.
   Return the address of the space we got.
   If we cannot get space at END, fail and return 0.  */
-static __ptr_t get_contiguous_space PP ((__malloc_ptrdiff_t, __ptr_t));
+static void *
-static __ptr_t
+get_contiguous_space (ptrdiff_t size, void *position)
-get_contiguous_space (size, position)
-     __malloc_ptrdiff_t size;
-     __ptr_t position;
 {
-  __ptr_t before;
+  void *before;
-  __ptr_t after;
+  void *after;
  before = (*__morecore) (0);
  /* If we can tell in advance that the break is at the wrong place,
@@ -525,7 +465,7 @@ get_contiguous_space (size, position)
 static inline void
 register_heapinfo (void)
 {
-  __malloc_size_t block, blocks;
+  size_t block, blocks;
  block = BLOCK (_heapinfo);
  blocks = BLOCKIFY (heapsize * sizeof (malloc_info));
@@ -548,21 +488,21 @@ pthread_mutex_t _aligned_blocks_mutex = PTHREAD_MUTEX_INITIALIZER;
 int _malloc_thread_enabled_p;
 static void
-malloc_atfork_handler_prepare ()
+malloc_atfork_handler_prepare (void)
 {
  LOCK ();
  LOCK_ALIGNED_BLOCKS ();
 }
 static void
-malloc_atfork_handler_parent ()
+malloc_atfork_handler_parent (void)
 {
  UNLOCK_ALIGNED_BLOCKS ();
  UNLOCK ();
 }
 static void
-malloc_atfork_handler_child ()
+malloc_atfork_handler_child (void)
 {
  UNLOCK_ALIGNED_BLOCKS ();
  UNLOCK ();
@@ -570,7 +510,7 @@ malloc_atfork_handler_child ()
 /* Set up mutexes and make malloc etc. thread-safe.  */
 void
-malloc_enable_thread ()
+malloc_enable_thread (void)
 {
  if (_malloc_thread_enabled_p)
    return;
@@ -589,7 +529,7 @@ malloc_enable_thread ()
 #endif
 static void
-malloc_initialize_1 ()
+malloc_initialize_1 (void)
 {
 #ifdef GC_MCHECK
  mcheck (NULL);
@@ -609,7 +549,7 @@ malloc_initialize_1 ()
    (*__malloc_initialize_hook) ();
  heapsize = HEAP / BLOCKSIZE;
-  _heapinfo = (malloc_info *) align (heapsize * sizeof (malloc_info));
+  _heapinfo = align (heapsize * sizeof (malloc_info));
  if (_heapinfo == NULL)
    return;
  memset (_heapinfo, 0, heapsize * sizeof (malloc_info));
@@ -630,7 +570,7 @@ malloc_initialize_1 ()
   main will call malloc which calls this function.  That is before any threads
   or signal handlers has been set up, so we don't need thread protection.  */
 int
-__malloc_initialize ()
+__malloc_initialize (void)
 {
  if (__malloc_initialized)
    return 0;
@@ -644,14 +584,12 @@ static int morecore_recursing;
 /* Get neatly aligned memory, initializing or
   growing the heap info table as necessary. */
-static __ptr_t morecore_nolock PP ((__malloc_size_t));
+static void *
-static __ptr_t
+morecore_nolock (size_t size)
-morecore_nolock (size)
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
  malloc_info *newinfo, *oldinfo;
-  __malloc_size_t newsize;
+  size_t newsize;
  if (morecore_recursing)
    /* Avoid recursion.  The caller will know how to handle a null return.  */
@@ -664,7 +602,7 @@ morecore_nolock (size)
  PROTECT_MALLOC_STATE (0);
  /* Check if we need to grow the info table.  */
-  if ((__malloc_size_t) BLOCK ((char *) result + size) > heapsize)
+  if ((size_t) BLOCK ((char *) result + size) > heapsize)
    {
      /* Calculate the new _heapinfo table size.  We do not account for the
         added blocks in the table itself, as we hope to place them in
@@ -673,7 +611,7 @@ morecore_nolock (size)
      newsize = heapsize;
      do
        newsize *= 2;
-      while ((__malloc_size_t) BLOCK ((char *) result + size) > newsize);
+      while ((size_t) BLOCK ((char *) result + size) > newsize);
      /* We must not reuse existing core for the new info table when called
         from realloc in the case of growing a large block, because the
@@ -689,8 +627,8 @@ morecore_nolock (size)
             `morecore_recursing' flag and return null.  */
          int save = errno;     /* Don't want to clobber errno with ENOMEM.  */
          morecore_recursing = 1;
-          newinfo = (malloc_info *) _realloc_internal_nolock
+          newinfo = _realloc_internal_nolock (_heapinfo,
-            (_heapinfo, newsize * sizeof (malloc_info));
+                                              newsize * sizeof (malloc_info));
          morecore_recursing = 0;
          if (newinfo == NULL)
            errno = save;
@@ -710,7 +648,7 @@ morecore_nolock (size)
      /* Allocate new space for the malloc info table.  */
      while (1)
        {
-          newinfo = (malloc_info *) align (newsize * sizeof (malloc_info));
+          newinfo = align (newsize * sizeof (malloc_info));
          /* Did it fail?  */
          if (newinfo == NULL)
@@ -721,8 +659,8 @@ morecore_nolock (size)
          /* Is it big enough to record status for its own space?
             If so, we win.  */
-          if ((__malloc_size_t) BLOCK ((char *) newinfo
+          if ((size_t) BLOCK ((char *) newinfo
-                                       + newsize * sizeof (malloc_info))
+                              + newsize * sizeof (malloc_info))
              < newsize)
            break;
@@ -759,13 +697,12 @@ morecore_nolock (size)
 }
 /* Allocate memory from the heap.  */
-__ptr_t
+void *
-_malloc_internal_nolock (size)
+_malloc_internal_nolock (size_t size)
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
-  __malloc_size_t block, blocks, lastblocks, start;
+  size_t block, blocks, lastblocks, start;
-  register __malloc_size_t i;
+  register size_t i;
  struct list *next;
  /* ANSI C allows `malloc (0)' to either return NULL, or to return a
@@ -790,7 +727,7 @@ _malloc_internal_nolock (size)
    {
      /* Small allocation to receive a fragment of a block.
         Determine the logarithm to base two of the fragment size. */
-      register __malloc_size_t log = 1;
+      register size_t log = 1;
      --size;
      while ((size /= 2) != 0)
        ++log;
@@ -803,15 +740,14 @@ _malloc_internal_nolock (size)
          /* There are free fragments of this size.
             Pop a fragment out of the fragment list and return it.
             Update the block's nfree and first counters. */
-          result = (__ptr_t) next;
+          result = next;
          next->prev->next = next->next;
          if (next->next != NULL)
            next->next->prev = next->prev;
          block = BLOCK (result);
          if (--_heapinfo[block].busy.info.frag.nfree != 0)
-            _heapinfo[block].busy.info.frag.first = (unsigned long int)
+            _heapinfo[block].busy.info.frag.first =
-              ((unsigned long int) ((char *) next->next - (char *) NULL)
+              (uintptr_t) next->next % BLOCKSIZE >> log;
-               % BLOCKSIZE) >> log;
          /* Update the statistics.  */
          ++_chunks_used;
@@ -843,7 +779,7 @@ _malloc_internal_nolock (size)
          next->prev = &_fraghead[log];
          _fraghead[log].next = next;
-          for (i = 2; i < (__malloc_size_t) (BLOCKSIZE >> log); ++i)
+          for (i = 2; i < (size_t) (BLOCKSIZE >> log); ++i)
            {
              next = (struct list *) ((char *) result + (i << log));
              next->next = _fraghead[log].next;
@@ -877,7 +813,7 @@ _malloc_internal_nolock (size)
          if (block == start)
            {
              /* Need to get more from the system.  Get a little extra.  */
-              __malloc_size_t wantblocks = blocks + __malloc_extra_blocks;
+              size_t wantblocks = blocks + __malloc_extra_blocks;
              block = _heapinfo[0].free.prev;
              lastblocks = _heapinfo[block].free.size;
              /* Check to see if the new core will be contiguous with the
@@ -959,11 +895,10 @@ _malloc_internal_nolock (size)
  return result;
 }
-__ptr_t
+void *
-_malloc_internal (size)
+_malloc_internal (size_t size)
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
  LOCK ();
  result = _malloc_internal_nolock (size);
@@ -972,11 +907,10 @@ _malloc_internal (size)
  return result;
 }
-__ptr_t
+void *
-malloc (size)
+malloc (size_t size)
-     __malloc_size_t size;
 {
-  __ptr_t (*hook) (__malloc_size_t);
+  void *(*hook) (size_t);
  if (!__malloc_initialized && !__malloc_initialize ())
    return NULL;
@@ -998,24 +932,24 @@ malloc (size)
 /* On some ANSI C systems, some libc functions call _malloc, _free
   and _realloc.  Make them use the GNU functions.  */
-__ptr_t
+extern void *_malloc (size_t);
-_malloc (size)
+extern void _free (void *);
-     __malloc_size_t size;
+extern void *_realloc (void *, size_t);
+void *
+_malloc (size_t size)
 {
  return malloc (size);
 }
 void
-_free (ptr)
+_free (void *ptr)
-     __ptr_t ptr;
 {
  free (ptr);
 }
-__ptr_t
+void *
-_realloc (ptr, size)
+_realloc (void *ptr, size_t size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
  return realloc (ptr, size);
 }
@@ -1043,14 +977,9 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 /* Debugging hook for free.  */
-void (*__free_hook) PP ((__ptr_t __ptr));
+void (*__free_hook) (void *__ptr);
 /* List of blocks allocated by memalign.  */
 struct alignlist *_aligned_blocks = NULL;
@@ -1058,15 +987,14 @@ struct alignlist *_aligned_blocks = NULL;
 /* Return memory to the heap.
   Like `_free_internal' but don't lock mutex.  */
 void
-_free_internal_nolock (ptr)
+_free_internal_nolock (void *ptr)
-     __ptr_t ptr;
 {
  int type;
-  __malloc_size_t block, blocks;
+  size_t block, blocks;
-  register __malloc_size_t i;
+  register size_t i;
  struct list *prev, *next;
-  __ptr_t curbrk;
+  void *curbrk;
-  const __malloc_size_t lesscore_threshold
+  const size_t lesscore_threshold
    /* Threshold of free space at which we will return some to the system.  */
    = FINAL_FREE_BLOCKS + 2 * __malloc_extra_blocks;
@@ -1076,7 +1004,7 @@ _free_internal_nolock (ptr)
    return;
 #ifdef CYGWIN
-  if (ptr < _heapbase)
+  if ((char *) ptr < _heapbase)
    /* We're being asked to free something in the static heap. */
    return;
 #endif
@@ -1162,12 +1090,12 @@ _free_internal_nolock (ptr)
             It's possible that moving _heapinfo will allow us to
             return some space to the system.  */
-          __malloc_size_t info_block = BLOCK (_heapinfo);
+          size_t info_block = BLOCK (_heapinfo);
-          __malloc_size_t info_blocks = _heapinfo[info_block].busy.info.size;
+          size_t info_blocks = _heapinfo[info_block].busy.info.size;
-          __malloc_size_t prev_block = _heapinfo[block].free.prev;
+          size_t prev_block = _heapinfo[block].free.prev;
-          __malloc_size_t prev_blocks = _heapinfo[prev_block].free.size;
+          size_t prev_blocks = _heapinfo[prev_block].free.size;
-          __malloc_size_t next_block = _heapinfo[block].free.next;
+          size_t next_block = _heapinfo[block].free.next;
-          __malloc_size_t next_blocks = _heapinfo[next_block].free.size;
+          size_t next_blocks = _heapinfo[next_block].free.size;
          if (/* Win if this block being freed is last in core, the info table
                 is just before it, the previous free block is just before the
@@ -1190,7 +1118,7 @@ _free_internal_nolock (ptr)
              )
            {
              malloc_info *newinfo;
-              __malloc_size_t oldlimit = _heaplimit;
+              size_t oldlimit = _heaplimit;
              /* Free the old info table, clearing _heaplimit to avoid
                 recursion into this code.  We don't want to return the
@@ -1205,8 +1133,7 @@ _free_internal_nolock (ptr)
              _heapindex = 0;
              /* Allocate new space for the info table and move its data.  */
-              newinfo = (malloc_info *) _malloc_internal_nolock (info_blocks
+              newinfo = _malloc_internal_nolock (info_blocks * BLOCKSIZE);
-                                                                 * BLOCKSIZE);
              PROTECT_MALLOC_STATE (0);
              memmove (newinfo, _heapinfo, info_blocks * BLOCKSIZE);
              _heapinfo = newinfo;
@@ -1222,7 +1149,7 @@ _free_internal_nolock (ptr)
          /* Now see if we can return stuff to the system.  */
          if (block + blocks == _heaplimit && blocks >= lesscore_threshold)
            {
-              register __malloc_size_t bytes = blocks * BLOCKSIZE;
+              register size_t bytes = blocks * BLOCKSIZE;
              _heaplimit -= blocks;
              (*__morecore) (-bytes);
              _heapinfo[_heapinfo[block].free.prev].free.next
@@ -1255,7 +1182,7 @@ _free_internal_nolock (ptr)
          /* If all fragments of this block are free, remove them
             from the fragment list and free the whole block.  */
          next = prev;
-          for (i = 1; i < (__malloc_size_t) (BLOCKSIZE >> type); ++i)
+          for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i)
            next = next->next;
          prev->prev->next = next;
          if (next != NULL)
@@ -1280,7 +1207,7 @@ _free_internal_nolock (ptr)
          /* If some fragments of this block are free, link this
             fragment into the fragment list after the first free
             fragment of this block. */
-          next = (struct list *) ptr;
+          next = ptr;
          next->next = prev->next;
          next->prev = prev;
          prev->next = next;
@@ -1293,11 +1220,10 @@ _free_internal_nolock (ptr)
          /* No fragments of this block are free, so link this
             fragment into the fragment list and announce that
             it is the first free fragment of this block. */
-          prev = (struct list *) ptr;
+          prev = ptr;
          _heapinfo[block].busy.info.frag.nfree = 1;
-          _heapinfo[block].busy.info.frag.first = (unsigned long int)
+          _heapinfo[block].busy.info.frag.first =
-            ((unsigned long int) ((char *) ptr - (char *) NULL)
+            (uintptr_t) ptr % BLOCKSIZE >> type;
-             % BLOCKSIZE >> type);
          prev->next = _fraghead[type].next;
          prev->prev = &_fraghead[type];
          prev->prev->next = prev;
@@ -1313,8 +1239,7 @@ _free_internal_nolock (ptr)
 /* Return memory to the heap.
   Like `free' but don't call a __free_hook if there is one.  */
 void
-_free_internal (ptr)
+_free_internal (void *ptr)
-     __ptr_t ptr;
 {
  LOCK ();
  _free_internal_nolock (ptr);
@@ -1324,10 +1249,9 @@ _free_internal (ptr)
 /* Return memory to the heap.  */
 void
-free (ptr)
+free (void *ptr)
-     __ptr_t ptr;
 {
-  void (*hook) (__ptr_t) = __free_hook;
+  void (*hook) (void *) = __free_hook;
  if (hook != NULL)
    (*hook) (ptr);
@@ -1340,8 +1264,7 @@ free (ptr)
 weak_alias (free, cfree)
 #else
 void
-cfree (ptr)
+cfree (void *ptr)
-     __ptr_t ptr;
 {
  free (ptr);
 }
@@ -1368,32 +1291,24 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 #define min(A, B) ((A) < (B) ? (A) : (B))
 /* On Cygwin the dumped emacs may try to realloc storage allocated in
   the static heap.  We just malloc space in the new heap and copy the
   data.  */
 #ifdef CYGWIN
-__ptr_t
+void *
-special_realloc (ptr, size)
+special_realloc (void *ptr, size_t size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
  int type;
-  __malloc_size_t block, oldsize;
+  size_t block, oldsize;
  block = ((char *) ptr - bss_sbrk_heapbase) / BLOCKSIZE + 1;
  type = bss_sbrk_heapinfo[block].busy.type;
  oldsize =
    type == 0 ? bss_sbrk_heapinfo[block].busy.info.size * BLOCKSIZE
-    : (__malloc_size_t) 1 << type;
+    : (size_t) 1 << type;
  result = _malloc_internal_nolock (size);
  if (result != NULL)
    memcpy (result, ptr, min (oldsize, size));
@@ -1402,7 +1317,7 @@ special_realloc (ptr, size)
 #endif
 /* Debugging hook for realloc.  */
-__ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size));
+void *(*__realloc_hook) (void *ptr, size_t size);
 /* Resize the given region to the new size, returning a pointer
   to the (possibly moved) region.  This is optimized for speed;
@@ -1410,14 +1325,12 @@ __ptr_t (*__realloc_hook) PP ((__ptr_t __ptr, __malloc_size_t __size));
   achieved by unconditionally allocating and copying to a
   new region.  This module has incestuous knowledge of the
   internals of both free and malloc. */
-__ptr_t
+void *
-_realloc_internal_nolock (ptr, size)
+_realloc_internal_nolock (void *ptr, size_t size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
  int type;
-  __malloc_size_t block, blocks, oldlimit;
+  size_t block, blocks, oldlimit;
  if (size == 0)
    {
@@ -1428,7 +1341,7 @@ _realloc_internal_nolock (ptr, size)
    return _malloc_internal_nolock (size);
 #ifdef CYGWIN
-  if (ptr < _heapbase)
+  if ((char *) ptr < _heapbase)
    /* ptr points into the static heap */
    return special_realloc (ptr, size);
 #endif
@@ -1497,7 +1410,7 @@ _realloc_internal_nolock (ptr, size)
                (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
              else
                {
-                  __ptr_t previous
+                  void *previous
                    = _malloc_internal_nolock ((block - _heapindex) * BLOCKSIZE);
                  (void) _malloc_internal_nolock (blocks * BLOCKSIZE);
                  _free_internal_nolock (previous);
@@ -1512,8 +1425,8 @@ _realloc_internal_nolock (ptr, size)
    default:
      /* Old size is a fragment; type is logarithm
         to base two of the fragment size.  */
-      if (size > (__malloc_size_t) (1 << (type - 1)) &&
+      if (size > (size_t) (1 << (type - 1)) &&
-          size <= (__malloc_size_t) (1 << type))
+          size <= (size_t) (1 << type))
        /* The new size is the same kind of fragment.  */
        result = ptr;
      else
@@ -1523,7 +1436,7 @@ _realloc_internal_nolock (ptr, size)
          result = _malloc_internal_nolock (size);
          if (result == NULL)
            goto out;
-          memcpy (result, ptr, min (size, (__malloc_size_t) 1 << type));
+          memcpy (result, ptr, min (size, (size_t) 1 << type));
          _free_internal_nolock (ptr);
        }
      break;
@@ -1534,12 +1447,10 @@ _realloc_internal_nolock (ptr, size)
  return result;
 }
-__ptr_t
+void *
-_realloc_internal (ptr, size)
+_realloc_internal (void *ptr, size_t size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
  LOCK ();
  result = _realloc_internal_nolock (ptr, size);
@@ -1548,12 +1459,10 @@ _realloc_internal (ptr, size)
  return result;
 }
-__ptr_t
+void *
-realloc (ptr, size)
+realloc (void *ptr, size_t size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
-  __ptr_t (*hook) (__ptr_t, __malloc_size_t);
+  void *(*hook) (void *, size_t);
  if (!__malloc_initialized && !__malloc_initialize ())
    return NULL;
@@ -1581,19 +1490,12 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 /* Allocate an array of NMEMB elements each SIZE bytes long.
   The entire array is initialized to zeros.  */
-__ptr_t
+void *
-calloc (nmemb, size)
+calloc (register size_t nmemb, register size_t size)
-     register __malloc_size_t nmemb;
-     register __malloc_size_t size;
 {
-  register __ptr_t result = malloc (nmemb * size);
+  register void *result = malloc (nmemb * size);
  if (result != NULL)
    (void) memset (result, 0, nmemb * size);
@@ -1618,11 +1520,6 @@ 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.  */
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
 /* uClibc defines __GNU_LIBRARY__, but it is not completely
   compatible.  */
 #if !defined (__GNU_LIBRARY__) || defined (__UCLIBC__)
@@ -1631,30 +1528,24 @@ MA 02110-1301, USA.  */
 /* It is best not to declare this and cast its result on foreign operating
   systems with potentially hostile include files.  */
-#include <stddef.h>
+extern void *__sbrk (ptrdiff_t increment);
-extern __ptr_t __sbrk PP ((ptrdiff_t increment));
 #endif /* __GNU_LIBRARY__ && ! defined (__UCLIBC__) */
-#ifndef NULL
-#define NULL 0
-#endif
 /* Allocate INCREMENT more bytes of data space,
   and return the start of data space, or NULL on errors.
   If INCREMENT is negative, shrink data space.  */
-__ptr_t
+void *
-__default_morecore (increment)
+__default_morecore (ptrdiff_t increment)
-     __malloc_ptrdiff_t increment;
 {
-  __ptr_t result;
+  void *result;
 #if defined (CYGWIN)
  if (!bss_sbrk_did_unexec)
    {
      return bss_sbrk (increment);
    }
 #endif
-  result = (__ptr_t) __sbrk (increment);
+  result = (void *) __sbrk (increment);
-  if (result == (__ptr_t) -1)
+  if (result == (void *) -1)
    return NULL;
  return result;
 }
@@ -1675,22 +1566,14 @@ 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.  */
-#ifndef _MALLOC_INTERNAL
+void *(*__memalign_hook) (size_t size, size_t alignment);
-#define _MALLOC_INTERNAL
-#include <malloc.h>
-#endif
-__ptr_t (*__memalign_hook) PP ((__malloc_size_t __size,
-                                __malloc_size_t __alignment));
-__ptr_t
+void *
-memalign (alignment, size)
+memalign (size_t alignment, size_t size)
-     __malloc_size_t alignment;
-     __malloc_size_t size;
 {
-  __ptr_t result;
+  void *result;
-  unsigned long int adj, lastadj;
+  size_t adj, lastadj;
-  __ptr_t (*hook) (__malloc_size_t, __malloc_size_t) = __memalign_hook;
+  void *(*hook) (size_t, size_t) = __memalign_hook;
  if (hook)
    return (*hook) (alignment, size);
@@ -1703,7 +1586,7 @@ memalign (alignment, size)
  /* Figure out how much we will need to pad this particular block
     to achieve the required alignment.  */
-  adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment;
+  adj = (uintptr_t) result % alignment;
  do
    {
@@ -1714,7 +1597,7 @@ memalign (alignment, size)
        return NULL;
      lastadj = adj;
-      adj = (unsigned long int) ((char *) result - (char *) NULL) % alignment;
+      adj = (uintptr_t) result % alignment;
      /* It's conceivable we might have been so unlucky as to get a
         different block with weaker alignment.  If so, this block is too
         short to contain SIZE after alignment correction.  So we must
@@ -1735,7 +1618,7 @@ memalign (alignment, size)
          break;
      if (l == NULL)
        {
-          l = (struct alignlist *) malloc (sizeof (struct alignlist));
+          l = malloc (sizeof (struct alignlist));
          if (l != NULL)
            {
              l->next = _aligned_blocks;
@@ -1767,15 +1650,12 @@ memalign (alignment, size)
 #endif
 int
-posix_memalign (memptr, alignment, size)
+posix_memalign (void **memptr, size_t alignment, size_t size)
-     __ptr_t *memptr;
-     __malloc_size_t alignment;
-     __malloc_size_t size;
 {
-  __ptr_t mem;
+  void *mem;
  if (alignment == 0
-      || alignment % sizeof (__ptr_t) != 0
+      || alignment % sizeof (void *) != 0
      || (alignment & (alignment - 1)) != 0)
    return EINVAL;
@@ -1809,43 +1689,27 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#if defined (_MALLOC_INTERNAL) && defined (GMALLOC_INHIBIT_VALLOC)
 /* Emacs defines GMALLOC_INHIBIT_VALLOC to avoid this definition
   on MSDOS, where it conflicts with a system header file.  */
-#define ELIDE_VALLOC
+#ifndef GMALLOC_INHIBIT_VALLOC
-#endif
+/* Allocate SIZE bytes on a page boundary.  */
+extern void *valloc (size_t);
-#ifndef ELIDE_VALLOC
-#if defined (__GNU_LIBRARY__) || defined (_LIBC)
-#include <stddef.h>
-#include <sys/cdefs.h>
-#if defined (__GLIBC__) && __GLIBC__ >= 2
-/* __getpagesize is already declared in <unistd.h> with return type int */
-#else
-extern size_t __getpagesize PP ((void));
-#endif
-#else
-#include "getpagesize.h"
-#define  __getpagesize()        getpagesize ()
-#endif
-#ifndef _MALLOC_INTERNAL
+#if defined _SC_PAGESIZE || !defined HAVE_GETPAGESIZE
-#define _MALLOC_INTERNAL
+# include "getpagesize.h"
-#include <malloc.h>
+#elif !defined getpagesize
+extern int getpagesize (void);
 #endif
-static __malloc_size_t pagesize;
+static size_t pagesize;
-__ptr_t
+void *
-valloc (size)
+valloc (size_t size)
-     __malloc_size_t size;
 {
  if (pagesize == 0)
-    pagesize = __getpagesize ();
+    pagesize = getpagesize ();
  return memalign (pagesize, size);
 }
@@ -1876,41 +1740,31 @@ Fifth Floor, Boston, MA 02110-1301, USA.
   The author may be reached (Email) at the address mike@ai.mit.edu,
   or (US mail) as Mike Haertel c/o Free Software Foundation.  */
-#ifdef emacs
-#include <stdio.h>
-#else
-#ifndef _MALLOC_INTERNAL
-#define _MALLOC_INTERNAL
-#include <malloc.h>
 #include <stdio.h>
-#endif
-#endif
 /* Old hook values.  */
-static void (*old_free_hook) (__ptr_t ptr);
+static void (*old_free_hook) (void *ptr);
-static __ptr_t (*old_malloc_hook) (__malloc_size_t size);
+static void *(*old_malloc_hook) (size_t size);
-static __ptr_t (*old_realloc_hook) (__ptr_t ptr, __malloc_size_t size);
+static void *(*old_realloc_hook) (void *ptr, size_t size);
 /* Function to call when something awful happens.  */
 static void (*abortfunc) (enum mcheck_status);
 /* Arbitrary magical numbers.  */
-#define MAGICWORD       0xfedabeeb
+#define MAGICWORD       (SIZE_MAX / 11 ^ SIZE_MAX / 13 << 3)
-#define MAGICFREE       0xd8675309
+#define MAGICFREE       (SIZE_MAX / 17 ^ SIZE_MAX / 19 << 4)
 #define MAGICBYTE       ((char) 0xd7)
 #define MALLOCFLOOD     ((char) 0x93)
 #define FREEFLOOD       ((char) 0x95)
 struct hdr
  {
-    __malloc_size_t size;               /* Exact size requested by user.  */
+    size_t size;        /* Exact size requested by user.  */
-    unsigned long int magic;    /* Magic number to check header integrity.  */
+    size_t magic;       /* Magic number to check header integrity.  */
  };
-static enum mcheck_status checkhdr (const struct hdr *);
 static enum mcheck_status
-checkhdr (hdr)
+checkhdr (const struct hdr *hdr)
-     const struct hdr *hdr;
 {
  enum mcheck_status status;
  switch (hdr->magic)
@@ -1933,10 +1787,8 @@ checkhdr (hdr)
  return status;
 }
-static void freehook (__ptr_t);
 static void
-freehook (ptr)
+freehook (void *ptr)
-     __ptr_t ptr;
 {
  struct hdr *hdr;
@@ -1955,15 +1807,13 @@ freehook (ptr)
  __free_hook = freehook;
 }
-static __ptr_t mallochook (__malloc_size_t);
+static void *
-static __ptr_t
+mallochook (size_t size)
-mallochook (size)
-     __malloc_size_t size;
 {
  struct hdr *hdr;
  __malloc_hook = old_malloc_hook;
-  hdr = (struct hdr *) malloc (sizeof (struct hdr) + size + 1);
+  hdr = malloc (sizeof (struct hdr) + size + 1);
  __malloc_hook = mallochook;
  if (hdr == NULL)
    return NULL;
@@ -1971,18 +1821,15 @@ mallochook (size)
  hdr->size = size;
  hdr->magic = MAGICWORD;
  ((char *) &hdr[1])[size] = MAGICBYTE;
-  memset ((__ptr_t) (hdr + 1), MALLOCFLOOD, size);
+  memset (hdr + 1, MALLOCFLOOD, size);
-  return (__ptr_t) (hdr + 1);
+  return hdr + 1;
 }
-static __ptr_t reallochook (__ptr_t, __malloc_size_t);
+static void *
-static __ptr_t
+reallochook (void *ptr, size_t size)
-reallochook (ptr, size)
-     __ptr_t ptr;
-     __malloc_size_t size;
 {
  struct hdr *hdr = NULL;
-  __malloc_size_t osize = 0;
+  size_t osize = 0;
  if (ptr)
    {
@@ -1997,7 +1844,7 @@ reallochook (ptr, size)
  __free_hook = old_free_hook;
  __malloc_hook = old_malloc_hook;
  __realloc_hook = old_realloc_hook;
-  hdr = (struct hdr *) realloc ((__ptr_t) hdr, sizeof (struct hdr) + size + 1);
+  hdr = realloc (hdr, sizeof (struct hdr) + size + 1);
  __free_hook = freehook;
  __malloc_hook = mallochook;
  __realloc_hook = reallochook;
@@ -2009,12 +1856,11 @@ reallochook (ptr, size)
  ((char *) &hdr[1])[size] = MAGICBYTE;
  if (size > osize)
    memset ((char *) (hdr + 1) + osize, MALLOCFLOOD, size - osize);
-  return (__ptr_t) (hdr + 1);
+  return hdr + 1;
 }
 static void
-mabort (status)
+mabort (enum mcheck_status status)
-     enum mcheck_status status;
 {
  const char *msg;
  switch (status)
@@ -2047,8 +1893,7 @@ mabort (status)
 static int mcheck_used = 0;
 int
-mcheck (func)
+mcheck (void (*func) (enum mcheck_status))
-     void (*func) (enum mcheck_status);
 {
  abortfunc = (func != NULL) ? func : &mabort;
@@ -2068,7 +1913,7 @@ mcheck (func)
 }
 enum mcheck_status
-mprobe (__ptr_t ptr)
+mprobe (void *ptr)
 {
  return mcheck_used ? checkhdr (ptr) : MCHECK_DISABLED;
 }
diff --git a/src/gnutls.c b/src/gnutls.c
index 8dbf01cedc9..c5e21cc8777 100644
--- a/src/gnutls.c
+++ b/src/gnutls.c
@@ -200,8 +200,12 @@ init_gnutls_functions (Lisp_Object libraries)
  max_log_level = global_gnutls_log_level;
-  GNUTLS_LOG2 (1, max_log_level, "GnuTLS library loaded:",
+  {
-               SDATA (Fget (Qgnutls_dll, QCloaded_from)));
+    Lisp_Object name = CAR_SAFE (Fget (Qgnutls_dll, QCloaded_from));
+    GNUTLS_LOG2 (1, max_log_level, "GnuTLS library loaded:",
+                 STRINGP (name) ? (const char *) SDATA (name) : "unknown");
+  }
  return 1;
 }
@@ -419,7 +423,7 @@ emacs_gnutls_read (struct Lisp_Process *proc, char *buf, ptrdiff_t nbyte)
        {
          proc->gnutls_handshakes_tried++;
          emacs_gnutls_handshake (proc);
-          GNUTLS_LOG2i (5, log_level, "Retried handshake", 
+          GNUTLS_LOG2i (5, log_level, "Retried handshake",
                        proc->gnutls_handshakes_tried);
          return -1;
        }
diff --git a/src/gtkutil.c b/src/gtkutil.c
index d39a0eedf41..4cf421b6616 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1090,7 +1090,9 @@ xg_create_frame_widgets (FRAME_PTR f)
  GtkWidget *wtop;
  GtkWidget *wvbox, *whbox;
  GtkWidget *wfixed;
+#ifndef HAVE_GTK3
  GtkRcStyle *style;
+#endif
  char *title = 0;
  BLOCK_INPUT;
diff --git a/src/insdel.c b/src/insdel.c
index 748e2d54109..148ba221940 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -31,10 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "blockinput.h"
 #include "region-cache.h"
-#ifndef NULL
-#define NULL 0
-#endif
 static void insert_from_string_1 (Lisp_Object string,
                                  ptrdiff_t pos, ptrdiff_t pos_byte,
                                  ptrdiff_t nchars, ptrdiff_t nbytes,
diff --git a/src/intervals.c b/src/intervals.c
index e6c1b4d60d2..0b332caf897 100644
--- a/src/intervals.c
+++ b/src/intervals.c
@@ -1000,6 +1000,7 @@ adjust_intervals_for_insertion (INTERVAL tree,
          Lisp_Object pleft, pright;
          struct interval newi;
+          RESET_INTERVAL (&newi);
          pleft = NULL_INTERVAL_P (prev) ? Qnil : prev->plist;
          pright = NULL_INTERVAL_P (i) ? Qnil : i->plist;
          newi.plist = merge_properties_sticky (pleft, pright);
diff --git a/src/keyboard.c b/src/keyboard.c
index 79d9e7a18e8..339cf2a7e9e 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1198,6 +1198,12 @@ This also exits all active minibuffers.  */)
  Fthrow (Qtop_level, Qnil);
 }
+static void user_error (const char*) NO_RETURN;
+static void user_error (const char *msg)
+{
+  xsignal1 (Quser_error, build_string (msg));
+}
 static Lisp_Object Fexit_recursive_edit (void) NO_RETURN;
 DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0, "",
       doc: /* Exit from the innermost recursive edit or minibuffer.  */)
@@ -1206,7 +1212,7 @@ DEFUN ("exit-recursive-edit", Fexit_recursive_edit, Sexit_recursive_edit, 0, 0,
  if (command_loop_level > 0 || minibuf_level > 0)
    Fthrow (Qexit, Qnil);
-  error ("No recursive edit is in progress");
+  user_error ("No recursive edit is in progress");
 }
 static Lisp_Object Fabort_recursive_edit (void) NO_RETURN;
@@ -1217,7 +1223,7 @@ DEFUN ("abort-recursive-edit", Fabort_recursive_edit, Sabort_recursive_edit, 0,
  if (command_loop_level > 0 || minibuf_level > 0)
    Fthrow (Qexit, Qt);
-  error ("No recursive edit is in progress");
+  user_error ("No recursive edit is in progress");
 }
 #if defined (HAVE_MOUSE) || defined (HAVE_GPM)
@@ -2983,11 +2989,16 @@ read_char (int commandflag, ptrdiff_t nmaps, Lisp_Object *maps,
     own stuff with the echo area.  */
  if (!CONSP (c)
      || (!(EQ (Qhelp_echo, XCAR (c)))
-          && !(EQ (Qswitch_frame, XCAR (c)))))
+          && !(EQ (Qswitch_frame, XCAR (c)))
+          /* Don't wipe echo area for select window events: These might
+             get delayed via `mouse-autoselect-window' (Bug#11304).  */
+          && !(EQ (Qselect_window, XCAR (c)))))
    {
      if (!NILP (echo_area_buffer[0]))
-        safe_run_hooks (Qecho_area_clear_hook);
+        {
-      clear_message (1, 0);
+          safe_run_hooks (Qecho_area_clear_hook);
+          clear_message (1, 0);
+        }
    }
 reread_for_input_method:
@@ -3775,7 +3786,6 @@ kbd_buffer_get_event (KBOARD **kbp,
                      int *used_mouse_menu,
                      struct timeval *end_time)
 {
-  register int c;
  Lisp_Object obj;
 #ifdef subprocesses
@@ -3792,16 +3802,18 @@ kbd_buffer_get_event (KBOARD **kbp,
    }
 #endif  /* subprocesses */
+#ifndef HAVE_DBUS  /* We want to read D-Bus events in batch mode.  */
  if (noninteractive
      /* In case we are running as a daemon, only do this before
         detaching from the terminal.  */
      || (IS_DAEMON && daemon_pipe[1] >= 0))
    {
-      c = getchar ();
+      int c = getchar ();
      XSETINT (obj, c);
      *kbp = current_kboard;
      return obj;
    }
+#endif  /* ! HAVE_DBUS  */
  /* Wait until there is input available.  */
  for (;;)
@@ -7173,6 +7185,7 @@ tty_read_avail_input (struct terminal *terminal,
  return nread;
 }
+#if defined SYNC_INPUT || defined SIGIO
 static void
 handle_async_input (void)
 {
@@ -7199,6 +7212,7 @@ handle_async_input (void)
  --handling_signal;
 #endif
 }
+#endif /* SYNC_INPUT || SIGIO */
 #ifdef SYNC_INPUT
 void
@@ -10341,146 +10355,6 @@ a special event, so ignore the prefix argument and don't clear it.  */)
-DEFUN ("execute-extended-command", Fexecute_extended_command, Sexecute_extended_command,
-       1, 1, "P",
-       doc: /* Read function name, then read its arguments and call it.
-To pass a numeric argument to the command you are invoking with, specify
-the numeric argument to this command.
-Noninteractively, the argument PREFIXARG is the prefix argument to
-give to the command you invoke, if it asks for an argument.  */)
-  (Lisp_Object prefixarg)
-{
-  Lisp_Object function;
-  ptrdiff_t saved_last_point_position;
-  Lisp_Object saved_keys, saved_last_point_position_buffer;
-  Lisp_Object bindings, value;
-  struct gcpro gcpro1, gcpro2, gcpro3;
-#ifdef HAVE_WINDOW_SYSTEM
-  /* The call to Fcompleting_read will start and cancel the hourglass,
-     but if the hourglass was already scheduled, this means that no
-     hourglass will be shown for the actual M-x command itself.
-     So we restart it if it is already scheduled.  Note that checking
-     hourglass_shown_p is not enough,  normally the hourglass is not shown,
-     just scheduled to be shown.  */
-  int hstarted = hourglass_started ();
-#endif
-  saved_keys = Fvector (this_command_key_count,
-                        XVECTOR (this_command_keys)->contents);
-  saved_last_point_position_buffer = last_point_position_buffer;
-  saved_last_point_position = last_point_position;
-  GCPRO3 (saved_keys, prefixarg, saved_last_point_position_buffer);
-  function = call0 (intern ("read-extended-command"));
-#ifdef HAVE_WINDOW_SYSTEM
-  if (hstarted) start_hourglass ();
-#endif
-  if (STRINGP (function) && SCHARS (function) == 0)
-    error ("No command name given");
-  /* Set this_command_keys to the concatenation of saved_keys and
-     function, followed by a RET.  */
-  {
-    Lisp_Object *keys;
-    int i;
-    this_command_key_count = 0;
-    this_command_key_count_reset = 0;
-    this_single_command_key_start = 0;
-    keys = XVECTOR (saved_keys)->contents;
-    for (i = 0; i < ASIZE (saved_keys); i++)
-      add_command_key (keys[i]);
-    for (i = 0; i < SCHARS (function); i++)
-      add_command_key (Faref (function, make_number (i)));
-    add_command_key (make_number ('\015'));
-  }
-  last_point_position = saved_last_point_position;
-  last_point_position_buffer = saved_last_point_position_buffer;
-  UNGCPRO;
-  function = Fintern (function, Qnil);
-  KVAR (current_kboard, Vprefix_arg) = prefixarg;
-  Vthis_command = function;
-  real_this_command = function;
-  /* If enabled, show which key runs this command.  */
-  if (!NILP (Vsuggest_key_bindings)
-      && NILP (Vexecuting_kbd_macro)
-      && SYMBOLP (function))
-    bindings = Fwhere_is_internal (function, Voverriding_local_map,
-                                   Qt, Qnil, Qnil);
-  else
-    bindings = Qnil;
-  value = Qnil;
-  GCPRO3 (bindings, value, function);
-  value = Fcommand_execute (function, Qt, Qnil, Qnil);
-  /* If the command has a key binding, print it now.  */
-  if (!NILP (bindings)
-      && ! (VECTORP (bindings) && EQ (Faref (bindings, make_number (0)),
-                                      Qmouse_movement)))
-    {
-      /* But first wait, and skip the message if there is input.  */
-      Lisp_Object waited;
-      /* If this command displayed something in the echo area;
-         wait a few seconds, then display our suggestion message.  */
-      if (NILP (echo_area_buffer[0]))
-        waited = sit_for (make_number (0), 0, 2);
-      else if (NUMBERP (Vsuggest_key_bindings))
-        waited = sit_for (Vsuggest_key_bindings, 0, 2);
-      else
-        waited = sit_for (make_number (2), 0, 2);
-      if (!NILP (waited) && ! CONSP (Vunread_command_events))
-        {
-          Lisp_Object binding;
-          char *newmessage;
-          int message_p = push_message ();
-          ptrdiff_t count = SPECPDL_INDEX ();
-          ptrdiff_t newmessage_len, newmessage_alloc;
-          USE_SAFE_ALLOCA;
-          record_unwind_protect (pop_message_unwind, Qnil);
-          binding = Fkey_description (bindings, Qnil);
-          newmessage_alloc =
-            (sizeof "You can run the command `' with "
-             + SBYTES (SYMBOL_NAME (function)) + SBYTES (binding));
-          SAFE_ALLOCA (newmessage, char *, newmessage_alloc);
-          newmessage_len =
-            esprintf (newmessage, "You can run the command `%s' with %s",
-                      SDATA (SYMBOL_NAME (function)),
-                      SDATA (binding));
-          message2 (newmessage,
-                    newmessage_len,
-                    STRING_MULTIBYTE (binding));
-          if (NUMBERP (Vsuggest_key_bindings))
-            waited = sit_for (Vsuggest_key_bindings, 0, 2);
-          else
-            waited = sit_for (make_number (2), 0, 2);
-          if (!NILP (waited) && message_p)
-            restore_message ();
-          SAFE_FREE ();
-          unbind_to (count, Qnil);
-        }
-    }
-  RETURN_UNGCPRO (value);
-}
 /* Return nonzero if input events are pending.  */
 int
@@ -11791,7 +11665,6 @@ syms_of_keyboard (void)
  defsubr (&Sset_quit_char);
  defsubr (&Sset_input_mode);
  defsubr (&Scurrent_input_mode);
-  defsubr (&Sexecute_extended_command);
  defsubr (&Sposn_at_point);
  defsubr (&Sposn_at_x_y);
@@ -12195,12 +12068,6 @@ If this variable is non-nil, `delayed-warnings-hook' will be run
 immediately after running `post-command-hook'.  */);
  Vdelayed_warnings_list = Qnil;
-  DEFVAR_LISP ("suggest-key-bindings", Vsuggest_key_bindings,
-               doc: /* Non-nil means show the equivalent key-binding when M-x command has one.
-The value can be a length of time to show the message for.
-If the value is non-nil and not a number, we wait 2 seconds.  */);
-  Vsuggest_key_bindings = Qt;
  DEFVAR_LISP ("timer-list", Vtimer_list,
               doc: /* List of active absolute time timers in order of increasing time.  */);
  Vtimer_list = Qnil;
@@ -12396,7 +12263,7 @@ keys_of_keyboard (void)
 }
 /* Mark the pointers in the kboard objects.
-   Called by the Fgarbage_collector.  */
+   Called by Fgarbage_collect.  */
 void
 mark_kboards (void)
 {
diff --git a/src/keymap.c b/src/keymap.c
index e8f2f88bb26..2a03dda5a5e 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -2571,7 +2571,8 @@ where_is_internal (Lisp_Object definition, Lisp_Object keymaps,
 DEFUN ("where-is-internal", Fwhere_is_internal, Swhere_is_internal, 1, 5, 0,
       doc: /* Return list of keys that invoke DEFINITION.
 If KEYMAP is a keymap, search only KEYMAP and the global keymap.
-If KEYMAP is nil, search all the currently active keymaps.
+If KEYMAP is nil, search all the currently active keymaps, except
+ for `overriding-local-map' (which is ignored).
 If KEYMAP is a list of keymaps, search only those keymaps.
 If optional 3rd arg FIRSTONLY is non-nil, return the first key sequence found,
@@ -2586,9 +2587,17 @@ If optional 4th arg NOINDIRECT is non-nil, don't follow indirections
 to other keymaps or slots.  This makes it possible to search for an
 indirect definition itself.
-If optional 5th arg NO-REMAP is non-nil, don't search for key sequences
+The optional 5th arg NO-REMAP alters how command remapping is handled:
-that invoke a command which is remapped to DEFINITION, but include the
-remapped command in the returned list.  */)
+- If another command OTHER-COMMAND is remapped to DEFINITION, normally
+  search for the bindings of OTHER-COMMAND and include them in the
+  returned list.  But if NO-REMAP is non-nil, include the vector
+  [remap OTHER-COMMAND] in the returned list instead, without
+  searching for those other bindings.
+- If DEFINITION is remapped to OTHER-COMMAND, normally return the
+  bindings for OTHER-COMMAND.  But if NO-REMAP is non-nil, return the
+  bindings for DEFINITION instead, ignoring its remapping.  */)
  (Lisp_Object definition, Lisp_Object keymap, Lisp_Object firstonly, Lisp_Object noindirect, Lisp_Object no_remap)
 {
  /* The keymaps in which to search.  */
diff --git a/src/lisp.h b/src/lisp.h
index 66e449b0039..551c15473a7 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -41,25 +41,36 @@ extern void check_cons_list (void);
   Build with CFLAGS='-DWIDE_EMACS_INT' to try them out.  */
 /* #undef WIDE_EMACS_INT */
-/* These are default choices for the types to use.  */
+/* EMACS_INT - signed integer wide enough to hold an Emacs value
+   EMACS_INT_MAX - maximum value of EMACS_INT; can be used in #if
+   pI - printf length modifier for EMACS_INT
+   EMACS_UINT - unsigned variant of EMACS_INT */
 #ifndef EMACS_INT
-# if BITS_PER_LONG < BITS_PER_LONG_LONG && defined WIDE_EMACS_INT
+# if LONG_MAX < LLONG_MAX && defined WIDE_EMACS_INT
 #  define EMACS_INT long long
-#  define BITS_PER_EMACS_INT BITS_PER_LONG_LONG
+#  define EMACS_INT_MAX LLONG_MAX
 #  define pI "ll"
-# elif BITS_PER_INT < BITS_PER_LONG
+# elif INT_MAX < LONG_MAX
 #  define EMACS_INT long
-#  define BITS_PER_EMACS_INT BITS_PER_LONG
+#  define EMACS_INT_MAX LONG_MAX
 #  define pI "l"
 # else
 #  define EMACS_INT int
-#  define BITS_PER_EMACS_INT BITS_PER_INT
+#  define EMACS_INT_MAX INT_MAX
 #  define pI ""
 # endif
 #endif
-#ifndef EMACS_UINT
+#define EMACS_UINT unsigned EMACS_INT
-# define EMACS_UINT unsigned EMACS_INT
-#endif
+/* Number of bits in some machine integer types.  */
+enum
+  {
+    BITS_PER_CHAR      = CHAR_BIT,
+    BITS_PER_SHORT     = CHAR_BIT * sizeof (short),
+    BITS_PER_INT       = CHAR_BIT * sizeof (int),
+    BITS_PER_LONG      = CHAR_BIT * sizeof (long int),
+    BITS_PER_EMACS_INT = CHAR_BIT * sizeof (EMACS_INT)
+  };
 /* printmax_t and uprintmax_t are types for printing large integers.
   These are the widest integers that are supported for printing.
@@ -164,13 +175,13 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
   variable VAR of type TYPE with the added requirement that it be
   TYPEBITS-aligned.  */
-#ifndef GCTYPEBITS
 #define GCTYPEBITS 3
-#endif
-#ifndef VALBITS
 #define VALBITS (BITS_PER_EMACS_INT - GCTYPEBITS)
-#endif
+/* The maximum value that can be stored in a EMACS_INT, assuming all
+   bits other than the type bits contribute to a nonnegative signed value.
+   This can be used in #if, e.g., '#if VAL_MAX < UINTPTR_MAX' below.  */
+#define VAL_MAX (EMACS_INT_MAX >> (GCTYPEBITS - 1))
 #ifndef NO_DECL_ALIGN
 # ifndef DECL_ALIGN
@@ -195,12 +206,12 @@ extern int suppress_checking EXTERNALLY_VISIBLE;
     || defined DARWIN_OS || defined __sun)
 /* We also need to be able to specify mult-of-8 alignment on static vars.  */
 # if defined DECL_ALIGN
-/* On hosts where VALBITS is greater than the pointer width in bits,
+/* On hosts where pointers-as-ints do not exceed VAL_MAX,
   USE_LSB_TAG is:
    a. unnecessary, because the top bits of an EMACS_INT are unused, and
    b. slower, because it typically requires extra masking.
   So, define USE_LSB_TAG only on hosts where it might be useful.  */
-#  if UINTPTR_MAX >> VALBITS != 0
+#  if VAL_MAX < UINTPTR_MAX
 #   define USE_LSB_TAG
 #  endif
 # endif
@@ -474,10 +485,11 @@ enum pvec_type
     (var) = (type) | (intptr_t) (ptr))
 #define XPNTR(a) ((intptr_t) ((a) & ~TYPEMASK))
+#define XUNTAG(a, type) ((intptr_t) ((a) - (type)))
 #else  /* not USE_LSB_TAG */
-#define VALMASK ((((EMACS_INT) 1) << VALBITS) - 1)
+#define VALMASK VAL_MAX
 /* One need to override this if there must be high bits set in data space
   (doing the result of the below & ((1 << (GCTYPE + 1)) - 1) would work
@@ -580,6 +592,13 @@ extern Lisp_Object make_number (EMACS_INT);
 # define XSETFASTINT(a, b) (XSETINT (a, b))
 #endif
+/* Extract the pointer value of the Lisp object A, under the
+   assumption that A's type is TYPE.  This is a fallback
+   implementation if nothing faster is available.  */
+#ifndef XUNTAG
+# define XUNTAG(a, type) XPNTR (a)
+#endif
 #define EQ(x, y) (XHASH (x) == XHASH (y))
 /* Number of bits in a fixnum, including the sign bit.  */
@@ -612,15 +631,20 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 /* Extract a value or address from a Lisp_Object.  */
-#define XCONS(a) (eassert (CONSP (a)), (struct Lisp_Cons *) XPNTR (a))
+#define XCONS(a)   (eassert (CONSP (a)), \
-#define XVECTOR(a) (eassert (VECTORLIKEP (a)), (struct Lisp_Vector *) XPNTR (a))
+                    (struct Lisp_Cons *) XUNTAG (a, Lisp_Cons))
-#define XSTRING(a) (eassert (STRINGP (a)), (struct Lisp_String *) XPNTR (a))
+#define XVECTOR(a) (eassert (VECTORLIKEP (a)), \
-#define XSYMBOL(a) (eassert (SYMBOLP (a)), (struct Lisp_Symbol *) XPNTR (a))
+                    (struct Lisp_Vector *) XUNTAG (a, Lisp_Vectorlike))
-#define XFLOAT(a) (eassert (FLOATP (a)), (struct Lisp_Float *) XPNTR (a))
+#define XSTRING(a) (eassert (STRINGP (a)), \
+                    (struct Lisp_String *) XUNTAG (a, Lisp_String))
+#define XSYMBOL(a) (eassert (SYMBOLP (a)), \
+                    (struct Lisp_Symbol *) XUNTAG (a, Lisp_Symbol))
+#define XFLOAT(a)  (eassert (FLOATP (a)), \
+                    (struct Lisp_Float *) XUNTAG (a, Lisp_Float))
 /* Misc types.  */
-#define XMISC(a)   ((union Lisp_Misc *) XPNTR (a))
+#define XMISC(a)        ((union Lisp_Misc *) XUNTAG (a, Lisp_Misc))
 #define XMISCANY(a)     (eassert (MISCP (a)), &(XMISC (a)->u_any))
 #define XMISCTYPE(a)   (XMISCANY (a)->type)
 #define XMARKER(a)      (eassert (MARKERP (a)), &(XMISC (a)->u_marker))
@@ -640,14 +664,24 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 /* Pseudovector types.  */
-#define XPROCESS(a) (eassert (PROCESSP (a)), (struct Lisp_Process *) XPNTR (a))
+#define XPROCESS(a) (eassert (PROCESSP (a)), \
-#define XWINDOW(a) (eassert (WINDOWP (a)), (struct window *) XPNTR (a))
+                     (struct Lisp_Process *) XUNTAG (a, Lisp_Vectorlike))
-#define XTERMINAL(a) (eassert (TERMINALP (a)), (struct terminal *) XPNTR (a))
+#define XWINDOW(a) (eassert (WINDOWP (a)), \
-#define XSUBR(a) (eassert (SUBRP (a)), (struct Lisp_Subr *) XPNTR (a))
+                    (struct window *) XUNTAG (a, Lisp_Vectorlike))
-#define XBUFFER(a) (eassert (BUFFERP (a)), (struct buffer *) XPNTR (a))
+#define XTERMINAL(a) (eassert (TERMINALP (a)), \
-#define XCHAR_TABLE(a) (eassert (CHAR_TABLE_P (a)), (struct Lisp_Char_Table *) XPNTR (a))
+                      (struct terminal *) XUNTAG (a, Lisp_Vectorlike))
-#define XSUB_CHAR_TABLE(a) (eassert (SUB_CHAR_TABLE_P (a)), (struct Lisp_Sub_Char_Table *) XPNTR (a))
+#define XSUBR(a) (eassert (SUBRP (a)), \
-#define XBOOL_VECTOR(a) (eassert (BOOL_VECTOR_P (a)), (struct Lisp_Bool_Vector *) XPNTR (a))
+                  (struct Lisp_Subr *) XUNTAG (a, Lisp_Vectorlike))
+#define XBUFFER(a) (eassert (BUFFERP (a)), \
+                    (struct buffer *) XUNTAG (a, Lisp_Vectorlike))
+#define XCHAR_TABLE(a) (eassert (CHAR_TABLE_P (a)), \
+                        (struct Lisp_Char_Table *) XUNTAG (a, Lisp_Vectorlike))
+#define XSUB_CHAR_TABLE(a) (eassert (SUB_CHAR_TABLE_P (a)), \
+                            ((struct Lisp_Sub_Char_Table *) \
+                             XUNTAG (a, Lisp_Vectorlike)))
+#define XBOOL_VECTOR(a) (eassert (BOOL_VECTOR_P (a)), \
+                         ((struct Lisp_Bool_Vector *) \
+                          XUNTAG (a, Lisp_Vectorlike)))
 /* Construct a Lisp_Object from a value or address.  */
@@ -674,7 +708,9 @@ clip_to_bounds (ptrdiff_t lower, EMACS_INT num, ptrdiff_t upper)
 /* The cast to struct vectorlike_header * avoids aliasing issues.  */
 #define XSETPSEUDOVECTOR(a, b, code) \
  XSETTYPED_PSEUDOVECTOR(a, b,       \
-                         ((struct vectorlike_header *) XPNTR (a))->size, \
+                         (((struct vectorlike_header *) \
+                           XUNTAG (a, Lisp_Vectorlike)) \
+                          ->size),                      \
                         code)
 #define XSETTYPED_PSEUDOVECTOR(a, b, size, code)                        \
  (XSETVECTOR (a, b),                                                   \
@@ -1282,7 +1318,7 @@ struct Lisp_Hash_Table
 #define XHASH_TABLE(OBJ) \
-     ((struct Lisp_Hash_Table *) XPNTR (OBJ))
+     ((struct Lisp_Hash_Table *) XUNTAG (OBJ, Lisp_Vectorlike))
 #define XSET_HASH_TABLE(VAR, PTR) \
     (XSETPSEUDOVECTOR (VAR, PTR, PVEC_HASH_TABLE))
@@ -1748,7 +1784,7 @@ typedef struct {
   code is CODE.  */
 #define TYPED_PSEUDOVECTORP(x, t, code)                         \
  (VECTORLIKEP (x)                                              \
-   && (((((struct t *) XPNTR (x))->size                         \
+   && (((((struct t *) XUNTAG (x, Lisp_Vectorlike))->size       \
         & (PSEUDOVECTOR_FLAG | (code))))                       \
       == (PSEUDOVECTOR_FLAG | (code))))
@@ -2409,7 +2445,7 @@ extern Lisp_Object Qerror, Qquit, Qargs_out_of_range;
 extern Lisp_Object Qvoid_variable, Qvoid_function;
 extern Lisp_Object Qinvalid_read_syntax;
 extern Lisp_Object Qinvalid_function, Qwrong_number_of_arguments, Qno_catch;
-extern Lisp_Object Qend_of_file, Qarith_error, Qmark_inactive;
+extern Lisp_Object Quser_error, Qend_of_file, Qarith_error, Qmark_inactive;
 extern Lisp_Object Qbeginning_of_buffer, Qend_of_buffer, Qbuffer_read_only;
 extern Lisp_Object Qtext_read_only;
 extern Lisp_Object Qinteractive_form;
@@ -2788,7 +2824,7 @@ extern int pos_visible_p (struct window *, ptrdiff_t, int *,
 extern void syms_of_xsettings (void);
 /* Defined in vm-limit.c.  */
-extern void memory_warnings (POINTER_TYPE *, void (*warnfun) (const char *));
+extern void memory_warnings (void *, void (*warnfun) (const char *));
 /* Defined in alloc.c */
 extern void check_pure_size (void);
@@ -3604,9 +3640,9 @@ extern int initialized;
 extern int immediate_quit;          /* Nonzero means ^G can quit instantly */
-extern POINTER_TYPE *xmalloc (size_t);
+extern void *xmalloc (size_t);
-extern POINTER_TYPE *xrealloc (POINTER_TYPE *, size_t);
+extern void *xrealloc (void *, size_t);
-extern void xfree (POINTER_TYPE *);
+extern void xfree (void *);
 extern void *xnmalloc (ptrdiff_t, ptrdiff_t);
 extern void *xnrealloc (void *, ptrdiff_t, ptrdiff_t);
 extern void *xpalloc (void *, ptrdiff_t *, ptrdiff_t, ptrdiff_t, ptrdiff_t);
diff --git a/src/lisp.mk b/src/lisp.mk
index 4895ca40959..4608cc3f687 100644
--- a/src/lisp.mk
+++ b/src/lisp.mk
@@ -128,7 +128,9 @@ lisp = \
        $(lispsource)/emacs-lisp/lisp-mode.elc \
        $(lispsource)/textmodes/text-mode.elc \
        $(lispsource)/textmodes/fill.elc \
+        $(lispsource)/newcomment.elc \
        $(lispsource)/replace.elc \
+        $(lispsource)/emacs-lisp/tabulated-list.elc \
        $(lispsource)/buff-menu.elc \
        $(lispsource)/fringe.elc \
        $(lispsource)/emacs-lisp/regexp-opt.elc \
diff --git a/src/lread.c b/src/lread.c
index a2a18921bdc..a7ceec3bb4a 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -24,7 +24,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <errno.h>
-#include <limits.h>     /* for CHAR_BIT */
+#include <limits.h>     /* For CHAR_BIT.  */
 #include <setjmp.h>
 #include "lisp.h"
 #include "intervals.h"
@@ -3996,10 +3996,12 @@ init_obarray (void)
  /* XSYMBOL (Qnil)->function = Qunbound; */
  SET_SYMBOL_VAL (XSYMBOL (Qnil), Qnil);
  XSYMBOL (Qnil)->constant = 1;
+  XSYMBOL (Qnil)->declared_special = 1;
  XSYMBOL (Qnil)->plist = Qnil;
  Qt = intern_c_string ("t");
  SET_SYMBOL_VAL (XSYMBOL (Qt), Qt);
+  XSYMBOL (Qnil)->declared_special = 1;
  XSYMBOL (Qt)->constant = 1;
  /* Qt is correct even if CANNOT_DUMP.  loadup.el will set to nil at end.  */
diff --git a/src/m/README b/src/m/README
deleted file mode 100644
index ad91167648e..00000000000
--- a/src/m/README
+++ /dev/null
@@ -1,7 +0,0 @@
-This directory contains C header files containing machine-specific
-definitions.  Each file describes a particular machine.  The emacs
-configuration script edits ../config.h to include the appropriate one of
-these files, and then each emacs source file includes config.h.
-template.h is a generic template for machine descriptions; it
-describes the parameters a machine file can specify.
diff --git a/src/m/alpha.h b/src/m/alpha.h
deleted file mode 100644
index 2a97a3d5b0c..00000000000
--- a/src/m/alpha.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/* Machine description file for the alpha chip.
-Copyright (C) 1994, 1997, 1999, 2001-2012  Free Software Foundation, Inc.
-Author: Rainer Schoepf
-(according to authors.el)
-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/>.  */
-#ifndef _LP64
-#define _LP64 /* This doesn't appear to be necessary on OSF 4/5  -- fx.  */
-#endif
-/* Now define a symbol for the cpu type, if your compiler
-   does not define it automatically.  */
-/* __alpha defined automatically */
-#ifdef __ELF__
-#if !defined (GNU_LINUX) && !defined (__NetBSD__)
-#define DATA_START    0x140000000
-#endif
-#else  /* not __ELF__ */
-/* Describe layout of the address space in an executing process.  */
-#define DATA_START    0x140000000
-#endif /* __ELF__ */
-/* On the Alpha it's best to avoid including TERMIO since struct
-   termio and struct termios are mutually incompatible.  */
-#define NO_TERMIO
-/* Many Alpha implementations (e.g. gas 2.8) can't handle DBL_MIN:
-   they generate code that uses a signaling NaN instead of DBL_MIN.
-   Define DBL_MIN_REPLACEMENT to be the next value larger than DBL_MIN:
-   this avoids the assembler bug.  */
-#define DBL_MIN_REPLACEMENT 2.2250738585072019e-308
diff --git a/src/m/amdx86-64.h b/src/m/amdx86-64.h
deleted file mode 100644
index f0482c733f9..00000000000
--- a/src/m/amdx86-64.h
+++ /dev/null
@@ -1,35 +0,0 @@
-/* machine description file for AMD x86-64.
-Copyright (C) 2002-2012  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/>.  */
-#define BITS_PER_LONG           64
-#define BITS_PER_EMACS_INT      64
-/* Now define a symbol for the cpu type, if your compiler
-   does not define it automatically:
-   Ones defined so far include vax, m68000, ns16000, pyramid,
-   orion, tahoe, APOLLO and many others */
-/* __x86_64 defined automatically.  */
-/* Define the type to use.  */
-#define EMACS_INT               long
-#define pI                      "l"
-#define EMACS_UINT              unsigned long
-/* Define XPNTR to avoid or'ing with DATA_SEG_BITS */
-#undef DATA_SEG_BITS
diff --git a/src/m/ia64.h b/src/m/ia64.h
deleted file mode 100644
index 47df94cedd0..00000000000
--- a/src/m/ia64.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* machine description file for the IA-64 architecture.
-Copyright (C) 2000-2012  Free Software Foundation, Inc.
-     Contributed by David Mosberger <davidm@hpl.hp.com>
-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/>.  */
-#define BITS_PER_LONG           64
-#define BITS_PER_EMACS_INT      64
-/* Now define a symbol for the cpu type, if your compiler
-   does not define it automatically.  */
-/* __ia64__ defined automatically */
-/* Define the type to use.  */
-#define EMACS_INT               long
-#define pI                      "l"
-#define EMACS_UINT              unsigned long
diff --git a/src/m/ibmrs6000.h b/src/m/ibmrs6000.h
deleted file mode 100644
index 9798ad2d3d7..00000000000
--- a/src/m/ibmrs6000.h
+++ /dev/null
@@ -1,46 +0,0 @@
-/* R2 AIX machine/system dependent defines
-Copyright (C) 1988, 2001-2012  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/>.  */
-/* The data segment in this machine always starts at address 0x20000000.
-   An address of data cannot be stored correctly in a Lisp object;
-   we always lose the high bits.  We must tell XPNTR to add them back.  */
-#define DATA_START 0x20000000
-#define DATA_SEG_BITS 0x20000000
-#ifndef NLIST_STRUCT
-/* AIX supposedly doesn't use this interface, but on the RS/6000
-   it apparently does.  */
-#define NLIST_STRUCT
-#endif
-#undef ADDR_CORRECT
-#define ADDR_CORRECT(x) ((int)(x))
-/*** BUILD 9008 - FIONREAD problem still exists in X-Windows. ***/
-#define BROKEN_FIONREAD
-/* As we define BROKEN_FIONREAD, SIGIO will be undefined in systty.h.
-   But, on AIX, SIGAIO, SIGPTY, and SIGPOLL are defined as SIGIO,
-   which causes compilation error at init_signals in sysdep.c.  So, we
-   define these macros so that syssignal.h detects them and undefine
-   SIGAIO, SIGPTY and SIGPOLL.  */
-#define BROKEN_SIGAIO
-#define BROKEN_SIGPTY
-#define BROKEN_SIGPOLL
diff --git a/src/m/ibms390x.h b/src/m/ibms390x.h
deleted file mode 100644
index aa652a8206a..00000000000
--- a/src/m/ibms390x.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Machine description file for IBM S390 in 64-bit mode
-Copyright (C) 2002-2012  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/>.  */
-#define BITS_PER_LONG 64
-#define BITS_PER_EMACS_INT 64
-/* Define the type to use.  */
-#define EMACS_INT long
-#define pI "l"
-#define EMACS_UINT unsigned long
-/* On the 64 bit architecture, we can use 60 bits for addresses */
-#define VALBITS         60
-/* Define XPNTR to avoid or'ing with DATA_SEG_BITS */
-#define XPNTR(a) XUINT (a)
diff --git a/src/m/intel386.h b/src/m/intel386.h
deleted file mode 100644
index 78a43e92c21..00000000000
--- a/src/m/intel386.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/* Machine description file for intel 386.
-Copyright (C) 1987, 2001-2012  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/>.  */
-#ifdef WINDOWSNT
-#define DATA_START      get_data_start ()
-#endif
-#ifdef GNU_LINUX
-/* libc-linux/sysdeps/linux/i386/ulimit.c says that due to shared library, */
-/* we cannot get the maximum address for brk */
-#define ULIMIT_BREAK_VALUE (32*1024*1024)
-#endif
diff --git a/src/m/m68k.h b/src/m/m68k.h
deleted file mode 100644
index 120a2bad293..00000000000
--- a/src/m/m68k.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* Machine description file for generic Motorola 68k.
-Copyright (C) 1985, 1995, 2001-2012  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/>.  */
-/* Now define a symbol for the cpu type, if your compiler
-   does not define it automatically.  */
-#ifndef m68k
-#define m68k
-#endif
-#ifdef GNU_LINUX
-#ifdef __ELF__
-#define DATA_SEG_BITS 0x80000000
-#endif
-#endif
diff --git a/src/m/macppc.h b/src/m/macppc.h
deleted file mode 100644
index 0303ead25d6..00000000000
--- a/src/m/macppc.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/* machine description file For the powerpc Macintosh.
-Copyright (C) 1994, 2001-2012  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/>.  */
-#ifdef _ARCH_PPC64
-#ifndef _LP64
-#define _LP64
-#endif
-#endif
diff --git a/src/m/sparc.h b/src/m/sparc.h
deleted file mode 100644
index 27b6070ba87..00000000000
--- a/src/m/sparc.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* machine description file for Sun 4 SPARC.
-Copyright (C) 1987, 2001-2012  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/>.  */
-/* __sparc__ is defined by the compiler by default.  */
-#ifdef __arch64__               /* GCC, 64-bit ABI.  */
-#define BITS_PER_LONG 64
-#ifndef _LP64
-#define _LP64 /* Done on Alpha -- not sure if it should be here.  -- fx */
-#endif
-#endif  /* __arch64__ */
diff --git a/src/m/template.h b/src/m/template.h
deleted file mode 100644
index 5f1a46c86e1..00000000000
--- a/src/m/template.h
+++ /dev/null
@@ -1,34 +0,0 @@
-/* machine description file template.
-Copyright (C) 1985-1986, 2001-2012  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/>.  */
-/* Now define a symbol for the cpu type, if your compiler
-   does not define it automatically.
-   Ones defined so far include m68k and many others */
-/* After adding support for a new machine, modify the large case
-   statement in configure.in to recognize reasonable
-   configuration names, and add a description of the system to
-   `etc/MACHINES'.
-   Check for any tests of $machine in configure.in, and add an entry
-   for the new machine if needed.
-   If you've just fixed a problem in an existing configuration file,
-   you should also check `etc/MACHINES' to make sure its descriptions
-   of known problems in that configuration should be updated.  */
diff --git a/src/m/vax.h b/src/m/vax.h
deleted file mode 100644
index e4bed4090b9..00000000000
--- a/src/m/vax.h
+++ /dev/null
@@ -1,23 +0,0 @@
-/* machine description file for vax.
-Copyright (C) 1985-1986, 2001-2012  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/>.  */
-/* #define vax    -- appears to be done automatically  */
-#define HAVE_FTIME
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 303445bc2d6..99b1241eab0 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -343,7 +343,7 @@ cleanall:	clean
 ##
 ## This works only with GNU Make.
-TAGS: $(OBJ0) $(OBJ1) $(OBJ2) $(CURDIR)/m/intel386.h $(CURDIR)/s/ms-w32.h
+TAGS: $(OBJ0) $(OBJ1) $(OBJ2) $(CURDIR)/s/ms-w32.h
        $(MAKE) $(MFLAGS) TAGS-$(MAKETYPE)
 TAGS-LISP: $(OBJ0) $(OBJ1) $(OBJ2)
@@ -357,7 +357,7 @@ TAGS-gmake:
          $(OBJ1_c)
        ../lib-src/$(BLD)/etags.exe -a --regex=@../nt/emacs-src.tags \
          $(OBJ2_c) \
-          $(CURDIR)/*.h $(CURDIR)/m/intel386.h $(CURDIR)/s/ms-w32.h
+          $(CURDIR)/*.h $(CURDIR)/s/ms-w32.h
 TAGS-nmake:
        echo This target is not supported with NMake
@@ -407,7 +407,6 @@ CODING_H       = $(SRC)/coding.h \
 MS_W32_H       = $(SRC)/s/ms-w32.h \
                 $(NT_INC)/sys/stat.h
 CONFIG_H       = $(SRC)/config.h \
-                 $(SRC)/m/intel386.h \
                 $(MS_W32_H)
 DIR_H          = $(NT_INC)/sys/dir.h \
                 $(SRC)/ndir.h
@@ -930,7 +929,7 @@ $(BLD)/fringe.$(O) : \
 $(BLD)/gmalloc.$(O) : \
        $(SRC)/gmalloc.c \
-        $(SRC)/getpagesize.h \
+        $(NT_INC)/stdint.h \
        $(NT_INC)/unistd.h \
        $(CONFIG_H)
@@ -1514,6 +1513,7 @@ $(BLD)/w32menu.$(O) : \
        $(SRC)/w32menu.c \
        $(SRC)/buffer.h \
        $(SRC)/keymap.h \
+        $(SRC)/w32heap.h \
        $(BLOCKINPUT_H) \
        $(CHARSET_H) \
        $(CODING_H) \
diff --git a/src/mem-limits.h b/src/mem-limits.h
index 244592a9768..1fd53b472f3 100644
--- a/src/mem-limits.h
+++ b/src/mem-limits.h
@@ -34,7 +34,7 @@ extern int etext;
 #endif
 extern char *start_of_data (void);
-#if defined USE_LSB_TAG || UINTPTR_MAX >> VALBITS == 0
+#if defined USE_LSB_TAG || UINTPTR_MAX <= VAL_MAX
 #define EXCEEDS_LISP_PTR(ptr) 0
 #elif defined DATA_SEG_BITS
 #define EXCEEDS_LISP_PTR(ptr) \
diff --git a/src/ns.mk b/src/ns.mk
index d3b5afeb99e..77fbf5845d9 100644
--- a/src/ns.mk
+++ b/src/ns.mk
@@ -1,6 +1,6 @@
 ### autodeps.mk --- src/Makefile fragment for GNU Emacs
-## Copyright (C) 2008-2012  Free Software Foundation, Inc.
+## Copyright (C) 2008-2012 Free Software Foundation, Inc.
 ## This file is part of GNU Emacs.
@@ -27,13 +27,13 @@
 ${ns_appdir}: ${ns_appsrc}
        rm -fr ${ns_appdir}
-        mkdir -p ${ns_appdir}
+        ${MKDIR_P} ${ns_appdir}
        ( cd ${ns_appsrc} ; tar cfh - . ) | ( cd ${ns_appdir} ; umask 022; tar xf - )
-${ns_appbindir}Emacs: emacs${EXEEXT}
+${ns_appbindir}/Emacs: emacs${EXEEXT}
-        mkdir -p ${ns_appbindir}
+        ${MKDIR_P} ${ns_appbindir}
-        cp -f emacs${EXEEXT} ${ns_appbindir}Emacs
+        cp -f emacs${EXEEXT} ${ns_appbindir}/Emacs
-ns-app: ${ns_appdir} ${ns_appbindir}Emacs
+ns-app: ${ns_appdir} ${ns_appbindir}/Emacs
 ### ns.mk ends here
diff --git a/src/nsterm.m b/src/nsterm.m
index 7cbaf991311..4b8b2bb4820 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -338,11 +338,18 @@ ns_init_paths (void)
 /*NSLog (@"loadPath: '%@'\n", resourcePaths); */
    }
+  /* Normally, Emacs does not add its own bin/ directory to the PATH.
+     However, a self-contained NS build has a different layout, with
+     bin/ and libexec/ subdirectories in the directory that contains
+     Emacs.app itself.
+     We put libexec first, because init_callproc_1 uses the first
+     element to initialize exec-directory.  An alternative would be
+     for init_callproc to check for invocation-directory/libexec.  */
  if (!getenv ("EMACSPATH"))
    {
      NSArray *paths = [binDir stringsByAppendingPaths:
-                                  [NSArray arrayWithObjects: @"bin",
+                                  [NSArray arrayWithObjects: @"libexec",
-                                                             @"lib-exec", nil]];
+                                                             @"bin", nil]];
      NSEnumerator *pathEnum = [paths objectEnumerator];
      resourcePaths = @"";
      while (resourcePath = [pathEnum nextObject])
diff --git a/src/print.c b/src/print.c
index bfe3287b92c..2912396bd33 100644
--- a/src/print.c
+++ b/src/print.c
@@ -854,7 +854,6 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
 {
  Lisp_Object errname, errmsg, file_error, tail;
  struct gcpro gcpro1;
-  int i;
  if (context != 0)
    write_string_1 (context, -1, stream);
@@ -885,9 +884,8 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
    }
  else
    {
-      Lisp_Object error_conditions;
+      Lisp_Object error_conditions = Fget (errname, Qerror_conditions);
      errmsg = Fget (errname, Qerror_message);
-      error_conditions = Fget (errname, Qerror_conditions);
      file_error = Fmemq (Qfile_error, error_conditions);
    }
@@ -901,22 +899,30 @@ print_error_message (Lisp_Object data, Lisp_Object stream, const char *context,
  if (!NILP (file_error) && CONSP (tail))
    errmsg = XCAR (tail), tail = XCDR (tail);
-  if (STRINGP (errmsg))
+  {
-    Fprinc (errmsg, stream);
+    const char *sep = ": ";
-  else
-    write_string_1 ("peculiar error", -1, stream);
-  for (i = 0; CONSP (tail); tail = XCDR (tail), i = 1)
+    if (!STRINGP (errmsg))
-    {
+      write_string_1 ("peculiar error", -1, stream);
-      Lisp_Object obj;
+    else if (SCHARS (errmsg))
+      Fprinc (errmsg, stream);
+    else
+      sep = NULL;
-      write_string_1 (i ? ", " : ": ", 2, stream);
+    for (; CONSP (tail); tail = XCDR (tail), sep = ", ")
-      obj = XCAR (tail);
+      {
-      if (!NILP (file_error) || EQ (errname, Qend_of_file))
+        Lisp_Object obj;
-        Fprinc (obj, stream);
+        
-      else
+        if (sep)
-        Fprin1 (obj, stream);
+          write_string_1 (sep, 2, stream);
-    }
+        obj = XCAR (tail);
+        if (!NILP (file_error)
+            || EQ (errname, Qend_of_file) || EQ (errname, Quser_error))
+          Fprinc (obj, stream);
+        else
+          Fprin1 (obj, stream);
+      }
+  }
  UNGCPRO;
 }
diff --git a/src/puresize.h b/src/puresize.h
index bca36b2a562..bee82d1e783 100644
--- a/src/puresize.h
+++ b/src/puresize.h
@@ -45,7 +45,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 /* Increase BASE_PURESIZE by a ratio depending on the machine's word size.  */
 #ifndef PURESIZE_RATIO
-#if BITS_PER_EMACS_INT > 32
+#if EMACS_INT_MAX >> 31 != 0
 #if PTRDIFF_MAX >> 31 != 0
 #define PURESIZE_RATIO 10/6     /* Don't surround with `()'. */
 #else
diff --git a/src/ralloc.c b/src/ralloc.c
index 4bb2f240438..d736e279520 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -31,9 +31,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <unistd.h>
-typedef POINTER_TYPE *POINTER;
-typedef size_t SIZE;
 #ifdef DOUG_LEA_MALLOC
 #define M_TOP_PAD           -2
 extern int mallopt (int, int);
@@ -47,9 +44,6 @@ extern size_t __malloc_extra_blocks;
 #include <stddef.h>
-typedef size_t SIZE;
-typedef void *POINTER;
 #include <unistd.h>
 #include <malloc.h>
@@ -58,6 +52,8 @@ typedef void *POINTER;
 #include "getpagesize.h"
+typedef size_t SIZE;
+typedef void *POINTER;
 #define NIL ((POINTER) 0)
 /* A flag to indicate whether we have initialized ralloc yet.  For
diff --git a/src/regex.c b/src/regex.c
index d16a5148054..f9a12a3c2dc 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -434,17 +434,7 @@ init_syntax_once (void)
 #endif /* not emacs */
-/* We remove any previous definition of `SIGN_EXTEND_CHAR',
+#define SIGN_EXTEND_CHAR(c) ((signed char) (c))
-   since ours (we hope) works properly with all combinations of
-   machines, compilers, `char' and `unsigned char' argument types.
-   (Per Bothner suggested the basic approach.)  */
-#undef SIGN_EXTEND_CHAR
-#if __STDC__
-# define SIGN_EXTEND_CHAR(c) ((signed char) (c))
-#else  /* not __STDC__ */
-/* As in Harbison and Steele.  */
-# define SIGN_EXTEND_CHAR(c) ((((unsigned char) (c)) ^ 128) - 128)
-#endif
 /* Should we use malloc or alloca?  If REGEX_MALLOC is not defined, we
   use `alloca' instead of `malloc'.  This is because using malloc in
@@ -553,12 +543,12 @@ typedef char boolean;
 #define false 0
 #define true 1
-static regoff_t re_match_2_internal _RE_ARGS ((struct re_pattern_buffer *bufp,
+static regoff_t re_match_2_internal (struct re_pattern_buffer *bufp,
-                                               re_char *string1, size_t size1,
+                                     re_char *string1, size_t size1,
-                                               re_char *string2, size_t size2,
+                                     re_char *string2, size_t size2,
-                                               ssize_t pos,
+                                     ssize_t pos,
-                                               struct re_registers *regs,
+                                     struct re_registers *regs,
-                                               ssize_t stop));
+                                     ssize_t stop);
 /* These are the command codes that appear in compiled regular
   expressions.  Some opcodes are followed by argument bytes.  A
@@ -735,11 +725,8 @@ typedef enum
  } while (0)
 #ifdef DEBUG
-static void extract_number _RE_ARGS ((int *dest, re_char *source));
 static void
-extract_number (dest, source)
+extract_number (int *dest, re_char *source)
-    int *dest;
-    re_char *source;
 {
  int temp = SIGN_EXTEND_CHAR (*(source + 1));
  *dest = *source & 0377;
@@ -763,12 +750,8 @@ extract_number (dest, source)
  } while (0)
 #ifdef DEBUG
-static void extract_number_and_incr _RE_ARGS ((int *destination,
-                                               re_char **source));
 static void
-extract_number_and_incr (destination, source)
+extract_number_and_incr (int *destination, re_char **source)
-    int *destination;
-    re_char **source;
 {
  extract_number (destination, *source);
  *source += 2;
@@ -1672,25 +1655,22 @@ do {									\
 /* Subroutine declarations and macros for regex_compile.  */
-static reg_errcode_t regex_compile _RE_ARGS ((re_char *pattern, size_t size,
+static reg_errcode_t regex_compile (re_char *pattern, size_t size,
-                                              reg_syntax_t syntax,
+                                    reg_syntax_t syntax,
-                                              struct re_pattern_buffer *bufp));
+                                    struct re_pattern_buffer *bufp);
-static void store_op1 _RE_ARGS ((re_opcode_t op, unsigned char *loc, int arg));
+static void store_op1 (re_opcode_t op, unsigned char *loc, int arg);
-static void store_op2 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
+static void store_op2 (re_opcode_t op, unsigned char *loc, int arg1, int arg2);
-                                 int arg1, int arg2));
+static void insert_op1 (re_opcode_t op, unsigned char *loc,
-static void insert_op1 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
+                        int arg, unsigned char *end);
-                                  int arg, unsigned char *end));
+static void insert_op2 (re_opcode_t op, unsigned char *loc,
-static void insert_op2 _RE_ARGS ((re_opcode_t op, unsigned char *loc,
+                        int arg1, int arg2, unsigned char *end);
-                                  int arg1, int arg2, unsigned char *end));
+static boolean at_begline_loc_p (re_char *pattern, re_char *p,
-static boolean at_begline_loc_p _RE_ARGS ((re_char *pattern,
+                                 reg_syntax_t syntax);
-                                           re_char *p,
+static boolean at_endline_loc_p (re_char *p, re_char *pend,
-                                           reg_syntax_t syntax));
+                                 reg_syntax_t syntax);
-static boolean at_endline_loc_p _RE_ARGS ((re_char *p,
+static re_char *skip_one_char (re_char *p);
-                                           re_char *pend,
+static int analyse_first (re_char *p, re_char *pend,
-                                           reg_syntax_t syntax));
+                          char *fastmap, const int multibyte);
-static re_char *skip_one_char _RE_ARGS ((re_char *p));
-static int analyse_first _RE_ARGS ((re_char *p, re_char *pend,
-                                    char *fastmap, const int multibyte));
 /* Fetch the next character in the uncompiled pattern, with no
   translation.  */
@@ -2442,9 +2422,8 @@ regex_grow_registers (int num_regs)
 #endif /* not MATCH_MAY_ALLOCATE */
-static boolean group_in_compile_stack _RE_ARGS ((compile_stack_type
+static boolean group_in_compile_stack (compile_stack_type compile_stack,
-                                                 compile_stack,
+                                       regnum_t regnum);
-                                                 regnum_t regnum));
 /* `regex_compile' compiles PATTERN (of length SIZE) according to SYNTAX.
   Returns one of error codes defined in `regex.h', or zero for success.
@@ -4554,10 +4533,10 @@ WEAK_ALIAS (__re_search_2, re_search_2)
 /* Declarations and macros for re_match_2.  */
-static int bcmp_translate _RE_ARGS ((re_char *s1, re_char *s2,
+static int bcmp_translate (re_char *s1, re_char *s2,
-                                     register ssize_t len,
+                           register ssize_t len,
-                                     RE_TRANSLATE_TYPE translate,
+                           RE_TRANSLATE_TYPE translate,
-                                     const int multibyte));
+                           const int multibyte);
 /* This converts PTR, a pointer into one of the search strings `string1'
   and `string2' into an offset from the beginning of that string.  */
diff --git a/src/regex.h b/src/regex.h
index 643d0b7b5ab..e0ede012b20 100644
--- a/src/regex.h
+++ b/src/regex.h
@@ -451,38 +451,21 @@ typedef struct
 /* Declarations for routines.  */
-/* To avoid duplicating every routine declaration -- once with a
-   prototype (if we are ANSI), and once without (if we aren't) -- we
-   use the following macro to declare argument types.  This
-   unfortunately clutters up the declarations a bit, but I think it's
-   worth it.  */
-#if defined __STDC__ || defined PROTOTYPES
-# define _RE_ARGS(args) args
-#else /* not __STDC__  || PROTOTYPES */
-# define _RE_ARGS(args) ()
-#endif /* not __STDC__  || PROTOTYPES */
 /* Sets the current default syntax to SYNTAX, and return the old syntax.
   You can also simply assign to the `re_syntax_options' variable.  */
-extern reg_syntax_t re_set_syntax _RE_ARGS ((reg_syntax_t syntax));
+extern reg_syntax_t re_set_syntax (reg_syntax_t __syntax);
 /* Compile the regular expression PATTERN, with length LENGTH
   and syntax given by the global `re_syntax_options', into the buffer
   BUFFER.  Return NULL if successful, and an error string if not.  */
-extern const char *re_compile_pattern
+extern const char *re_compile_pattern (const char *__pattern, size_t __length,
-  _RE_ARGS ((const char *pattern, size_t length,
+                                       struct re_pattern_buffer *__buffer);
-             struct re_pattern_buffer *buffer));
 /* Compile a fastmap for the compiled pattern in BUFFER; used to
   accelerate searches.  Return 0 if successful and -2 if was an
   internal error.  */
-extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
+extern int re_compile_fastmap (struct re_pattern_buffer *__buffer);
 /* Search in the string STRING (with length LENGTH) for the pattern
@@ -490,33 +473,35 @@ extern int re_compile_fastmap _RE_ARGS ((struct re_pattern_buffer *buffer));
   characters.  Return the starting position of the match, -1 for no
   match, or -2 for an internal error.  Also return register
   information in REGS (if REGS and BUFFER->no_sub are nonzero).  */
-extern regoff_t re_search
+extern regoff_t re_search (struct re_pattern_buffer *__buffer,
-  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+                           const char *__string, size_t __length,
-             size_t length, ssize_t start, ssize_t range,
+                           ssize_t __start, ssize_t __range,
-             struct re_registers *regs));
+                           struct re_registers *__regs);
 /* Like `re_search', but search in the concatenation of STRING1 and
   STRING2.  Also, stop searching at index START + STOP.  */
-extern regoff_t re_search_2
+extern regoff_t re_search_2 (struct re_pattern_buffer *__buffer,
-  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+                             const char *__string1, size_t __length1,
-             size_t length1, const char *string2, size_t length2,
+                             const char *__string2, size_t __length2,
-             ssize_t start, ssize_t range, struct re_registers *regs,
+                             ssize_t __start, ssize_t __range,
-             ssize_t stop));
+                             struct re_registers *__regs,
+                             ssize_t __stop);
 /* Like `re_search', but return how many characters in STRING the regexp
   in BUFFER matched, starting at position START.  */
-extern regoff_t re_match
+extern regoff_t re_match (struct re_pattern_buffer *__buffer,
-  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string,
+                          const char *__string, size_t __length,
-             size_t length, ssize_t start, struct re_registers *regs));
+                          ssize_t __start, struct re_registers *__regs);
 /* Relates to `re_match' as `re_search_2' relates to `re_search'.  */
-extern regoff_t re_match_2
+extern regoff_t re_match_2 (struct re_pattern_buffer *__buffer,
-  _RE_ARGS ((struct re_pattern_buffer *buffer, const char *string1,
+                            const char *__string1, size_t __length1,
-             size_t length1, const char *string2, size_t length2,
+                            const char *__string2, size_t __length2,
-             ssize_t start, struct re_registers *regs, ssize_t stop));
+                            ssize_t __start, struct re_registers *__regs,
+                            ssize_t __stop);
 /* Set REGS to hold NUM_REGS registers, storing them in STARTS and
@@ -531,15 +516,16 @@ extern regoff_t re_match_2
   Unless this function is called, the first search or match using
   PATTERN_BUFFER will allocate its own register data, without
   freeing the old data.  */
-extern void re_set_registers
+extern void re_set_registers (struct re_pattern_buffer *__buffer,
-  _RE_ARGS ((struct re_pattern_buffer *buffer, struct re_registers *regs,
+                              struct re_registers *__regs,
-             unsigned num_regs, regoff_t *starts, regoff_t *ends));
+                              unsigned __num_regs,
+                              regoff_t *__starts, regoff_t *__ends);
 #if defined _REGEX_RE_COMP || defined _LIBC
 # ifndef _CRAY
 /* 4.2 bsd compatibility.  */
-extern char *re_comp _RE_ARGS ((const char *));
+extern char *re_comp (const char *);
-extern int re_exec _RE_ARGS ((const char *));
+extern int re_exec (const char *);
 # endif
 #endif
@@ -562,20 +548,19 @@ extern int re_exec _RE_ARGS ((const char *));
 #endif
 /* POSIX compatibility.  */
-extern reg_errcode_t regcomp _RE_ARGS ((regex_t *__restrict __preg,
+extern reg_errcode_t regcomp (regex_t *__restrict __preg,
-                                        const char *__restrict __pattern,
+                              const char *__restrict __pattern,
-                                        int __cflags));
+                              int __cflags);
-extern reg_errcode_t regexec _RE_ARGS ((const regex_t *__restrict __preg,
+extern reg_errcode_t regexec (const regex_t *__restrict __preg,
-                                        const char *__restrict __string,
+                              const char *__restrict __string, size_t __nmatch,
-                                        size_t __nmatch,
+                              regmatch_t __pmatch[__restrict_arr],
-                                        regmatch_t __pmatch[__restrict_arr],
+                              int __eflags);
-                                        int __eflags));
-extern size_t regerror _RE_ARGS ((int __errcode, const regex_t *__preg,
+extern size_t regerror (int __errcode, const regex_t * __preg,
-                                  char *__errbuf, size_t __errbuf_size));
+                        char *__errbuf, size_t __errbuf_size);
-extern void regfree _RE_ARGS ((regex_t *__preg));
+extern void regfree (regex_t *__preg);
 #ifdef __cplusplus
diff --git a/src/s/aix4-2.h b/src/s/aix4-2.h
index 354ffda0988..cacfdc7ed63 100644
--- a/src/s/aix4-2.h
+++ b/src/s/aix4-2.h
@@ -76,6 +76,17 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
   to avoid a crash just use the Emacs implementation for that function.  */
 #define BROKEN_GET_CURRENT_DIR_NAME 1
+/*** BUILD 9008 - FIONREAD problem still exists in X-Windows. ***/
+#define BROKEN_FIONREAD
+/* As we define BROKEN_FIONREAD, SIGIO will be undefined in systty.h.
+   But, on AIX, SIGAIO, SIGPTY, and SIGPOLL are defined as SIGIO,
+   which causes compilation error at init_signals in sysdep.c.  So, we
+   define these macros so that syssignal.h detects them and undefine
+   SIGAIO, SIGPTY and SIGPOLL.  */
+#define BROKEN_SIGAIO
+#define BROKEN_SIGPTY
+#define BROKEN_SIGPOLL
 /* Conservative garbage collection has not been tested, so for now
   play it safe and stick with the old-fashioned way of marking.  */
 #define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
diff --git a/src/s/gnu-linux.h b/src/s/gnu-linux.h
index d04ea33068a..409d0205520 100644
--- a/src/s/gnu-linux.h
+++ b/src/s/gnu-linux.h
@@ -157,3 +157,9 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #else
 #define GC_MARK_STACK GC_USE_GCPROS_AS_BEFORE
 #endif
+#ifdef __i386__
+/* libc-linux/sysdeps/linux/i386/ulimit.c says that due to shared library, */
+/* we cannot get the maximum address for brk */
+# define ULIMIT_BREAK_VALUE (32*1024*1024)
+#endif
diff --git a/src/s/gnu.h b/src/s/gnu.h
index a09e0e824c9..cd72164a520 100644
--- a/src/s/gnu.h
+++ b/src/s/gnu.h
@@ -24,8 +24,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #undef SYSTEM_TYPE
 #define SYSTEM_TYPE "gnu"
-#undef NLIST_STRUCT
 #define SIGNALS_VIA_CHARACTERS
 /* libc defines data_start.  */
diff --git a/src/s/irix6-5.h b/src/s/irix6-5.h
index e5d90c1bd5d..e5479c3b8d3 100644
--- a/src/s/irix6-5.h
+++ b/src/s/irix6-5.h
@@ -85,10 +85,6 @@ char *_getpty();
 #define NARROWPROTO 1
-#if _MIPS_SZLONG == 64          /* -mabi=64 (gcc) or -64 (MIPSpro) */
-#define _LP64                   /* lisp.h takes care of the rest */
-#endif /* _MIPS_SZLONG */
 #undef SA_RESTART
 #undef TIOCSIGSEND              /* defined in usg5-4-common.h */
diff --git a/src/s/ms-w32.h b/src/s/ms-w32.h
index e89ecb05931..f88128b27aa 100644
--- a/src/s/ms-w32.h
+++ b/src/s/ms-w32.h
@@ -122,7 +122,6 @@ struct sigaction {
 #define HAVE_GETTIMEOFDAY 1
 #define HAVE_GETHOSTNAME 1
-#undef  HAVE_GETDOMAINNAME
 #define HAVE_DUP2 1
 #define HAVE_RENAME 1
 #define HAVE_CLOSEDIR 1
@@ -147,7 +146,6 @@ struct sigaction {
 #define HAVE_FMOD 1
 #undef  HAVE_RINT
 #undef  HAVE_CBRT
-#define HAVE_FTIME 1
 #undef  HAVE_RES_INIT /* For -lresolv on Suns.  */
 #undef  HAVE_SETSID
 #undef  HAVE_FPATHCONF
@@ -383,6 +381,8 @@ extern int getloadavg (double *, int);
 /* We need a little extra space, see ../../lisp/loadup.el.  */
 #define SYSTEM_PURESIZE_EXTRA 50000
+#define DATA_START      get_data_start ()
 /* For unexec to work on Alpha systems, we need to put Emacs'
   initialized data into a separate section from the CRT initialized
   data (because the Alpha linker freely reorders data variables, even
diff --git a/src/search.c b/src/search.c
index 503720b70ab..a9542a2ed97 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2079,112 +2079,6 @@ set_search_regs (ptrdiff_t beg_byte, ptrdiff_t nbytes)
  XSETBUFFER (last_thing_searched, current_buffer);
 }
-DEFUN ("word-search-regexp", Fword_search_regexp, Sword_search_regexp, 1, 2, 0,
-       doc: /* Return a regexp which matches words, ignoring punctuation.
-Given STRING, a string of words separated by word delimiters,
-compute a regexp that matches those exact words separated by
-arbitrary punctuation.  If LAX is non-nil, the end of the string
-need not match a word boundary unless it ends in whitespace.
-Used in `word-search-forward', `word-search-backward',
-`word-search-forward-lax', `word-search-backward-lax'.  */)
-  (Lisp_Object string, Lisp_Object lax)
-{
-  register unsigned char *o;
-  register ptrdiff_t i, i_byte, len, punct_count = 0, word_count = 0;
-  Lisp_Object val;
-  int prev_c = 0;
-  EMACS_INT adjust;
-  int whitespace_at_end;
-  CHECK_STRING (string);
-  len = SCHARS (string);
-  for (i = 0, i_byte = 0; i < len; )
-    {
-      int c;
-      FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c, string, i, i_byte);
-      if (SYNTAX (c) != Sword)
-        {
-          punct_count++;
-          if (SYNTAX (prev_c) == Sword)
-            word_count++;
-        }
-      prev_c = c;
-    }
-  if (SYNTAX (prev_c) == Sword)
-    {
-      word_count++;
-      whitespace_at_end = 0;
-    }
-  else
-    {
-      whitespace_at_end = 1;
-      if (!word_count)
-        return empty_unibyte_string;
-    }
-  adjust = word_count - 1;
-  if (TYPE_MAXIMUM (EMACS_INT) / 5 < adjust)
-    memory_full (SIZE_MAX);
-  adjust = - punct_count + 5 * adjust
-    + ((!NILP (lax) && !whitespace_at_end) ? 2 : 4);
-  if (STRING_MULTIBYTE (string))
-    {
-      if (INT_ADD_OVERFLOW (SBYTES (string), adjust))
-        memory_full (SIZE_MAX);
-      val = make_uninit_multibyte_string (len + adjust,
-                                          SBYTES (string) + adjust);
-    }
-  else
-    {
-      if (INT_ADD_OVERFLOW (len, adjust))
-        memory_full (SIZE_MAX);
-      val = make_uninit_string (len + adjust);
-    }
-  o = SDATA (val);
-  *o++ = '\\';
-  *o++ = 'b';
-  prev_c = 0;
-  for (i = 0, i_byte = 0; i < len; )
-    {
-      int c;
-      ptrdiff_t i_byte_orig = i_byte;
-      FETCH_STRING_CHAR_AS_MULTIBYTE_ADVANCE (c, string, i, i_byte);
-      if (SYNTAX (c) == Sword)
-        {
-          memcpy (o, SDATA (string) + i_byte_orig, i_byte - i_byte_orig);
-          o += i_byte - i_byte_orig;
-        }
-      else if (SYNTAX (prev_c) == Sword && --word_count)
-        {
-          *o++ = '\\';
-          *o++ = 'W';
-          *o++ = '\\';
-          *o++ = 'W';
-          *o++ = '*';
-        }
-      prev_c = c;
-    }
-  if (NILP (lax) || whitespace_at_end)
-    {
-      *o++ = '\\';
-      *o++ = 'b';
-    }
-  return val;
-}
 DEFUN ("search-backward", Fsearch_backward, Ssearch_backward, 1, 4,
       "MSearch backward: ",
       doc: /* Search backward from point for STRING.
@@ -2227,86 +2121,6 @@ See also the functions `match-beginning', `match-end' and `replace-match'.  */)
  return search_command (string, bound, noerror, count, 1, 0, 0);
 }
-DEFUN ("word-search-backward", Fword_search_backward, Sword_search_backward, 1, 4,
-       "sWord search backward: ",
-       doc: /* Search backward from point for STRING, ignoring differences in punctuation.
-Set point to the beginning of the occurrence found, and return point.
-An optional second argument bounds the search; it is a buffer position.
-The match found must not extend before that position.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, move to limit of search and return nil.
-Optional fourth argument is repeat count--search for successive occurrences.
-Relies on the function `word-search-regexp' to convert a sequence
-of words in STRING to a regexp used to search words without regard
-to punctuation.  */)
-  (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
-{
-  return search_command (Fword_search_regexp (string, Qnil), bound, noerror, count, -1, 1, 0);
-}
-DEFUN ("word-search-forward", Fword_search_forward, Sword_search_forward, 1, 4,
-       "sWord search: ",
-       doc: /* Search forward from point for STRING, ignoring differences in punctuation.
-Set point to the end of the occurrence found, and return point.
-An optional second argument bounds the search; it is a buffer position.
-The match found must not extend after that position.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, move to limit of search and return nil.
-Optional fourth argument is repeat count--search for successive occurrences.
-Relies on the function `word-search-regexp' to convert a sequence
-of words in STRING to a regexp used to search words without regard
-to punctuation.  */)
-  (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
-{
-  return search_command (Fword_search_regexp (string, Qnil), bound, noerror, count, 1, 1, 0);
-}
-DEFUN ("word-search-backward-lax", Fword_search_backward_lax, Sword_search_backward_lax, 1, 4,
-       "sWord search backward: ",
-       doc: /* Search backward from point for STRING, ignoring differences in punctuation.
-Set point to the beginning of the occurrence found, and return point.
-Unlike `word-search-backward', the end of STRING need not match a word
-boundary, unless STRING ends in whitespace.
-An optional second argument bounds the search; it is a buffer position.
-The match found must not extend before that position.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, move to limit of search and return nil.
-Optional fourth argument is repeat count--search for successive occurrences.
-Relies on the function `word-search-regexp' to convert a sequence
-of words in STRING to a regexp used to search words without regard
-to punctuation.  */)
-  (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
-{
-  return search_command (Fword_search_regexp (string, Qt), bound, noerror, count, -1, 1, 0);
-}
-DEFUN ("word-search-forward-lax", Fword_search_forward_lax, Sword_search_forward_lax, 1, 4,
-       "sWord search: ",
-       doc: /* Search forward from point for STRING, ignoring differences in punctuation.
-Set point to the end of the occurrence found, and return point.
-Unlike `word-search-forward', the end of STRING need not match a word
-boundary, unless STRING ends in whitespace.
-An optional second argument bounds the search; it is a buffer position.
-The match found must not extend after that position.
-Optional third argument, if t, means if fail just return nil (no error).
-  If not nil and not t, move to limit of search and return nil.
-Optional fourth argument is repeat count--search for successive occurrences.
-Relies on the function `word-search-regexp' to convert a sequence
-of words in STRING to a regexp used to search words without regard
-to punctuation.  */)
-  (Lisp_Object string, Lisp_Object bound, Lisp_Object noerror, Lisp_Object count)
-{
-  return search_command (Fword_search_regexp (string, Qt), bound, noerror, count, 1, 1, 0);
-}
 DEFUN ("re-search-backward", Fre_search_backward, Sre_search_backward, 1, 4,
       "sRE search backward: ",
       doc: /* Search backward from point for match for regular expression REGEXP.
@@ -3277,11 +3091,6 @@ is to bind it with `let' around a small expression.  */);
  defsubr (&Sposix_string_match);
  defsubr (&Ssearch_forward);
  defsubr (&Ssearch_backward);
-  defsubr (&Sword_search_regexp);
-  defsubr (&Sword_search_forward);
-  defsubr (&Sword_search_backward);
-  defsubr (&Sword_search_forward_lax);
-  defsubr (&Sword_search_backward_lax);
  defsubr (&Sre_search_forward);
  defsubr (&Sre_search_backward);
  defsubr (&Sposix_search_forward);
diff --git a/src/sound.c b/src/sound.c
index bd34628767b..143653e48e4 100644
--- a/src/sound.c
+++ b/src/sound.c
@@ -124,9 +124,6 @@ static int parse_sound (Lisp_Object, Lisp_Object *);
 #ifndef DEFAULT_SOUND_DEVICE
 #define DEFAULT_SOUND_DEVICE "/dev/dsp"
 #endif
-#ifndef DEFAULT_ALSA_SOUND_DEVICE
-#define DEFAULT_ALSA_SOUND_DEVICE "default"
-#endif
 /* Structure forward declarations.  */
@@ -908,6 +905,10 @@ vox_write (struct sound_device *sd, const char *buffer, ptrdiff_t nbytes)
 /* This driver is available on GNU/Linux. */
+#ifndef DEFAULT_ALSA_SOUND_DEVICE
+#define DEFAULT_ALSA_SOUND_DEVICE "default"
+#endif
 static void
 alsa_sound_perror (const char *msg, int err)
 {
diff --git a/src/sysdep.c b/src/sysdep.c
index 9d09d1d2c67..a82f802a785 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -52,9 +52,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define read sys_read
 #define write sys_write
 #include <windows.h>
-#ifndef NULL
-#define NULL 0
-#endif
 #endif /* not WINDOWSNT */
 #include <sys/types.h>
diff --git a/src/syssignal.h b/src/syssignal.h
index 86135d71215..a2522f24429 100644
--- a/src/syssignal.h
+++ b/src/syssignal.h
@@ -1,5 +1,6 @@
 /* syssignal.h - System-dependent definitions for signals.
-   Copyright (C) 1993, 1999, 2001-2012  Free Software Foundation, Inc.
+Copyright (C) 1993, 1999, 2001-2012 Free Software Foundation, Inc.
 This file is part of GNU Emacs.
@@ -82,24 +83,18 @@ void croak (char *) NO_RETURN;
 #define sigfree() sigsetmask (SIGEMPTYMASK)
-#if defined (SIGINFO) && defined (BROKEN_SIGINFO)
-#undef SIGINFO
-#endif
 #if defined (SIGIO) && defined (BROKEN_SIGIO)
 # undef SIGIO
 #endif
+/* Last user: m/ibmrs6000.h  */
 #if defined (SIGPOLL) && defined (BROKEN_SIGPOLL)
 #undef SIGPOLL
 #endif
-#if defined (SIGTSTP) && defined (BROKEN_SIGTSTP)
+/* Last user: m/ibmrs6000.h  */
-#undef SIGTSTP
-#endif
-#if defined (SIGURG) && defined (BROKEN_SIGURG)
-#undef SIGURG
-#endif
 #if defined (SIGAIO) && defined (BROKEN_SIGAIO)
 #undef SIGAIO
 #endif
+/* Last user: m/ibmrs6000.h  */
 #if defined (SIGPTY) && defined (BROKEN_SIGPTY)
 #undef SIGPTY
 #endif
diff --git a/src/term.c b/src/term.c
index 09888bc6dda..3d7a677374c 100644
--- a/src/term.c
+++ b/src/term.c
@@ -3599,7 +3599,7 @@ delete_tty (struct terminal *terminal)
 /* Mark the pointers in the tty_display_info objects.
-   Called by the Fgarbage_collector.  */
+   Called by Fgarbage_collect.  */
 void
 mark_ttys (void)
diff --git a/src/termcap.c b/src/termcap.c
index 10c195eebe2..61f9d9a31ea 100644
--- a/src/termcap.c
+++ b/src/termcap.c
@@ -30,10 +30,6 @@ Boston, MA 02110-1301, USA.  */
 #include "msdos.h"
 #endif
-#ifndef NULL
-#define NULL (char *) 0
-#endif
 /* BUFSIZE is the initial size allocated for the buffer
   for reading the termcap file.
   It is not a limit.
@@ -661,10 +657,6 @@ gobble_line (int fd, register struct termcap_buffer *bufp, char *append_end)
 #ifdef TEST
-#ifdef NULL
-#undef NULL
-#endif
 #include <stdio.h>
 static void
diff --git a/src/textprop.c b/src/textprop.c
index f9339c66893..83d07c56f28 100644
--- a/src/textprop.c
+++ b/src/textprop.c
@@ -23,10 +23,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "buffer.h"
 #include "window.h"
-#ifndef NULL
-#define NULL (void *)0
-#endif
 /* Test for membership, allowing for t (actually any non-cons) to mean the
   universal set.  */
diff --git a/src/tparam.c b/src/tparam.c
index ac21667d65b..4d26ef524fb 100644
--- a/src/tparam.c
+++ b/src/tparam.c
@@ -22,10 +22,6 @@ Boston, MA 02110-1301, USA.  */
 #include <setjmp.h>
 #include "lisp.h"               /* for xmalloc */
 #include "tparam.h"
-#ifndef NULL
-#define NULL (char *) 0
-#endif
 /* Assuming STRING is the value of a termcap string entry
   containing `%' constructs to expand parameters,
diff --git a/src/undo.c b/src/undo.c
index 929955ffcf5..9b763984d7f 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -436,6 +436,13 @@ truncate_undo_list (struct buffer *b)
  unbind_to (count, Qnil);
 }
+static void user_error (const char*) NO_RETURN;
+static void user_error (const char *msg)
+{
+  xsignal1 (Quser_error, build_string (msg));
+}
 DEFUN ("primitive-undo", Fprimitive_undo, Sprimitive_undo, 2, 2, 0,
       doc: /* Undo N records from the front of the list LIST.
@@ -528,7 +535,7 @@ Return what remains of the list.  */)
                  end = Fcdr (cdr);
                  if (XINT (beg) < BEGV || XINT (end) > ZV)
-                    error ("Changes to be undone are outside visible portion of buffer");
+                    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))
@@ -537,7 +544,7 @@ Return what remains of the list.  */)
                  if (XINT (car) < BEGV
                      || XINT (cdr) > ZV)
-                    error ("Changes to be undone are outside visible portion of buffer");
+                    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);
@@ -588,14 +595,14 @@ Return what remains of the list.  */)
                  if (pos < 0)
                    {
                      if (-pos < BEGV || -pos > ZV)
-                        error ("Changes to be undone are outside visible portion of buffer");
+                        user_error ("Changes to be undone are outside visible portion of buffer");
                      SET_PT (-pos);
                      Finsert (1, &membuf);
                    }
                  else
                    {
                      if (pos < BEGV || pos > ZV)
-                        error ("Changes to be undone are outside visible portion of buffer");
+                        user_error ("Changes to be undone are outside visible portion of buffer");
                      SET_PT (pos);
                      /* Now that we record marker adjustments
diff --git a/src/unexaix.c b/src/unexaix.c
index 1bf65b68518..29fa0fd6287 100644
--- a/src/unexaix.c
+++ b/src/unexaix.c
@@ -78,13 +78,13 @@ static long data_scnptr;
 static long load_scnptr;
 static long orig_load_scnptr;
 static long orig_data_scnptr;
-static int unrelocate_symbols (int, int, char *, char *);
+static int unrelocate_symbols (int, int, const char *, const char *);
 #ifndef MAX_SECTIONS
 #define MAX_SECTIONS    10
 #endif
-static int adjust_lnnoptrs (int, int, char *);
+static int adjust_lnnoptrs (int, int, const char *);
 static int pagemask;
@@ -92,7 +92,7 @@ static int pagemask;
 #include "lisp.h"
 static void
-report_error (char *file, int fd)
+report_error (const char *file, int fd)
 {
  if (fd)
    close (fd);
@@ -104,16 +104,16 @@ report_error (char *file, int fd)
 #define ERROR2(msg,x,y) report_error_1 (new, msg, x, y); return -1
 static void
-report_error_1 (int fd, char *msg, int a1, int a2)
+report_error_1 (int fd, const char *msg, int a1, int a2)
 {
  close (fd);
  error (msg, a1, a2);
 }
-static int make_hdr (int, int, unsigned, unsigned, unsigned, char *, char *);
+static int make_hdr (int, int, const char *, const char *);
-static void mark_x (char *);
+static void mark_x (const char *);
 static int copy_text_and_data (int);
-static int copy_sym (int, int, char *, char *);
+static int copy_sym (int, int, const char *, const char *);
 static void write_segment (int, char *, char *);
 /* ****************************************************************
@@ -159,7 +159,7 @@ unexec (const char *new_name, const char *a_name)
 */
 static int
 make_hdr (int new, int a_out,
-          char *a_name, char *new_name)
+          const char *a_name, const char *new_name)
 {
  int scns;
  unsigned int bss_start;
@@ -429,7 +429,7 @@ write_segment (int new, char *ptr, char *end)
 * Copy the relocation information and symbol table from the a.out to the new
 */
 static int
-copy_sym (int new, int a_out, char *a_name, char *new_name)
+copy_sym (int new, int a_out, const char *a_name, const char *new_name)
 {
  char page[UnexBlockSz];
  int n;
@@ -465,7 +465,7 @@ copy_sym (int new, int a_out, char *a_name, char *new_name)
 * After successfully building the new a.out, mark it executable
 */
 static void
-mark_x (char *name)
+mark_x (const char *name)
 {
  struct stat sbuf;
  int um;
@@ -483,7 +483,7 @@ mark_x (char *name)
 }
 static int
-adjust_lnnoptrs (int writedesc, int readdesc, char *new_name)
+adjust_lnnoptrs (int writedesc, int readdesc, const char *new_name)
 {
  int nsyms;
  int naux;
@@ -530,7 +530,8 @@ adjust_lnnoptrs (int writedesc, int readdesc, char *new_name)
 }
 static int
-unrelocate_symbols (int new, int a_out, char *a_name, char *new_name)
+unrelocate_symbols (int new, int a_out,
+                    const char *a_name, const char *new_name)
 {
  int i;
  LDHDR ldhdr;
diff --git a/src/unexelf.c b/src/unexelf.c
index ac9c9e75764..f35b53aeab3 100644
--- a/src/unexelf.c
+++ b/src/unexelf.c
@@ -506,11 +506,7 @@ typedef struct {
 #endif
 #ifndef ElfW
-# ifdef __STDC__
+# define ElfBitsW(bits, type) Elf##bits##_##type
-#  define ElfBitsW(bits, type) Elf##bits##_##type
-# else
-#  define ElfBitsW(bits, type) Elf/**/bits/**/_/**/type
-# endif
 # ifdef _LP64
 #  define ELFSIZE 64
 # else
diff --git a/src/vm-limit.c b/src/vm-limit.c
index 94725044048..c313a900f2c 100644
--- a/src/vm-limit.c
+++ b/src/vm-limit.c
@@ -31,7 +31,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 enum warnlevel { not_warned, warned_75, warned_85, warned_95 };
 static enum warnlevel warnlevel;
-typedef POINTER_TYPE *POINTER;
+typedef void *POINTER;
 /* Function to call to issue a warning;
   0 means don't issue them.  */
diff --git a/src/w32fns.c b/src/w32fns.c
index 3a6929844de..d7114f19b90 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -4003,7 +4003,7 @@ unwind_create_frame (Lisp_Object frame)
 #if GLYPH_DEBUG
      /* Check that reference counts are indeed correct.  */
      xassert (dpyinfo->reference_count == dpyinfo_refcount);
-      xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
+      xassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
 #endif
      return Qt;
    }
@@ -5016,16 +5016,6 @@ no value of TYPE (always string in the MS Windows case).  */)
   cursor.  Duplicated from xdisp.c, but cannot use the version there
   due to lack of atimers on w32.  */
 #define DEFAULT_HOURGLASS_DELAY 1
-/* Return non-zero if hourglass timer has been started or hourglass is
-   shown.  */
-/* PENDING: if W32 can use atimers (atimer.[hc]) then the common impl in
-            xdisp.c could be used. */
-int
-hourglass_started (void)
-{
-  return hourglass_shown_p || hourglass_timer;
-}
 /* Cancel a currently active hourglass timer, and start a new one.  */
@@ -5246,7 +5236,7 @@ x_create_tip_frame (struct w32_display_info *dpyinfo,
 #if GLYPH_DEBUG
  image_cache_refcount =
-    FRAME_IMAGE_CACHE ? FRAME_IMAGE_CACHE (f)->refcount : 0;
+    FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
  dpyinfo_refcount = dpyinfo->reference_count;
 #endif /* GLYPH_DEBUG */
  FRAME_KBOARD (f) = kb;
diff --git a/src/w32font.c b/src/w32font.c
index dab9f4c61b4..8badace9635 100644
--- a/src/w32font.c
+++ b/src/w32font.c
@@ -2045,8 +2045,11 @@ fill_in_logfont (FRAME_PTR f, LOGFONT *logfont, Lisp_Object font_spec)
        /* Font families are interned, but allow for strings also in case of
           user input.  */
      else if (SYMBOLP (tmp))
-        strncpy (logfont->lfFaceName,
+        {
-                 SDATA (ENCODE_SYSTEM (SYMBOL_NAME (tmp))), LF_FACESIZE);
+          strncpy (logfont->lfFaceName,
+                   SDATA (ENCODE_SYSTEM (SYMBOL_NAME (tmp))), LF_FACESIZE);
+          logfont->lfFaceName[LF_FACESIZE-1] = '\0';
+        }
    }
  tmp = AREF (font_spec, FONT_ADSTYLE_INDEX);
diff --git a/src/w32menu.c b/src/w32menu.c
index dd741a01b5b..2bc4c208956 100644
--- a/src/w32menu.c
+++ b/src/w32menu.c
@@ -48,6 +48,8 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include "dispextern.h"
+#include "w32heap.h"    /* for osinfo_cache */
 #undef HAVE_DIALOGS /* TODO: Implement native dialogs.  */
 #ifndef TRUE
@@ -1498,8 +1500,11 @@ add_menu_item (HMENU menu, widget_value *wv, HMENU item)
            AppendMenu (menu, fuFlags,
                        item != NULL ? (UINT) item: (UINT) wv->call_data,
                        out_string);
-          /* Don't use Unicode menus in future.  */
+          /* Don't use Unicode menus in future, unless this is Windows
-          unicode_append_menu = NULL;
+             NT or later, where a failure of AppendMenuW does NOT mean
+             Unicode menus are unsupported.  */
+          if (osinfo_cache.dwPlatformId != VER_PLATFORM_WIN32_NT)
+            unicode_append_menu = NULL;
        }
      if (unicode_append_menu && (fuFlags & MF_OWNERDRAW))
diff --git a/src/w32proc.c b/src/w32proc.c
index 28591f90128..5bdeba25958 100644
--- a/src/w32proc.c
+++ b/src/w32proc.c
@@ -141,7 +141,25 @@ new_child (void)
      cp->char_consumed = CreateEvent (NULL, FALSE, FALSE, NULL);
      if (cp->char_consumed)
        {
-          cp->thrd = CreateThread (NULL, 1024, reader_thread, cp, 0, &id);
+          /* The 0x00010000 flag is STACK_SIZE_PARAM_IS_A_RESERVATION.
+             It means that the 64K stack we are requesting in the 2nd
+             argument is how much memory should be reserved for the
+             stack.  If we don't use this flag, the memory requested
+             by the 2nd argument is the amount actually _committed_,
+             but Windows reserves 8MB of memory for each thread's
+             stack.  (The 8MB figure comes from the -stack
+             command-line argument we pass to the linker when building
+             Emacs, but that's because we need a large stack for
+             Emacs's main thread.)  Since we request 2GB of reserved
+             memory at startup (see w32heap.c), which is close to the
+             maximum memory available for a 32-bit process on Windows,
+             the 8MB reservation for each thread causes failures in
+             starting subprocesses, because we create a thread running
+             reader_thread for each subprocess.  As 8MB of stack is
+             way too much for reader_thread, forcing Windows to
+             reserve less wins the day.  */
+          cp->thrd = CreateThread (NULL, 64 * 1024, reader_thread, cp,
+                                   0x00010000, &id);
          if (cp->thrd)
            return cp;
        }
diff --git a/src/w32term.c b/src/w32term.c
index 18a3753f9e9..2ccd7574332 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -231,6 +231,10 @@ static void my_set_focus (struct frame *, HWND);
 static void my_set_foreground_window (HWND);
 static void my_destroy_window (struct frame *, HWND);
+#if GLYPH_DEBUG
+static void x_check_font (struct frame *, struct font *);
+#endif
 static Lisp_Object Qvendor_specific_keysyms;
@@ -5906,6 +5910,27 @@ x_wm_set_icon_position (struct frame *f, int icon_x, int icon_y)
 /***********************************************************************
+                                Fonts
+ ***********************************************************************/
+#if GLYPH_DEBUG
+/* Check that FONT is valid on frame F.  It is if it can be found in F's
+   font table.  */
+static void
+x_check_font (struct frame *f, struct font *font)
+{
+  xassert (font != NULL && ! NILP (font->props[FONT_TYPE_INDEX]));
+  if (font->driver->check)
+    xassert (font->driver->check (f, font) == 0);
+}
+#endif /* GLYPH_DEBUG != 0 */
+/***********************************************************************
                            Initialization
 ***********************************************************************/
diff --git a/src/window.c b/src/window.c
index 19f27ec5320..37bcf64181a 100644
--- a/src/window.c
+++ b/src/window.c
@@ -4223,6 +4223,11 @@ window_scroll_pixel_based (Lisp_Object window, int n, int whole, int noerror)
  void *itdata = NULL;
  SET_TEXT_POS_FROM_MARKER (start, w->start);
+  /* Scrolling a minibuffer window via scroll bar when the echo area
+     shows long text sometimes resets the minibuffer contents behind
+     our backs.  */
+  if (CHARPOS (start) > ZV)
+    SET_TEXT_POS (start, BEGV, BEGV_BYTE);
  /* If PT is not visible in WINDOW, move back one half of
     the screen.  Allow PT to be partially visible, otherwise
diff --git a/src/window.h b/src/window.h
index ea127ca95a8..1524805579f 100644
--- a/src/window.h
+++ b/src/window.h
@@ -852,11 +852,6 @@ extern EMACS_INT minibuf_level;
 extern int update_mode_lines;
-/* Nonzero if BEGV - BEG or Z - ZV of current buffer has changed since
-   last redisplay that finished.  */
-extern int clip_changed;
 /* Nonzero if window sizes or contents have changed since last
   redisplay that finished */
diff --git a/src/xdisp.c b/src/xdisp.c
index 43b92bcf536..0a25eab1cbc 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -383,11 +383,21 @@ static Lisp_Object Qline_height;
 #define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it) 0
 #endif /* HAVE_WINDOW_SYSTEM */
-/* Test if the display element loaded in IT is a space or tab
+/* Test if the display element loaded in IT, or the underlying buffer
-   character.  This is used to determine word wrapping.  */
+   or string character, is a space or a TAB character.  This is used
+   to determine where word wrapping can occur.  */
-#define IT_DISPLAYING_WHITESPACE(it)                            \
-  (it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))
+#define IT_DISPLAYING_WHITESPACE(it)                                    \
+  ((it->what == IT_CHARACTER && (it->c == ' ' || it->c == '\t'))        \
+   || ((STRINGP (it->string)                                            \
+        && (SREF (it->string, IT_STRING_BYTEPOS (*it)) == ' '           \
+            || SREF (it->string, IT_STRING_BYTEPOS (*it)) == '\t'))     \
+       || (it->s                                                        \
+           && (it->s[IT_BYTEPOS (*it)] == ' '                           \
+               || it->s[IT_BYTEPOS (*it)] == '\t'))                     \
+       || (IT_BYTEPOS (*it) < ZV_BYTE                                   \
+           && (*BYTE_POS_ADDR (IT_BYTEPOS (*it)) == ' '                 \
+               || *BYTE_POS_ADDR (IT_BYTEPOS (*it)) == '\t'))))         \
 /* Name of the face used to highlight trailing whitespace.  */
@@ -839,6 +849,7 @@ static int try_cursor_movement (Lisp_Object, struct text_pos, int *);
 static int trailing_whitespace_p (ptrdiff_t);
 static intmax_t message_log_check_duplicate (ptrdiff_t, ptrdiff_t);
 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);
@@ -1265,6 +1276,11 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
    }
  SET_TEXT_POS_FROM_MARKER (top, w->start);
+  /* Scrolling a minibuffer window via scroll bar when the echo area
+     shows long text sometimes resets the minibuffer contents behind
+     our backs.  */
+  if (CHARPOS (top) > ZV)
+    SET_TEXT_POS (top, BEGV, BEGV_BYTE);
  /* Compute exact mode line heights.  */
  if (WINDOW_WANTS_MODELINE_P (w))
@@ -1298,8 +1314,8 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
         glyph.  */
      int top_x = it.current_x;
      int top_y = it.current_y;
-      enum it_method it_method = it.method;
      /* Calling line_bottom_y may change it.method, it.position, etc.  */
+      enum it_method it_method = it.method;
      int bottom_y = (last_height = 0, line_bottom_y (&it));
      int window_top_y = WINDOW_HEADER_LINE_HEIGHT (w);
@@ -1307,6 +1323,31 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
        visible_p = bottom_y > window_top_y;
      else if (top_y < it.last_visible_y)
        visible_p = 1;
+      if (bottom_y >= it.last_visible_y
+          && it.bidi_p && it.bidi_it.scan_dir == -1
+          && IT_CHARPOS (it) < charpos)
+        {
+          /* When the last line of the window is scanned backwards
+             under bidi iteration, we could be duped into thinking
+             that we have passed CHARPOS, when in fact move_it_to
+             simply stopped short of CHARPOS because it reached
+             last_visible_y.  To see if that's what happened, we call
+             move_it_to again with a slightly larger vertical limit,
+             and see if it actually moved vertically; if it did, we
+             didn't really reach CHARPOS, which is beyond window end.  */
+          struct it save_it = it;
+          /* Why 10? because we don't know how many canonical lines
+             will the height of the next line(s) be.  So we guess.  */
+          int ten_more_lines =
+            10 * FRAME_LINE_HEIGHT (XFRAME (WINDOW_FRAME (w)));
+          move_it_to (&it, charpos, -1, bottom_y + ten_more_lines, -1,
+                      MOVE_TO_POS | MOVE_TO_Y);
+          if (it.current_y > top_y)
+            visible_p = 0;
+          it = save_it;
+        }
      if (visible_p)
        {
          if (it_method == GET_FROM_DISPLAY_VECTOR)
@@ -1370,6 +1411,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                  Lisp_Object startpos, endpos;
                  EMACS_INT start, end;
                  struct it it3;
+                  int it3_moved;
                  /* Find the first and the last buffer positions
                     covered by the display string.  */
@@ -1426,6 +1468,15 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                     begins.  */
                  start_display (&it3, w, top);
                  move_it_to (&it3, -1, 0, top_y, -1, MOVE_TO_X | MOVE_TO_Y);
+                  /* If it3_moved stays zero after the 'while' loop
+                     below, that means we already were at a newline
+                     before the loop (e.g., the display string begins
+                     with a newline), so we don't need to (and cannot)
+                     inspect the glyphs of it3.glyph_row, because
+                     PRODUCE_GLYPHS will not produce anything for a
+                     newline, and thus it3.glyph_row stays at its
+                     stale content it got at top of the window.  */
+                  it3_moved = 0;
                  /* Finally, advance the iterator until we hit the
                     first display element whose character position is
                     CHARPOS, or until the first newline from the
@@ -1437,6 +1488,7 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                      if (IT_CHARPOS (it3) == charpos
                          || ITERATOR_AT_END_OF_LINE_P (&it3))
                        break;
+                      it3_moved = 1;
                      set_iterator_to_next (&it3, 0);
                    }
                  top_x = it3.current_x - it3.pixel_width;
@@ -1447,7 +1499,8 @@ pos_visible_p (struct window *w, ptrdiff_t charpos, int *x, int *y,
                     display string, move back over the glyphs
                     produced from the string, until we find the
                     rightmost glyph not from the string.  */
-                  if (IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
+                  if (it3_moved
+                      && IT_CHARPOS (it3) != charpos && EQ (it3.object, string))
                    {
                      struct glyph *g = it3.glyph_row->glyphs[TEXT_AREA]
                                        + it3.glyph_row->used[TEXT_AREA];
@@ -3111,7 +3164,15 @@ handle_stop (struct it *it)
                 overlays even if the actual buffer text is replaced.  */
              if (!handle_overlay_change_p
                  || it->sp > 1
-                  || !get_overlay_strings_1 (it, 0, 0))
+                  /* Don't call get_overlay_strings_1 if we already
+                     have overlay strings loaded, because doing so
+                     will load them again and push the iterator state
+                     onto the stack one more time, which is not
+                     expected by the rest of the code that processes
+                     overlay strings.  */
+                  || (it->n_overlay_strings <= 0
+                      ? !get_overlay_strings_1 (it, 0, 0)
+                      : 0))
                {
                  if (it->ellipsis_p)
                    setup_for_ellipsis (it, 0);
@@ -4667,10 +4728,22 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          if (!FRAME_WINDOW_P (it->f))
            /* If we return here, POSITION has been advanced
               across the text with this property.  */
-            return 0;
+            {
+              /* Synchronize the bidi iterator with POSITION.  This is
+                 needed because we are not going to push the iterator
+                 on behalf of this display property, so there will be
+                 no pop_it call to do this synchronization for us.  */
+              if (it->bidi_p)
+                {
+                  it->position = *position;
+                  iterate_out_of_display_property (it);
+                  *position = it->position;
+                }
+              return 1;
+            }
        }
      else if (!frame_window_p)
-        return 0;
+        return 1;
 #ifdef HAVE_WINDOW_SYSTEM
      value = XCAR (XCDR (spec));
@@ -4678,7 +4751,15 @@ handle_single_display_spec (struct it *it, Lisp_Object spec, Lisp_Object object,
          || !(fringe_bitmap = lookup_fringe_bitmap (value)))
        /* If we return here, POSITION has been advanced
           across the text with this property.  */
-        return 0;
+        {
+          if (it && it->bidi_p)
+            {
+              it->position = *position;
+              iterate_out_of_display_property (it);
+              *position = it->position;
+            }
+          return 1;
+        }
      if (it)
        {
@@ -5602,7 +5683,7 @@ push_it (struct it *it, struct text_pos *position)
 static void
 iterate_out_of_display_property (struct it *it)
 {
-  int buffer_p = BUFFERP (it->object);
+  int buffer_p = !STRINGP (it->string);
  ptrdiff_t eob = (buffer_p ? ZV : it->end_charpos);
  ptrdiff_t bob = (buffer_p ? BEGV : 0);
@@ -6769,6 +6850,16 @@ get_next_display_element (struct it *it)
               && FACE_FROM_ID (it->f, face_id)->box == FACE_NO_BOX);
        }
    }
+  /* If we reached the end of the object we've been iterating (e.g., a
+     display string or an overlay string), and there's something on
+     IT->stack, proceed with what's on the stack.  It doesn't make
+     sense to return zero if there's unprocessed stuff on the stack,
+     because otherwise that stuff will never be displayed.  */
+  if (!success_p && it->sp > 0)
+    {
+      set_iterator_to_next (it, 0);
+      success_p = get_next_display_element (it);
+    }
  /* Value is 0 if end of buffer or string reached.  */
  return success_p;
@@ -6950,7 +7041,7 @@ set_iterator_to_next (struct it *it, int reseat_p)
         display vector entry (these entries may contain faces).  */
      it->face_id = it->saved_face_id;
-      if (it->dpvec + it->current.dpvec_index == it->dpend)
+      if (it->dpvec + it->current.dpvec_index >= it->dpend)
        {
          int recheck_faces = it->ellipsis_p;
@@ -6988,6 +7079,26 @@ set_iterator_to_next (struct it *it, int reseat_p)
    case GET_FROM_STRING:
      /* Current display element is a character from a Lisp string.  */
      xassert (it->s == NULL && STRINGP (it->string));
+      /* Don't advance past string end.  These conditions are true
+         when set_iterator_to_next is called at the end of
+         get_next_display_element, in which case the Lisp string is
+         already exhausted, and all we want is pop the iterator
+         stack.  */
+      if (it->current.overlay_string_index >= 0)
+        {
+          /* This is an overlay string, so there's no padding with
+             spaces, and the number of characters in the string is
+             where the string ends.  */
+          if (IT_STRING_CHARPOS (*it) >= SCHARS (it->string))
+            goto consider_string_end;
+        }
+      else
+        {
+          /* Not an overlay string.  There could be padding, so test
+             against it->end_charpos . */
+          if (IT_STRING_CHARPOS (*it) >= it->end_charpos)
+            goto consider_string_end;
+        }
      if (it->cmp_it.id >= 0)
        {
          int i;
@@ -12707,6 +12818,9 @@ redisplay_internal (void)
     frames.  Zero means, only selected_window is considered.  */
  int consider_all_windows_p;
+  /* Non-zero means redisplay has to redisplay the miniwindow */
+  int update_miniwindow_p = 0;
  TRACE ((stderr, "redisplay_internal %d\n", redisplaying_p));
  /* No redisplay if running in batch mode or frame is not yet fully
@@ -12893,6 +13007,10 @@ redisplay_internal (void)
          && !MINI_WINDOW_P (XWINDOW (selected_window))))
    {
      int window_height_changed_p = echo_area_display (0);
+      if (message_cleared_p)
+        update_miniwindow_p = 1;
      must_finish = 1;
      /* If we don't display the current message, don't clear the
@@ -12929,7 +13047,7 @@ redisplay_internal (void)
 /* FIXME: this causes all frames to be updated, which seems unnecessary
   since only the current frame needs to be considered.  This function needs
   to be rewritten with two variables, consider_all_windows and
-   consider_all_frames. */
+   consider_all_frames.  */
      consider_all_windows_p = 1;
      ++windows_or_buffers_changed;
      ++update_mode_lines;
@@ -13115,7 +13233,8 @@ redisplay_internal (void)
         then we can't just move the cursor.  */
      else if (! (!NILP (Vtransient_mark_mode)
                  && !NILP (BVAR (current_buffer, mark_active)))
-               && (EQ (selected_window, BVAR (current_buffer, last_selected_window))
+               && (EQ (selected_window,
+                       BVAR (current_buffer, last_selected_window))
                   || highlight_nonselected_windows)
               && NILP (w->region_showing)
               && NILP (Vshow_trailing_whitespace)
@@ -13268,7 +13387,7 @@ redisplay_internal (void)
    }
  else if (FRAME_VISIBLE_P (sf) && !FRAME_OBSCURED_P (sf))
    {
-      Lisp_Object mini_window;
+      Lisp_Object mini_window = FRAME_MINIBUF_WINDOW (sf);
      struct frame *mini_frame;
      displayed_buffer = XBUFFER (XWINDOW (selected_window)->buffer);
@@ -13277,6 +13396,10 @@ redisplay_internal (void)
      internal_condition_case_1 (redisplay_window_1, selected_window,
                                 list_of_error,
                                 redisplay_window_error);
+      if (update_miniwindow_p)
+        internal_condition_case_1 (redisplay_window_1, mini_window,
+                                   list_of_error,
+                                   redisplay_window_error);
      /* Compare desired and current matrices, perform output.  */
@@ -28850,14 +28973,6 @@ init_xdisp (void)
 /* Platform-independent portion of hourglass implementation. */
-/* Return non-zero if hourglass timer has been started or hourglass is
-   shown.  */
-int
-hourglass_started (void)
-{
-  return hourglass_shown_p || hourglass_atimer != NULL;
-}
 /* Cancel a currently active hourglass timer, and start a new one.  */
 void
 start_hourglass (void)
diff --git a/src/xfns.c b/src/xfns.c
index 2d2ab46fb36..767507805fb 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -136,7 +136,7 @@ char *gray_bitmap_bits = gray_bits;
 /* Nonzero if using X.  */
-static int x_in_use;
+int x_in_use;
 static Lisp_Object Qnone;
 static Lisp_Object Qsuppress_icon;
@@ -2439,7 +2439,6 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
  /* Do some needed geometry management.  */
  {
-    ptrdiff_t len;
    char *tem, shell_position[sizeof "=x++" + 4 * INT_STRLEN_BOUND (int)];
    Arg gal[10];
    int gac = 0;
@@ -2508,13 +2507,11 @@ x_window (struct frame *f, long window_prompting, int minibuffer_only)
        }
    }
-    len = strlen (shell_position) + 1;
    /* We don't free this because we don't know whether
       it is safe to free it while the frame exists.
       It isn't worth the trouble of arranging to free it
       when the frame is deleted.  */
-    tem = (char *) xmalloc (len);
+    tem = (char *) xstrdup (shell_position);
-    strncpy (tem, shell_position, len);
    XtSetArg (gal[gac], XtNgeometry, tem); gac++;
    XtSetValues (shell_widget, gal, gac);
  }
diff --git a/src/xgselect.c b/src/xgselect.c
index 80dbfc32aee..9d6a3ba774a 100644
--- a/src/xgselect.c
+++ b/src/xgselect.c
@@ -27,28 +27,33 @@ along with GNU Emacs.  If not, see <http§://www.gnu.org/licenses/>.  */
 #include <glib.h>
 #include <errno.h>
 #include <setjmp.h>
+#include "xterm.h"
 static GPollFD *gfds;
 static ptrdiff_t gfds_size;
 int
-xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
+xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
           EMACS_TIME *timeout)
 {
  SELECT_TYPE all_rfds, all_wfds;
  EMACS_TIME tmo, *tmop = timeout;
-  GMainContext *context = g_main_context_default ();
+  GMainContext *context;
  int have_wfds = wfds != NULL;
-  int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0;
+  int n_gfds = 0, our_tmo = 0, retval = 0, our_fds = 0, max_fds = fds_lim - 1;
  int i, nfds, tmo_in_millisec;
+  if (!x_in_use)
+    return select (fds_lim, rfds, wfds, efds, timeout);
  if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
  else FD_ZERO (&all_rfds);
  if (wfds) memcpy (&all_wfds, wfds, sizeof (all_rfds));
  else FD_ZERO (&all_wfds);
  /* Update event sources in GLib. */
+  context = g_main_context_default ();
  g_main_context_pending (context);
  do {
@@ -97,14 +102,14 @@ xg_select (int max_fds, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
      if (our_tmo) tmop = &tmo;
    }
-  nfds = select (max_fds+1, &all_rfds, have_wfds ? &all_wfds : NULL,
+  fds_lim = max_fds + 1;
-                 efds, tmop);
+  nfds = select (fds_lim, &all_rfds, have_wfds ? &all_wfds : NULL, efds, tmop);
  if (nfds < 0)
    retval = nfds;
  else if (nfds > 0)
    {
-      for (i = 0; i < max_fds+1; ++i)
+      for (i = 0; i < fds_lim; ++i)
        {
          if (FD_ISSET (i, &all_rfds))
            {
diff --git a/src/xselect.c b/src/xselect.c
index 290f4d7eb4d..48baeb32581 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -930,6 +930,7 @@ x_convert_selection (struct input_event *event, Lisp_Object selection_symbol,
  /* Otherwise, record the converted selection to binary.  */
  cs = xmalloc (sizeof (struct selection_data));
+  cs->data = NULL;
  cs->nofree = 1;
  cs->property = property;
  cs->wait_object = NULL;
diff --git a/src/xterm.c b/src/xterm.c
index 1a5bc913f60..0ebaf87c252 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -256,11 +256,7 @@ static Time last_user_time;
 /* Incremented by XTread_socket whenever it really tries to read
   events.  */
-#ifdef __STDC__
 static int volatile input_signal_count;
-#else
-static int input_signal_count;
-#endif
 /* Used locally within XTread_socket.  */
@@ -10146,7 +10142,7 @@ x_term_init (Lisp_Object display_name, char *xrm_option, char *resource_name)
  /* Set the name of the terminal. */
  terminal->name = (char *) xmalloc (SBYTES (display_name) + 1);
-  strncpy (terminal->name, SSDATA (display_name), SBYTES (display_name));
+  memcpy (terminal->name, SSDATA (display_name), SBYTES (display_name));
  terminal->name[SBYTES (display_name)] = 0;
 #if 0
diff --git a/src/xterm.h b/src/xterm.h
index b498261a805..8919b648371 100644
--- a/src/xterm.h
+++ b/src/xterm.h
@@ -1031,6 +1031,7 @@ extern void x_clipboard_manager_save_all (void);
 extern struct x_display_info * check_x_display_info (Lisp_Object);
 extern Lisp_Object x_get_focus_frame (struct frame *);
+extern int x_in_use;
 #ifdef USE_GTK
 extern int xg_set_icon (struct frame *, Lisp_Object);
author	Paul Eggert	2012-05-25 11:19:24 -0700
committer	Paul Eggert	2012-05-25 11:19:24 -0700
commit	42b2a986d9d4b7040fb20c90ec0efeffb78e761a (patch)
tree	d38e7bf5307837f2f38982757f088100de18a64e /src
parent	e4d81efc58695c19154d5f6733d91172b4c3e5b7 (diff)
parent	a8d3cbf75d219d7a249fc0623219511179e959da (diff)
download	emacs-42b2a986d9d4b7040fb20c90ec0efeffb78e761a.tar.gz emacs-42b2a986d9d4b7040fb20c90ec0efeffb78e761a.zip