Merged from miles@gnu.org--gnu-2005 (patch 12-13, 79-90)

Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-79
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-80
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-81
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-82
   Merge from gnus--rel--5.10

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-83
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-84
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-85
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-86
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-87
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-88
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-89
   Update from CVS

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-90
   Update from CVS: man/calc.texi: Add macro for LaTeX for info output.

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-12
   Merge from emacs--cvs-trunk--0

 * miles@gnu.org--gnu-2005/gnus--rel--5.10--patch-13
   Update from CVS

git-archimport-id: lorentey@elte.hu--2004/emacs--multi-tty--0--patch-290

7 files changed, 301 insertions, 84 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index eb8bab64362..c00c06cc358 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,68 @@
+2005-02-09  Kim F. Storm  <storm@cua.dk>
+
+        * undo.c (Fprimitive_undo): Check that undo function does not
+        switch buffer.
+
+2005-02-08  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xselect.c (selection_data_to_lisp_data): For the special case
+        type == XA_ATOM, data contains array of int, not array of Atom.
+        (x_property_data_to_lisp, selection_data_to_lisp_data): Comment
+        update: data must be array of int for format == 32.
+
+2005-02-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * undo.c (Fprimitive_undo): Check veracity of delta,start,end.
+
+2005-02-07  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xfns.c (Fx_change_window_property): Use long array when format is 32.
+        (Fx_window_property): If format is 32 and long is bigger than 32 bits,
+        convert long array returned from XGetWindowProperty to an int array.
+        (x_set_tool_bar_lines): Check that width and height is greater than
+        zero before clearing area.
+
+        * xselect.c (x_reply_selection_request): Pass long array to
+        XChangeProperty so that 64 bit longs are handeled correctly.
+        (x_get_window_property): If format is 32 and long is bigger than 32
+        bits convert data from XGetWindowProperty from long array to int array.
+        (lisp_data_to_selection_data): When the input is a vector and the
+        format is 32, allocate a long array even if long is bigger than 32 bits.
+        (x_fill_property_data): Use char, short and long as the man page
+        for XChangeProperty specifies.  This way the data returned is OK for
+        both 32 and 64 bit machines.
+        (x_handle_dnd_message): Calculate size correctly even for 64 bit
+        machines.
+        (Fx_send_client_event): Undo change from 2005-02-05,
+        x_fill_property_data now handles that case.
+
+        * xfns.c (Fx_backspace_delete_keys_p): Add comment about the
+        reason for the approach in the code.
+
+2005-02-07  Kim F. Storm  <storm@cua.dk>
+
+        * undo.c (Fprimitive_undo): Record max one dummmy apply element.
+
+2005-02-06  Richard M. Stallman  <rms@gnu.org>
+
+        * eval.c (Frun_hook_with_args)
+        (Frun_hook_with_args_until_success)
+        (Frun_hook_with_args_until_failure): Doc fixes.
+
+2005-02-05  Andreas Schwab  <schwab@suse.de>
+
+        * sysdep.c (sys_subshell): Properly terminate execlp argument list.
+
+2005-02-05  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xselect.c (Fx_send_client_event, x_handle_dnd_message): Handle
+        the longs in a XClientMessageEvent correctly when long is 64 bits.
+
+2005-02-05  Eli Zaretskii  <eliz@gnu.org>
+
+        * xfaces.c (face_color_supported_p): Use HAVE_WINDOW_SYSTEM
+        instead of HAVE_X_WINDOWS, for non-X windowed sessions.
+
 2005-02-03  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
         * xmenu.c (menubar_selection_callback): Force out GTK buffered
@@ -26,8 +91,7 @@
 
         * macfns.c (x_create_tip_frame): Likewise.
 
-        * macterm.c (mac_draw_string_common, x_make_frame_visible):
-        Likewise.
+        * macterm.c (mac_draw_string_common, x_make_frame_visible): Likewise.
 
 2005-02-03  Richard M. Stallman  <rms@gnu.org>
 
