18 files changed, 544 insertions, 265 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 8736a6f156a..c38032b163a 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,130 @@
+2005-06-15  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macterm.c (mac_compute_glyph_string_overhangs): Don't set
+        overhangs unless the given glyph type is noncomposite CHAR_GLYPH.
+        [USE_CARBON_EVENTS] (mac_convert_event_ref): Convert dead key down
+        events.
+        (XTread_socket): Don't pass keyboard events with the option
+        modifier to the system when Vmac_command_key_is_meta is nil or
+        Vmac_option_modifier is non-nil.
+        [USE_CARBON_EVENTS] (read_socket_inev): New variable.
+        [USE_CARBON_EVENTS] (init_command_handler): Fix argument.
+        [USE_CARBON_EVENTS] (mac_handle_mouse_event): New Carbon event
+        handler function.
+        (install_window_handler) [USE_CARBON_EVENTS]: Install it.
+        (XTread_socket) [USE_CARBON_EVENTS]: Move mouse wheel event
+        handler part to mac_handle_mouse_event.
+
+2005-06-14  Juanma Barranquero  <lekktu@gmail.com>
+
+        * eval.c (Fdefvaralias): Rename arguments SYMBOL and ALIASED to
+        NEW-ALIAS and BASE-VARIABLE, respectively.
+
+2005-06-13  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * xdisp.c (note_mode_line_or_margin_highlight): Lisp_Object/int mixup.
+        (get_phys_cursor_geometry, format_mode_line_unwind_data)
+        (get_line_height_property, x_produce_glyphs): Remove unused vars.
+
+        * coding.c (run_pre_post_conversion_on_str): Remove unused var `buf'.
+
+2005-06-13  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32term.c (x_use_underline_position_properties): New variable.
+        (x_draw_glyph_string): Remind in a comment to change doc string of
+        x-use-underline-position-properties if/when underline positioning
+        is implemented.
+        (syms_of_w32term): DEFVAR_BOOL x-use-underline-position-properties,
+        and initialize it to nil.
+
+2005-06-12  Jason Rumney  <jasonr@gnu.org>
+
+        * w32fns.c (NEWOPENFILENAME): New struct.
+        (Fx_file_dialog): Use it to trick the system into giving us up to
+        date dialogs on systems that are documented to support it.
+        Do not set OFN_FILEMUSTEXIST flag if looking for a directory.
+
+2005-06-12  Eli Zaretskii  <eliz@gnu.org>
+
+        * w32fns.c (w32_abort): Use the MB_YESNO dialog instead of
+        MB_ABORTRETRYIGNORE.  Never return, even if DebugBreak does.
+
+2005-06-11  Eli Zaretskii  <eliz@gnu.org>
+
+        * image.c (x_create_x_image_and_pixmap) [HAVE_NTGUI]: Cast 4th arg
+        to CreateDIBSection to avoid a compiler warning.
+        (pbm_load): Cast 3rd arg to IMAGE_BACKGROUND to avoid a compiler
+        warning.
+        (png_load): Cast return values of fn_png_create_read_struct and
+        fn_png_create_info_struct, to avoid compiler warnings on W32.
+        Cast 3rd arg to IMAGE_BACKGROUND and image_background_transparent
+        to avoid compiler warnings.
+        (jpeg_load): Cast return value of fn_jpeg_std_error to avoid a
+        compiler warning on W32.  Cast 3rd arg to IMAGE_BACKGROUND to
+        avoid a compiler warning.
+        (tiff_load): Cast return values of fn_TIFFOpen and
+        fn_TIFFClientOpen to avoid compiler warning on W32.  Cast 3rd arg
+        to IMAGE_BACKGROUND to avoid a compiler warning.
+        (gif_load): Cast return values of fn_DGifOpenFileName and
+        fn_DGifOpen to avoid compiler warnings on W32.  Cast 3rd arg to
+        IMAGE_BACKGROUND to avoid a compiler warning.
+        (DrawText) [HAVE_NTGUI || MAC_OS]: If already defined, undef
+        before redefining.
+
+        * w32bdf.c (create_offscreen_bitmap): Cast `bitsp' to `void **' in
+        the call to CreateDIBSection, to avoid a compiler warning.
+
+2005-06-11  Jason Rumney  <jasonr@gnu.org>
+
+        * w32fns.c (Fx_file_dialog): Unblock input before falling back to
+        minibuffer.
+        * macfns.c (Fx_file_dialog): Likewise.
+
+2005-06-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * makefile.w32-in ($(TEMACS)): Depend on addsection.exe.
+
+2005-06-10  Juanma Barranquero  <lekktu@gmail.com>
+
+        * process.c (syms_of_process) [ADAPTIVE_READ_BUFFERING]:
+        * w32fns.c (syms_of_w32fns): Fix spellings.
+
+2005-06-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * unexw32.c (COPY_CHUNK, COPY_PROC_CHUNK): Add a new argument
+        `verbose'; print diagnostic messages only if it is non-zero.
+        All callers changed to pass a zero value unless DEBUG_DUMP is defined
+        in the environment.
+        (copy_executable_and_dump_data): Print section names with %.8s.
+
+2005-06-10  Masatake YAMATO  <jet@gyve.org>
+
+        * xdisp.c (note_mode_line_or_margin_highlight): Call clear_mouse_face
+        when mouse_face is not given.
+        Remove unnecessary tabs.
+
+2005-06-09  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * window.c (Fselect_window): Adapt call to Fselect_frame.
+
+        * lisp.h: Update EXFUN of Fselect_frame.
+
+        * keyboard.c (command_loop_1): Adapt call to Fselect_frame.
+
+        * frame.c (Fhandle_switch_frame, Fselect_frame): Delete unused arg
+        no_enter.
+        (Fset_mouse_position, Fset_mouse_pixel_position, Ficonify_frame):
+        Adapt to above change.
+
+2005-06-10  Juanma Barranquero  <lekktu@gmail.com>
+
+        * fns.c (Fmemq, Fmaphash): Doc fixes.
+
+2005-06-09  Juanma Barranquero  <lekktu@gmail.com>
+
+        * xfaces.c (Fdisplay_supports_face_attributes_p):
+        Fix typo in docstring.
+
 2005-06-08  Steven Tamm  <steventamm@mac.com>
 
         * unexmacosx.c (copy_data_segment): Copy __la_sym_ptr2 section
@@ -40,8 +167,8 @@
 
 2005-06-07  Masatake YAMATO  <jet@gyve.org>
 
-        * xdisp.c (note_mode_line_or_margin_highlight): Check
-        the overlapping of re-rendering area to avoid flickering.
+        * xdisp.c (note_mode_line_or_margin_highlight):
+        Check the overlapping of re-rendering area to avoid flickering.
         (note_mouse_highlight): Call clear_mouse_face if PART
         is not ON_MODE_LINE nor ON_HEADER_LINE.
 
@@ -56,21 +183,21 @@
 
 2005-06-06  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
-        * macmenu.c (menu_quit_handler, install_menu_quit_handler): New
-        functions for popping down menus on C-g.
+        * macmenu.c (menu_quit_handler, install_menu_quit_handler):
+        New functions for popping down menus on C-g.
         (set_frame_menubar, mac_menu_show): Call install_menu_quit_handler.
 
         * macterm.c: Make mac_quit_char_modifiers and mac_quit_char_keycode
         non-static.
 
-        * config.in: Added HAVE_CANCELMENUTRACKING
+        * config.in: Add HAVE_CANCELMENUTRACKING.
 
 2005-06-06  Eli Zaretskii  <eliz@gnu.org>
 
-        * w32heap.h (OFFSET_TO_RVA, RVA_TO_OFFSET, RVA_TO_PTR): Remove
-        macros.
+        * w32heap.h (OFFSET_TO_RVA, RVA_TO_OFFSET, RVA_TO_PTR):
+        Remove macros.
 
-        * unexw32.c (RVA_TO_PTR): Moved here from w32heap.h.
+        * unexw32.c (RVA_TO_PTR): Move here from w32heap.h.
 
         * w32proc.c (RVA_TO_PTR): New macro.
 
@@ -194,11 +321,11 @@
         (format_mode_line_unwind_data, unwind_format_mode_line):
         New functions for unwind protection in mode line formatting.
         (x_consider_frame_title): Use them and new local var 'title_start'
-        to support nested calls to format-mode-line and redisplay.  Set
-        mode_line_target to MODE_LINE_TITLE.
+        to support nested calls to format-mode-line and redisplay.
+        Set mode_line_target to MODE_LINE_TITLE.
         (Fformat_mode_line): Use them and new local var 'string_start' to
-        support nested calls to format-mode-line and redisplay.  Set
-        mode_line_target to MODE_LINE_NOPROP or MODE_LINE_STRING.
+        support nested calls to format-mode-line and redisplay.
+        Set mode_line_target to MODE_LINE_NOPROP or MODE_LINE_STRING.
         Don't trim trailing dashes.
         (decode_mode_spec): Don't make infinite number of trailing dashes
         for MODE_LINE_NOPROP and MODE_LINE_STRING targets.
@@ -12989,9 +13116,9 @@
         * sound.c: Added a partial implementation of play-sound-internal
         for Microsoft Windows.  Added various #ifdef / #else / #endif
         code blocks to separate the code that will compile under
-        Microsoft Windows from the code that is specific to Gnu/Linux.
+        Microsoft Windows from the code that is specific to GNU/Linux.
         Moved several blocks of code around to make this separation of code
-        into Windows compatible and Gnu/Linux compatible code blocks easier.
+        into Windows compatible and GNU/Linux compatible code blocks easier.
 
         * makefile.w32-in: Include sound.c and link with WinMM.lib.
 
diff --git a/src/eval.c b/src/eval.c
index 46affcac418..445eb283114 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -722,35 +722,36 @@ usage: (defmacro NAME ARGLIST [DOCSTRING] [DECL] BODY...)  */)
 
 
 DEFUN ("defvaralias", Fdefvaralias, Sdefvaralias, 2, 3, 0,
-       doc: /* Make SYMBOL a variable alias for symbol ALIASED.
-Setting the value of SYMBOL will subsequently set the value of ALIASED,
-and getting the value of SYMBOL will return the value ALIASED has.
-Third arg DOCSTRING, if non-nil, is documentation for SYMBOL.  If it is
-omitted or nil, SYMBOL gets the documentation string of ALIASED, or of the
-variable at the end of the chain of aliases, if ALIASED is itself an alias.
-The return value is ALIASED.  */)
-     (symbol, aliased, docstring)
-     Lisp_Object symbol, aliased, docstring;
+       doc: /* Make NEW-ALIAS a variable alias for symbol BASE-VARIABLE.
+Setting the value of NEW-ALIAS will subsequently set the value of BASE-VARIABLE,
+ and getting the value of NEW-ALIAS will return the value BASE-VARIABLE has.
+Third arg DOCSTRING, if non-nil, is documentation for NEW-ALIAS.  If it is
+ omitted or nil, NEW-ALIAS gets the documentation string of BASE-VARIABLE,
+ or of the variable at the end of the chain of aliases, if BASE-VARIABLE is
+ itself an alias.
+The return value is BASE-VARIABLE.  */)
+     (new_alias, base_variable, docstring)
+     Lisp_Object new_alias, base_variable, docstring;
 {
   struct Lisp_Symbol *sym;
 
-  CHECK_SYMBOL (symbol);
-  CHECK_SYMBOL (aliased);
+  CHECK_SYMBOL (new_alias);
+  CHECK_SYMBOL (base_variable);
 
-  if (SYMBOL_CONSTANT_P (symbol))
+  if (SYMBOL_CONSTANT_P (new_alias))
     error ("Cannot make a constant an alias");
 
-  sym = XSYMBOL (symbol);
+  sym = XSYMBOL (new_alias);
   sym->indirect_variable = 1;
-  sym->value = aliased;
-  sym->constant = SYMBOL_CONSTANT_P (aliased);
-  LOADHIST_ATTACH (symbol);
+  sym->value = base_variable;
+  sym->constant = SYMBOL_CONSTANT_P (base_variable);
+  LOADHIST_ATTACH (new_alias);
   if (!NILP (docstring))
-    Fput (symbol, Qvariable_documentation, docstring);
+    Fput (new_alias, Qvariable_documentation, docstring);
   else
-    Fput (symbol, Qvariable_documentation, Qnil);
+    Fput (new_alias, Qvariable_documentation, Qnil);
 
-  return aliased;
+  return base_variable;
 }
 
 
diff --git a/src/fns.c b/src/fns.c
index d8018216bd8..7b33b031282 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -1390,7 +1390,7 @@ The value is actually the tail of LIST whose car is ELT.  */)
 
 DEFUN ("memq", Fmemq, Smemq, 2, 2, 0,
        doc: /* Return non-nil if ELT is an element of LIST.
-Comparison done with EQ.  The value is actually the tail of LIST
+Comparison done with `eq'.  The value is actually the tail of LIST
 whose car is ELT.  */)
      (elt, list)
      Lisp_Object elt, list;
