Revision: miles@gnu.org--gnu-2005/emacs--unicode--0--patch-13

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-83
 - 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/emacs--cvs-trunk--0--patch-91
 - miles@gnu.org--gnu-2005/emacs--cvs-trunk--0--patch-94
   Update from CVS

7 files changed, 296 insertions, 109 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index b15fba5254c..d2afed264eb 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,7 +1,70 @@
+2005-02-12  Dan Nicolaescu  <dann@ics.uci.edu>
+
+        * keyboard.c: If HAVE_FCNTL_H include fcntl.h.
+
+2005-02-12  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (expose_window): Don't fix overlaps for mode lines.
+
+2005-02-10  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (try_window_id): Set first_unchanged_at_end_row to NULL
+        if it moves outside window or it doesn't display text.
+
+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.
+        * sysdep.c (sys_subshell): Properly terminate execlp argument list.
 
 2005-02-05  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
@@ -41,8 +104,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>
 
@@ -9915,7 +9977,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>
@@ -10622,7 +10684,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.
 
@@ -12724,9 +12786,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,
@@ -12769,7 +12831,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.
@@ -12787,7 +12849,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.
 
@@ -13545,7 +13607,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
@@ -14784,7 +14846,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').
@@ -14797,7 +14859,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.
@@ -15155,7 +15217,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.
@@ -15572,7 +15634,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/keyboard.c b/src/keyboard.c
index 8abc38b1072..e10b111d12d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -65,6 +65,10 @@ Boston, MA 02111-1307, USA.  */
 #include <unistd.h>
 #endif
 
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
 /* This is to get the definitions of the XK_ symbols.  */
 #ifdef HAVE_X_WINDOWS
 #include "xterm.h"
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/xdisp.c b/src/xdisp.c
index 6ee9efafc62..a90483aae1e 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -13927,7 +13927,12 @@ try_window_id (w)
                         bottom_vpos, dy);
 
   if (first_unchanged_at_end_row)
-    first_unchanged_at_end_row += dvpos;
+    {
+      first_unchanged_at_end_row += dvpos;
+      if (first_unchanged_at_end_row->y >= it.last_visible_y
+          || !MATRIX_ROW_DISPLAYS_TEXT_P (first_unchanged_at_end_row))
+        first_unchanged_at_end_row = NULL;
+    }
 
   /* If scrolling up, there may be some lines to display at the end of
      the window.  */
@@ -13984,7 +13989,6 @@ try_window_id (w)
 
   /* Update window_end_pos and window_end_vpos.  */
   if (first_unchanged_at_end_row
-      && first_unchanged_at_end_row->y < it.last_visible_y
       && !last_text_row_at_end)
     {
       /* Window end line if one of the preserved rows from the current
@@ -22235,7 +22239,9 @@ expose_window (w, fr)
               || (r.y >= y0 && r.y < y1)
               || (r.y + r.height > y0 && r.y + r.height < y1))
             {
-              if (row->overlapping_p)
+              /* A header line may be overlapping, but there is no need
+                 to fix overlapping areas for them.  KFS 2005-02-12 */
+              if (row->overlapping_p && !row->mode_line_p)
                 {
                   if (first_overlapping_row == NULL)
                     first_overlapping_row = row;
diff --git a/src/xfns.c b/src/xfns.c
index 2732a1be051..d1edf554feb 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -1399,10 +1399,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);
@@ -4051,8 +4055,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);
     }
@@ -4187,6 +4196,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
@@ -5387,6 +5420,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 daae84b276c..bf37cde4d0b 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 ();
 
 
 
@@ -769,9 +763,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...  */
@@ -796,9 +798,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;
 
@@ -1523,9 +1525,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);
@@ -1738,7 +1769,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).  */
 
 
 
@@ -1780,15 +1815,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;
         }
     }
@@ -1970,6 +2011,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;
@@ -1982,7 +2024,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]
@@ -2469,8 +2515,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)
@@ -2479,10 +2527,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))
@@ -2490,24 +2538,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;
     }
@@ -2522,6 +2570,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
@@ -2633,7 +2685,8 @@ 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];
@@ -2712,8 +2765,6 @@ are ignored.  */)
   struct frame *f = check_x_frame (from);
   int count;
   int to_root;
-  int idata[5];
-  void *data;
 
   CHECK_STRING (message_type);
   CHECK_NUMBER (format);
@@ -2774,30 +2825,10 @@ are ignored.  */)
   event.xclient.window = to_root ? FRAME_OUTER_WINDOW (f) : wdest;
 
   
-  if (event.xclient.format == 32 && event.xclient.format < BITS_PER_LONG)
-    {
-      /* x_fill_property_data expects data to hold 32 bit values when
-         format == 32, but on a 64 bit machine long is 64 bits.
-         event.xclient.l is an array of long, so we must compensate. */
-
-      memset (idata, 0, sizeof (idata));
-      data = idata;
-    }
-  else
-    {
-      memset (event.xclient.data.b, 0, sizeof (event.xclient.data.b));
-      data = event.xclient.data.b;
-    }
-
-  x_fill_property_data (dpyinfo->display, values, data, event.xclient.format);
+  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);
 
-  if (data == idata)
-    {
-      int i;
-      for (i = 0; i < 5; ++i) /* There are only 5 longs in a ClientMessage. */
-        event.xclient.data.l[i] = (long) idata[i];
-    }
-  
   /* If event mask is 0 the event is sent to the client that created
      the destination window.  But if we are sending to the root window,
      there is no such client.  Then we set the event mask to 0xffff.  The