@@ -9905,7 +9969,7 @@
         * search.c (Fmatch_data): Doc fix.  Explicitly state that
         match-data is undefined if last search failed.
 
-        * keymap.c (Fcommand_remapping): Renamed from Fremap_command.
+        * keymap.c (Fcommand_remapping): Rename from Fremap_command.
         All uses changed.
 
 2003-02-12  Juanma Barranquero  <lektu@terra.es>
@@ -10612,7 +10676,7 @@
         selected frame.
 
         * keymap.c (apropos_predicate, apropos_accumulate): Make them static.
-        (syms_of_keymap): staticpro them.
+        (syms_of_keymap): Staticpro them.
         (Fapropos_internal): Initialize them and clear them out.
         Don't GCPRO them.
 
@@ -12714,9 +12778,9 @@
         * fns.c (concat): Likewise.
         * lread.c (read_vector): Likewise.
 
-        * lisp.h (SMBP): Deleted.  All uses changed to STRING_MULTIBYTE.
+        * lisp.h (SMBP): Delete.  All uses changed to STRING_MULTIBYTE.
         (STRING_SET_UNIBYTE): New macro.
-        (SET_STRING_BYTES): Deleted.  Callers (all of which supplied a
+        (SET_STRING_BYTES): Delete.  Callers (all of which supplied a
         length of -1) changed to use STRING_SET_UNIBYTE.
         * abbrev.c, alloc.c, buffer.c, bytecode.c, callint.c, callproc.c,
         casefiddle.c, category.c, ccl.c, charset.c, charset.h, coding.c,
@@ -12759,7 +12823,7 @@
 2002-07-11  Richard M. Stallman  <rms@gnu.org>
 
         * alloc.c (Vmemory_full): New variable.
-        (Vmemory_signal_data): Renamed from memory_signal_data.
+        (Vmemory_signal_data): Rename from memory_signal_data.
         Uses changed.
         (syms_of_alloc): Defvar them.
         (memory_full, buffer_memory_full): Set Vmemory_full.
@@ -12777,7 +12841,7 @@
         (reseat_at_next_visible_line_start, next_element_from_buffer):
         Use `double', not `float', when calling indented_beyond_p.
 
-        * s/hpux11.h (BROKEN_SA_RESTART): Defined.
+        * s/hpux11.h (BROKEN_SA_RESTART): Define.
 
         * sysdep.c (sys_signal): Test BROKEN_SA_RESTART.
 
@@ -13535,7 +13599,7 @@
 
 2002-05-11  Kim F. Storm  <storm@cua.dk>
 
-        * keymap.c (current_minor_maps): Fixed resizing of cmm_maps;
+        * keymap.c (current_minor_maps): Fix resizing of cmm_maps;
         only update cmm_size if realloc actually succeeds.
         Testing with initial size of 2 elements revealed that using
         realloc on GNU/Linux would cause a random trap in xmalloc
@@ -14774,7 +14838,7 @@
 
 2002-02-24  Kim F. Storm  <storm@cua.dk>
 
-        * keymap.c (Flookup_key): Fixed problem in 2001-12-28 patch:
+        * keymap.c (Flookup_key): Fix problem in 2001-12-28 patch:
         The validation of the event type was too strict as it didn't
         allow string events; buffer names are used in bindings for
         menu-bar-select-buffer (see `menu-bar-update-buffers').
@@ -14787,7 +14851,7 @@
         prefix in the keymaps, i.e. [remap COMMAND].
 
         * keymap.c (Qremap, remap_command_vector): New variables.
-        (is_command_symbol): Removed function.
+        (is_command_symbol): Remove function.
         (Fdefine_key): No longer accept a symbol for KEY.
         Added validation of [remap COMMAND] argument for KEY.
         The DEF is no longer required to be a symbol when remapping a command.
@@ -15145,7 +15209,7 @@
         Doc updated.  Callers changed.  Pass arg to where_is_internal.
 
         * keymap.h (Fkey_binding, Fwhere_is_internal): Update prototype.
-        (is_command_symbol): Added prototype.
+        (is_command_symbol): Add prototype.
 
         * keyboard.c (Vthis_original_command): New variable.
         (syms_of_keyboard): DEFVAR_LISP it.
@@ -15562,7 +15626,7 @@
 
 2002-01-03  Kim F. Storm  <storm@cua.dk>
 
-        * keyboard.c (read_key_sequence): Fixed cast of submaps arg to bcopy.
+        * keyboard.c (read_key_sequence): Fix cast of submaps arg to bcopy.
 
 2002-01-02  Richard M. Stallman  <rms@gnu.org>
 
diff --git a/src/eval.c b/src/eval.c
index 9c27caa29ca..83e16360473 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -2323,7 +2323,7 @@ called to run the hook.  If the value is a function, it is called with
 the given arguments and its return value is returned.  If it is a list
 of functions, those functions are called, in order,
 with the given arguments ARGS.
-It is best not to depend on the value return by `run-hook-with-args',
+It is best not to depend on the value returned by `run-hook-with-args',
 as that may change.
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
@@ -2339,11 +2339,14 @@ usage: (run-hook-with-args HOOK &rest ARGS)  */)
 DEFUN ("run-hook-with-args-until-success", Frun_hook_with_args_until_success,
        Srun_hook_with_args_until_success, 1, MANY, 0,
        doc: /* Run HOOK with the specified arguments ARGS.
-HOOK should be a symbol, a hook variable.  Its value should
-be a list of functions.  We call those functions, one by one,
-passing arguments ARGS to each of them, until one of them
+HOOK should be a symbol, a hook variable.  If HOOK has a non-nil
+value, that value may be a function or a list of functions to be
+called to run the hook.  If the value is a function, it is called with
+the given arguments and its return value is returned.
+If it is a list of functions, those functions are called, in order,
+with the given arguments ARGS, until one of them
 returns a non-nil value.  Then we return that value.
-If all the functions return nil, we return nil.
+However, if they all return nil, we return nil.
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
@@ -2358,11 +2361,13 @@ usage: (run-hook-with-args-until-success HOOK &rest ARGS)  */)
 DEFUN ("run-hook-with-args-until-failure", Frun_hook_with_args_until_failure,
        Srun_hook_with_args_until_failure, 1, MANY, 0,
        doc: /* Run HOOK with the specified arguments ARGS.
-HOOK should be a symbol, a hook variable.  Its value should
-be a list of functions.  We call those functions, one by one,
-passing arguments ARGS to each of them, until one of them
-returns nil.  Then we return nil.
-If all the functions return non-nil, we return non-nil.
+HOOK should be a symbol, a hook variable.  If HOOK has a non-nil
+value, that value may be a function or a list of functions to be
+called to run the hook.  If the value is a function, it is called with
+the given arguments and its return value is returned.
+If it is a list of functions, those functions are called, in order,
+with the given arguments ARGS, until one of them returns nil.
+Then we return nil.  However, if they all return non-nil, we return non-nil.
 
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.
diff --git a/src/sysdep.c b/src/sysdep.c
index 55b333bfbc9..581a225c33b 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1,6 +1,6 @@
 /* Interfaces to system-dependent kernel and library entries.
    Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
-     2003, 2004  Free Software Foundation, Inc.
+     2003, 2004, 2005  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -866,7 +866,7 @@ sys_subshell ()
       if (pid == -1)
         write (1, "Can't execute subshell", 22);
 #else   /* not WINDOWSNT */
-      execlp (sh, sh, 0);
+      execlp (sh, sh, (char *) 0);
       write (1, "Can't execute subshell", 22);
       _exit (1);
 #endif  /* not WINDOWSNT */
diff --git a/src/undo.c b/src/undo.c
index eaf312be676..b4e16bfd0e5 100644
--- a/src/undo.c
+++ b/src/undo.c
@@ -1,5 +1,6 @@
 /* undo handling for GNU Emacs.
-   Copyright (C) 1990, 1993, 1994, 2000 Free Software Foundation, Inc.
+   Copyright (C) 1990, 1993, 1994, 2000, 2002, 2004, 2005
+        Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -454,6 +455,8 @@ Return what remains of the list.  */)
   Lisp_Object next;
   int count = SPECPDL_INDEX ();
   register int arg;
+  Lisp_Object oldlist;
+  int did_apply = 0;
 
 #if 0  /* This is a good feature, but would make undo-start
           unable to do what is expected.  */
@@ -470,6 +473,8 @@ Return what remains of the list.  */)
   arg = XINT (n);
   next = Qnil;
   GCPRO2 (next, list);
+  /* I don't think we need to gcpro oldlist, as we use it only
+     to check for EQ.  ++kfs  */
 
   /* In a writable buffer, enable undoing read-only text that is so
      because of text properties.  */
@@ -479,6 +484,8 @@ Return what remains of the list.  */)
   /* Don't let `intangible' properties interfere with undo.  */
   specbind (Qinhibit_point_motion_hooks, Qt);
 
+  oldlist = current_buffer->undo_list;
+
   while (arg > 0)
     {
       while (CONSP (list))
@@ -549,24 +556,38 @@ Return what remains of the list.  */)
                 }
               else if (EQ (car, Qapply))
                 {
-                  Lisp_Object oldlist = current_buffer->undo_list;
-                  /* Element (apply FUNNAME . ARGS) means call FUNNAME to undo.  */
+                  /* Element (apply FUN . ARGS) means call FUN to undo.  */
+                  struct buffer *save_buffer = current_buffer;
+
                   car = Fcar (cdr);
+                  cdr = Fcdr (cdr);
                   if (INTEGERP (car))
                     {
-                      /* Long format: (apply DELTA START END FUNNAME . ARGS).  */
-                      cdr = Fcdr (Fcdr (Fcdr (cdr)));
-                      car = Fcar (cdr);
+                      /* Long format: (apply DELTA START END FUN . ARGS).  */
+                      Lisp_Object delta = car;
+                      Lisp_Object start = Fcar (cdr);
+                      Lisp_Object end   = Fcar (Fcdr (cdr));
+                      Lisp_Object start_mark = Fcopy_marker (start, Qnil);
+                      Lisp_Object end_mark   = Fcopy_marker (end, Qt);
+
+                      cdr = Fcdr (Fcdr (cdr));
+                      apply1 (Fcar (cdr), Fcdr (cdr));
+
+                      /* Check that the function did what the entry said it
+                         would do.  */
+                      if (!EQ (start, Fmarker_position (start_mark))
+                          || (XINT (delta) + XINT (end)
+                              != marker_position (end_mark)))
+                        error ("Changes to be undone by function different than announced");
+                      Fset_marker (start_mark, Qnil, Qnil);
+                      Fset_marker (end_mark, Qnil, Qnil);
                     }
-                  cdr = Fcdr (cdr);
-                  apply1 (car, cdr);
-
-                  /* Make sure this produces at least one undo entry,
-                     so the test in `undo' for continuing an undo series
-                     will work right.  */
-                  if (EQ (oldlist, current_buffer->undo_list))
-                    current_buffer->undo_list
-                      = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
+                  else
+                    apply1 (car, cdr);
+
+                  if (save_buffer != current_buffer)
+                    error ("Undo function switched buffer");
+                  did_apply = 1;
                 }
               else if (STRINGP (car) && INTEGERP (cdr))
                 {
@@ -611,6 +632,15 @@ Return what remains of the list.  */)
       arg--;
     }
 