@@ -4845,7 +4845,7 @@ DEFUN ("remhash", Fremhash, Sremhash, 2, 2, 0,
 
 DEFUN ("maphash", Fmaphash, Smaphash, 2, 2, 0,
        doc: /* Call FUNCTION for all entries in hash table TABLE.
-FUNCTION is called with 2 arguments KEY and VALUE.  */)
+FUNCTION is called with two arguments, KEY and VALUE.  */)
      (function, table)
      Lisp_Object function, table;
 {
diff --git a/src/frame.c b/src/frame.c
index 1a84072b40b..204a31fa050 100644
--- a/src/frame.c
+++ b/src/frame.c
@@ -729,7 +729,7 @@ do_switch_frame (frame, track, for_deletion)
   return frame;
 }
 
-DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 2, "e",
+DEFUN ("select-frame", Fselect_frame, Sselect_frame, 1, 1, "e",
        doc: /* Select the frame FRAME.
 Subsequent editing commands apply to its selected window.
 The selection of FRAME lasts until the next time the user does
@@ -740,14 +740,14 @@ the command loop, because it still may have the window system's input
 focus.  On a text-only terminal, the next redisplay will display FRAME.
 
 This function returns FRAME, or nil if FRAME has been deleted.  */)
-  (frame, no_enter)
-    Lisp_Object frame, no_enter;
+  (frame)
+    Lisp_Object frame;
 {
   return do_switch_frame (frame, 1, 0);
 }
 
 
-DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 2, "e",
+DEFUN ("handle-switch-frame", Fhandle_switch_frame, Shandle_switch_frame, 1, 1, "e",
        doc: /* Handle a switch-frame event EVENT.
 Switch-frame events are usually bound to this function.
 A switch-frame event tells Emacs that the window manager has requested
@@ -756,8 +756,8 @@ This function selects the selected window of the frame of EVENT.
 
 If EVENT is frame object, handle it as if it were a switch-frame event
 to that frame.  */)
-     (event, no_enter)
-     Lisp_Object event, no_enter;
+     (event)
+     Lisp_Object event;
 {
   /* Preserve prefix arg that the command loop just cleared.  */
   current_kboard->Vprefix_arg = Vcurrent_prefix_arg;
@@ -1530,7 +1530,7 @@ before calling this function on it, like this.
 #if defined (MSDOS) && defined (HAVE_MOUSE)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
-      Fselect_frame (frame, Qnil);
+      Fselect_frame (frame);
       mouse_moveto (XINT (x), XINT (y));
     }
 #endif
@@ -1562,7 +1562,7 @@ before calling this function on it, like this.
 #if defined (MSDOS) && defined (HAVE_MOUSE)
   if (FRAME_MSDOS_P (XFRAME (frame)))
     {
-      Fselect_frame (frame, Qnil);
+      Fselect_frame (frame);
       mouse_moveto (XINT (x), XINT (y));
     }
 #endif