+
+  /* Make sure an apply entry produces at least one undo entry,
+     so the test in `undo' for continuing an undo series
+     will work right.  */
+  if (did_apply
+      && EQ (oldlist, current_buffer->undo_list))
+    current_buffer->undo_list
+      = Fcons (list3 (Qapply, Qcdr, Qnil), current_buffer->undo_list);
+
   UNGCPRO;
   return unbind_to (count, list);
 }
diff --git a/src/xfaces.c b/src/xfaces.c
index a0ac3867ef6..9b2d5731508 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -1516,7 +1516,7 @@ face_color_supported_p (f, color_name, background_p)
 
   XSETFRAME (frame, f);
   return
-#ifdef HAVE_X_WINDOWS
+#ifdef HAVE_WINDOW_SYSTEM
     FRAME_WINDOW_P (f)
     ? (!NILP (Fxw_display_color_p (frame))
        || xstricmp (color_name, "black") == 0
diff --git a/src/xfns.c b/src/xfns.c
index 48967575f0c..8c5039d0cf6 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1408,10 +1408,14 @@ x_set_tool_bar_lines (f, value, oldval)
       int width = FRAME_PIXEL_WIDTH (f);
       int y = nlines * FRAME_LINE_HEIGHT (f);
 
-      BLOCK_INPUT;
-      x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
-                    0, y, width, height, False);
-      UNBLOCK_INPUT;
+      /* height can be zero here. */
+      if (height > 0 && width > 0)
+        {
+          BLOCK_INPUT;
+          x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
+                        0, y, width, height, False);
+          UNBLOCK_INPUT;
+        }
 
       if (WINDOWP (f->tool_bar_window))
         clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