@@ -1684,7 +1684,7 @@ If omitted, FRAME defaults to the currently selected frame.  */)
 #if 0 /* This isn't logically necessary, and it can do GC.  */
   /* Don't let the frame remain selected.  */
   if (EQ (frame, selected_frame))
-    Fhandle_switch_frame (next_frame (frame, Qt), Qnil);
+    Fhandle_switch_frame (next_frame (frame, Qt));
 #endif
 
   /* Don't allow minibuf_window to remain on a deleted frame.  */
diff --git a/src/image.c b/src/image.c
index bc88c9d1d04..462294b33b4 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1972,7 +1972,8 @@ x_create_x_image_and_pixmap (f, width, height, depth, ximg, pixmap)
      and store its handle in *pixmap.  */
   *pixmap = CreateDIBSection (hdc, &((*ximg)->info),
                               (depth < 16) ? DIB_PAL_COLORS : DIB_RGB_COLORS,
-                              &((*ximg)->data), NULL, 0);
+                              /* casting avoids a GCC warning */
+                              (void **)&((*ximg)->data), NULL, 0);
 
   /* Realize display palette and garbage all frames. */
   release_frame_dc (f, hdc);
@@ -5517,7 +5518,8 @@ pbm_load (f, img)
   /* Maybe fill in the background field while we have ximg handy.  */
 
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
-    IMAGE_BACKGROUND (img, f, ximg);
+    /* Casting avoids a GCC warning.  */
+    IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
   /* Put the image into a pixmap.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
@@ -5843,9 +5845,11 @@ png_load (f, img)
       tbr.bytes += sizeof (sig);
     }
 
-  /* Initialize read and info structs for PNG lib.  */
-  png_ptr = fn_png_create_read_struct (PNG_LIBPNG_VER_STRING, NULL,
-                                       my_png_error, my_png_warning);
+  /* Initialize read and info structs for PNG lib.  Casting return
+     value avoids a GCC warning on W32.  */
+  png_ptr = (png_structp)fn_png_create_read_struct (PNG_LIBPNG_VER_STRING,
+                                                    NULL, my_png_error,
+                                                    my_png_warning);
   if (!png_ptr)
     {
       if (fp) fclose (fp);
@@ -5853,7 +5857,8 @@ png_load (f, img)
       return 0;
     }
 
-  info_ptr = fn_png_create_info_struct (png_ptr);
+  /* Casting return value avoids a GCC warning on W32.  */
+  info_ptr = (png_infop)fn_png_create_info_struct (png_ptr);
   if (!info_ptr)
     {
       fn_png_destroy_read_struct (&png_ptr, NULL, NULL);
@@ -5862,7 +5867,8 @@ png_load (f, img)
       return 0;
     }
 
-  end_info = fn_png_create_info_struct (png_ptr);
+  /* Casting return value avoids a GCC warning on W32.  */
+  end_info = (png_infop)fn_png_create_info_struct (png_ptr);
   if (!end_info)
     {
       fn_png_destroy_read_struct (&png_ptr, &info_ptr, NULL);
@@ -6135,8 +6141,9 @@ png_load (f, img)
   img->width = width;
   img->height = height;
 
-  /* Maybe fill in the background field while we have ximg handy. */
-  IMAGE_BACKGROUND (img, f, ximg);
+  /* Maybe fill in the background field while we have ximg handy.
+     Casting avoids a GCC warning.  */
+  IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
   /* Put the image into the pixmap, then free the X image and its buffer.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
@@ -6145,9 +6152,9 @@ png_load (f, img)
   /* Same for the mask.  */
   if (mask_img)
     {
-      /* Fill in the background_transparent field while we have the mask
-         handy. */
-      image_background_transparent (img, f, mask_img);
+      /* Fill in the background_transparent field while we have the
+         mask handy.  Casting avoids a GCC warning.  */
+      image_background_transparent (img, f, (XImagePtr_or_DC)mask_img);
 
       x_put_x_image (f, mask_img, img->mask, img->width, img->height);
       x_destroy_x_image (mask_img);
@@ -6494,8 +6501,9 @@ jpeg_load (f, img)
     }
 
   /* Customize libjpeg's error handling to call my_error_exit when an
-     error is detected.  This function will perform a longjmp.  */
-  cinfo.err = fn_jpeg_std_error (&mgr.pub);
+     error is detected.  This function will perform a longjmp.
+     Casting return value avoids a GCC warning on W32.  */
+  cinfo.err = (struct jpeg_error_mgr *)fn_jpeg_std_error (&mgr.pub);
   mgr.pub.error_exit = my_error_exit;
 
   if ((rc = setjmp (mgr.setjmp_buffer)) != 0)
@@ -6606,7 +6614,8 @@ jpeg_load (f, img)
 
   /* Maybe fill in the background field while we have ximg handy. */
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
-    IMAGE_BACKGROUND (img, f, ximg);
+    /* Casting avoids a GCC warning.  */
+    IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
   /* Put the image into the pixmap.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
@@ -6932,8 +6941,9 @@ tiff_load (f, img)
           return 0;
         }
 
-      /* Try to open the image file.  */
-      tiff = fn_TIFFOpen (SDATA (file), "r");
+      /* Try to open the image file.  Casting return value avoids a
+         GCC warning on W32.  */
+      tiff = (TIFF *)fn_TIFFOpen (SDATA (file), "r");
       if (tiff == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
@@ -6948,14 +6958,15 @@ tiff_load (f, img)
       memsrc.len = SBYTES (specified_data);
       memsrc.index = 0;
 
-      tiff = fn_TIFFClientOpen ("memory_source", "r", &memsrc,
-                                (TIFFReadWriteProc) tiff_read_from_memory,
-                                (TIFFReadWriteProc) tiff_write_from_memory,
-                                tiff_seek_in_memory,
-                                tiff_close_memory,
-                                tiff_size_of_memory,
-                                tiff_mmap_memory,
-                                tiff_unmap_memory);
+      /* Casting return value avoids a GCC warning on W32.  */
+      tiff = (TIFF *)fn_TIFFClientOpen ("memory_source", "r", &memsrc,
+                                        (TIFFReadWriteProc) tiff_read_from_memory,
+                                        (TIFFReadWriteProc) tiff_write_from_memory,
+                                        tiff_seek_in_memory,
+                                        tiff_close_memory,
+                                        tiff_size_of_memory,
+                                        tiff_mmap_memory,
+                                        tiff_unmap_memory);
 
       if (!tiff)
         {
@@ -7018,7 +7029,8 @@ tiff_load (f, img)
 
   /* Maybe fill in the background field while we have ximg handy. */
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
-    IMAGE_BACKGROUND (img, f, ximg);
+    /* Casting avoids a GCC warning on W32.  */
+    IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
   /* Put the image into the pixmap, then free the X image and its buffer.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
@@ -7126,6 +7138,11 @@ gif_image_p (object)
 #ifdef HAVE_GIF
 
 #if defined (HAVE_NTGUI) || defined (MAC_OS)
+/* winuser.h might define DrawText to DrawTextA or DrawTextW.
+   Undefine before redefining to avoid a preprocessor warning.  */
+#ifdef DrawText
+#undef DrawText
+#endif
 /* avoid conflict with QuickdrawText.h */
 #define DrawText gif_DrawText
 #include <gif_lib.h>
@@ -7239,8 +7256,9 @@ gif_load (f, img)
           return 0;
         }
 
-      /* Open the GIF file.  */
-      gif = fn_DGifOpenFileName (SDATA (file));
+      /* Open the GIF file.  Casting return value avoids a GCC warning
+         on W32.  */
+      gif = (GifFileType *)fn_DGifOpenFileName (SDATA (file));
       if (gif == NULL)
         {
           image_error ("Cannot open `%s'", file, Qnil);
@@ -7256,7 +7274,8 @@ gif_load (f, img)
       memsrc.len = SBYTES (specified_data);
       memsrc.index = 0;
 
-      gif = fn_DGifOpen(&memsrc, gif_read_from_memory);
+      /* Casting return value avoids a GCC warning on W32.  */
+      gif = (GifFileType *)fn_DGifOpen(&memsrc, gif_read_from_memory);
       if (!gif)
         {
           image_error ("Cannot open memory source `%s'", img->spec, Qnil);
@@ -7390,7 +7409,8 @@ gif_load (f, img)
 
   /* Maybe fill in the background field while we have ximg handy. */
   if (NILP (image_spec_value (img->spec, QCbackground, NULL)))
-    IMAGE_BACKGROUND (img, f, ximg);
+    /* Casting avoids a GCC warning.  */
+    IMAGE_BACKGROUND (img, f, (XImagePtr_or_DC)ximg);
 
   /* Put the image into the pixmap, then free the X image and its buffer.  */
   x_put_x_image (f, ximg, img->pixmap, width, height);
@@ -7400,7 +7420,7 @@ gif_load (f, img)
   return 1;
 }
 
-#else
+#else  /* !HAVE_GIF */
 
 #ifdef MAC_OS
 static int
diff --git a/src/keyboard.c b/src/keyboard.c
index dee131b8c61..7c268dc475e 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1509,7 +1509,7 @@ command_loop_1 ()
          Is this a good idea?  */
       if (FRAMEP (internal_last_event_frame)
           && !EQ (internal_last_event_frame, selected_frame))
-        Fselect_frame (internal_last_event_frame, Qnil);
+        Fselect_frame (internal_last_event_frame);
 #endif
       /* If it has changed current-menubar from previous value,
          really recompute the menubar from the value.  */
diff --git a/src/lisp.h b/src/lisp.h
index af07de3fbaa..d523f98f937 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2992,7 +2992,7 @@ extern Lisp_Object do_switch_frame P_ ((Lisp_Object, int, int));
 extern Lisp_Object get_frame_param P_ ((struct frame *, Lisp_Object));
 extern Lisp_Object frame_buffer_predicate P_ ((Lisp_Object));
 EXFUN (Fframep, 1);
-EXFUN (Fselect_frame, 2);
+EXFUN (Fselect_frame, 1);
 EXFUN (Fselected_frame, 0);
 EXFUN (Fwindow_frame, 1);
 EXFUN (Fframe_root_window, 1);
diff --git a/src/macfns.c b/src/macfns.c
index 8ec05b59e19..96f588207d1 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -4375,14 +4375,15 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
           break;
         }
       NavDialogDispose(dialogRef);
+      UNBLOCK_INPUT;
     }
     else {
+      UNBLOCK_INPUT;
       /* Fall back on minibuffer if there was a problem */
       file = Fcompleting_read (prompt, intern ("read-file-name-internal"),
                                dir, mustmatch, dir, Qfile_name_history,
                                default_filename, Qnil);
     }
-    UNBLOCK_INPUT;
   }
 
   UNGCPRO;