@@ -4086,8 +4090,13 @@ Value is VALUE.  */)
         data = (unsigned char *) xmalloc (nelements);
       else if (element_format == 16)
         data = (unsigned char *) xmalloc (nelements*2);
-      else
-        data = (unsigned char *) xmalloc (nelements*4);
+      else /* format == 32 */
+        /* The man page for XChangeProperty:
+               "If the specified format is 32, the property data must be a
+                long array."
+           This applies even if long is more than 64 bits.  The X library
+           converts to 32 bits before sending to the X server.  */
+        data = (unsigned char *) xmalloc (nelements * sizeof(long));
 
       x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
     }
@@ -4222,6 +4231,30 @@ no value of TYPE.  */)
                                (unsigned char **) &tmp_data);
       if (rc == Success && tmp_data)
         {
+          /* The man page for XGetWindowProperty says:
+             "If the returned format is 32, the returned data is represented
+             as a long array and should be cast to that type to obtain the
+             elements."
+             This applies even if long is more than 32 bits, the X library
+             converts from 32 bit elements received from the X server to long
+             and passes the long array to us.  Thus, for that case bcopy can not
+             be used.  We convert to a 32 bit type here, because so much code
+             assume on that.
+
+             The bytes and offsets passed to XGetWindowProperty refers to the
+             property and those are indeed in 32 bit quantities if format is
+             32.  */
+
+          if (actual_format == 32 && actual_format < BITS_PER_LONG)
+            {
+              unsigned long i;
+              int  *idata = (int *) tmp_data;
+              long *ldata = (long *) tmp_data;
+
+              for (i = 0; i < actual_size; ++i)
+                idata[i]= (int) ldata[i];
+            }
+
           if (NILP (vector_ret_p))
             prop_value = make_string (tmp_data, size);
           else
@@ -5438,6 +5471,22 @@ usual X keysyms.  */)
       return Qnil;
     }
 