diff --git a/src/macterm.c b/src/macterm.c
index dd48d43a039..cef213024fa 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -2002,33 +2002,37 @@ static void
 mac_compute_glyph_string_overhangs (s)
      struct glyph_string *s;
 {
-  Rect r;
-  MacFontStruct *font = s->font;
-
-  TextFont (font->mac_fontnum);
-  TextSize (font->mac_fontsize);
-  TextFace (font->mac_fontface);
-
-  if (s->two_byte_p)
-    QDTextBounds (s->nchars * 2, (char *)s->char2b, &r);
-  else
+  if (s->cmp == NULL
+      && s->first_glyph->type == CHAR_GLYPH)
     {
-      int i;
-      char *buf = xmalloc (s->nchars);
+      Rect r;
+      MacFontStruct *font = s->font;
 
-      if (buf == NULL)
-        SetRect (&r, 0, 0, 0, 0);
+      TextFont (font->mac_fontnum);
+      TextSize (font->mac_fontsize);
+      TextFace (font->mac_fontface);
+
+      if (s->two_byte_p)
+        QDTextBounds (s->nchars * 2, (char *)s->char2b, &r);
       else
         {
-          for (i = 0; i < s->nchars; ++i)
-            buf[i] = s->char2b[i].byte2;
-          QDTextBounds (s->nchars, buf, &r);
-          xfree (buf);
+          int i;
+          char *buf = xmalloc (s->nchars);
+
+          if (buf == NULL)
+            SetRect (&r, 0, 0, 0, 0);
+          else
+            {
+              for (i = 0; i < s->nchars; ++i)
+                buf[i] = s->char2b[i].byte2;
+              QDTextBounds (s->nchars, buf, &r);
+              xfree (buf);
+            }
         }
-    }
 
-  s->right_overhang = r.right > s->width ? r.right - s->width : 0;
-  s->left_overhang = r.left < 0 ? -r.left : 0;
+      s->right_overhang = r.right > s->width ? r.right - s->width : 0;
+      s->left_overhang = r.left < 0 ? -r.left : 0;
+    }
 }
 
 
@@ -7495,6 +7499,11 @@ Lisp_Object Vmac_pass_command_to_system;
 /* If Non-nil, the Mac "Control" key is passed on to the Mac Toolbox
    for processing before Emacs sees it.  */
 Lisp_Object Vmac_pass_control_to_system;
+
+/* Points to the variable `inev' in the function XTread_socket.  It is
+   used for passing an input event to the function back from a Carbon
+   event handler.  */
+static struct input_event *read_socket_inev = NULL;
 #endif
 
 /* Set in term/mac-win.el to indicate that event loop can now generate
@@ -7627,45 +7636,79 @@ mac_get_mouse_btn (EventRef ref)
 
 /* Normally, ConvertEventRefToEventRecord will correctly handle all
    events.  However the click of the mouse wheel is not converted to a
-   mouseDown or mouseUp event.  This calls ConvertEventRef, but then
-   checks to see if it is a mouse up or down carbon event that has not
-   been converted, and if so, converts it by hand (to be picked up in
-   the XTread_socket loop).  */
+   mouseDown or mouseUp event.  Likewise for dead key down events.
+   This calls ConvertEventRef, but then checks to see if it is a mouse
+   up/down, or a dead key down carbon event that has not been
+   converted, and if so, converts it by hand (to be picked up in the
+   XTread_socket loop).  */
 static Boolean mac_convert_event_ref (EventRef eventRef, EventRecord *eventRec)
 {
   Boolean result = ConvertEventRefToEventRecord (eventRef, eventRec);
-  /* Do special case for mouse wheel button.  */
-  if (!result && GetEventClass (eventRef) == kEventClassMouse)
+
+  if (result)
+    return result;
+
+  switch (GetEventClass (eventRef))
     {
-      UInt32 kind = GetEventKind (eventRef);
-      if (kind == kEventMouseDown && !(eventRec->what == mouseDown))
+    case kEventClassMouse:
+      switch (GetEventKind (eventRef))
         {
+        case kEventMouseDown:
           eventRec->what = mouseDown;
-          result=1;
-        }
-      if (kind == kEventMouseUp && !(eventRec->what == mouseUp))
-        {
+          result = 1;
+          break;
+
+        case kEventMouseUp:
           eventRec->what = mouseUp;
-          result=1;
+          result = 1;
+          break;
+
+        default:
+          break;
         }
-      if (result)
+
+    case kEventClassKeyboard:
+      switch (GetEventKind (eventRef))
         {
-          /* Need where and when.  */
-          UInt32 mods;
-          GetEventParameter (eventRef, kEventParamMouseLocation,
-                             typeQDPoint, NULL, sizeof (Point),
-                             NULL, &eventRec->where);
-          /* Use two step process because new event modifiers are
-             32-bit and old are 16-bit.  Currently, only loss is
-             NumLock & Fn. */
-          GetEventParameter (eventRef, kEventParamKeyModifiers,
-                             typeUInt32, NULL, sizeof (UInt32),
-                             NULL, &mods);
-          eventRec->modifiers = mods;
-
-          eventRec->when = EventTimeToTicks (GetEventTime (eventRef));
+        case kEventRawKeyDown:
+          {
+            unsigned char char_codes;
+            UInt32 key_code;
+
+            eventRec->what = keyDown;
+            GetEventParameter (eventRef, kEventParamKeyMacCharCodes, typeChar,
+                               NULL, sizeof (char), NULL, &char_codes);
+            GetEventParameter (eventRef, kEventParamKeyCode, typeUInt32,
+                               NULL, sizeof (UInt32), NULL, &key_code);
+            eventRec->message = char_codes | ((key_code & 0xff) << 8);
+            result = 1;
+          }
+          break;
+
+        default:
+          break;
         }
+
+    default:
+      break;
     }
+
+  if (result)
+    {
+      /* Need where and when.  */
+      UInt32 mods;
+
+      GetEventParameter (eventRef, kEventParamMouseLocation, typeQDPoint,
+                         NULL, sizeof (Point), NULL, &eventRec->where);
+      /* Use two step process because new event modifiers are 32-bit
+         and old are 16-bit.  Currently, only loss is NumLock & Fn. */
+      GetEventParameter (eventRef, kEventParamKeyModifiers, typeUInt32,
+                         NULL, sizeof (UInt32), NULL, &mods);
+      eventRec->modifiers = mods;
+
+      eventRec->when = EventTimeToTicks (GetEventTime (eventRef));
+    }
+
   return result;
 }
 
@@ -8235,8 +8278,7 @@ mac_handle_command_event (next_handler, event, data)
 }
 
 static OSErr
-init_command_handler (window)
-     WindowPtr window;
+init_command_handler ()
 {
   OSErr err = noErr;
   EventTypeSpec specs[] = {{kEventClassCommand, kEventCommandProcess}};
@@ -8321,6 +8363,68 @@ mac_handle_window_event (next_handler, event, data)
 
   return eventNotHandledErr;
 }
+
+static pascal OSStatus
+mac_handle_mouse_event (next_handler, event, data)
+     EventHandlerCallRef next_handler;
+     EventRef event;
+     void *data;
+{
+  OSStatus result;
+
+  switch (GetEventKind (event))
+    {
+    case kEventMouseWheelMoved:
+      {
+        WindowPtr wp;
+        struct frame *f;
+        EventMouseWheelAxis axis;
+        SInt32 delta;
+        Point point;
+
+        result = CallNextEventHandler (next_handler, event);
+        if (result != eventNotHandledErr || read_socket_inev == NULL)
+          return result;
+
+        GetEventParameter (event, kEventParamWindowRef, typeWindowRef,
+                           NULL, sizeof (WindowRef), NULL, &wp);
+        f = mac_window_to_frame (wp);
+        if (f != mac_focus_frame (&one_mac_display_info))
+          break;
+
+        GetEventParameter (event, kEventParamMouseWheelAxis,
+                           typeMouseWheelAxis, NULL,
+                           sizeof (EventMouseWheelAxis), NULL, &axis);
+        if (axis != kEventMouseWheelAxisY)
+          break;
+
+        GetEventParameter (event, kEventParamMouseWheelDelta, typeSInt32,
+                           NULL, sizeof (SInt32), NULL, &delta);
+        GetEventParameter (event, kEventParamMouseLocation, typeQDPoint,
+                           NULL, sizeof (Point), NULL, &point);
+        read_socket_inev->kind = WHEEL_EVENT;
+        read_socket_inev->code = 0;
+        read_socket_inev->modifiers =
+          (mac_event_to_emacs_modifiers (event)
+           | ((delta < 0) ? down_modifier : up_modifier));
+        SetPortWindowPort (wp);
+        GlobalToLocal (&point);
+        XSETINT (read_socket_inev->x, point.h);
+        XSETINT (read_socket_inev->y, point.v);
+        XSETFRAME (read_socket_inev->frame_or_window, f);
+        read_socket_inev->timestamp =
+          EventTimeToTicks (GetEventTime (event)) * (1000/60);
+
+        return noErr;
+      }
+      break;
+
+    default:
+      break;
+    }
+
+  return eventNotHandledErr;
+}
 #endif  /* USE_CARBON_EVENTS */
 
 
@@ -8330,16 +8434,24 @@ install_window_handler (window)
 {
   OSErr err = noErr;
 #if USE_CARBON_EVENTS
-  EventTypeSpec specs[] = {{kEventClassWindow, kEventWindowUpdate},
-                           {kEventClassWindow, kEventWindowBoundsChanging}};
-  static EventHandlerUPP handle_window_event_UPP = NULL;
-
-  if (handle_window_event_UPP == NULL)
-    handle_window_event_UPP = NewEventHandlerUPP (mac_handle_window_event);
-
-  err = InstallWindowEventHandler (window, handle_window_event_UPP,
-                                   GetEventTypeCount (specs), specs,
-                                   NULL, NULL);
+  EventTypeSpec specs_window[] =
+    {{kEventClassWindow, kEventWindowUpdate},
+     {kEventClassWindow, kEventWindowBoundsChanging}};
+  EventTypeSpec specs_mouse[] = {{kEventClassMouse, kEventMouseWheelMoved}};
+  static EventHandlerUPP handle_window_eventUPP = NULL;
+  static EventHandlerUPP handle_mouse_eventUPP = NULL;
+
+  if (handle_window_eventUPP == NULL)
+    handle_window_eventUPP = NewEventHandlerUPP (mac_handle_window_event);
+  if (handle_mouse_eventUPP == NULL)
+    handle_mouse_eventUPP = NewEventHandlerUPP (mac_handle_mouse_event);
+  err = InstallWindowEventHandler (window, handle_window_eventUPP,
+                                   GetEventTypeCount (specs_window),
+                                   specs_window, NULL, NULL);
+  if (err == noErr)
+    err = InstallWindowEventHandler (window, handle_mouse_eventUPP,
+                                     GetEventTypeCount (specs_mouse),
+                                     specs_mouse, NULL, NULL);
 #endif
 #if TARGET_API_MAC_CARBON
   if (mac_do_track_dragUPP == NULL)
@@ -8891,68 +9003,19 @@ XTread_socket (sd, expected, hold_quit)
 #if USE_CARBON_EVENTS
       /* Handle new events */
       if (!mac_convert_event_ref (eventRef, &er))
-        switch (GetEventClass (eventRef))
-          {
-          case kEventClassWindow:
-            if (GetEventKind (eventRef) == kEventWindowBoundsChanged)
-              {
-                WindowPtr window_ptr;
-                GetEventParameter(eventRef, kEventParamDirectObject,
-                                  typeWindowRef, NULL, sizeof(WindowPtr),
-                                  NULL, &window_ptr);
-                f = mac_window_to_frame (window_ptr);
-                if (f && !f->async_iconified)
-                  x_real_positions (f, &f->left_pos, &f->top_pos);
-                SendEventToEventTarget (eventRef, toolbox_dispatcher);
-              }
-            break;
-          case kEventClassMouse:
-            if (GetEventKind (eventRef) == kEventMouseWheelMoved)
-              {
-                SInt32 delta;
-                Point point;
-                struct frame *f = mac_focus_frame (dpyinfo);
-                WindowPtr window_ptr;
-
-#if 0
-                if (dpyinfo->x_focus_frame == NULL)
-                  {
-                    /* Beep if wheel move occurs when all the frames
-                       are invisible.  */
-                    SysBeep(1);
-                    break;
-                  }
-#endif
-
-                GetEventParameter(eventRef, kEventParamMouseWheelDelta,
-                                  typeSInt32, NULL, sizeof (SInt32),
-                                  NULL, &delta);
-                GetEventParameter(eventRef, kEventParamMouseLocation,
-                                  typeQDPoint, NULL, sizeof (Point),
-                                  NULL, &point);
-                inev.kind = WHEEL_EVENT;
-                inev.code = 0;
-                inev.modifiers = (mac_event_to_emacs_modifiers (eventRef)
-                                  | ((delta < 0) ? down_modifier
-                                     : up_modifier));
-                window_ptr = FRAME_MAC_WINDOW (f);
-                SetPortWindowPort (window_ptr);
-                GlobalToLocal (&point);
-                XSETINT (inev.x, point.h);
-                XSETINT (inev.y, point.v);
-                XSETFRAME (inev.frame_or_window,
-                           mac_window_to_frame (window_ptr));
-                inev.timestamp = EventTimeToTicks (GetEventTime (eventRef))*(1000/60);
-              }
-            else
-              SendEventToEventTarget (eventRef, toolbox_dispatcher);
-
-            break;
-
-          default:
-            /* Send the event to the appropriate receiver.  */
-            SendEventToEventTarget (eventRef, toolbox_dispatcher);
-          }
+        {
+          /* There used to be a handler for the kEventMouseWheelMoved
+             event here.  But as of Mac OS X 10.4, this kind of event
+             is not directly posted to the main event queue by
+             two-finger scrolling on the trackpad.  Instead, some
+             private event is posted and it is converted to a wheel
+             event by the default handler for the application target.
+             The converted one can be received by a Carbon event
+             handler installed on a window target.  */
+          read_socket_inev = &inev;
+          SendEventToEventTarget (eventRef, toolbox_dispatcher);
+          read_socket_inev = NULL;
+        }
       else
 #endif /* USE_CARBON_EVENTS */
       switch (er.what)
@@ -9388,7 +9451,10 @@ XTread_socket (sd, expected, hold_quit)
             if ((!NILP (Vmac_pass_command_to_system)
                  || !(er.modifiers & cmdKey))
                 && (!NILP (Vmac_pass_control_to_system)
-                    || !(er.modifiers & controlKey)))
+                    || !(er.modifiers & controlKey))
+                && (!NILP (Vmac_command_key_is_meta)
+                    && NILP (Vmac_option_modifier)
+                    || !(er.modifiers & optionKey)))
               if (SendEventToEventTarget (eventRef, toolbox_dispatcher)
                   != eventNotHandledErr)
                 break;