+  /* In this code we check that the keyboard has physical keys with names
+     that start with BKSP (Backspace) and DELE (Delete), and that they
+     generate keysym XK_BackSpace and XK_Delete respectively.
+     This function is used to test if normal-erase-is-backspace should be
+     turned on.
+     An alternative approach would be to just check if XK_BackSpace and
+     XK_Delete are mapped to any key.  But if any of those are mapped to
+     some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
+     user doesn't know about it, it is better to return false here.
+     It is more obvious to the user what to do if she/he has two keys
+     clearly marked with names/symbols and one key does something not
+     expected (i.e. she/he then tries the other).
+     The cases where Backspace/Delete is mapped to some other key combination
+     are rare, and in those cases, normal-erase-is-backspace can be turned on
+     manually.  */
+
   have_keys = Qnil;
   kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
   if (kb)
diff --git a/src/xselect.c b/src/xselect.c
index f26014746ba..adea1f3c2d6 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -173,12 +173,6 @@ static Lisp_Object Vselection_converter_alist;
 /* If the selection owner takes too long to reply to a selection request,
    we give up on it.  This is in milliseconds (0 = no timeout.)  */
 static EMACS_INT x_selection_timeout;
-
-/* Utility functions */
-
-static void lisp_data_to_selection_data ();
-static Lisp_Object selection_data_to_lisp_data ();
-static Lisp_Object x_get_window_property_as_lisp_data ();
 
 
 