diff --git a/src/makefile.w32-in b/src/makefile.w32-in
index 471f0cbc6ea..0ab23c72f78 100644
--- a/src/makefile.w32-in
+++ b/src/makefile.w32-in
@@ -170,7 +170,8 @@ $(EMACS):       $(DOC) $(TEMACS)
 # (it is the preload heap size in MB).
 #
 temacs:         $(BLD) $(TEMACS)
-$(TEMACS):      $(TLIB0) $(TLIB1) $(TLIBW32) $(TLASTLIB) $(TOBJ) $(TRES)
+$(TEMACS):      $(TLIB0) $(TLIB1) $(TLIBW32) $(TLASTLIB) $(TOBJ) $(TRES) \
+                  ../nt/$(BLD)/addsection.exe
         $(LINK) $(LINK_OUT)$(TEMACS_TMP) $(FULL_LINK_FLAGS) $(TOBJ) $(TRES) $(LIBS)
         "../nt/$(BLD)/addsection" "$(TEMACS_TMP)" "$(TEMACS)" EMHEAP 20
         echo $(OBJ0) > $(BLD)/buildobj.lst
diff --git a/src/process.c b/src/process.c
index d60fe1e3bf6..b61c6e8d6fe 100644
--- a/src/process.c
+++ b/src/process.c
@@ -6822,7 +6822,7 @@ The value takes effect when `start-process' is called.  */);
                doc: /* If non-nil, improve receive buffering by delaying after short reads.
 On some systems, when Emacs reads the output from a subprocess, the output data
 is read in very small blocks, potentially resulting in very poor performance.
-This behaviour can be remedied to some extent by setting this variable to a
+This behavior can be remedied to some extent by setting this variable to a
 non-nil value, as it will automatically delay reading from such processes, to
 allowing them to produce more output before Emacs tries to read it.
 If the value is t, the delay is reset after each write to the process; any other
diff --git a/src/unexw32.c b/src/unexw32.c
index 1b2dbe74c31..ebeb7355673 100644
--- a/src/unexw32.c
+++ b/src/unexw32.c
@@ -1,5 +1,5 @@
 /* unexec for GNU Emacs on Windows NT.
-   Copyright (C) 1994 Free Software Foundation, Inc.
+   Copyright (C) 1994, 2005 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -491,27 +491,34 @@ copy_executable_and_dump_data (file_data *p_infile,
   PIMAGE_SECTION_HEADER dst_section;
   DWORD offset;
   int i;
+  int be_verbose = GetEnvironmentVariable ("DEBUG_DUMP", NULL, 0) > 0;
 
-#define COPY_CHUNK(message, src, size)                                          \
+#define COPY_CHUNK(message, src, size, verbose)                                 \
   do {                                                                          \
     unsigned char *s = (void *)(src);                                           \
     unsigned long count = (size);                                               \
-    printf ("%s\n", (message));                                                 \
-    printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base);       \
-    printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base);   \
-    printf ("\t0x%08x Size in bytes.\n", count);                                \
+    if (verbose)                                                                \
+      {                                                                         \
+        printf ("%s\n", (message));                                             \
+        printf ("\t0x%08x Offset in input file.\n", s - p_infile->file_base);   \
+        printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
+        printf ("\t0x%08x Size in bytes.\n", count);                            \
+      }                                                                         \
     memcpy (dst, s, count);                                                     \
     dst += count;                                                               \
   } while (0)
 
-#define COPY_PROC_CHUNK(message, src, size)                                     \
+#define COPY_PROC_CHUNK(message, src, size, verbose)                            \
   do {                                                                          \
     unsigned char *s = (void *)(src);                                           \
     unsigned long count = (size);                                               \
-    printf ("%s\n", (message));                                                 \
-    printf ("\t0x%08x Address in process.\n", s);                               \
-    printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base);   \
-    printf ("\t0x%08x Size in bytes.\n", count);                                \
+    if (verbose)                                                                \
+      {                                                                         \
+        printf ("%s\n", (message));                                             \
+        printf ("\t0x%08x Address in process.\n", s);                           \
+        printf ("\t0x%08x Offset in output file.\n", dst - p_outfile->file_base); \
+        printf ("\t0x%08x Size in bytes.\n", count);                            \
+      }                                                                         \
     memcpy (dst, s, count);                                                     \
     dst += count;                                                               \
   } while (0)
@@ -542,13 +549,14 @@ copy_executable_and_dump_data (file_data *p_infile,
   dst = (unsigned char *) p_outfile->file_base;
 
   COPY_CHUNK ("Copying DOS header...", dos_header,
-              (DWORD) nt_header - (DWORD) dos_header);
+              (DWORD) nt_header - (DWORD) dos_header, be_verbose);
   dst_nt_header = (PIMAGE_NT_HEADERS) dst;
   COPY_CHUNK ("Copying NT header...", nt_header,
-              (DWORD) section - (DWORD) nt_header);
+              (DWORD) section - (DWORD) nt_header, be_verbose);
   dst_section = (PIMAGE_SECTION_HEADER) dst;
   COPY_CHUNK ("Copying section table...", section,
-              nt_header->FileHeader.NumberOfSections * sizeof (*section));
+              nt_header->FileHeader.NumberOfSections * sizeof (*section),
+              be_verbose);
 
   /* Align the first section's raw data area, and set the header size
      field accordingly.  */
@@ -558,7 +566,9 @@ copy_executable_and_dump_data (file_data *p_infile,
   for (i = 0; i < nt_header->FileHeader.NumberOfSections; i++)
     {
       char msg[100];
-      sprintf (msg, "Copying raw data for %s...", section->Name);
+      /* Windows section names are fixed 8-char strings, only
+         zero-terminated if the name is shorter than 8 characters.  */
+      sprintf (msg, "Copying raw data for %.8s...", section->Name);
 
       dst_save = dst;
 
@@ -571,7 +581,7 @@ copy_executable_and_dump_data (file_data *p_infile,
       /* Can always copy the original raw data.  */
       COPY_CHUNK
         (msg, OFFSET_TO_PTR (section->PointerToRawData, p_infile),
-         section->SizeOfRawData);
+         section->SizeOfRawData, be_verbose);
       /* Ensure alignment slop is zeroed.  */
       ROUND_UP_DST_AND_ZERO (dst_nt_header->OptionalHeader.FileAlignment);
 
@@ -580,7 +590,8 @@ copy_executable_and_dump_data (file_data *p_infile,
         {
           dst = dst_save
             + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (data_start), dst_section);
-          COPY_PROC_CHUNK ("Dumping initialized data...", data_start, data_size);
+          COPY_PROC_CHUNK ("Dumping initialized data...",
+                           data_start, data_size, be_verbose);
           dst = dst_save + dst_section->SizeOfRawData;
         }
       if (section == bss_section)
@@ -589,7 +600,8 @@ copy_executable_and_dump_data (file_data *p_infile,
              data size as necessary.  */
           dst = dst_save
             + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start), dst_section);
-          COPY_PROC_CHUNK ("Dumping bss data...", bss_start, bss_size);
+          COPY_PROC_CHUNK ("Dumping bss data...", bss_start,
+                           bss_size, be_verbose);
           ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
           dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
           /* Determine new size of raw data area.  */
@@ -604,7 +616,8 @@ copy_executable_and_dump_data (file_data *p_infile,
              section's raw data size as necessary.  */
           dst = dst_save
             + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (bss_start_static), dst_section);
-          COPY_PROC_CHUNK ("Dumping static bss data...", bss_start_static, bss_size_static);
+          COPY_PROC_CHUNK ("Dumping static bss data...", bss_start_static,
+                           bss_size_static, be_verbose);
           ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
           dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
           /* Determine new size of raw data area.  */
@@ -622,7 +635,8 @@ copy_executable_and_dump_data (file_data *p_infile,
              section's size to the appropriate size.  */
           dst = dst_save
             + RVA_TO_SECTION_OFFSET (PTR_TO_RVA (heap_start), dst_section);
-          COPY_PROC_CHUNK ("Dumping heap...", heap_start, heap_size);
+          COPY_PROC_CHUNK ("Dumping heap...", heap_start, heap_size,
+                           be_verbose);
           ROUND_UP_DST (dst_nt_header->OptionalHeader.FileAlignment);
           dst_section->PointerToRawData = PTR_TO_OFFSET (dst_save, p_outfile);
           /* Determine new size of raw data area.  */
@@ -657,7 +671,7 @@ copy_executable_and_dump_data (file_data *p_infile,
   COPY_CHUNK
     ("Copying remainder of executable...",
      OFFSET_TO_PTR (offset, p_infile),
-     p_infile->size - offset);
+     p_infile->size - offset, be_verbose);
 
   /* Final size for new image.  */
   p_outfile->size = DST_TO_OFFSET ();
diff --git a/src/w32bdf.c b/src/w32bdf.c
index 5f073dc8478..425669ee2a5 100644
--- a/src/w32bdf.c
+++ b/src/w32bdf.c
@@ -604,7 +604,7 @@ create_offscreen_bitmap(HDC hdc, int width, int height, unsigned char **bitsp)
   info.c[1].rgbRed = info.c[1].rgbGreen = info.c[1].rgbBlue = 255;
 
   return CreateDIBSection(hdc, (LPBITMAPINFO)&info,
-                          DIB_RGB_COLORS, bitsp, NULL, 0);
+                          DIB_RGB_COLORS, (void **)bitsp, NULL, 0);
 }
 
 glyph_metric *
diff --git a/src/w32fns.c b/src/w32fns.c
index e05c45c2a4e..db7297059a2 100644
--- a/src/w32fns.c
+++ b/src/w32fns.c
@@ -7821,6 +7821,19 @@ file_dialog_callback (hwnd, msg, wParam, lParam)
   return 0;
 }
 
+/* Since we compile with _WIN32_WINNT set to 0x0400 (for NT4 compatibility)
+   we end up with the old file dialogs. Define a big enough struct for the
+   new dialog to trick GetOpenFileName into giving us the new dialogs on
+   Windows 2000 and XP.  */
+typedef struct
+{
+  OPENFILENAME real_details;
+  void * pReserved;
+  DWORD dwReserved;
+  DWORD FlagsEx;
+} NEWOPENFILENAME;
+
+    
 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
        doc: /* Read file name, prompting with PROMPT in directory DIR.
 Use a file selection dialog.
@@ -7869,39 +7882,58 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     filename[0] = '\0';
 
   {
-    OPENFILENAME file_details;
-
+    NEWOPENFILENAME new_file_details;
+    BOOL file_opened = FALSE;
+    OPENFILENAME * file_details = &new_file_details.real_details;
+  
     /* Prevent redisplay.  */
     specbind (Qinhibit_redisplay, Qt);
     BLOCK_INPUT;
 
-    bzero (&file_details, sizeof (file_details));
-    file_details.lStructSize = sizeof (file_details);
-    file_details.hwndOwner = FRAME_W32_WINDOW (f);
+    bzero (&new_file_details, sizeof (new_file_details));
+    /* Apparently NT4 crashes if you give it an unexpected size.
+       I'm not sure about Windows 9x, so play it safe.  */
+    if (w32_major_version > 4 && w32_major_version < 95)
+      file_details->lStructSize = sizeof (new_file_details);
+    else
+      file_details->lStructSize = sizeof (file_details);
+
+    file_details->hwndOwner = FRAME_W32_WINDOW (f);
     /* Undocumented Bug in Common File Dialog:
        If a filter is not specified, shell links are not resolved.  */
-    file_details.lpstrFilter = "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
-    file_details.lpstrFile = filename;
-    file_details.nMaxFile = sizeof (filename);
-    file_details.lpstrInitialDir = init_dir;
-    file_details.lpstrTitle = SDATA (prompt);
+    file_details->lpstrFilter = "All Files (*.*)\0*.*\0Directories\0*|*\0\0";
+    file_details->lpstrFile = filename;
+    file_details->nMaxFile = sizeof (filename);
+    file_details->lpstrInitialDir = init_dir;
+    file_details->lpstrTitle = SDATA (prompt);
 
     if (! NILP (only_dir_p))
       default_filter_index = 2;
 
-    file_details.nFilterIndex = default_filter_index;
+    file_details->nFilterIndex = default_filter_index;
 
-    file_details.Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
+    file_details->Flags = (OFN_HIDEREADONLY | OFN_NOCHANGEDIR
                           | OFN_EXPLORER | OFN_ENABLEHOOK);
     if (!NILP (mustmatch))
-      file_details.Flags |= OFN_FILEMUSTEXIST | OFN_PATHMUSTEXIST;
+      {
+        /* Require that the path to the parent directory exists.  */
+        file_details->Flags |= OFN_PATHMUSTEXIST;
+        /* If we are looking for a file, require that it exists.  */
+        if (NILP (only_dir_p))
+          file_details->Flags |= OFN_FILEMUSTEXIST;
+      }
+
+    file_details->lpfnHook = (LPOFNHOOKPROC) file_dialog_callback;
 
-    file_details.lpfnHook = (LPOFNHOOKPROC) file_dialog_callback;
+    file_opened = GetOpenFileName (file_details);
 
-    if (GetOpenFileName (&file_details))
+    UNBLOCK_INPUT;
+
+    if (file_opened)
       {
         dostounix_filename (filename);
-        if (file_details.nFilterIndex == 2)
+
+        if (file_details->nFilterIndex == 2)
           {
             /* "Directories" selected - strip dummy file name.  */
             char * last = strrchr (filename, '/');
@@ -7919,7 +7951,6 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
                                dir, mustmatch, dir, Qfile_name_history,
                                default_filename, Qnil);
 
-    UNBLOCK_INPUT;
     file = unbind_to (count, file);
   }
 
@@ -8760,7 +8791,7 @@ fontsets are automatically created.  */);
   DEFVAR_BOOL ("w32-strict-painting",
                &w32_strict_painting,
                doc: /* Non-nil means use strict rules for repainting frames.
-Set this to nil to get the old behaviour for repainting; this should
+Set this to nil to get the old behavior for repainting; this should
 only be necessary if the default setting causes problems.  */);
   w32_strict_painting = 1;
 
@@ -8953,24 +8984,25 @@ void globals_of_w32fns ()
 
 #undef abort
 
+void w32_abort (void) NO_RETURN;
+
 void
 w32_abort()
 {
   int button;
   button = MessageBox (NULL,
                        "A fatal error has occurred!\n\n"
-                       "Select Abort to exit, Retry to debug, Ignore to continue",
+                       "Would you like to attach a debugger?\n\n"
+                       "Select YES to debug, NO to abort Emacs",
                        "Emacs Abort Dialog",
                        MB_ICONEXCLAMATION | MB_TASKMODAL
-                       | MB_SETFOREGROUND | MB_ABORTRETRYIGNORE);
+                       | MB_SETFOREGROUND | MB_YESNO);
   switch (button)
     {
-    case IDRETRY:
+    case IDYES:
       DebugBreak ();
-      break;
-    case IDIGNORE:
-      break;
-    case IDABORT:
+      exit (2); /* tell the compiler we will never return */
+    case IDNO:
     default:
       abort ();
       break;
diff --git a/src/w32term.c b/src/w32term.c
index 51f001bfd45..0bb5607512c 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -89,6 +89,10 @@ static int any_help_event_p;
 /* Last window where we saw the mouse.  Used by mouse-autoselect-window.  */
 static Lisp_Object last_window;
 
+/* Non-zero means make use of UNDERLINE_POSITION font properties.
+   (Not yet supported, see TODO in x_draw_glyph_string.)  */
+int x_use_underline_position_properties;
+
 extern unsigned int msh_mousewheel;
 
 extern void free_frame_menubar ();
@@ -2639,7 +2643,9 @@ x_draw_glyph_string (s)
           unsigned long dy = s->height - h;
 
           /* TODO: Use font information for positioning and thickness
-             of underline.  See OUTLINETEXTMETRIC, and xterm.c.  */
+             of underline.  See OUTLINETEXTMETRIC, and xterm.c.
+             Note: If you make this work, don't forget to change the
+             doc string of x-use-underline-position-properties below.  */
           if (s->face->underline_defaulted_p)
             {
               w32_fill_area (s->f, s->hdc, s->gc->foreground, s->x,
@@ -6707,6 +6713,18 @@ the cursor have no effect.  */);
                              &w32_use_visible_system_caret, 0))
     w32_use_visible_system_caret = 0;
 
+  /* We don't yet support this, but defining this here avoids whining
+     from cus-start.el and other places, like "M-x set-variable".  */
+  DEFVAR_BOOL ("x-use-underline-position-properties",
+               &x_use_underline_position_properties,
+     doc: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
+nil means ignore them.  If you encounter fonts with bogus
+UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
+to 4.1, set this to nil.
+
+NOTE: Not supported on MS-Windows yet.  */);
+  x_use_underline_position_properties = 0;
+
   DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
                doc: /* If not nil, Emacs uses toolkit scroll bars.  */);
   Vx_toolkit_scroll_bars = Qt;
diff --git a/src/window.c b/src/window.c
index 4d7c71f82c6..8e1a97ee1aa 100644
--- a/src/window.c
+++ b/src/window.c
@@ -3234,7 +3234,7 @@ selects the buffer of the selected window before each command.  */)
          so that FRAME_FOCUS_FRAME is moved appropriately as we
          move around in the state where a minibuffer in a separate
          frame is active.  */
-      Fselect_frame (WINDOW_FRAME (w), Qnil);
+      Fselect_frame (WINDOW_FRAME (w));
     }
   else
     sf->selected_window = window;
diff --git a/src/xdisp.c b/src/xdisp.c
index 8d146ebcb23..71fa930a4c6 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1901,7 +1901,7 @@ get_phys_cursor_geometry (w, row, glyph, heightp)
      int *heightp;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
-  int x, y, wd, h, h0, y0;
+  int y, wd, h, h0, y0;
 
   /* Compute the width of the rectangle to draw.  If on a stretch
      glyph, and `x-stretch-block-cursor' is nil, don't draw a
@@ -8358,7 +8358,6 @@ static Lisp_Object
 format_mode_line_unwind_data (obuf)
      struct buffer *obuf;
 {
-  int i = 0;
   Lisp_Object vector;
 
   /* Reduce consing by keeping one vector in
@@ -19302,7 +19301,7 @@ get_line_height_property (it, prop)
      struct it *it;
      Lisp_Object prop;
 {
-  Lisp_Object position, val;
+  Lisp_Object position;
 
   if (STRINGP (it->object))
     position = make_number (IT_STRING_CHARPOS (*it));
@@ -19647,7 +19646,6 @@ x_produce_glyphs (it)
           else
             {
               Lisp_Object spacing;
-              int total = 0;
 
               it->phys_ascent = it->ascent;
               it->phys_descent = it->descent;
@@ -21664,7 +21662,7 @@ note_mode_line_or_margin_highlight (window, x, y, area)
           int ignore;
 
           int vpos, hpos;
-          
+
           b = Fprevious_single_property_change (make_number (charpos + 1),
                                                 Qmouse_face, string, Qnil);
           if (NILP (b))
@@ -21712,18 +21710,18 @@ note_mode_line_or_margin_highlight (window, x, y, area)
           hpos = (area == ON_MODE_LINE
                   ? (w->current_matrix)->nrows - 1
                   : 0);
-          
+
           /* If the re-rendering position is included in the last
              re-rendering area, we should do nothing. */
-          if ( window == dpyinfo->mouse_face_window
+          if ( EQ (window, dpyinfo->mouse_face_window)
                && dpyinfo->mouse_face_beg_col <= vpos
                && vpos < dpyinfo->mouse_face_end_col
                && dpyinfo->mouse_face_beg_row == hpos )
             return;
-          
+
           if (clear_mouse_face (dpyinfo))
             cursor = No_Cursor;
-          
+
           dpyinfo->mouse_face_beg_col = vpos;
           dpyinfo->mouse_face_beg_row = hpos;
 
@@ -21748,8 +21746,9 @@ note_mode_line_or_margin_highlight (window, x, y, area)
           if (NILP (pointer))
             pointer = Qhand;
         }
+      else if ((area == ON_MODE_LINE) || (area == ON_HEADER_LINE))
+        clear_mouse_face (dpyinfo);
     }
-
   define_frame_cursor1 (f, cursor, pointer);
 }
 
diff --git a/src/xfaces.c b/src/xfaces.c
index fc8a0bc05af..25d11c066b0 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -6258,7 +6258,7 @@ DEFUN ("display-supports-face-attributes-p",
        1, 2, 0,
        doc: /* Return non-nil if all the face attributes in ATTRIBUTES are supported.
 The optional argument DISPLAY can be a display name, a frame, or
-nil (meaning the selected frame's display)
+nil (meaning the selected frame's display).
 
 The definition of `supported' is somewhat heuristic, but basically means
 that a face containing all the attributes in ATTRIBUTES, when merged
@@ -6271,7 +6271,7 @@ Point (2) implies that a `:weight black' attribute will be satisfied by
 any display that can display bold, and a `:foreground \"yellow\"' as long
 as it can display a yellowish color, but `:slant italic' will _not_ be
 satisfied by the tty display code's automatic substitution of a `dim'
-face for italic. */)
+face for italic.  */)
   (attributes, display)
      Lisp_Object attributes, display;
 {