@@ -777,9 +771,17 @@ x_reply_selection_request (event, format, data, size, type)
 
       TRACE1 ("Set %s to number of bytes to send",
               XGetAtomName (display, reply.property));
-      XChangeProperty (display, window, reply.property, dpyinfo->Xatom_INCR,
-                       32, PropModeReplace,
-                       (unsigned char *) &bytes_remaining, 1);
+      {
+        /* XChangeProperty expects an array of long even if long is more than
+           32 bits.  */
+        long value[1];
+
+        value[0] = bytes_remaining;
+        XChangeProperty (display, window, reply.property, dpyinfo->Xatom_INCR,
+                         32, PropModeReplace,
+                         (unsigned char *) value, 1);
+      }
+
       XSelectInput (display, window, PropertyChangeMask);
 
       /* Tell 'em the INCR data is there...  */
@@ -804,9 +806,9 @@ x_reply_selection_request (event, format, data, size, type)
       TRACE0 ("Got ACK");
       while (bytes_remaining)
         {
-          int i = ((bytes_remaining < max_bytes)
-                   ? bytes_remaining
-                   : max_bytes);
+          int i = ((bytes_remaining < max_bytes)
+                   ? bytes_remaining
+                   : max_bytes);
 
           BLOCK_INPUT;
 
@@ -1540,9 +1542,38 @@ x_get_window_property (display, window, property, data_ret, bytes_ret,
          reading it.  Deal with that, I guess.... */
       if (result != Success)
         break;
-      *actual_size_ret *= *actual_format_ret / 8;
-      bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
-      offset += *actual_size_ret;
+
+      /* The man page for XGetWindowProperty says:
+         "If the returned format is 32, the returned data is represented
+          as a long array and should be cast to that type to obtain the
+          elements."
+         This applies even if long is more than 32 bits, the X library
+         converts from 32 bit elements received from the X server to long
+         and passes the long array to us.  Thus, for that case bcopy can not
+         be used.  We convert to a 32 bit type here, because so much code
+         assume on that.
+
+         The bytes and offsets passed to XGetWindowProperty refers to the
+         property and those are indeed in 32 bit quantities if format is 32.  */
+
+      if (*actual_format_ret == 32 && *actual_format_ret < BITS_PER_LONG)
+        {
+          unsigned long i;
+          int  *idata = (int *) ((*data_ret) + offset);
+          long *ldata = (long *) tmp_data;
+
+          for (i = 0; i < *actual_size_ret; ++i)
+            {
+              idata[i]= (int) ldata[i];
+              offset += 4;
+            }
+        }
+      else
+        {
+          *actual_size_ret *= *actual_format_ret / 8;
+          bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
+          offset += *actual_size_ret;
+        }
 
       /* This was allocated by Xlib, so use XFree.  */
       XFree ((char *) tmp_data);
@@ -1755,7 +1786,11 @@ x_get_window_property_as_lisp_data (display, window, property, target_type,
 
    When converting an object to C, it may be of the form (SYMBOL . <data>)
    where SYMBOL is what we should claim that the type is.  Format and
-   representation are as above.  */
+   representation are as above.
+
+   Important: When format is 32, data should contain an array of int,
+   not an array of long as the X library returns.  This makes a difference
+   when sizeof(long) != sizeof(int).  */
 
 
 
@@ -1797,15 +1832,21 @@ selection_data_to_lisp_data (display, data, size, type, format)
   else if (type == XA_ATOM)
     {
       int i;
-      if (size == sizeof (Atom))
-        return x_atom_to_symbol (display, *((Atom *) data));
+      /* On a 64 bit machine sizeof(Atom) == sizeof(long) == 8.
+         But the callers of these function has made sure the data for
+         format == 32 is an array of int.  Thus, use int instead
+         of Atom.  */
+      int *idata = (int *) data;
+
+      if (size == sizeof (int))
+        return x_atom_to_symbol (display, (Atom) idata[0]);
       else
         {
-          Lisp_Object v = Fmake_vector (make_number (size / sizeof (Atom)),
+          Lisp_Object v = Fmake_vector (make_number (size / sizeof (int)),
                                         make_number (0));
-          for (i = 0; i < size / sizeof (Atom); i++)
+          for (i = 0; i < size / sizeof (int); i++)
             Faset (v, make_number (i),
-                   x_atom_to_symbol (display, ((Atom *) data) [i]));
+                   x_atom_to_symbol (display, (Atom) idata[i]));
           return v;
         }
     }
@@ -1987,6 +2028,7 @@ lisp_data_to_selection_data (display, obj,
       else
         /* This vector is an INTEGER set, or something like it */
         {
+          int data_size = 2;
           *size_ret = XVECTOR (obj)->size;
           if (NILP (type)) type = QINTEGER;
           *format_ret = 16;
@@ -1999,7 +2041,11 @@ lisp_data_to_selection_data (display, obj,
         ("elements of selection vector must be integers or conses of integers"),
                               Fcons (obj, Qnil)));
 
-          *data_ret = (unsigned char *) xmalloc (*size_ret * (*format_ret/8));
+          /* Use sizeof(long) even if it is more than 32 bits.  See comment
+             in x_get_window_property and x_fill_property_data.  */
+          
+          if (*format_ret == 32) data_size = sizeof(long);
+          *data_ret = (unsigned char *) xmalloc (*size_ret * data_size);
           for (i = 0; i < *size_ret; i++)
             if (*format_ret == 32)
               (*((unsigned long **) data_ret)) [i]
@@ -2501,8 +2547,10 @@ x_check_property_data (data)
    DATA is a Lisp list of values to be converted.
    RET is the C array that contains the converted values.  It is assumed
    it is big enough to hold all values.
-   FORMAT is 8, 16 or 32 and gives the size in bits for each C value to
-   be stored in RET.  */
+   FORMAT is 8, 16 or 32 and denotes char/short/long for each C value to
+   be stored in RET.  Note that long is used for 32 even if long is more
+   than 32 bits (see man pages for XChangeProperty, XGetWindowProperty and
+   XClientMessageEvent).  */
 
 void
 x_fill_property_data (dpy, data, ret, format)
@@ -2511,10 +2559,10 @@ x_fill_property_data (dpy, data, ret, format)
      void *ret;
      int format;
 {
-  CARD32 val;
-  CARD32 *d32 = (CARD32 *) ret;
-  CARD16 *d16 = (CARD16 *) ret;
-  CARD8  *d08 = (CARD8  *) ret;
+  long val;
+  long  *d32 = (long  *) ret;
+  short *d16 = (short *) ret;
+  char  *d08 = (char  *) ret;
   Lisp_Object iter;
 
   for (iter = data; CONSP (iter); iter = XCDR (iter))
@@ -2522,24 +2570,24 @@ x_fill_property_data (dpy, data, ret, format)
       Lisp_Object o = XCAR (iter);
 
       if (INTEGERP (o))
-        val = (CARD32) XFASTINT (o);
+        val = (long) XFASTINT (o);
       else if (FLOATP (o))
-        val = (CARD32) XFLOAT_DATA (o);
+        val = (long) XFLOAT_DATA (o);
       else if (CONSP (o))
-        val = (CARD32) cons_to_long (o);
+        val = (long) cons_to_long (o);
       else if (STRINGP (o))
         {
           BLOCK_INPUT;
-          val = XInternAtom (dpy, (char *) SDATA (o), False);
+          val = (long) XInternAtom (dpy, (char *) SDATA (o), False);
           UNBLOCK_INPUT;
         }
       else
         error ("Wrong type, must be string, number or cons");
 
       if (format == 8)
-        *d08++ = (CARD8) val;
+        *d08++ = (char) val;
       else if (format == 16)
-        *d16++ = (CARD16) val;
+        *d16++ = (short) val;
       else
         *d32++ = val;
     }
@@ -2554,6 +2602,10 @@ x_fill_property_data (dpy, data, ret, format)
    be stored in RET.
    SIZE is the number of elements in DATA.
 
+   Important: When format is 32, data should contain an array of int,
+   not an array of long as the X library returns.  This makes a difference
+   when sizeof(long) != sizeof(int).
+
    Also see comment for selection_data_to_lisp_data above.  */
 
 Lisp_Object
@@ -2568,7 +2620,7 @@ x_property_data_to_lisp (f, data, type, format, size)
                                       data, size*format/8, type, format);
 }
 
-/* Get the mouse position frame relative coordinates.  */
+/* Get the mouse position in frame relative coordinates.  */
 
 static void
 mouse_position_for_drop (f, x, y)
@@ -2665,18 +2717,34 @@ x_handle_dnd_message (f, event, dpyinfo, bufp)
 {
   Lisp_Object vec;
   Lisp_Object frame;
-  unsigned long size = (8*sizeof (event->data))/event->format;
+  /* format 32 => size 5, format 16 => size 10, format 8 => size 20 */
+  unsigned long size = 160/event->format;
   int x, y;
+  unsigned char *data = (unsigned char *) event->data.b;
+  int idata[5];
 
   XSETFRAME (frame, f);
 
+  /* On a 64 bit machine, the event->data.l array members are 64 bits (long),
+     but the x_property_data_to_lisp (or rather selection_data_to_lisp_data)
+     function expects them to be of size int (i.e. 32).  So to be able to
+     use that function, put the data in the form it expects if format is 32. */
+
+  if (event->format == 32 && event->format < BITS_PER_LONG)
+    {
+      int i;
+      for (i = 0; i < 5; ++i) /* There are only 5 longs in a ClientMessage. */
+        idata[i] = (int) event->data.l[i];
+      data = (unsigned char *) idata;
+    }
+
   vec = Fmake_vector (make_number (4), Qnil);
   AREF (vec, 0) = SYMBOL_NAME (x_atom_to_symbol (FRAME_X_DISPLAY (f),
                                                  event->message_type));
   AREF (vec, 1) = frame;
   AREF (vec, 2) = make_number (event->format);
   AREF (vec, 3) = x_property_data_to_lisp (f,
-                                           event->data.b,
+                                           data,
                                            event->message_type,
                                            event->format,
                                            size);
@@ -2788,6 +2856,7 @@ are ignored.  */)
      when sending to the root window.  */
   event.xclient.window = to_root ? FRAME_OUTER_WINDOW (f) : wdest;
 
+  
   memset (event.xclient.data.b, 0, sizeof (event.xclient.data.b));
   x_fill_property_data (dpyinfo->display, values, event.xclient.data.b,
                         event.xclient.format);