Revision: miles@gnu.org--gnu-2004/emacs--unicode--0--patch-74

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-709
   Update from CVS: src/indent.c (Fvertical_motion): Fix last change.

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-710
 - miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-715
   Update from CVS

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

 * miles@gnu.org--gnu-2004/gnus--rel--5.10--patch-74
   Update from CVS

43 files changed, 1628 insertions, 532 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 0d0a33d747e..45a69442444 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,400 @@
+2004-12-07  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * emacs.c (Fdump_emacs): Add ! defined (SYSTEM_MALLOC) around
+        reset_malloc_hooks.
+
+        * keyboard.c (handle_async_input, input_available_signal): Add
+        ! defined (SYSTEM_MALLOC) around thread code.
+
+        * alloc.c: Add comment about the reason for (UN)BLOCK_INPUT_ALLOC.
+
+2004-12-07  Stefan  <monnier@iro.umontreal.ca>
+
+        * eval.c (init_eval_once): Increase max_specpdl_size to 1000.
+
+        * config.in: Regenerate.
+
+2004-12-07  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xmenu.c (Fx_popup_menu): Correct documentation about position.
+        (xmenu_show): Do not call XTranslateCoordinates.  Adjust position
+        if not given by a mouse click to correspond with x-popup-menu
+        documentation.
+
+        * config.in: Regenerate.
+
+        * gtkutil.c: Include signal.h and syssignal.h.
+        (xg_get_file_name): Block and unblock __SIGRTMIN if defined.
+
+        * alloc.c: If HAVE_GTK_AND_PTHREAD, include pthread.h,
+        new variables main_thread and alloc_mutex,
+        define (UN)BLOCK_INPUT_ALLOC to use alloc_mutex to protect
+        emacs_blocked_* calls and only do (UN)BLOCK_INPUT in the main thread.
+        If not HAVE_GTK_AND_PTHREAD, (UN)BLOCK_INPUT_ALLOC is the same as
+        (UN)BLOCK_INPUT.
+        (emacs_blocked_free, emacs_blocked_malloc)
+        (emacs_blocked_realloc): Use (UN)BLOCK_INPUT_ALLOC.
+        (uninterrupt_malloc): Initialize main_thread and alloc_mutex.
+        (reset_malloc_hooks): New function.
+
+        * lisp.h: Declare reset_malloc_hooks.
+
+        * emacs.c (Fdump_emacs): Call reset_malloc_hooks.
+
+        * keyboard.c: Conditionally include pthread.h
+        (handle_async_inpu, input_available_signalt): If not in the main
+        thread, block signal, send signal to main thread and return.
+
+        * gtkutil.c (xg_get_file_with_chooser): Handle local files only.
+        Set current folder in file chooser if default_filename is a
+        directory.
+
+2004-12-05  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * regex.c (GET_UNSIGNED_NUMBER): Signal an error when reaching the end.
+        Remove redundant correctness checks.
+        (regex_compile): Fix up error codes for \{..\} expressions.
+
+2004-12-05  Richard M. Stallman  <rms@gnu.org>
+
+        * regex.c (regex_compile): Fix end-of-pattern case for space.
+
+2004-12-03  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macterm.h (cfstring_create_with_utf8_cstring): Add prototype.
+        * mac.c (cfstring_create_with_utf8_cstring): Add to prevent
+        crashes with invalid characters.
+        * macmenu.c (add_menu_item): Use it.
+        * image.c (image_load_quartz2d): Likewise.
+        * macfns.c (x_set_name, x_set_title): Likewise.
+        (Fx_file_dialog): Likewise.  Use constant CFRefs instead of
+        creating them each time for labels.
+
+2004-12-02  Richard M. Stallman  <rms@gnu.org>
+
+        * config.in (RE_TRANSLATE_P): If make_number is not a macro,
+        don't use it here.
+
+        * eval.c (Fcalled_interactively_p): Don't check INTERACTIVE.
+        (interactive_p): Skip Scalled_interactively_p frames
+        like Sinteractive_p frames.
+
+        * data.c (Fmake_variable_buffer_local): Doc fix.
+        (Fmake_local_variable): Doc fix.
+
+        * insdel.c (insert_from_string_before_markers)
+        (insert_from_string): Don't modify buffer on empty insertion.
+
+        * window.c (Fget_lru_window, Fget_largest_window): Doc fixes.
+
+2004-12-01  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macmenu.c (add_menu_item): Fallback on MacRoman if encoding
+        menu text as UTF8 fails.
+
+2004-12-01  Kim F. Storm  <storm@cua.dk>
+
+        * alloc.c: Add commentary for last change.
+        (XMALLOC_PUT_SIZE, XMALLOC_GET_SIZE): New macros to handle
+        sizeof(size_t) != 4.
+        (overrun_check_malloc, overrun_check_realloc, overrun_check_free):
+        Use them.  Also clear header and trailer of freed memory.
+        (GC_STRING_OVERRUN_COOKIE_SIZE): Rename from GC_STRING_EXTRA.
+        (string_overrun_cookie): Rename from string_overrun_pattern.
+        (GC_STRING_EXTRA): Define from GC_STRING_OVERRUN_COOKIE_SIZE.
+
+2004-12-01  Andreas Schwab  <schwab@suse.de>
+
+        * lisp.h: Declare string_to_multibyte.
+
+2004-12-01  Kenichi Handa  <handa@m17n.org>
+
+        * w32console.c (w32con_write_glyphs): Decide coding here.
+        Adjusted for the change of encode_terminal_code.
+
+        * term.c (encode_terminal_code): Don't make it "static".
+
+2004-11-30  Kenichi Handa  <handa@m17n.org>
+
+        * term.c (encode_terminal_buf, encode_terminal_bufsize): New variables.
+        (encode_terminal_code): Argument changed.  Encode all
+        characters at once, and return a pointer to the result of encoding.
+        (write_glyphs): Decide coding here.  Adjusted for the above change.
+        (insert_glyphs): Likewise.
+        (term_init): Initialize encode_terminal_bufsize to 0.
+
+        * coding.c (Vcode_conversion_workbuf_name): New variable.
+        (syms_of_coding): Initialize and staticpro it.
+        (set_conversion_work_buffer): New function.
+        (run_pre_post_conversion_on_str): Use it.
+        (run_pre_write_conversin_on_c_str): New function.
+
+        * coding.h (run_pre_write_conversin_on_c_str): Extern it.
+
+2004-11-30  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * keyboard.c: Don't undef SIGIO
+        * s/darwin.h (NO_SOCK_SIGIO): Define NO_SOCK_SIGIO on carbon
+        * Makefile.in (mac.o): Depend on blockinput.h and atimer.h.
+        (macfns.o): Don't depend on ccl.h.
+        * macfns.c (mac_frame_parm_handlers): Set handlers for
+        Qleft_fringe and Qright_fringe.
+        * macterm.c (mac_fill_rectangle_to_pixmap)
+        (mac_draw_rectangle_to_pixmap, mac_copy_area_to_pixmap)
+        (mac_copy_area_with_mask_to_pixmap, x_draw_image_foreground_1):
+        Put in #if 0.
+        (mac_scroll_area) [TARGET_API_MAC_CARBON]: Use ScrollWindowRect.
+        (x_flush) [TARGET_API_MAC_CARBON]: Don't traverse frames.
+        (XFlush) [TARGET_API_MAC_CARBON]: Define to an empty replacement.
+        (x_draw_glyph_string_background, x_draw_glyph_string_foreground)
+        [!MAC_OS8]: Added ifdef'd out code for os8.  Don't use
+        XDrawImageString.  Always draw background and foreground separately.
+        (x_draw_image_foreground): Use clipping instead of computing the
+        intersection rectangle.
+        (x_draw_image_glyph_string): Don't draw an image with mask to a
+        pixmap.
+        (x_redisplay_interface): Set flush_display_optional member to 0.
+        (XTread_socket): Correctly reset the TEConverter
+        object.
+
+2004-11-30  Kim F. Storm  <storm@cua.dk>
+
+        * lisp.h: New defines to enable buffer overrun checking.
+        (GC_CHECK_STRING_OVERRUN, GC_CHECK_STRING_FREE_LIST)
+        (XMALLOC_OVERRUN_CHECK, GC_CHECK_CONS_LIST): Add.
+
+        * alloc.c: Add more checks for buffer overruns.
+        (XMALLOC_OVERRUN_CHECK_SIZE, xmalloc_overrun_check_header)
+        xmalloc_overrun_check_trailer, overrun_check_malloc)
+        overrun_check_realloc, overrun_check_free): Add.
+        (GC_STRING_EXTRA, string_overrun_pattern): Add.
+        (check_sblock, allocate_string_data, compact_small_strings):
+        Set and check string_overrun_pattern if GC_CHECK_STRING_OVERRUN.
+        (check_cons_list): Condition on GC_CHECK_CONS_LIST.
+        (check_string_free_list): Add.
+        (allocate_string, sweep_strings): Call check_string_free_list.
+
+        * emacs.c (malloc_initialize_hook): Don't free malloc_state_ptr if
+        XMALLOC_OVERRUN_CHECK to avoid crash during load.
+
+2004-11-29  Kim F. Storm  <storm@cua.dk>
+
+        * fns.c (concat): Use SAFE_ALLOCA.
+
+2004-11-29  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * sysdep.c (emacs_write): Don't use QUIT.
+
+2004-11-29  Kenichi Handa  <handa@m17n.org>
+
+        * buffer.c (init_buffer): Set current_buffer->directory to a
+        multibyte string made by string_to_multibyte.
+
+        * emacs.c (init_cmdargs): Set unibyte strings in Vcommand_line_args.
+
+2004-11-27  Andreas Schwab  <schwab@suse.de>
+
+        * alloc.c (mark_stack): Call GC_MARK_SECONDARY_STACK if defined.
+
+        * s/gnu-linux.h: Enable no-op gcpros on ia64.
+        (GC_MARK_SECONDARY_STACK) [__ia64__]: Define.
+
+        * filelock.c (lock_file_1): Call get_boot_time early.
+        Increase buffer size.
+
+2004-11-27  Eli Zaretskii  <eliz@gnu.org>
+
+        * lisp.h (DECL_ALIGN): Define non-trivially only if NO_DECL_ALIGN
+        is not defined.
+
+2004-11-27  Kim F. Storm  <storm@cua.dk>
+
+        * search.c (syms_of_search) <search-spaces-regexp>: Move 'doc:'
+        marker out of doc string.
+
+2004-11-26  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * s/darwin.h (POSIX_SIGNALS): Undo the removal of 2002-08-25,
+        which was not mentioned in the log.
+
+2004-11-26  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c (update_window_fringes): Prefer truncation bitmaps over
+        angle bitmaps at top/bottom line.
+
+        * xdisp.c: Undo recent changes for restoring saved_face_id. Instead,
+        set it when it->method is set to next_element_from_display_vector.
+        (setup_for_ellipsis): Add LEN argument.  Callers changed.
+        Set it->saved_face_id.
+        (get_next_display_element): Use loop instead of recursion.
+        Set it->saved_face_id.  Combine duplicate code for ctr chars.
+        (next_element_from_display_vector): Do not set it->saved_face_id.
+        (next_element_from_ellipsis): Use setup_for_ellipsis.
+
+2004-11-26  Eli Zaretskii  <eliz@gnu.org>
+
+        * eval.c (Fdefvar): Declare pdl from last change as `volatile' to
+        prevent compiler warnings.
+
+2004-11-25  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * keyboard.c (command_loop_1): Print a message describing the key
+        the user just pressed when this key has no binding.
+
+        * sysdep.c (sys_signal): Don't use SA_RESTART if SYNC_INPUT is set.
+        (emacs_open, emacs_read, emacs_write): Check QUIT when interrupted.
+
+        * lread.c (readchar): Check QUIT when `getc' is interrupted.
+
+2004-11-24  Richard M. Stallman  <rms@gnu.org>
+
+        * coding.c (run_pre_post_conversion_on_str): Bind Qinhibit_read_only.
+
+        * buffer.c (syms_of_buffer) <indicate-buffer-boundaries>: Doc fix.
+
+2004-11-24  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (move_it_in_display_line_to, display_line):
+        Restore saved_face_id also when truncate-lines or hscrolled.
+
+2004-11-23  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * gtkutil.c (xg_get_file_name): Rename use-old-gtk-file-dialog to
+        x-use-old-gtk-file-dialog.
+
+        * xfns.c: Define x_use_old_gtk_file_dialog.
+        (syms_of_xfns): Rename use-old-gtk-file-dialog to x-...  Move it
+        outside ifdef USE_GTK.
+
+2004-11-23  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * coding.h (ENCODE_FILE, DECODE_FILE, ENCODE_SYSTEM, DECODE_SYSTEM):
+        Don't use XFASTINT blindly.
+
+        * config.in (RE_TRANSLATE_P): Don't use XFASTINT blindly.
+
+        * indent.c (skip_invisible): Avoid non-idempotent side-effects
+        in macro arguments.
+
+        * keymap.c (Flookup_key): Check INTEGERP before XINT.
+
+        * lread.c (oblookup): Don't use XFASTINT blindly.
+
+        * window.c (Fset_window_scroll_bars): Don't use XINT if it isn't int.
+        (decode_next_window_args, window_loop): Don't use XFASTINT blindly.
+
+2004-11-23  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P)
+        (MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P): Not if dpvec_index is zero.
+
+        * xfaces.c (lookup_named_face): Add signal_p arg.  Return -1 if
+        signal_p is zero and face name is unknown.
+        (Fx_list_fonts): Don't signal error in lookup_named_face.
+        (Fface_font): Signal error in lookup_named_face.
+        (ascii_face_of_lisp_face): Likewise.
+
+        * dispextern.h (lookup_named_face): Fix prototype.
+
+        * xdisp.c (handle_single_display_prop): Don't signal error in
+        lookup_named_face for unknown fringe face name.
+        (highlight_trailing_whitespace): Don't signal error in
+        lookup_named_face if trailing-whitespace face unknown.
+        (calc_line_height_property): Don't signal error in
+        lookup_named_face if specified face name is unknown.
+
+        * fringe.c (update_window_fringes): Show top row indicator if
+        window has header-line.  Don't show arrow at bob and eob
+        if the boundary indicators are not used.
+        (Fset_fringe_bitmap_face): Signal error in lookup_named_face.
+
+        * window.c (set_window_buffer): Clear display_error_modiff.
+
+2004-11-22  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c (update_window_fringes): Provide sensible fall-back
+        value for non-nil indicate-buffer-boundaries setting.
+
+2004-11-22  Markus Rost  <rost@ias.edu>
+
+        * minibuf.c (Fminibuffer_complete_and_exit): Fix previous change.
+
+2004-11-22  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * eval.c (Fdefvar): Warn when var is let-bound but globally void.
+
+2004-11-21  Kim F. Storm  <storm@cua.dk>
+
+        * xdisp.c (erase_phys_cursor): Clear hollow cursor inside TEXT_AREA.
+
+        * xterm.c (x_clip_to_row): Add area arg.  Callers changed.
+        (x_draw_hollow_cursor, x_draw_bar_cursor): Clip to TEXT_AREA.
+
+        * w32term.c (w32_clip_to_row): Add area arg.  Callers changed.
+        (x_draw_hollow_cursor, x_draw_bar_cursor): Clip to TEXT_AREA.
+
+        * macterm.c (x_clip_to_row): Add area arg.  Callers changed.
+        (x_draw_hollow_cursor, x_draw_bar_cursor): Clip to TEXT_AREA.
+
+        * xdisp.c (move_it_in_display_line_to, display_line):
+        Restore saved_face_id if overflow-newline-into-fringe is enabled and
+        line is continued before or in middle of element from display vector.
+
+        * indent.c (Fvertical_motion): Fix last change.  Use another
+        method to detect if iterator moved too far ahead after reseat.
+
+        * xdisp.c (IT_EXPAND_MATRIX_WIDTH): New macro.  Do not
+        expand matrix width for overflow in zero-width area.
+        (append_glyph, append_composite_glyph, produce_image_glyph)
+        (append_stretch_glyph): Use it to avoid loop in redisplay.
+        (note_mode_line_or_margin_highlight): Don't let help-echo from
+        string override help-echo from image map.
+
+2004-11-20  Luc Teirlinck  <teirllm@auburn.edu>
+
+        * fns.c (Fyes_or_no_p): Call Fread_from_minibuffer with extra argument.
+        * callint.c (Fcall_interactively): Ditto.
+
+2004-11-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * minibuf.c (Fminibuffer_complete_and_exit):
+        Fixup the case of the completed value, for case-indep completion.
+
+2004-11-20  Richard M. Stallman  <rms@gnu.org>
+
+        * lisp.h (Fread_from_minibuffer): Add arg in decl.
+
+        * minibuf.c (read_minibuf): New arg KEEP_ALL.  Callers changed.
+        (Fread_from_minibuffer): New arg KEEP_ALL.  Callers changed.
+
+        * search.c (Vsearch_spaces_regexp):
+        Rename from Vsearch_whitespace_regexp.  All uses changed.
+
+2004-11-20  Thien-Thi Nguyen  <ttn@gnu.org>
+
+        * eval.c (init_eval_once): Increase `max_specpdl_size' to 650.
+
+2004-11-19  Richard M. Stallman  <rms@gnu.org>
+
+        * search.c (Vsearch_whitespace_regexp): New variable.
+        (syms_of_search): Defvar it.
+        (compile_pattern_1): Call re_set_whitespace_regexp with it.
+        (search_buffer): No regexp is trivial if Vsearch_whitespace_regexp
+        is non-nil.
+        (struct regexp_cache): New element whitespace_regexp.
+        (syms_of_search): Initialize whitespace_regexp elements.
+        (compile_pattern): Compare whitespace_regexp elements.
+        (compile_pattern_1): Set whitespace_regexp elements.
+
+        * regex.c (regex_compile): Substitute whitespace_regexp
+        for spaces, if it is nonzero.
+        (whitespace_regexp): New variable.
+        (re_set_whitespace_regexp): New function.
+
+2004-11-19  Kim F. Storm  <storm@cua.dk>
+
+        * indent.c (Fvertical_motion): Fix last change.
+
 2004-11-18  Kim F. Storm  <storm@cua.dk>
 
         * indent.c (Fvertical_motion): Undo 2004-11-16 change.
@@ -13,8 +410,7 @@
 
 2004-11-16  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
-        * gtkutil.c (xg_get_file_name): Fix typo in
-        HAVE_GTK_FILE_SELECTION_NEW.
+        * gtkutil.c (xg_get_file_name): Typo in HAVE_GTK_FILE_SELECTION_NEW.
 
         * xmenu.c (x_menu_in_use): Remove.
         (x_menu_set_in_use): Also set popup_activated_flag.
@@ -6262,7 +6658,7 @@
 
 2003-06-01  David Ponce  <david@dponce.com>
 
-        * termhooks.h (enum event_kind): Added new WHEEL_EVENT event.
+        * termhooks.h (enum event_kind): Add new WHEEL_EVENT event.
         Declare MOUSE_WHEEL_EVENT only if MAC_OSX defined.
 
         * keyboard.c (Qmouse_wheel): Declare only if MAC_OSX defined.
@@ -6270,8 +6666,7 @@
         (discard_mouse_events): Discard WHEEL_EVENT events too.
         (lispy_wheel_names, wheel_syms): New.
         (syms_of_keyboard): Init and staticpro `wheel_syms'.  Init and
-        staticpro `Qmouse_wheel' and `mouse_wheel_syms' only if MAC_OSX
-        defined.
+        staticpro `Qmouse_wheel' and `mouse_wheel_syms' only if MAC_OSX defined.
         (make_lispy_event): Add WHEEL_EVENT handler.
 
         * w32term.c (construct_mouse_wheel): Construct WHEEL_EVENT.
@@ -6313,8 +6708,7 @@
 
         * ccl.h (struct ccl_program) <eight_bit_control>: Comment fixed.
 
-        * ccl.c (CCL_WRITE_CHAR): Increment extra_bytes only when it is
-        nonzero.
+        * ccl.c (CCL_WRITE_CHAR): Increment extra_bytes only when it is nonzero.
         (ccl_driver): Initialize extra_bytes to ccl->eight_bit_control.
         (setup_ccl_program): Initialize ccl->eight_bit_control to zero.
 
@@ -6330,19 +6724,18 @@
 
 2003-05-28  Kenichi Handa  <handa@m17n.org>
 
-        * coding.c (ENCODE_UNSAFE_CHARACTER): Adjusted for the name change
+        * coding.c (ENCODE_UNSAFE_CHARACTER): Adjust for the name change
         of CODING_REPLACEMENT_CHARACTER.
         (decode_coding_iso2022): If CODING_FLAG_ISO_SAFE, set
         CODING_MODE_INHIBIT_UNENCODABLE_CHAR flag in coding->mode, and
         check this flag on encoding.
-        (encode_coding_sjis_big5): Check
-        CODING_MODE_INHIBIT_UNENCODABLE_CHAR flag of coding->mode.
-        (Fset_terminal_coding_system_internal): Set
-        CODING_MODE_INHIBIT_UNENCODABLE_CHAR flag in terminal_coding.mode
-        instead of setting CODING_FLAG_ISO_SAFE flag in
-        terminal_coding.flags.
-
-        * coding.h (CODING_REPLACEMENT_CHARACTER): Renamed from
+        (encode_coding_sjis_big5):
+        Check CODING_MODE_INHIBIT_UNENCODABLE_CHAR flag of coding->mode.
+        (Fset_terminal_coding_system_internal):
+        Set CODING_MODE_INHIBIT_UNENCODABLE_CHAR flag in terminal_coding.mode
+        instead of setting CODING_FLAG_ISO_SAFE flag in terminal_coding.flags.
+
+        * coding.h (CODING_REPLACEMENT_CHARACTER): Rename from
         CODING_INHIBIT_CHARACTER_SUBSTITUTION.
         (CODING_MODE_INHIBIT_UNENCODABLE_CHAR): New macro.
 
@@ -6484,65 +6877,65 @@
         (struct frame): New member scroll_bar_actual_width which
         consolidates and renames the vertical_scroll_bar_extra member of
         x_output, w32_output, and mac_output structures.  All uses changed.
-        (FRAME_PIXEL_HEIGHT): Renamed from PIXEL_HEIGHT and moved
+        (FRAME_PIXEL_HEIGHT): Rename from PIXEL_HEIGHT and moved
         from x/w32/macterm.h files.  All uses changed.  Also change code
         which referred to f->output_data...->pixel_height.
-        (FRAME_PIXEL_WIDTH): Renamed from PIXEL_WIDTH and moved
+        (FRAME_PIXEL_WIDTH): Rename from PIXEL_WIDTH and moved
         from x/w32/macterm.h files.  All uses changed.  Also change code
         which referred to f->output_data...->pixel_width.
-        (FRAME_LINES): Renamed from FRAME_HEIGHT.  All uses changed.
+        (FRAME_LINES): Rename from FRAME_HEIGHT.  All uses changed.
         Also change code which referred to f->height.
-        (FRAME_COLS): Renamed from FRAME_WIDTH.  All uses changed.
+        (FRAME_COLS): Rename from FRAME_WIDTH.  All uses changed.
         Also change code which referred to f->width.
         (FRAME_NEW_HEIGHT, FRAME_NEW_WIDTH): Remove macros; change uses
         to update new_text_lines and new_text_cols members directly.
-        (FRAME_CONFIG_SCROLL_BAR_WIDTH): Renamed from
+        (FRAME_CONFIG_SCROLL_BAR_WIDTH): Rename from
         FRAME_SCROLL_BAR_PIXEL_WIDTH.  All uses changed.
-        (FRAME_CONFIG_SCROLL_BAR_COLS): Renamed from
+        (FRAME_CONFIG_SCROLL_BAR_COLS): Rename from
         FRAME_SCROLL_BAR_COLS.  All uses changed.
         (FRAME_LEFT_SCROLL_BAR_COLS, FRAME_RIGHT_SCROLL_BAR_COLS):
-        Renamed from FRAME_LEFT_SCROLL_BAR_WIDTH and
+        Rename from FRAME_LEFT_SCROLL_BAR_WIDTH and
         FRAME_RIGHT_SCROLL_BAR_WIDTH, resp.  All uses changed.
         (FRAME_SCROLL_BAR_AREA_WIDTH, FRAME_LEFT_SCROLL_BAR_AREA_WIDTH)
         (FRAME_RIGHT_SCROLL_BAR_AREA_WIDTH): New macros.
-        (FRAME_TOTAL_COLS): Renamed from FRAME_WINDOW_WIDTH.
-        (SET_FRAME_COLS): Renamed from SET_FRAME_WIDTH.
-        (FRAME_TOTAL_COLS_ARG): Renamed from FRAME_WINDOW_WIDTH_ARG.
+        (FRAME_TOTAL_COLS): Rename from FRAME_WINDOW_WIDTH.
+        (SET_FRAME_COLS): Rename from SET_FRAME_WIDTH.
+        (FRAME_TOTAL_COLS_ARG): Rename from FRAME_WINDOW_WIDTH_ARG.
         (WINDOW_VERTICAL_SCROLL_BAR_COLUMN): Remove unused macro.
         (WINDOW_VERTICAL_SCROLL_BAR_HEIGHT): Remove unused macro.
-        (FRAME_LINE_HEIGHT): Renamed from CANON_Y_UNIT.  Unconditionally
-        return line_height member (it now has proper value also for
-        non-window frames).
-        (FRAME_COLUMN_WIDTH): Renamed from CANON_X_UNIT.  Unconditionally
+        (FRAME_LINE_HEIGHT): Rename from CANON_Y_UNIT.
+        Unconditionally return line_height member (it now has proper value
+        also for non-window frames).
+        (FRAME_COLUMN_WIDTH): Rename from CANON_X_UNIT.  Unconditionally
         return new column_width member (rather than the default font width).
         (FRAME_FRINGE_COLS, FRAME_LEFT_FRINGE_WIDTH)
-        (FRAME_RIGHT_FRINGE_WIDTH): Renamed from FRAME_X_... and moved
+        (FRAME_RIGHT_FRINGE_WIDTH): Rename from FRAME_X_... and moved
         from x/w32/macterm.h files.  Unconditionally return corresponding
         member of frame structure (they now have proper values also for
         non-window frames).
-        (FRAME_TOTAL_FRINGE_WIDTH): Renamed from FRAME_FRINGE_WIDTH.
+        (FRAME_TOTAL_FRINGE_WIDTH): Rename from FRAME_FRINGE_WIDTH.
         Calculate return value from left and right widths.
         (FRAME_INTERNAL_BORDER_WIDTH): Unconditionally return
         internal_border_width member (has proper value for non-window frame).
-        (FRAME_PIXEL_X_FROM_CANON_X): Renamed from PIXEL_X_FROM_CANON_X.
-        (FRAME_PIXEL_Y_FROM_CANON_Y): Renamed from PIXEL_Y_FROM_CANON_Y.
-        (FRAME_CANON_X_FROM_PIXEL_X): Renamed from CANON_X_FROM_PIXEL_X.
-        (FRAME_CANON_Y_FROM_PIXEL_Y): Renamed from CANON_Y_FROM_PIXEL_Y.
-        (FRAME_LINE_TO_PIXEL_Y): Renamed from CHAR_TO_PIXEL_ROW,
+        (FRAME_PIXEL_X_FROM_CANON_X): Rename from PIXEL_X_FROM_CANON_X.
+        (FRAME_PIXEL_Y_FROM_CANON_Y): Rename from PIXEL_Y_FROM_CANON_Y.
+        (FRAME_CANON_X_FROM_PIXEL_X): Rename from CANON_X_FROM_PIXEL_X.
+        (FRAME_CANON_Y_FROM_PIXEL_Y): Rename from CANON_Y_FROM_PIXEL_Y.
+        (FRAME_LINE_TO_PIXEL_Y): Rename from CHAR_TO_PIXEL_ROW,
         consolidated from xterm.h, macterm.h, and w32term.h.
-        (FRAME_COL_TO_PIXEL_X): Renamed from CHAR_TO_PIXEL_COL,
+        (FRAME_COL_TO_PIXEL_X): Rename from CHAR_TO_PIXEL_COL,
         consolidated from xterm.h, macterm.h, and w32term.h.
-        (FRAME_TEXT_COLS_TO_PIXEL_WIDTH): Renamed from
+        (FRAME_TEXT_COLS_TO_PIXEL_WIDTH): Rename from
         CHAR_TO_PIXEL_WIDTH consolidated from x/mac/w32term.h.
-        (FRAME_TEXT_LINES_TO_PIXEL_HEIGHT): Renamed from
+        (FRAME_TEXT_LINES_TO_PIXEL_HEIGHT): Rename from
         CHAR_TO_PIXEL_HEIGHT consolidated from x/mac/w32term.h.
-        (FRAME_PIXEL_Y_TO_LINE): Renamed from PIXEL_TO_CHAR_ROW
+        (FRAME_PIXEL_Y_TO_LINE): Rename from PIXEL_TO_CHAR_ROW
         consolidated from x/mac/w32term.h.
-        (FRAME_PIXEL_X_TO_COL): Renamed from PIXEL_TO_CHAR_COL
+        (FRAME_PIXEL_X_TO_COL): Rename from PIXEL_TO_CHAR_COL
         consolidated from x/mac/w32term.h.
-        (FRAME_PIXEL_WIDTH_TO_TEXT_COLS): Renamed from
+        (FRAME_PIXEL_WIDTH_TO_TEXT_COLS): Rename from
         PIXEL_TO_CHAR_WIDTH consolidated from x/mac/w32term.h.
-        (FRAME_PIXEL_HEIGHT_TO_TEXT_LINES): Renamed from
+        (FRAME_PIXEL_HEIGHT_TO_TEXT_LINES): Rename from
         PIXEL_TO_CHAR_HEIGHT consolidated from x/mac/w32term.h.
 
         * window.h (struct window): Rename members left to left_col,
@@ -6564,7 +6957,7 @@
         referred to XINT (w->height) * canon_y_unit.
         (WINDOW_LEFT_EDGE_COL): New macro.  Change relevant code that
         referred to XINT (w->left).
-        (WINDOW_RIGHT_EDGE_COL): Renamed from WINDOW_RIGHT_EDGE.  Change
+        (WINDOW_RIGHT_EDGE_COL): Rename from WINDOW_RIGHT_EDGE.  Change
         all uses and code that referred to XINT (w->left) + XINT (w->width).
         (WINDOW_TOP_EDGE_LINE): New macro.  Change relevant code that
         referred to XINT (w->top).
@@ -6579,14 +6972,14 @@
         (WINDOW_BOTTOM_EDGE_Y): New macro.  Change relevant code that
         referred to (XINT (w->top) + XINT (w->height)) * canon_y_unit.
         (WINDOW_LEFTMOST_P): New macro.
-        (WINDOW_BOX_LEFT_EDGE_COL): Renamed from WINDOW_LEFT_MARGIN.
+        (WINDOW_BOX_LEFT_EDGE_COL): Rename from WINDOW_LEFT_MARGIN.
         All uses changed.
-        (WINDOW_BOX_RIGHT_EDGE_COL): Renamed from WINDOW_RIGHT_MARGIN.
+        (WINDOW_BOX_RIGHT_EDGE_COL): Rename from WINDOW_RIGHT_MARGIN.
         All uses changed.
-        (WINDOW_BOX_LEFT_EDGE_X): Renamed from
+        (WINDOW_BOX_LEFT_EDGE_X): Rename from
         WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X, moved from dispextern.h.
         Do not exclude left fringe width.
-        (WINDOW_BOX_RIGHT_EDGE_X): Renamed from
+        (WINDOW_BOX_RIGHT_EDGE_X): Rename from
         WINDOW_DISPLAY_RIGHT_EDGE_PIXEL_X, moved from dispextern.h.
         Do not exclude fringe widths.
         (WINDOW_LEFT_FRINGE_WIDTH, WINDOW_RIGHT_FRINGE_WIDTH)
@@ -6613,18 +7006,18 @@
         FRAME_SCROLL_BAR_WIDTH.
         (WINDOW_SCROLL_BAR_COLS, WINDOW_SCROLL_BAR_AREA_WIDTH)
         (WINDOW_SCROLL_BAR_AREA_X): New macros.
-        (WINDOW_HEADER_LINE_HEIGHT): Renamed from
+        (WINDOW_HEADER_LINE_HEIGHT): Rename from
         WINDOW_DISPLAY_HEADER_LINE_HEIGHT, moved from dispextern.h.
-        (WINDOW_BOX_HEIGHT_NO_MODE_LINE): Renamed from
+        (WINDOW_BOX_HEIGHT_NO_MODE_LINE): Rename from
         WINDOW_DISPLAY_HEIGHT_NO_MODE_LINE, moved from dispextern.h.
-        (WINDOW_BOX_TEXT_HEIGHT): Renamed from
+        (WINDOW_BOX_TEXT_HEIGHT): Rename from
         WINDOW_DISPLAY_PIXEL_WIDTH, moved from dispextern.h.
         (WINDOW_TO_FRAME_PIXEL_X, WINDOW_TO_FRAME_PIXEL_Y)
         (FRAME_TO_WINDOW_PIXEL_X, FRAME_TO_WINDOW_PIXEL_Y)
-        (WINDOW_TEXT_TO_FRAME_PIXEL_X): Moved here from dispextern.h.
-        (WINDOW_LEFT_MARGIN_WIDTH): Renamed from
+        (WINDOW_TEXT_TO_FRAME_PIXEL_X): Move here from dispextern.h.
+        (WINDOW_LEFT_MARGIN_WIDTH): Rename from
         WINDOW_DISPLAY_LEFT_AREA_PIXEL_WIDTH, moved from dispextern.h.
-        (WINDOW_RIGHT_MARGIN_WIDTH): Renamed from
+        (WINDOW_RIGHT_MARGIN_WIDTH): Rename from
         WINDOW_DISPLAY_RIGHT_AREA_PIXEL_WIDTH, moved from dispextern.h.
         (window_from_coordinates): Update prototype.
         (Fset_window_buffer): Update EXFUN.
@@ -6718,7 +7111,7 @@
         left_margin_cols, right_margin_cols, left_fringe_width,
         right_fringe_width, fringes_outside_margins, scroll_bar_width,
         and vertical_scroll_bar_type.
-        (coordinates_in_window): Adapted to new fringe/margin positions
+        (coordinates_in_window): Adapt to new fringe/margin positions
         and per-window fringes and scroll-bars.
         Fix bug related to incorrectly adjusting coordinates by
         frame's internal_border_width (the effect normally negible since
@@ -6753,7 +7146,7 @@
         narrow.  This fixes a bug which could cause Emacs to trap if the
         width of the split window was less than the width of the display
         margins.
-        (window_box_text_cols): Renamed from window_internal_width.
+        (window_box_text_cols): Rename from window_internal_width.
         All uses changed.  Adapt to per-window fringes and scroll bars.
         Fix bug that caused vertical separator to be subtracted also on
         window frames.  Fix another bug that did not reduce the returned
@@ -6785,8 +7178,7 @@
         the width of the window.
         (Fset_window_fringes): New defun to allow user to specifically set
         this window's fringe widths and position vs. display margins.
-        (Fwindow_fringes): New defun to return window's actual fringe
-        settings.
+        (Fwindow_fringes): New defun to return window's actual fringe settings.
         (Fset_window_scroll_bars): New defun to allow user to specifically
         set this window's scroll bar width and position.
         (Fwindow_scroll_bars): New defun to return window's actual scroll
@@ -6853,17 +7245,16 @@
         (FRAME_DEFAULT_FONT_WIDTH): Remove macro.
         (PIXEL_WIDTH, PIXEL_HEIGHT)
         (FRAME_X_FRINGE_COLS, FRAME_X_FRINGE_WIDTH)
-        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Moved to
+        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Move to
         frame.h and renamed [see frame.h changes].
         (CHAR_TO_PIXEL_ROW, CHAR_TO_PIXEL_COL, CHAR_TO_PIXEL_WIDTH)
         (CHAR_TO_PIXEL_HEIGHT, PIXEL_TO_CHAR_ROW, PIXEL_TO_CHAR_COL)
-        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Moved to frame.h
+        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Move to frame.h
         and renamed [see frame.h changes].
 
         * xterm.c: Make (several) trivial substitutions for renamed and
         new macros in dispextern.h, frame.h and window.h.
-        (x_draw_glyph_string_box): Adapt to per-window fringes and
-        scroll-bars.
+        (x_draw_glyph_string_box): Adapt to per-window fringes and scroll-bars.
         (scroll_run): Adapt to new fringe position.
         (glyph_rect): Use window coordinates returned from
         window_from_coordinates rather than frame_to_window_pixel_xy.
@@ -6887,17 +7278,16 @@
         (FRAME_DEFAULT_FONT_WIDTH): Remove macro.
         (PIXEL_WIDTH, PIXEL_HEIGHT)
         (FRAME_X_FRINGE_COLS, FRAME_X_FRINGE_WIDTH)
-        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Moved to
+        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Move to
         frame.h and renamed [see frame.h changes].
         (CHAR_TO_PIXEL_ROW, CHAR_TO_PIXEL_COL, CHAR_TO_PIXEL_WIDTH)
         (CHAR_TO_PIXEL_HEIGHT, PIXEL_TO_CHAR_ROW, PIXEL_TO_CHAR_COL)
-        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Moved to frame.h
+        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Move to frame.h
         and renamed [see frame.h changes].
 
         * w32term.c: Make (several) trivial substitutions for renamed and
         new macros in dispextern.h, frame.h and window.h.
-        (x_draw_glyph_string_box): Adapt to per-window fringes and
-        scroll-bars.
+        (x_draw_glyph_string_box): Adapt to per-window fringes and scroll-bars.
         (glyph_rect): Use window coordinates returned from
         window_from_coordinates rather than frame_to_window_pixel_xy.
         (XTset_vertical_scroll_bar): Adapt to per-window fringes and
@@ -6928,17 +7318,16 @@
         (FRAME_DEFAULT_FONT_WIDTH): Remove macro.
         (PIXEL_WIDTH, PIXEL_HEIGHT)
         (FRAME_X_FRINGE_COLS, FRAME_X_FRINGE_WIDTH)
-        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Moved to
+        (FRAME_X_LEFT_FRINGE_WIDTH, FRAME_X_RIGHT_FRINGE_WIDTH): Move to
         frame.h and renamed [see frame.h changes].
         (CHAR_TO_PIXEL_ROW, CHAR_TO_PIXEL_COL, CHAR_TO_PIXEL_WIDTH)
         (CHAR_TO_PIXEL_HEIGHT, PIXEL_TO_CHAR_ROW, PIXEL_TO_CHAR_COL)
-        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Moved to frame.h
+        (PIXEL_TO_CHAR_WIDTH, PIXEL_TO_CHAR_HEIGHT): Move to frame.h
         and renamed [see frame.h changes].
 
         * macterm.c: Make (several) trivial substitutions for renamed and
         new macros in dispextern.h, frame.h and window.h.
-        (x_draw_glyph_string_box): Adapt to per-window fringes and
-        scroll-bars.
+        (x_draw_glyph_string_box): Adapt to per-window fringes and scroll-bars.
         (glyph_rect): Use window coordinates returned from
         window_from_coordinates rather than frame_to_window_pixel_xy.
         (XTset_vertical_scroll_bar): Adapt to per-window fringes and
diff --git a/src/Makefile.in b/src/Makefile.in
index 40d7e2df53c..8423a630937 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -1220,10 +1220,10 @@ abbrev.o buffer.o callint.o cmds.o dispnew.o editfns.o fileio.o frame.o \
   fontset.o indent.o insdel.o keyboard.o macros.o minibuf.o msdos.o process.o \
   scroll.o sysdep.o term.o widget.o window.o xdisp.o xfaces.o xfns.o xmenu.o \
   xterm.o xselect.o sound.o: macgui.h
-mac.o: mac.c process.h sysselect.h systime.h $(config_h)
+mac.o: mac.c process.h sysselect.h blockinput.h atimer.h systime.h $(config_h)
 macfns.o: macfns.c charset.h macterm.h macgui.h frame.h window.h buffer.h \
   dispextern.h macgui.h fontset.h $(INTERVAL_SRC) keyboard.h blockinput.h \
-  atimer.h systime.h epaths.h termhooks.h coding.h ccl.h systime.h $(config_h)
+  atimer.h systime.h epaths.h termhooks.h coding.h systime.h $(config_h)
 macmenu.o: macmenu.c termhooks.h frame.h window.h dispextern.h macgui.h \
   keyboard.h blockinput.h atimer.h systime.h buffer.h macterm.h $(config_h)
 macterm.o: blockinput.h atimer.h systime.h syssignal.h macterm.h macgui.h \
diff --git a/src/alloc.c b/src/alloc.c
index e783ba581e0..2a539920f22 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -31,6 +31,10 @@ Boston, MA 02111-1307, USA.  */
 
 #include <signal.h>
 
+#ifdef HAVE_GTK_AND_PTHREAD
+#include <pthread.h>
+#endif
+
 /* This file is part of the core Lisp implementation, and thus must
    deal with the real data structures.  If the Lisp implementation is
    replaced, this file likely will not be used.  */
@@ -85,6 +89,52 @@ extern __malloc_size_t __malloc_extra_blocks;
 
 #endif /* not DOUG_LEA_MALLOC */
 
+#if ! defined (SYSTEM_MALLOC) && defined (HAVE_GTK_AND_PTHREAD)
+
+/* When GTK uses the file chooser dialog, different backends can be loaded
+   dynamically.  One such a backend is the Gnome VFS backend that gets loaded
+   if you run Gnome.  That backend creates several threads and also allocates
+   memory with malloc.
+
+   If Emacs sets malloc hooks (! SYSTEM_MALLOC) and the emacs_blocked_*
+   functions below are called from malloc, there is a chance that one
+   of these threads preempts the Emacs main thread and the hook variables
+   end up in a inconsistent state.  So we have a mutex to prevent that (note
+   that the backend handles concurrent access to malloc within its own threads
+   but Emacs code running in the main thread is not included in that control).
+
+   When UNBLOCK_INPUT is called, revoke_input_signal may be called.  If this
+   happens in one of the backend threads we will have two threads that tries
+   to run Emacs code at once, and the code is not prepared for that.
+   To prevent that, we only call BLOCK/UNBLOCK from the main thread.  */
+
+static pthread_mutex_t alloc_mutex;
+pthread_t main_thread;
+
+#define BLOCK_INPUT_ALLOC                       \
+  do                                            \
+    {                                           \
+      pthread_mutex_lock (&alloc_mutex);        \
+      if (pthread_self () == main_thread)       \
+        BLOCK_INPUT;                            \
+    }                                           \
+  while (0)
+#define UNBLOCK_INPUT_ALLOC                     \
+  do                                            \
+    {                                           \
+      if (pthread_self () == main_thread)       \
+        UNBLOCK_INPUT;                          \
+      pthread_mutex_unlock (&alloc_mutex);      \
+    }                                           \
+  while (0)
+
+#else /* SYSTEM_MALLOC || not HAVE_GTK_AND_PTHREAD */
+
+#define BLOCK_INPUT_ALLOC BLOCK_INPUT
+#define UNBLOCK_INPUT_ALLOC UNBLOCK_INPUT
+
+#endif /* SYSTEM_MALLOC || not HAVE_GTK_AND_PTHREAD */
+
 /* Value of _bytes_used, when spare_memory was freed.  */
 
 static __malloc_size_t bytes_used_when_full;
@@ -516,6 +566,140 @@ buffer_memory_full ()
 }
 
 
+#ifdef XMALLOC_OVERRUN_CHECK
+
+/* Check for overrun in malloc'ed buffers by wrapping a 16 byte header
+   and a 16 byte trailer around each block.
+
+   The header consists of 12 fixed bytes + a 4 byte integer contaning the
+   original block size, while the trailer consists of 16 fixed bytes.
+
+   The header is used to detect whether this block has been allocated
+   through these functions -- as it seems that some low-level libc
+   functions may bypass the malloc hooks.
+*/
+
+
+#define XMALLOC_OVERRUN_CHECK_SIZE 16
+
+static char xmalloc_overrun_check_header[XMALLOC_OVERRUN_CHECK_SIZE-4] =
+  { 0x9a, 0x9b, 0xae, 0xaf,
+    0xbf, 0xbe, 0xce, 0xcf,
+    0xea, 0xeb, 0xec, 0xed };
+
+static char xmalloc_overrun_check_trailer[XMALLOC_OVERRUN_CHECK_SIZE] =
+  { 0xaa, 0xab, 0xac, 0xad,
+    0xba, 0xbb, 0xbc, 0xbd,
+    0xca, 0xcb, 0xcc, 0xcd,
+    0xda, 0xdb, 0xdc, 0xdd };
+
+/* Macros to insert and extract the block size in the header.  */
+
+#define XMALLOC_PUT_SIZE(ptr, size)     \
+  (ptr[-1] = (size & 0xff),             \
+   ptr[-2] = ((size >> 8) & 0xff),      \
+   ptr[-3] = ((size >> 16) & 0xff),     \
+   ptr[-4] = ((size >> 24) & 0xff))
+
+#define XMALLOC_GET_SIZE(ptr)                   \
+  (size_t)((unsigned)(ptr[-1])          |       \
+           ((unsigned)(ptr[-2]) << 8)   |       \
+           ((unsigned)(ptr[-3]) << 16)  |       \
+           ((unsigned)(ptr[-4]) << 24))
+
+
+/* Like malloc, but wraps allocated block with header and trailer.  */
+
+POINTER_TYPE *
+overrun_check_malloc (size)
+     size_t size;
+{
+  register unsigned char *val;
+
+  val = (unsigned char *) malloc (size + XMALLOC_OVERRUN_CHECK_SIZE*2);
+  if (val)
+    {
+      bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
+      val += XMALLOC_OVERRUN_CHECK_SIZE;
+      XMALLOC_PUT_SIZE(val, size);
+      bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
+    }
+  return (POINTER_TYPE *)val;
+}
+
+
+/* Like realloc, but checks old block for overrun, and wraps new block
+   with header and trailer.  */
+
+POINTER_TYPE *
+overrun_check_realloc (block, size)
+     POINTER_TYPE *block;
+     size_t size;
+{
+  register unsigned char *val = (unsigned char *)block;
+
+  if (val
+      && bcmp (xmalloc_overrun_check_header,
+               val - XMALLOC_OVERRUN_CHECK_SIZE,
+               XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
+    {
+      size_t osize = XMALLOC_GET_SIZE (val);
+      if (bcmp (xmalloc_overrun_check_trailer,
+                val + osize,
+                XMALLOC_OVERRUN_CHECK_SIZE))
+        abort ();
+      bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
+      val -= XMALLOC_OVERRUN_CHECK_SIZE;
+      bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+    }
+
+  val = (unsigned char *) realloc ((POINTER_TYPE *)val, size + XMALLOC_OVERRUN_CHECK_SIZE*2);
+
+  if (val)
+    {
+      bcopy (xmalloc_overrun_check_header, val, XMALLOC_OVERRUN_CHECK_SIZE - 4);
+      val += XMALLOC_OVERRUN_CHECK_SIZE;
+      XMALLOC_PUT_SIZE(val, size);
+      bcopy (xmalloc_overrun_check_trailer, val + size, XMALLOC_OVERRUN_CHECK_SIZE);
+    }
+  return (POINTER_TYPE *)val;
+}
+
+/* Like free, but checks block for overrun.  */
+
+void
+overrun_check_free (block)
+     POINTER_TYPE *block;
+{
+  unsigned char *val = (unsigned char *)block;
+
+  if (val
+      && bcmp (xmalloc_overrun_check_header,
+               val - XMALLOC_OVERRUN_CHECK_SIZE,
+               XMALLOC_OVERRUN_CHECK_SIZE - 4) == 0)
+    {
+      size_t osize = XMALLOC_GET_SIZE (val);
+      if (bcmp (xmalloc_overrun_check_trailer,
+                val + osize,
+                XMALLOC_OVERRUN_CHECK_SIZE))
+        abort ();
+      bzero (val + osize, XMALLOC_OVERRUN_CHECK_SIZE);
+      val -= XMALLOC_OVERRUN_CHECK_SIZE;
+      bzero (val, XMALLOC_OVERRUN_CHECK_SIZE);
+    }
+
+  free (val);
+}
+
+#undef malloc
+#undef realloc
+#undef free
+#define malloc overrun_check_malloc
+#define realloc overrun_check_realloc
+#define free overrun_check_free
+#endif
+
+
 /* Like malloc but check for no memory and block interrupt input..  */
 
 POINTER_TYPE *
@@ -602,7 +786,9 @@ safe_alloca_unwind (arg)
    number of bytes to allocate, TYPE describes the intended use of the
    allcated memory block (for strings, for conses, ...).  */
 
+#ifndef USE_LSB_TAG
 static void *lisp_malloc_loser;
+#endif
 
 static POINTER_TYPE *
 lisp_malloc (nbytes, type)
@@ -932,7 +1118,7 @@ static void
 emacs_blocked_free (ptr)
      void *ptr;
 {
-  BLOCK_INPUT;
+  BLOCK_INPUT_ALLOC;
 
 #ifdef GC_MALLOC_CHECK
   if (ptr)
@@ -970,7 +1156,7 @@ emacs_blocked_free (ptr)
     spare_memory = (char *) malloc ((size_t) SPARE_MEMORY);
 
   __free_hook = emacs_blocked_free;
-  UNBLOCK_INPUT;
+  UNBLOCK_INPUT_ALLOC;
 }
 
 
@@ -996,7 +1182,7 @@ emacs_blocked_malloc (size)
 {
   void *value;
 
-  BLOCK_INPUT;
+  BLOCK_INPUT_ALLOC;
   __malloc_hook = old_malloc_hook;
 #ifdef DOUG_LEA_MALLOC
     mallopt (M_TOP_PAD, malloc_hysteresis * 4096);
@@ -1028,7 +1214,7 @@ emacs_blocked_malloc (size)
 #endif /* GC_MALLOC_CHECK */
 
   __malloc_hook = emacs_blocked_malloc;
-  UNBLOCK_INPUT;
+  UNBLOCK_INPUT_ALLOC;
 
   /* fprintf (stderr, "%p malloc\n", value); */
   return value;
@@ -1044,7 +1230,7 @@ emacs_blocked_realloc (ptr, size)
 {
   void *value;
 
-  BLOCK_INPUT;
+  BLOCK_INPUT_ALLOC;
   __realloc_hook = old_realloc_hook;
 
 #ifdef GC_MALLOC_CHECK
@@ -1089,17 +1275,45 @@ emacs_blocked_realloc (ptr, size)
 #endif /* GC_MALLOC_CHECK */
 
   __realloc_hook = emacs_blocked_realloc;
-  UNBLOCK_INPUT;
+  UNBLOCK_INPUT_ALLOC;
 
   return value;
 }
 
 
+#ifdef HAVE_GTK_AND_PTHREAD
+/* Called from Fdump_emacs so that when the dumped Emacs starts, it has a
+   normal malloc.  Some thread implementations need this as they call
+   malloc before main.  The pthread_self call in BLOCK_INPUT_ALLOC then
+   calls malloc because it is the first call, and we have an endless loop.  */
+
+void
+reset_malloc_hooks ()
+{
+  __free_hook = 0;
+  __malloc_hook = 0;
+  __realloc_hook = 0;
+}
+#endif /* HAVE_GTK_AND_PTHREAD */
+
+
 /* Called from main to set up malloc to use our hooks.  */
 
 void
 uninterrupt_malloc ()
 {
+#ifdef HAVE_GTK_AND_PTHREAD
+  pthread_mutexattr_t attr;
+
+  /*  GLIBC has a faster way to do this, but lets keep it portable.
+      This is according to the Single UNIX Specification.  */
+  pthread_mutexattr_init (&attr);
+  pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
+  pthread_mutex_init (&alloc_mutex, &attr);
+
+  main_thread = pthread_self ();
+#endif /* HAVE_GTK_AND_PTHREAD */
+
   if (__free_hook != emacs_blocked_free)
     old_free_hook = __free_hook;
   __free_hook = emacs_blocked_free;
@@ -1428,6 +1642,21 @@ static int total_string_size;
 
 #endif /* not GC_CHECK_STRING_BYTES */
 
+
+#ifdef GC_CHECK_STRING_OVERRUN
+
+/* We check for overrun in string data blocks by appending a small
+   "cookie" after each allocated string data block, and check for the
+   presense of this cookie during GC.  */
+
+#define GC_STRING_OVERRUN_COOKIE_SIZE   4
+static char string_overrun_cookie[GC_STRING_OVERRUN_COOKIE_SIZE] =
+  { 0xde, 0xad, 0xbe, 0xef };
+
+#else
+#define GC_STRING_OVERRUN_COOKIE_SIZE 0
+#endif
+
 /* Value is the size of an sdata structure large enough to hold NBYTES
    bytes of string data.  The value returned includes a terminating
    NUL byte, the size of the sdata structure, and padding.  */
@@ -1451,6 +1680,10 @@ static int total_string_size;
 
 #endif /* not GC_CHECK_STRING_BYTES */
 
+/* Extra bytes to allocate for each string.  */
+
+#define GC_STRING_EXTRA (GC_STRING_OVERRUN_COOKIE_SIZE)
+
 /* Initialize string allocation.  Called from init_alloc_once.  */
 
 void
@@ -1515,7 +1748,7 @@ check_sblock (b)
         nbytes = SDATA_NBYTES (from);
 
       nbytes = SDATA_SIZE (nbytes);
-      from_end = (struct sdata *) ((char *) from + nbytes);
+      from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
     }
 }
 
@@ -1548,6 +1781,28 @@ check_string_bytes (all_p)
 
 #endif /* GC_CHECK_STRING_BYTES */
 
+#ifdef GC_CHECK_STRING_FREE_LIST
+
+/* Walk through the string free list looking for bogus next pointers.
+   This may catch buffer overrun from a previous string.  */
+
+static void
+check_string_free_list ()
+{
+  struct Lisp_String *s;
+
+  /* Pop a Lisp_String off the free-list.  */
+  s = string_free_list;
+  while (s != NULL)
+    {
+      if ((unsigned)s < 1024)
+        abort();
+      s = NEXT_FREE_LISP_STRING (s);
+    }
+}
+#else
+#define check_string_free_list()
+#endif
 
 /* Return a new Lisp_String.  */
 
@@ -1579,6 +1834,8 @@ allocate_string ()
       total_free_strings += STRING_BLOCK_SIZE;
     }
 
+  check_string_free_list ();
+
   /* Pop a Lisp_String off the free-list.  */
   s = string_free_list;
   string_free_list = NEXT_FREE_LISP_STRING (s);
@@ -1648,7 +1905,7 @@ allocate_string_data (s, nchars, nbytes)
       mallopt (M_MMAP_MAX, 0);
 #endif
 
-      b = (struct sblock *) lisp_malloc (size, MEM_TYPE_NON_LISP);
+      b = (struct sblock *) lisp_malloc (size + GC_STRING_EXTRA, MEM_TYPE_NON_LISP);
 
 #ifdef DOUG_LEA_MALLOC
       /* Back to a reasonable maximum of mmap'ed areas. */
@@ -1663,7 +1920,7 @@ allocate_string_data (s, nchars, nbytes)
   else if (current_sblock == NULL
            || (((char *) current_sblock + SBLOCK_SIZE
                 - (char *) current_sblock->next_free)
-               < needed))
+               < (needed + GC_STRING_EXTRA)))
     {
       /* Not enough room in the current sblock.  */
       b = (struct sblock *) lisp_malloc (SBLOCK_SIZE, MEM_TYPE_NON_LISP);
@@ -1692,7 +1949,11 @@ allocate_string_data (s, nchars, nbytes)
   s->size = nchars;
   s->size_byte = nbytes;
   s->data[nbytes] = '\0';
-  b->next_free = (struct sdata *) ((char *) data + needed);
+#ifdef GC_CHECK_STRING_OVERRUN
+  bcopy (string_overrun_cookie, (char *) data + needed,
+         GC_STRING_OVERRUN_COOKIE_SIZE);
+#endif
+  b->next_free = (struct sdata *) ((char *) data + needed + GC_STRING_EXTRA);
 
   /* If S had already data assigned, mark that as free by setting its
      string back-pointer to null, and recording the size of the data
@@ -1797,9 +2058,13 @@ sweep_strings ()
         }
     }
 
+  check_string_free_list ();
+
   string_blocks = live_blocks;
   free_large_strings ();
   compact_small_strings ();
+
+  check_string_free_list ();
 }
 
 
@@ -1871,28 +2136,38 @@ compact_small_strings ()
           else
             nbytes = SDATA_NBYTES (from);
 
+          if (nbytes > LARGE_STRING_BYTES)
+            abort ();
+
           nbytes = SDATA_SIZE (nbytes);
-          from_end = (struct sdata *) ((char *) from + nbytes);
+          from_end = (struct sdata *) ((char *) from + nbytes + GC_STRING_EXTRA);
+
+#ifdef GC_CHECK_STRING_OVERRUN
+          if (bcmp (string_overrun_cookie,
+                    ((char *) from_end) - GC_STRING_OVERRUN_COOKIE_SIZE,
+                    GC_STRING_OVERRUN_COOKIE_SIZE))
+            abort ();
+#endif
 
           /* FROM->string non-null means it's alive.  Copy its data.  */
           if (from->string)
             {
               /* If TB is full, proceed with the next sblock.  */
-              to_end = (struct sdata *) ((char *) to + nbytes);
+              to_end = (struct sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
               if (to_end > tb_end)
                 {
                   tb->next_free = to;
                   tb = tb->next;
                   tb_end = (struct sdata *) ((char *) tb + SBLOCK_SIZE);
                   to = &tb->first_data;
-                  to_end = (struct sdata *) ((char *) to + nbytes);
+                  to_end = (struct sdata *) ((char *) to + nbytes + GC_STRING_EXTRA);
                 }
 
               /* Copy, and update the string's `data' pointer.  */
               if (from != to)
                 {
                   xassert (tb != b || to <= from);
-                  safe_bcopy ((char *) from, (char *) to, nbytes);
+                  safe_bcopy ((char *) from, (char *) to, nbytes + GC_STRING_EXTRA);
                   to->string->data = SDATA_DATA (to);
                 }
 
@@ -2402,9 +2677,9 @@ DEFUN ("cons", Fcons, Scons, 2, 2, 0,
 void
 check_cons_list ()
 {
+#ifdef GC_CHECK_CONS_LIST
   struct Lisp_Cons *tail = cons_free_list;
 
-#if 0
   while (tail)
     tail = *(struct Lisp_Cons **)&tail->cdr;
 #endif
@@ -4056,6 +4331,11 @@ mark_stack ()
 #endif
   for (i = 0; i < sizeof (Lisp_Object); i += GC_LISP_OBJECT_ALIGNMENT)
     mark_memory ((char *) stack_base + i, end);
+  /* Allow for marking a secondary stack, like the register stack on the
+     ia64.  */
+#ifdef GC_MARK_SECONDARY_STACK
+  GC_MARK_SECONDARY_STACK ();
+#endif
 
 #if GC_MARK_STACK == GC_MARK_STACK_CHECK_GCPROS
   check_gcpros ();
diff --git a/src/buffer.c b/src/buffer.c
index b3dd6149487..15dbd2df34f 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5178,7 +5178,13 @@ init_buffer ()
     }
 #endif /* not VMS */
 
-  current_buffer->directory = build_string (buf);
+  current_buffer->directory = make_unibyte_string (buf, strlen (buf));
+  if (! NILP (buffer_defaults.enable_multibyte_characters))
+    /* At this momemnt, we still don't know how to decode the
+       direcotry name.  So, we keep the bytes in multibyte form so
+       that ENCODE_FILE correctly gets the original bytes.  */
+    current_buffer->directory
+      = string_to_multibyte (current_buffer->directory);
 
   /* Add /: to the front of the name
      if it would otherwise be treated as magic.  */
@@ -5700,10 +5706,13 @@ scrolled, the top and bottom line of the window are marked with up and down
 arrow bitmaps.
 
 If value is a symbol `left' or `right', both angle and arrow bitmaps
-are displayed in the left or right fringe, resp.
+are displayed in the left or right fringe, resp.  Any other value
+that doesn't look like an alist means displat the angle bitmaps in
+the left fringe but no arrows.
 
-If value is an alist, each element (INDICATOR . POSITION) specifies
-the position of one of the indicators.  INDICATOR is one of `top',
+You can exercise more precise control by using an alist as the
+value.  Each alist element (INDICATOR . POSITION) specifies
+where to show one of the indicators.  INDICATOR is one of `top',
 `bottom', `up', `down', or t, which specifies the default position,
 and POSITION is one of `left', `right', or nil, meaning do not show
 this indicator.
diff --git a/src/callint.c b/src/callint.c
index bb71ad50f44..933601f67d0 100644
--- a/src/callint.c
+++ b/src/callint.c
@@ -723,7 +723,7 @@ If KEYS is omitted or nil, the return value of `this-command-keys' is used.  */)
 
                 tem = Fread_from_minibuffer (build_string (callint_message),
                                              Qnil, Qnil, Qnil, Qnil, Qnil,
-                                             Qnil);
+                                             Qnil, Qnil);
                 if (! STRINGP (tem) || SCHARS (tem) == 0)
                   args[i] = Qnil;
                 else
diff --git a/src/coding.c b/src/coding.c
index 8ca1d19c4c3..de65884254f 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -6578,6 +6578,37 @@ code_conversion_restore (arg)
   return Qnil;
 }
 
+/* Name (or base name) of work buffer for code conversion.  */
+static Lisp_Object Vcode_conversion_workbuf_name;
+
+/* Set the current buffer to the working buffer prepared for
+   code-conversion.  MULTIBYTE specifies the multibyteness of the
+   buffer.  */
+
+static struct buffer *
+set_conversion_work_buffer (multibyte)
+     int multibyte;
+{
+  Lisp_Object buffer;
+  struct buffer *buf;
+
+  buffer = Fget_buffer_create (Vcode_conversion_workbuf_name);
+  buf = XBUFFER (buffer);
+  delete_all_overlays (buf);
+  buf->directory = current_buffer->directory;
+  buf->read_only = Qnil;
+  buf->filename = Qnil;
+  buf->undo_list = Qt;
+  eassert (buf->overlays_before == NULL);
+  eassert (buf->overlays_after == NULL);
+  set_buffer_internal (buf);
+  if (BEG != BEGV || Z != ZV)
+    Fwiden ();
+  del_range_2 (BEG, BEG_BYTE, Z, Z_BYTE, 0);
+  buf->enable_multibyte_characters = multibyte ? Qt : Qnil;
+  return buf;
+}
+
 Lisp_Object
 code_conversion_save (with_work_buf, multibyte)
      int with_work_buf, multibyte;
@@ -6995,6 +7026,64 @@ encode_coding_object (coding, src_object, from, from_byte, to, to_byte,
 }
 
 
+
+/* Run pre-write-conversion function of CODING on NCHARS/NBYTES
+   text in *STR.  *SIZE is the allocated bytes for STR.  As it
+   is intended that this function is called from encode_terminal_code,
+   the pre-write-conversion function is run by safe_call and thus
+   "Error during redisplay: ..." is logged when an error occurs.
+
+   Store the resulting text in *STR and set CODING->produced_char and
+   CODING->produced to the number of characters and bytes
+   respectively.  If the size of *STR is too small, enlarge it by
+   xrealloc and update *STR and *SIZE.  */
+
+void
+run_pre_write_conversin_on_c_str (str, size, nchars, nbytes, coding)
+     unsigned char **str;
+     int *size, nchars, nbytes;
+     struct coding_system *coding;
+{
+  struct gcpro gcpro1, gcpro2;
+  struct buffer *cur = current_buffer;
+  Lisp_Object old_deactivate_mark, old_last_coding_system_used;
+  Lisp_Object args[3];
+
+  /* It is not crucial to specbind this.  */
+  old_deactivate_mark = Vdeactivate_mark;
+  old_last_coding_system_used = Vlast_coding_system_used;
+  GCPRO2 (old_deactivate_mark, old_last_coding_system_used);
+
+  /* We must insert the contents of STR as is without
+     unibyte<->multibyte conversion.  For that, we adjust the
+     multibyteness of the working buffer to that of STR.  */
+  set_conversion_work_buffer (coding->src_multibyte);
+  insert_1_both (*str, nchars, nbytes, 0, 0, 0);
+  UNGCPRO;
+  inhibit_pre_post_conversion = 1;
+  args[0] = coding->pre_write_conversion;
+  args[1] = make_number (BEG);
+  args[2] = make_number (Z);
+  safe_call (3, args);
+  inhibit_pre_post_conversion = 0;
+  Vdeactivate_mark = old_deactivate_mark;
+  Vlast_coding_system_used = old_last_coding_system_used;
+  coding->produced_char = Z - BEG;
+  coding->produced = Z_BYTE - BEG_BYTE;
+  if (coding->produced > *size)
+    {
+      *size = coding->produced;
+      *str = xrealloc (*str, *size);
+    }
+  if (BEG < GPT && GPT < Z)
+    move_gap (BEG);
+  bcopy (BEG_ADDR, *str, coding->produced);
+  coding->src_multibyte
+    = ! NILP (current_buffer->enable_multibyte_characters);
+  set_buffer_internal (cur);
+}
+
+
 Lisp_Object
 preferred_coding_system ()
 {
diff --git a/src/coding.h b/src/coding.h
index d970c1ea257..39bd62867af 100644
--- a/src/coding.h
+++ b/src/coding.h
@@ -1,4 +1,5 @@
 /* Header for coding system handler.
+   Copyright (C) 2004  Free Software Foundation, Inc.
    Copyright (C) 1995, 1997 Electrotechnical Laboratory, JAPAN.
      Licensed to the Free Software Foundation.
    Copyright (C) 2003
@@ -579,10 +580,10 @@ struct coding_system
    for file names, if any.  */
 #define ENCODE_FILE(name)                                                  \
   (! NILP (Vfile_name_coding_system)                                       \
-   && XFASTINT (Vfile_name_coding_system) != 0                             \
+   && !EQ (Vfile_name_coding_system, make_number (0))                      \
    ? code_convert_string_norecord (name, Vfile_name_coding_system, 1)      \
    : (! NILP (Vdefault_file_name_coding_system)                            \
-      && XFASTINT (Vdefault_file_name_coding_system) != 0                  \
+      && !EQ (Vdefault_file_name_coding_system, make_number (0))           \
       ? code_convert_string_norecord (name, Vdefault_file_name_coding_system, 1) \
       : name))
 
@@ -591,10 +592,10 @@ struct coding_system
    for file names, if any.  */
 #define DECODE_FILE(name)                                                  \
   (! NILP (Vfile_name_coding_system)                                       \
-   && XFASTINT (Vfile_name_coding_system) != 0                             \
+   && !EQ (Vfile_name_coding_system, make_number (0))                      \
    ? code_convert_string_norecord (name, Vfile_name_coding_system, 0)      \
    : (! NILP (Vdefault_file_name_coding_system)                            \
-      && XFASTINT (Vdefault_file_name_coding_system) != 0                  \
+      && !EQ (Vdefault_file_name_coding_system, make_number (0))           \
       ? code_convert_string_norecord (name, Vdefault_file_name_coding_system, 0) \
       : name))
 
@@ -602,18 +603,18 @@ struct coding_system
 #ifdef WINDOWSNT
 /* Encode the string STR using the specified coding system
    for w32 system functions, if any.  */
-#define ENCODE_SYSTEM(str)                                              \
-  (! NILP (Vlocale_coding_system)                                       \
-   && XFASTINT (Vlocale_coding_system) != 0                             \
-   ? code_convert_string_norecord (str, Vlocale_coding_system, 1)       \
+#define ENCODE_SYSTEM(str)                                                 \
+  (! NILP (Vlocale_coding_system)                                          \
+   && !EQ (Vlocale_coding_system, make_number (0))                         \
+   ? code_convert_string_norecord (str, Vlocale_coding_system, 1)          \
    : str)
 
 /* Decode the string STR using the specified coding system
    for w32 system functions, if any.  */
-#define DECODE_SYSTEM(name)                                             \
-  (! NILP (Vlocale_coding_system)                                       \
-   && XFASTINT (Vlocale_coding_system) != 0                             \
-   ? code_convert_string_norecord (str, Vlocale_coding_system, 0)       \
+#define DECODE_SYSTEM(name)                                                \
+  (! NILP (Vlocale_coding_system)                                          \
+   && !EQ (Vlocale_coding_system, make_number (0))                         \
+   ? code_convert_string_norecord (str, Vlocale_coding_system, 0)          \
    : str)
 
 #else /* WINDOWSNT */
diff --git a/src/config.in b/src/config.in
index fe1adc39f9d..87e37e65ef2 100644
--- a/src/config.in
+++ b/src/config.in
@@ -1,7 +1,8 @@
 /* src/config.in.  Generated from configure.in by autoheader.  */
 
 /* GNU Emacs site configuration template file.
-   Copyright (C) 1988, 93, 94, 99, 2000, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1988, 1993, 1994, 1999, 2000, 2002, 2004
+             Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -220,6 +221,9 @@ Boston, MA 02111-1307, USA.  */
 /* Define to 1 if using GTK. */
 #undef HAVE_GTK
 
+/* Define to 1 if you have GTK and pthread (-lpthread). */
+#undef HAVE_GTK_AND_PTHREAD
+
 /* Define to 1 if GTK has both file selection and chooser dialog. */
 #undef HAVE_GTK_FILE_BOTH
 
@@ -441,6 +445,9 @@ Boston, MA 02111-1307, USA.  */
 /* Define to 1 if you have the `pstat_getdynamic' function. */
 #undef HAVE_PSTAT_GETDYNAMIC
 
+/* Define to 1 if you have the <pthread.h> header file. */
+#undef HAVE_PTHREAD_H
+
 /* Define to 1 if you have the <pty.h> header file. */
 #undef HAVE_PTY_H
 
@@ -769,9 +776,9 @@ Boston, MA 02111-1307, USA.  */
 /* If using the C implementation of alloca, define if you know the
    direction of stack growth for your system; otherwise it will be
    automatically deduced at run-time.
-        STACK_DIRECTION > 0 => grows toward higher addresses
-        STACK_DIRECTION < 0 => grows toward lower addresses
-        STACK_DIRECTION = 0 => direction of growth unknown */
+        STACK_DIRECTION > 0 => grows toward higher addresses
+        STACK_DIRECTION < 0 => grows toward lower addresses
+        STACK_DIRECTION = 0 => direction of growth unknown */
 #undef STACK_DIRECTION
 
 /* Define to 1 if you have the ANSI C header files. */
@@ -920,7 +927,7 @@ Boston, MA 02111-1307, USA.  */
 /* Don't try to switch on inline handling as detected by AC_C_INLINE
    generally, because even if non-gcc compilers accept `inline', they
    may reject `extern inline'.  */
-#ifdef __GNUC__
+#if defined (__GNUC__) && defined (OPTIMIZE)
 #define INLINE __inline__
 #else
 #define INLINE
@@ -968,7 +975,13 @@ Boston, MA 02111-1307, USA.  */
 /* Tell regex.c to use a type compatible with Emacs.  */
 #define RE_TRANSLATE_TYPE Lisp_Object
 #define RE_TRANSLATE(TBL, C) CHAR_TABLE_TRANSLATE (TBL, C)
-#define RE_TRANSLATE_P(TBL) (XFASTINT (TBL) != 0)
+#ifdef make_number
+/* If make_number is a macro, use it.  */
+#define RE_TRANSLATE_P(TBL) (!EQ (TBL, make_number (0)))
+#else
+/* If make_number is a function, avoid it.  */
+#define RE_TRANSLATE_P(TBL) (!(INTEGERP (TBL) && XINT (TBL) == 0))
+#endif
 #endif
 
 /* Avoid link-time collision with system mktime if we will use our own.  */
diff --git a/src/data.c b/src/data.c
index 7f68cc864df..0439d5763bc 100644
--- a/src/data.c
+++ b/src/data.c
@@ -1509,6 +1509,9 @@ Note that binding the variable with `let', or setting it while
 a `let'-style binding made in this buffer is in effect,
 does not make the variable buffer-local.  Return VARIABLE.
 
+In most cases it is better to use `make-local-variable',
+which makes a variable local in just one buffer.
+
 The function `default-value' gets the default value and `set-default' sets it.  */)
      (variable)
      register Lisp_Object variable;
@@ -1552,7 +1555,7 @@ DEFUN ("make-local-variable", Fmake_local_variable, Smake_local_variable,
 Other buffers will continue to share a common default value.
 \(The buffer-local value of VARIABLE starts out as the same value
 VARIABLE previously had.  If VARIABLE was void, it remains void.\)
-See also `make-variable-buffer-local'.  Return VARIABLE.
+Return VARIABLE.
 
 If the variable is already arranged to become local when set,
 this function causes a local value to exist for this buffer,
@@ -1562,6 +1565,8 @@ This function returns VARIABLE, and therefore
   (set (make-local-variable 'VARIABLE) VALUE-EXP)
 works.
 
+See also `make-variable-buffer-local'.
+
 Do not use `make-local-variable' to make a hook variable buffer-local.
 Instead, use `add-hook' and specify t for the LOCAL argument.  */)
      (variable)
diff --git a/src/dispextern.h b/src/dispextern.h
index 463e719d1bc..f88db043b27 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -974,7 +974,7 @@ struct glyph_row *matrix_row P_ ((struct glyph_matrix *, int));
    or a control char, or an overlay string.  */
 
 #define MATRIX_ROW_ENDS_IN_MIDDLE_OF_CHAR_P(ROW)        \
-     ((ROW)->end.dpvec_index >= 0                       \
+     ((ROW)->end.dpvec_index > 0                        \
       || (ROW)->end.overlay_string_index >= 0           \
       || (ROW)->ends_in_middle_of_char_p)
 
@@ -986,7 +986,7 @@ struct glyph_row *matrix_row P_ ((struct glyph_matrix *, int));
 /* Non-zero if ROW starts in the middle of a character.  See above.  */
 
 #define MATRIX_ROW_STARTS_IN_MIDDLE_OF_CHAR_P(ROW)      \
-     ((ROW)->start.dpvec_index >= 0                     \
+     ((ROW)->start.dpvec_index > 0                      \
       || (ROW)->starts_in_middle_of_char_p              \
       || ((ROW)->start.overlay_string_index >= 0        \
           && (ROW)->start.string_pos.charpos > 0))
@@ -2737,7 +2737,7 @@ void prepare_face_for_display P_ ((struct frame *, struct face *));
 int xstricmp P_ ((const unsigned char *, const unsigned char *));
 int lookup_face P_ ((struct frame *, Lisp_Object *));
 int lookup_non_ascii_face P_ ((struct frame *, int, struct face *));
-int lookup_named_face P_ ((struct frame *, Lisp_Object));
+int lookup_named_face P_ ((struct frame *, Lisp_Object, int));
 int smaller_face P_ ((struct frame *, int, int));
 int face_with_height P_ ((struct frame *, int, int));
 int lookup_derived_face P_ ((struct frame *, Lisp_Object, int));
diff --git a/src/emacs.c b/src/emacs.c
index 16ae1129840..03f20b9e97b 100644
--- a/src/emacs.c
+++ b/src/emacs.c
@@ -580,8 +580,12 @@ init_cmdargs (argc, argv, skip_args)
   for (i = argc - 1; i >= 0; i--)
     {
       if (i == 0 || i > skip_args)
+        /* For the moment, we keep arguments as is in unibyte strings.
+           They are decoded in the function command-line after we know
+           locale-coding-system.  */
         Vcommand_line_args
-          = Fcons (build_string (argv[i]), Vcommand_line_args);
+          = Fcons (make_unibyte_string (argv[i], strlen (argv[i])),
+                   Vcommand_line_args);
     }
 
   unbind_to (count, Qnil);
@@ -744,7 +748,9 @@ malloc_initialize_hook ()
         }
 
       malloc_set_state (malloc_state_ptr);
+#ifndef XMALLOC_OVERRUN_CHECK
       free (malloc_state_ptr);
+#endif
     }
   else
     {
@@ -1988,9 +1994,9 @@ sort_args (argc, argv)
 
   bcopy (new, argv, sizeof (char *) * argc);
 
-  free (options);
-  free (new);
-  free (priority);
+  xfree (options);
+  xfree (new);
+  xfree (priority);
 }
 
 DEFUN ("kill-emacs", Fkill_emacs, Skill_emacs, 0, 1, "P",
@@ -2240,6 +2246,12 @@ You must run Emacs in batch mode in order to dump it.  */)
   memory_warnings (my_edata, malloc_warning);
 #endif /* not WINDOWSNT */
 #endif
+#if ! defined (SYSTEM_MALLOC) && defined (HAVE_GTK_AND_PTHREAD)
+  /* Pthread may call malloc before main, and then we will get an endless
+     loop, because pthread_self (see alloc.c) calls malloc the first time
+     it is called on some systems.  */
+  reset_malloc_hooks ();
+#endif
 #ifdef DOUG_LEA_MALLOC
   malloc_state_ptr = malloc_get_state ();
 #endif
diff --git a/src/eval.c b/src/eval.c
index d1d5d195762..0eb519fbfca 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -204,7 +204,7 @@ init_eval_once ()
   specpdl_size = 50;
   specpdl = (struct specbinding *) xmalloc (specpdl_size * sizeof (struct specbinding));
   specpdl_ptr = specpdl;
-  max_specpdl_size = 600;
+  max_specpdl_size = 1000;
   max_lisp_eval_depth = 300;
 
   Vrun_hooks = Qnil;
@@ -573,7 +573,7 @@ optional argument, and making the `interactive' spec specify non-nil
 unconditionally for that argument.  (`p' is a good way to do this.)  */)
      ()
 {
-  return (INTERACTIVE && interactive_p (1)) ? Qt : Qnil;
+  return interactive_p (1) ? Qt : Qnil;
 }
 
 
@@ -595,7 +595,8 @@ interactive_p (exclude_subrs_p)
   /* If this isn't a byte-compiled function, there may be a frame at
      the top for Finteractive_p.  If so, skip it.  */
   fun = Findirect_function (*btp->function);
-  if (SUBRP (fun) && XSUBR (fun) == &Sinteractive_p)
+  if (SUBRP (fun) && (XSUBR (fun) == &Sinteractive_p
+                      || XSUBR (fun) == &Scalled_interactively_p))
     btp = btp->next;
 
   /* If we're running an Emacs 18-style byte-compiled function, there
@@ -786,6 +787,21 @@ usage: (defvar SYMBOL &optional INITVALUE DOCSTRING)  */)
     {
       if (NILP (tem))
         Fset_default (sym, Feval (Fcar (tail)));
+      else
+        { /* Check if there is really a global binding rather than just a let
+             binding that shadows the global unboundness of the var.  */
+          volatile struct specbinding *pdl = specpdl_ptr;
+          while (--pdl >= specpdl)
+            {
+              if (EQ (pdl->symbol, sym) && !pdl->func
+                  && EQ (pdl->old_value, Qunbound))
+                {
+                  message_with_string ("Warning: defvar ignored because %s is let-bound",
+                                       SYMBOL_NAME (sym), 1);
+                  break;
+                }
+            }
+        }
       tail = Fcdr (tail);
       tem = Fcar (tail);
       if (!NILP (tem))
@@ -1158,9 +1174,10 @@ unwind_to_catch (catch, value)
   /* Save the value in the tag.  */
   catch->val = value;
 
-  /* Restore the polling-suppression count.  */
+  /* Restore certain special C variables.  */
   set_poll_suppress_count (catch->poll_suppress_count);
   interrupt_input_blocked = catch->interrupt_input_blocked;
+  handling_signal = 0;
 
   do
     {
diff --git a/src/filelock.c b/src/filelock.c
index b802d0e2a51..fc214b5a34a 100644
--- a/src/filelock.c
+++ b/src/filelock.c
@@ -377,6 +377,9 @@ lock_file_1 (lfname, force)
   char *host_name;
   char *lock_info_str;
 
+  /* Call this first because it can GC.  */
+  boot_time = get_boot_time ();
+
   if (STRINGP (Fuser_login_name (Qnil)))
     user_name = (char *)SDATA (Fuser_login_name (Qnil));
   else
@@ -386,9 +389,8 @@ lock_file_1 (lfname, force)
   else
     host_name = "";
   lock_info_str = (char *)alloca (strlen (user_name) + strlen (host_name)
-                                  + LOCK_PID_MAX + 5);
+                                  + LOCK_PID_MAX + 30);
 
-  boot_time = get_boot_time ();
   if (boot_time)
     sprintf (lock_info_str, "%s@%s.%lu:%lu", user_name, host_name,
              (unsigned long) getpid (), (unsigned long) boot_time);
diff --git a/src/fns.c b/src/fns.c
index 8d63b731fcf..f7a6246d15d 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -522,6 +522,7 @@ concat (nargs, args, target_type, last_special)
   struct textprop_rec  *textprops = NULL;
   /* Number of elments in textprops.  */
   int num_textprops = 0;
+  USE_SAFE_ALLOCA;
 
   tail = Qnil;
 
@@ -630,8 +631,7 @@ concat (nargs, args, target_type, last_special)
 
   prev = Qnil;
   if (STRINGP (val))
-    textprops
-      = (struct textprop_rec *) alloca (sizeof (struct textprop_rec) * nargs);
+    SAFE_ALLOCA (textprops, struct textprop_rec *, sizeof (struct textprop_rec) * nargs);
 
   for (argnum = 0; argnum < nargs; argnum++)
     {
@@ -769,6 +769,8 @@ concat (nargs, args, target_type, last_special)
           last_to_end = textprops[argnum].to + SCHARS (this);
         }
     }
+
+  SAFE_FREE ();
   return val;
 }
 
@@ -2767,7 +2769,7 @@ is nil, and `use-dialog-box' is non-nil.  */)
     {
       ans = Fdowncase (Fread_from_minibuffer (prompt, Qnil, Qnil, Qnil,
                                               Qyes_or_no_p_history, Qnil,
-                                              Qnil));
+                                              Qnil, Qnil));
       if (SCHARS (ans) == 3 && !strcmp (SDATA (ans), "yes"))
         {
           UNGCPRO;
diff --git a/src/fringe.c b/src/fringe.c
index 591d6acb290..52273af13ef 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -809,12 +809,13 @@ update_window_fringes (w, force_p)
             arrow_bot = XCDR (pos);
         }
       else
-        ind = Qnil;
+        /* Anything else means boundary on left and no arrows.  */
+        boundary_top = boundary_bot = Qleft;
     }
 
   if (!NILP (ind))
     {
-      int do_eob = 1, do_bob = 1;
+      int done_top = 0, done_bot = 0;
 
       for (y = 0, rn = 0;
            y < yb && rn < nrows;
@@ -835,19 +836,25 @@ update_window_fringes (w, force_p)
           row->indicate_bob_p = row->indicate_top_line_p = 0;
           row->indicate_eob_p = row->indicate_bottom_line_p = 0;
 
-          if (!NILP (boundary_top)
-              && MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
-            row->indicate_bob_p = do_bob, do_bob = 0;
-          else if (!NILP (arrow_top)
-                   && (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0) == rn)
-            row->indicate_top_line_p = 1;
+          if (!row->mode_line_p)
+            {
+              if (!done_top)
+                {
+                  if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
+                    row->indicate_bob_p = !NILP (boundary_top);
+                  else
+                    row->indicate_top_line_p = !NILP (arrow_top);
+                  done_top = 1;
+                }
 
-          if (!NILP (boundary_bot)
-              && MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
-            row->indicate_eob_p = do_eob, do_eob = 0;
-          else if (!NILP (arrow_bot)
-                   && y + row->height >= yb)
-            row->indicate_bottom_line_p = 1;
+              if (!done_bot)
+                {
+                  if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
+                    row->indicate_eob_p = !NILP (boundary_bot), done_bot = 1;
+                  else if (y + row->height >= yb)
+                    row->indicate_bottom_line_p = !NILP (arrow_bot), done_bot = 1;
+                }
+            }
 
           if (indicate_bob_p != row->indicate_bob_p
               || indicate_top_line_p != row->indicate_top_line_p
@@ -883,13 +890,13 @@ update_window_fringes (w, force_p)
           left = row->left_user_fringe_bitmap;
           left_face_id = row->left_user_fringe_face_id;
         }
+      else if (row->truncated_on_left_p)
+        left = LEFT_TRUNCATION_BITMAP;
       else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
         left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
                 ? LEFT_BRACKET_BITMAP : TOP_LEFT_ANGLE_BITMAP);
       else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
         left = BOTTOM_LEFT_ANGLE_BITMAP;
-      else if (row->truncated_on_left_p)
-        left = LEFT_TRUNCATION_BITMAP;
       else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
         left = CONTINUATION_LINE_BITMAP;
       else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
@@ -909,13 +916,13 @@ update_window_fringes (w, force_p)
           right = row->right_user_fringe_bitmap;
           right_face_id = row->right_user_fringe_face_id;
         }
+      else if (row->truncated_on_right_p)
+        right = RIGHT_TRUNCATION_BITMAP;
       else if (row->indicate_bob_p && EQ (boundary_top, Qright))
         right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
                  ? RIGHT_BRACKET_BITMAP : TOP_RIGHT_ANGLE_BITMAP);
       else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
         right = BOTTOM_RIGHT_ANGLE_BITMAP;
-      else if (row->truncated_on_right_p)
-        right = RIGHT_TRUNCATION_BITMAP;
       else if (row->continued_p)
         right = CONTINUED_LINE_BITMAP;
       else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
@@ -1346,7 +1353,7 @@ If FACE is nil, reset face to default fringe face.  */)
 
   if (!NILP (face))
     {
-      face_id = lookup_named_face (SELECTED_FRAME (), face);
+      face_id = lookup_named_face (SELECTED_FRAME (), face, 1);
       if (face_id < 0)
         error ("No such face");
     }
diff --git a/src/gtkutil.c b/src/gtkutil.c
index 25dd88d544e..317f7824267 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -23,10 +23,12 @@ Boston, MA 02111-1307, USA.  */
 
 #ifdef USE_GTK
 #include <string.h>
+#include <signal.h>
 #include <stdio.h>
 #include "lisp.h"
 #include "xterm.h"
 #include "blockinput.h"
+#include "syssignal.h"
 #include "window.h"
 #include "atimer.h"
 #include "gtkutil.h"
@@ -1122,10 +1124,6 @@ create_dialog (wv, select_cb, deactivate_cb)
 /***********************************************************************
                       File dialog functions
  ***********************************************************************/
-#ifdef HAVE_GTK_FILE_BOTH
-int use_old_gtk_file_dialog;
-#endif
-
 /* Function that is called when the file dialog pops down.
    W is the dialog widget, RESPONSE is the response code.
    USER_DATA is what we passed in to g_signal_connect (pointer to int).  */
@@ -1204,6 +1202,7 @@ xg_get_file_with_chooser (f, prompt, default_filename,
                                           GTK_STOCK_OPEN : GTK_STOCK_OK),
                                          GTK_RESPONSE_OK,
                                          NULL);
+  gtk_file_chooser_set_local_only (GTK_FILE_CHOOSER (filewin), TRUE);
 
   if (default_filename)
     {
@@ -1211,16 +1210,20 @@ xg_get_file_with_chooser (f, prompt, default_filename,
       struct gcpro gcpro1;
       GCPRO1 (file);
 
+      file = build_string (default_filename);
+
       /* File chooser does not understand ~/... in the file name.  It must be
          an absolute name starting with /.  */
       if (default_filename[0] != '/')
-        {
-          file = Fexpand_file_name (build_string (default_filename), Qnil);
-          default_filename = SDATA (file);
-        }
+        file = Fexpand_file_name (file, Qnil);
 
-      gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin),
-                                     default_filename);
+      default_filename = SDATA (file);
+      if (Ffile_directory_p (file))
+        gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (filewin),
+                                             default_filename);
+      else
+        gtk_file_chooser_set_filename (GTK_FILE_CHOOSER (filewin),
+                                       default_filename);
 
       UNGCPRO;
     }
@@ -1310,8 +1313,17 @@ xg_get_file_name (f, prompt, default_filename, mustmatch_p, only_dir_p)
   int filesel_done = 0;
   xg_get_file_func func;
 
+#if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
+  /* I really don't know why this is needed, but without this the GLIBC add on
+     library linuxthreads hangs when the Gnome file chooser backend creates
+     threads.  */
+  sigblock (sigmask (__SIGRTMIN));
+#endif /* HAVE_GTK_AND_PTHREAD */
+
 #ifdef HAVE_GTK_FILE_BOTH
-  if (use_old_gtk_file_dialog)
+  extern int x_use_old_gtk_file_dialog;
+
+  if (x_use_old_gtk_file_dialog)
     w = xg_get_file_with_selection (f, prompt, default_filename,
                                     mustmatch_p, only_dir_p, &func);
   else
@@ -1355,6 +1367,10 @@ xg_get_file_name (f, prompt, default_filename, mustmatch_p, only_dir_p)
       gtk_main_iteration ();
     }
 
+#if defined (HAVE_GTK_AND_PTHREAD) && defined (__SIGRTMIN)
+  sigunblock (sigmask (__SIGRTMIN));
+#endif
+
   if (filesel_done == GTK_RESPONSE_OK)
     fn = (*func) (w);
 
diff --git a/src/image.c b/src/image.c
index 4ab672ca58e..d1925cf36e4 100644
--- a/src/image.c
+++ b/src/image.c
@@ -2416,8 +2416,7 @@ image_load_quartz2d (f, img, png_p)
           UNGCPRO;
           return 0;
         }
-      path = CFStringCreateWithCString (NULL, SDATA (file),
-                                        kCFStringEncodingUTF8);
+      path = cfstring_create_with_utf8_cstring (SDATA (file));
       url = CFURLCreateWithFileSystemPath (NULL, path,
                                            kCFURLPOSIXPathStyle, 0);
       CFRelease (path);
diff --git a/src/indent.c b/src/indent.c
index 5b2faba7fda..b573c53e666 100644
--- a/src/indent.c
+++ b/src/indent.c
@@ -220,7 +220,7 @@ skip_invisible (pos, next_boundary_p, to, window)
      Lisp_Object window;
 {
   Lisp_Object prop, position, overlay_limit, proplimit;
-  Lisp_Object buffer;
+  Lisp_Object buffer, tmp;
   int end, inv_p;
 
   XSETFASTINT (position, pos);
@@ -251,8 +251,9 @@ skip_invisible (pos, next_boundary_p, to, window)
       /* No matter what. don't go past next overlay change.  */
       if (XFASTINT (overlay_limit) < XFASTINT (proplimit))
         proplimit = overlay_limit;
-      end = XFASTINT (Fnext_single_property_change (position, Qinvisible,
-                                                    buffer, proplimit));
+      tmp = Fnext_single_property_change (position, Qinvisible,
+                                          buffer, proplimit);
+      end = XFASTINT (tmp);
 #if 0
       /* Don't put the boundary in the middle of multibyte form if
          there is no actual property change.  */
@@ -2069,6 +2070,8 @@ whether or not it is currently displayed in some window.  */)
     }
   else
     {
+      int it_start;
+
       SET_TEXT_POS (pt, PT, PT_BYTE);
       start_display (&it, w, pt);
 
@@ -2078,13 +2081,14 @@ whether or not it is currently displayed in some window.  */)
          we end up with the iterator placed at where it thinks X is 0,
          while the end position is really at some X > 0, the same X that
          PT had.  */
+      it_start = IT_CHARPOS (it);
       reseat_at_previous_visible_line_start (&it);
       it.current_x = it.hpos = 0;
       move_it_to (&it, PT, -1, -1, -1, MOVE_TO_POS);
 
       /* Move back if we got too far.  This may happen if
          truncate-lines is on and PT is beyond right margin.  */
-      if (IT_CHARPOS (it) > PT && XINT (lines) > 0)
+      if (IT_CHARPOS (it) > it_start && XINT (lines) > 0)
         move_it_by_lines (&it, -1, 0);
 
       it.vpos = 0;
diff --git a/src/insdel.c b/src/insdel.c
index 4a97eab79ef..aec393692a2 100644
--- a/src/insdel.c
+++ b/src/insdel.c
@@ -1046,6 +1046,10 @@ insert_from_string (string, pos, pos_byte, length, length_byte, inherit)
      int inherit;
 {
   int opoint = PT;
+
+  if (SCHARS (string) == 0)
+    return;
+
   insert_from_string_1 (string, pos, pos_byte, length, length_byte,
                         inherit, 0);
   signal_after_change (opoint, 0, PT - opoint);
@@ -1063,6 +1067,10 @@ insert_from_string_before_markers (string, pos, pos_byte,
      int inherit;
 {
   int opoint = PT;
+
+  if (SCHARS (string) == 0)
+    return;
+
   insert_from_string_1 (string, pos, pos_byte, length, length_byte,
                         inherit, 1);
   signal_after_change (opoint, 0, PT - opoint);
diff --git a/src/keyboard.c b/src/keyboard.c
index 75bfa2180c7..c77c53790b1 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -45,6 +45,9 @@ Boston, MA 02111-1307, USA.  */
 #include <setjmp.h>
 #include <errno.h>
 
+#ifdef HAVE_GTK_AND_PTHREAD
+#include <pthread.h>
+#endif
 #ifdef MSDOS
 #include "msdos.h"
 #include <time.h>
@@ -607,7 +610,7 @@ int flow_control;
 
 /* We are unable to use interrupts if FIONREAD is not available,
    so flush SIGIO so we won't try.  */
-#if !defined (FIONREAD) || defined(HAVE_CARBON)
+#if !defined (FIONREAD)
 #ifdef SIGIO
 #undef SIGIO
 #endif
@@ -1618,7 +1621,10 @@ command_loop_1 ()
       if (NILP (Vthis_command))
         {
           /* nil means key is undefined.  */
+          Lisp_Object keys = Fvector (i, keybuf);
+          keys = Fkey_description (keys, Qnil);
           bitch_at_user ();
+          message_with_string ("%s is undefined", keys, 0);
           current_kboard->defining_kbd_macro = Qnil;
           update_mode_lines = 1;
           current_kboard->Vprefix_arg = Qnil;
@@ -6773,6 +6779,25 @@ handle_async_input ()
 #ifdef BSD4_1
   extern int select_alarmed;
 #endif
+#if ! defined (SYSTEM_MALLOC) && defined (HAVE_GTK_AND_PTHREAD)
+  extern pthread_t main_thread;
+  if (pthread_self () != main_thread)
+    {
+      /* POSIX says any thread can receive the signal.  On GNU/Linux that is
+         not true, but for other systems (FreeBSD at least) it is.  So direct
+         the signal to the correct thread and block it from this thread.  */
+#ifdef SIGIO
+      sigset_t new_mask;
+
+      sigemptyset (&new_mask);
+      sigaddset (&new_mask, SIGIO);
+      pthread_sigmask (SIG_BLOCK, &new_mask, 0);
+      pthread_kill (main_thread, SIGIO);
+#endif
+      return;
+    }
+#endif
+
   interrupt_input_pending = 0;
 
   while (1)
@@ -6800,7 +6825,22 @@ input_available_signal (signo)
 {
   /* Must preserve main program's value of errno.  */
   int old_errno = errno;
-
+#if ! defined (SYSTEM_MALLOC) && defined (HAVE_GTK_AND_PTHREAD)
+  extern pthread_t main_thread;
+  if (pthread_self () != main_thread)
+    {
+      /* POSIX says any thread can receive the signal.  On GNU/Linux that is
+         not true, but for other systems (FreeBSD at least) it is.  So direct
+         the signal to the correct thread and block it from this thread.  */
+      sigset_t new_mask;
+
+      sigemptyset (&new_mask);
+      sigaddset (&new_mask, SIGIO);
+      pthread_sigmask (SIG_BLOCK, &new_mask, 0);
+      pthread_kill (main_thread, SIGIO);
+      return;
+    }
+#endif /* HAVE_GTK_AND_PTHREAD */
 #if defined (USG) && !defined (POSIX_SIGNALS)
   /* USG systems forget handlers when they are used;
      must reestablish each time */
diff --git a/src/keymap.c b/src/keymap.c
index e76cbf5c00a..5a7c8b19123 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1273,7 +1273,7 @@ recognize the default bindings, just as `read-key-sequence' does.  */)
         c = Fevent_convert_list (c);
 
       /* Turn the 8th bit of string chars into a meta modifier.  */
-      if (XINT (c) & 0x80 && STRINGP (key))
+      if (INTEGERP (c) && XINT (c) & 0x80 && STRINGP (key))
         XSETINT (c, (XINT (c) | meta_modifier) & ~0x80);
 
       /* Allow string since binding for `menu-bar-select-buffer'
diff --git a/src/lisp.h b/src/lisp.h
index e89f778aa0e..47eb7604b41 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -35,6 +35,22 @@ Boston, MA 02111-1307, USA.  */
    be compared to the sizes recorded in Lisp strings.  */
 
 #define GC_CHECK_STRING_BYTES 1
+
+/* Define this to check for short string overrun.  */
+
+#define GC_CHECK_STRING_OVERRUN 1
+
+/* Define this to check the string free list.  */
+
+#define GC_CHECK_STRING_FREE_LIST 1
+
+/* Define this to check for malloc buffer overrun.  */
+
+#define XMALLOC_OVERRUN_CHECK 1
+
+/* Define this to check for errors in cons list.  */
+/* #define GC_CHECK_CONS_LIST 1 */
+
 #endif /* 0 */
 
 
@@ -305,11 +321,13 @@ enum pvec_type
 /* First, try and define DECL_ALIGN(type,var) which declares a static
    variable VAR of type TYPE with the added requirement that it be
    TYPEBITS-aligned. */
-#ifndef DECL_ALIGN
+#ifndef NO_DECL_ALIGN
+# ifndef DECL_ALIGN
 /* What compiler directive should we use for non-gcc compilers?  -stef  */
-# if defined (__GNUC__)
-#  define DECL_ALIGN(type, var) \
-    type __attribute__ ((__aligned__ (1 << GCTYPEBITS))) var
+#  if defined (__GNUC__)
+#   define DECL_ALIGN(type, var) \
+     type __attribute__ ((__aligned__ (1 << GCTYPEBITS))) var
+#  endif
 # endif
 #endif
 
@@ -324,7 +342,7 @@ enum pvec_type
 # endif
 #endif
 
-/* Just remove the alignment annotation if we don't use it.  */
+/* If we cannot use 8-byte alignment, make DECL_ALIGN a no-op.  */
 #ifndef DECL_ALIGN
 # ifdef USE_LSB_TAG
 #  error "USE_LSB_TAG used without defining DECL_ALIGN"
@@ -2325,6 +2343,7 @@ extern void clear_string_char_byte_cache P_ ((void));
 extern int string_char_to_byte P_ ((Lisp_Object, int));
 extern int string_byte_to_char P_ ((Lisp_Object, int));
 extern Lisp_Object string_make_multibyte P_ ((Lisp_Object));
+extern Lisp_Object string_to_multibyte P_ ((Lisp_Object));
 extern Lisp_Object string_make_unibyte P_ ((Lisp_Object));
 EXFUN (Fcopy_alist, 1);
 EXFUN (Fplist_get, 2);
@@ -2455,6 +2474,7 @@ extern void memory_warnings P_ ((POINTER_TYPE *, void (*warnfun) ()));
 /* Defined in alloc.c */
 extern void check_pure_size P_ ((void));
 extern void allocate_string_data P_ ((struct Lisp_String *, int, int));
+extern void reset_malloc_hooks P_ ((void));
 extern void uninterrupt_malloc P_ ((void));
 extern void malloc_warning P_ ((char *));
 extern void memory_full P_ ((void));
@@ -2849,7 +2869,7 @@ extern void syms_of_search P_ ((void));
 extern Lisp_Object last_minibuf_string;
 extern void choose_minibuf_frame P_ ((void));
 EXFUN (Fcompleting_read, 8);
-EXFUN (Fread_from_minibuffer, 7);
+EXFUN (Fread_from_minibuffer, 8);
 EXFUN (Fread_variable, 2);
 EXFUN (Fread_buffer, 3);
 EXFUN (Fread_minibuffer, 2);
diff --git a/src/lread.c b/src/lread.c
index 5e733f22a6d..49ec852eff3 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1,6 +1,6 @@
 /* Lisp parsing and input streams.
-   Copyright (C) 1985,86,87,88,89,93,94,95,97,98,99,2000,01,03,2004
-      Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 1987, 1988, 1989, 1993, 1994, 1995, 1997, 1998,
+     1999, 2000, 2001, 2003, 2004  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -484,12 +484,13 @@ readbyte_from_file (c, readcharfun)
 
   c = getc (instream);
 #ifdef EINTR
-  /* Interrupted reads have been observed while reading over the network */
-  while (c == EOF && ferror (instream) && errno == EINTR)
-    {
-      clearerr (instream);
-      c = getc (instream);
-    }
+      /* Interrupted reads have been observed while reading over the network */
+      while (c == EOF && ferror (instream) && errno == EINTR)
+        {
+          QUIT;
+          clearerr (instream);
+          c = getc (instream);
+        }
 #endif
   return (c == EOF ? -1 : c);
 }
@@ -3414,7 +3415,7 @@ oblookup (obarray, ptr, size, size_byte)
   hash %= obsize;
   bucket = XVECTOR (obarray)->contents[hash];
   oblookup_last_bucket_number = hash;
-  if (XFASTINT (bucket) == 0)
+  if (EQ (bucket, make_number (0)))
     ;
   else if (!SYMBOLP (bucket))
     error ("Bad data in guts of obarray"); /* Like CADR error message */
diff --git a/src/mac.c b/src/mac.c
index 91d07372578..53e56cfb541 100644
--- a/src/mac.c
+++ b/src/mac.c
@@ -262,6 +262,22 @@ posix_to_mac_pathname (const char *ufn, char *mfn, int mfnbuflen)
   return 1;
 }
 
+#if TARGET_API_MAC_CARBON
+CFStringRef
+cfstring_create_with_utf8_cstring (c_str)
+     const char *c_str;
+{
+  CFStringRef str;
+
+  str = CFStringCreateWithCString (NULL, c_str, kCFStringEncodingUTF8);
+  if (str == NULL)
+    /* Failed to interpret as UTF 8.  Fall back on Mac Roman.  */
+    str = CFStringCreateWithCString (NULL, c_str, kCFStringEncodingMacRoman);
+
+  return str;
+}
+#endif
+
 #ifndef MAC_OSX
 
 /* The following functions with "sys_" prefix are stubs to Unix
diff --git a/src/macfns.c b/src/macfns.c
index 401c7011fea..fdfe7a52416 100644
--- a/src/macfns.c
+++ b/src/macfns.c
@@ -1932,8 +1932,7 @@ x_set_name (f, name, explicit)
       {
 #if TARGET_API_MAC_CARBON
         CFStringRef windowTitle =
-          CFStringCreateWithCString (NULL, SDATA (name),
-                                     kCFStringEncodingUTF8);
+          cfstring_create_with_utf8_cstring (SDATA (name));
 
         SetWindowTitleWithCFString (FRAME_MAC_WINDOW (f), windowTitle);
         CFRelease (windowTitle);
@@ -2015,8 +2014,7 @@ x_set_title (f, name, old_name)
       {
 #if TARGET_API_MAC_CARBON
         CFStringRef windowTitle =
-          CFStringCreateWithCString (NULL, SDATA (name),
-                                     kCFStringEncodingUTF8);
+          cfstring_create_with_utf8_cstring (SDATA (name));
 
         SetWindowTitleWithCFString (FRAME_MAC_WINDOW (f), windowTitle);
         CFRelease (windowTitle);
@@ -4246,8 +4244,7 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     NavDialogRef dialogRef;
     NavTypeListHandle fileTypes = NULL;
     NavUserAction userAction;
-    CFStringRef message=NULL, client=NULL, saveName = NULL, ok = NULL;
-    CFStringRef title = NULL;
+    CFStringRef message=NULL, saveName = NULL;
     
     BLOCK_INPUT;
     /* No need for a callback function because we are modal */
@@ -4259,15 +4256,11 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     options.optionFlags |= kNavSelectAllReadableItem;
     if (!NILP(prompt))
       {
-        message = CFStringCreateWithCStringNoCopy(NULL, SDATA(prompt),
-                                                  kCFStringEncodingUTF8, 
-                                                  kCFAllocatorNull);
+        message = cfstring_create_with_utf8_cstring (SDATA (prompt));
         options.message = message;
       }
     /* Don't set the application, let it use default.
-    client = CFStringCreateWithCStringNoCopy(NULL, "Emacs", 
-                                             kCFStringEncodingMacRoman, NULL);
-    options.clientName = client;
+    options.clientName = CFSTR ("Emacs");
     */
 
     if (!NILP (only_dir_p))
@@ -4276,17 +4269,14 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     else if (NILP (mustmatch)) 
       { 
         /* This is a save dialog */
-        ok = CFStringCreateWithCString (NULL, "Ok", kCFStringEncodingUTF8);
-        title = CFStringCreateWithCString (NULL, "Enter name",
-                                           kCFStringEncodingUTF8);
         options.optionFlags |= kNavDontConfirmReplacement;
-        options.actionButtonLabel = ok;
-        options.windowTitle = title;
+        options.actionButtonLabel = CFSTR ("Ok");
+        options.windowTitle = CFSTR ("Enter name");
 
         if (!NILP(default_filename))
           {
-            saveName = CFStringCreateWithCString(NULL, SDATA(default_filename),
-                                                 kCFStringEncodingUTF8);
+            saveName =
+              cfstring_create_with_utf8_cstring (SDATA (default_filename));
             options.saveFileName = saveName;
             options.optionFlags |= kNavSelectDefaultLocation;
           }
@@ -4320,10 +4310,7 @@ If ONLY-DIR-P is non-nil, the user can only select directories.  */)
     }
 
     if (saveName) CFRelease(saveName);
-    if (client) CFRelease(client);
     if (message) CFRelease(message);
-    if (ok) CFRelease(ok);
-    if (title) CFRelease(title);
 
     if (status == noErr) {
       userAction = NavDialogGetUserAction(dialogRef);
@@ -4415,8 +4402,8 @@ frame_parm_handler mac_frame_parm_handlers[] =
   0, /* MAC_TODO: x_set_scroll_bar_background, */
   x_set_screen_gamma,
   x_set_line_spacing,
-  0, /* MAC_TODO: x_set_fringe_width, */
-  0, /* MAC_TODO: x_set_fringe_width, */
+  x_set_fringe_width,
+  x_set_fringe_width,
   0, /* x_set_wait_for_wm, */
   0, /* MAC_TODO: x_set_fullscreen, */
 };
diff --git a/src/macmenu.c b/src/macmenu.c
index 007fab15eab..f0696a49774 100644
--- a/src/macmenu.c
+++ b/src/macmenu.c
@@ -2264,8 +2264,7 @@ add_menu_item (MenuHandle menu, widget_value *wv, int submenu,
       item_name[255] = 0;
 #if TARGET_API_MAC_CARBON
       {
-        CFStringRef string =
-          CFStringCreateWithCString (NULL, item_name, kCFStringEncodingUTF8);
+        CFStringRef string = cfstring_create_with_utf8_cstring (item_name);
 
         SetMenuItemTextWithCFString (menu, pos, string);
         CFRelease (string);
diff --git a/src/macterm.c b/src/macterm.c
index bc35ab21547..ba19e0fbc31 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -281,7 +281,7 @@ static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
                                    enum text_cursor_kinds));
 
-static void x_clip_to_row P_ ((struct window *, struct glyph_row *, GC));
+static void x_clip_to_row P_ ((struct window *, struct glyph_row *, int, GC));
 static void x_flush P_ ((struct frame *f));
 static void x_update_begin P_ ((struct frame *));
 static void x_update_window_begin P_ ((struct window *));
@@ -569,7 +569,7 @@ XCreatePixmap (display, w, width, height, depth)
      Display *display;          /* not used */
      WindowPtr w;
      unsigned int width, height;
-     unsigned int depth;        /* not used */
+     unsigned int depth;
 {
   Pixmap pixmap;
   Rect r;
@@ -645,6 +645,7 @@ XFillRectangle (display, w, gc, x, y, width, height)
 }
 
 
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
 static void
 mac_fill_rectangle_to_pixmap (display, p, gc, x, y, width, height)
      Display *display;
@@ -668,6 +669,7 @@ mac_fill_rectangle_to_pixmap (display, p, gc, x, y, width, height)
 
   SetGWorld (old_port, old_gdh);
 }
+#endif
 
 
 /* Mac replacement for XDrawRectangle: dest is a window.  */
@@ -691,6 +693,7 @@ mac_draw_rectangle (display, w, gc, x, y, width, height)
 }
 
 
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
 /* Mac replacement for XDrawRectangle: dest is a Pixmap.  */
 
 static void
@@ -716,6 +719,7 @@ mac_draw_rectangle_to_pixmap (display, p, gc, x, y, width, height)
 
   SetGWorld (old_port, old_gdh);
 }
+#endif
 
 
 static void
@@ -910,24 +914,13 @@ mac_scroll_area (display, w, gc, src_x, src_y, width, height, dest_x, dest_y)
      int dest_x, dest_y;
 {
 #if TARGET_API_MAC_CARBON
-  Rect gw_r, src_r, dest_r;
+  Rect src_r;
+  RgnHandle dummy = NewRgn ();  /* For avoiding update events.  */
 
   SetRect (&src_r, src_x, src_y, src_x + width, src_y + height);
-  SetRect (&dest_r, dest_x, dest_y, dest_x + width, dest_y + height);
-
-  SetPortWindowPort (w);
-
-  ForeColor (blackColor);
-  BackColor (whiteColor);
-
-  LockPortBits (GetWindowPort (w));
-  {
-    const BitMap *bitmap = GetPortBitMapForCopyBits (GetWindowPort (w));
-    CopyBits (bitmap, bitmap, &src_r, &dest_r, srcCopy, 0);
-  }
-  UnlockPortBits (GetWindowPort (w));
-
-  mac_set_colors (gc);
+  ScrollWindowRect (w, &src_r, dest_x - src_x, dest_y - src_y,
+                    kScrollWindowNoOptions, dummy);
+  DisposeRgn (dummy);
 #else /* not TARGET_API_MAC_CARBON */
   Rect src_r, dest_r;
 
@@ -961,6 +954,7 @@ mac_scroll_area (display, w, gc, src_x, src_y, width, height, dest_x, dest_y)
 }
 
 
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
 /* Mac replacement for XCopyArea: dest must be Pixmap.  */
 
 static void
@@ -1039,6 +1033,7 @@ mac_copy_area_with_mask_to_pixmap (display, src, mask, dest, gc, src_x, src_y,
 
   SetGWorld (old_port, old_gdh);
 }
+#endif
 
 
 /* Mac replacement for XChangeGC.  */
@@ -1133,40 +1128,32 @@ x_sync (f)
 }
 
 
-/* Remove calls to XFlush by defining XFlush to an empty replacement.
-   Calls to XFlush should be unnecessary because the X output buffer
-   is flushed automatically as needed by calls to XPending,
-   XNextEvent, or XWindowEvent according to the XFlush man page.
-   XTread_socket calls XPending.  Removing XFlush improves
-   performance.  */
-
-#if TARGET_API_MAC_CARBON
-#define XFlush(DISPLAY) QDFlushPortBuffer (GetQDGlobalsThePort (), NULL)
-#else
-#define XFlush(DISPLAY) (void) 0
-#endif
-
 /* Flush display of frame F, or of all frames if F is null.  */
 
-void
+static void
 x_flush (f)
      struct frame *f;
 {
 #if TARGET_API_MAC_CARBON
   BLOCK_INPUT;
-  if (f == NULL)
-    {
-      Lisp_Object rest, frame;
-      FOR_EACH_FRAME (rest, frame)
-        x_flush (XFRAME (frame));
-    }
-  else if (FRAME_MAC_P (f))
-    XFlush (FRAME_MAC_DISPLAY (f));
+  if (f)
+    QDFlushPortBuffer (GetWindowPort (FRAME_MAC_WINDOW (f)), NULL);
+  else
+    QDFlushPortBuffer (GetQDGlobalsThePort (), NULL);
   UNBLOCK_INPUT;
-#endif /* TARGET_API_MAC_CARBON */
+#endif
 }
 
 
+/* Remove calls to XFlush by defining XFlush to an empty replacement.
+   Calls to XFlush should be unnecessary because the X output buffer
+   is flushed automatically as needed by calls to XPending,
+   XNextEvent, or XWindowEvent according to the XFlush man page.
+   XTread_socket calls XPending.  Removing XFlush improves
+   performance.  */
+
+#define XFlush(DISPLAY) (void) 0
+
 
 /* Return the struct mac_display_info corresponding to DPY.  There's
    only one.  */
@@ -1456,12 +1443,12 @@ x_draw_fringe_bitmap (w, row, p)
       int oldVH = row->visible_height;
       row->visible_height = p->h;
       row->y -= rowY - p->y;
-      x_clip_to_row (w, row, gc);
+      x_clip_to_row (w, row, -1, gc);
       row->y = oldY;
       row->visible_height = oldVH;
     }
   else
-    x_clip_to_row (w, row, gc);
+    x_clip_to_row (w, row, -1, gc);
 
   if (p->bx >= 0 && !p->overlay_p)
     {
@@ -1963,6 +1950,14 @@ x_clear_glyph_string_rect (s, x, y, w, h)
 }
 
 
+/* We prefer not to use XDrawImageString (srcCopy text transfer mode)
+   on Mac OS X because:
+   - Screen is double-buffered.  (In srcCopy mode, a text is drawn
+     into an offscreen graphics world first.  So performance gain
+     cannot be expected.)
+   - It lowers rendering quality.
+   - Some fonts leave garbage on cursor movement.  */
+
 /* Draw the background of glyph_string S.  If S->background_filled_p
    is non-zero don't draw it.  FORCE_P non-zero means draw the
    background even if it wouldn't be drawn normally.  This is used
@@ -1994,10 +1989,12 @@ x_draw_glyph_string_background (s, force_p)
         }
       else
 #endif
+#if 0 /* defined(MAC_OS8)*/
         if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
                || s->font_not_found_p
                || s->extends_to_end_of_line_p
                || force_p)
+#endif
         {
           x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
                                      s->background_width,
@@ -2050,6 +2047,7 @@ x_draw_glyph_string_foreground (s)
         for (i = 0; i < s->nchars; ++i)
           char1b[i] = s->char2b[i].byte2;
 
+#if 0 /* defined(MAC_OS8) */
       /* Draw text with XDrawString if background has already been
          filled.  Otherwise, use XDrawImageString.  (Note that
          XDrawImageString is usually faster than XDrawString.)  Always
@@ -2057,6 +2055,7 @@ x_draw_glyph_string_foreground (s)
          no chance that characters under a box cursor are invisible.  */
       if (s->for_overlaps_p
           || (s->background_filled_p && s->hl != DRAW_CURSOR))
+#endif
         {
           /* Draw characters with 16-bit or 8-bit functions.  */
           if (s->two_byte_p)
@@ -2066,6 +2065,7 @@ x_draw_glyph_string_foreground (s)
             XDrawString (s->display, s->window, s->gc, x,
                          s->ybase - boff, char1b, s->nchars);
         }
+#if 0 /* defined(MAC_OS8)*/
       else
         {
           if (s->two_byte_p)
@@ -2075,6 +2075,7 @@ x_draw_glyph_string_foreground (s)
             XDrawImageString (s->display, s->window, s->gc, x,
                               s->ybase - boff, char1b, s->nchars);
         }
+#endif
     }
 }
 
@@ -2641,38 +2642,17 @@ x_draw_image_foreground (s)
 
   if (s->img->pixmap)
     {
+      x_set_glyph_string_clipping (s);
+
       if (s->img->mask)
-        {
-          Rect nr;
-          XRectangle clip_rect, image_rect, r;
-
-          get_glyph_string_clip_rect (s, &nr);
-          CONVERT_TO_XRECT (clip_rect, nr);
-          image_rect.x = x;
-          image_rect.y = y;
-          image_rect.width = s->slice.width;
-          image_rect.height = s->slice.height;
-          if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
-            mac_copy_area_with_mask (s->display, s->img->pixmap, s->img->mask,
-                                     s->window, s->gc,
-                                     s->slice.x + r.x - x, s->slice.y + r.y - y,
-                                     r.width, r.height, r.x, r.y);
-        }
+        mac_copy_area_with_mask (s->display, s->img->pixmap, s->img->mask,
+                                 s->window, s->gc, s->slice.x, s->slice.y,
+                                 s->slice.width, s->slice.height, x, y);
       else
         {
-          Rect nr;
-          XRectangle clip_rect, image_rect, r;
-
-          get_glyph_string_clip_rect (s, &nr);
-          CONVERT_TO_XRECT (clip_rect, nr);
-          image_rect.x = x;
-          image_rect.y = y;
-          image_rect.width = s->slice.width;
-          image_rect.height = s->slice.height;
-          if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
-            mac_copy_area (s->display, s->img->pixmap, s->window, s->gc,
-                           s->slice.x + r.x - x, s->slice.y + r.y - y,
-                           r.width, r.height, r.x, r.y);
+          mac_copy_area (s->display, s->img->pixmap,
+                         s->window, s->gc, s->slice.x, s->slice.y,
+                         s->slice.width, s->slice.height, x, y);
 
           /* When the image has a mask, we can expect that at
              least part of a mouse highlight or a block cursor will
@@ -2751,6 +2731,7 @@ x_draw_image_relief (s)
 }
 
 
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
 /* Draw the foreground of image glyph string S to PIXMAP.  */
 
 static void
@@ -2811,6 +2792,7 @@ x_draw_image_foreground_1 (s, pixmap)
     mac_draw_rectangle_to_pixmap (s->display, pixmap, s->gc, x, y,
                                   s->slice.width - 1, s->slice.height - 1);
 }
+#endif
 
 
 /* Draw part of the background of glyph string S.  X, Y, W, and H
@@ -2882,6 +2864,7 @@ x_draw_image_glyph_string (s)
       if (s->slice.y == 0)
         y += box_line_vwidth;
 
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
       if (s->img->mask)
         {
           /* Create a pixmap as large as the glyph string.  Fill it
@@ -2918,12 +2901,14 @@ x_draw_image_glyph_string (s)
             }
         }
       else
+#endif
         x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
 
       s->background_filled_p = 1;
     }
 
   /* Draw the foreground.  */
+#if 0 /* TODO: figure out if we need to do this on Mac.  */
   if (pixmap != 0)
     {
       x_draw_image_foreground_1 (s, pixmap);
@@ -2934,6 +2919,7 @@ x_draw_image_glyph_string (s)
       XFreePixmap (s->display, pixmap);
     }
   else
+#endif
     x_draw_image_foreground (s);
 
   /* If we must draw a relief around the image, do it.  */
@@ -4621,18 +4607,19 @@ x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
    mode lines must be clipped to the whole window.  */
 
 static void
-x_clip_to_row (w, row, gc)
+x_clip_to_row (w, row, area, gc)
      struct window *w;
      struct glyph_row *row;
+     int area;
      GC gc;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   Rect clip_rect;
-  int window_y, window_width;
+  int window_x, window_y, window_width;
 
-  window_box (w, -1, 0, &window_y, &window_width, 0);
+  window_box (w, area, &window_x, &window_y, &window_width, 0);
 
-  clip_rect.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+  clip_rect.left = window_x;
   clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
   clip_rect.top = max (clip_rect.top, window_y);
   clip_rect.right = clip_rect.left + window_width;
@@ -4698,7 +4685,7 @@ x_draw_hollow_cursor (w, row)
   gc = dpyinfo->scratch_cursor_gc;
 
   /* Set clipping, draw the rectangle, and reset clipping again.  */
-  x_clip_to_row (w, row, gc);
+  x_clip_to_row (w, row, TEXT_AREA, gc);
   mac_draw_rectangle (dpy, FRAME_MAC_WINDOW (f), gc, x, y, wd, h);
   mac_reset_clipping (dpy, FRAME_MAC_WINDOW (f));
 }
@@ -4769,7 +4756,7 @@ x_draw_bar_cursor (w, row, width, kind)
       width = min (cursor_glyph->pixel_width, width);
 
       w->phys_cursor_width = width;
-      x_clip_to_row (w, row, gc);
+      x_clip_to_row (w, row, TEXT_AREA, gc);
 
       if (kind == BAR_CURSOR)
         XFillRectangle (dpy, window, gc,
@@ -5915,7 +5902,14 @@ mac_font_match (char *mf, char *xf)
 static Lisp_Object Qbig5, Qcn_gb, Qsjis, Qeuc_kr;
 
 static void
-decode_mac_font_name (char *name, int size, short scriptcode)
+decode_mac_font_name (name, size, scriptcode)
+     char *name;
+     int size;
+#if TARGET_API_MAC_CARBON
+     int scriptcode;
+#else
+     short scriptcode;
+#endif
 {
   Lisp_Object coding_system;
   struct coding_system coding;
@@ -5957,7 +5951,15 @@ decode_mac_font_name (char *name, int size, short scriptcode)
 
 
 static char *
-mac_to_x_fontname (char *name, int size, Style style, short scriptcode)
+mac_to_x_fontname (name, size, style, scriptcode, encoding_base)
+     char *name;
+     int size;
+     Style style;
+#if TARGET_API_MAC_CARBON
+     int scriptcode;
+#else
+     short scriptcode;
+#endif
 {
   char foundry[32], family[32], cs[32];
   char xf[256], *result, *p;
@@ -5969,13 +5971,13 @@ mac_to_x_fontname (char *name, int size, Style style, short scriptcode)
 
       switch (scriptcode)
       {
-      case smTradChinese:
+      case smTradChinese:       /* == kTextEncodingMacChineseTrad */
         strcpy(cs, "big5-0");
         break;
-      case smSimpChinese:
+      case smSimpChinese:       /* == kTextEncodingMacChineseSimp */
         strcpy(cs, "gb2312.1980-0");
         break;
-      case smJapanese:
+      case smJapanese:          /* == kTextEncodingMacJapanese */
         strcpy(cs, "jisx0208.1983-sjis");
         break;
       case -smJapanese:
@@ -5987,12 +5989,24 @@ mac_to_x_fontname (char *name, int size, Style style, short scriptcode)
            font is being built.  */
         strcpy(cs, "jisx0201.1976-0");
         break;
-      case smKorean:
+      case smKorean:            /* == kTextEncodingMacKorean */
         strcpy(cs, "ksc5601.1989-0");
         break;
+#if TARGET_API_MAC_CARBON
+      case kTextEncodingMacCyrillic:
+        strcpy(cs, "mac-cyrillic");
+        break;
+      case kTextEncodingMacCentralEurRoman:
+        strcpy(cs, "mac-centraleuropean");
+        break;
+      case kTextEncodingMacSymbol:
+      case kTextEncodingMacDingbats:
+        strcpy(cs, "adobe-fontspecific");
+        break;
+#endif
       default:
-        strcpy(cs, "mac-roman");
-        break;
+        strcpy(cs, "mac-roman");
+        break;
       }
     }
 
@@ -6039,7 +6053,10 @@ x_font_name_to_mac_font_name (char *xf, char *mf)
     coding_system = Qsjis;
   else if (strcmp (cs, "ksc5601.1989-0") == 0)
     coding_system = Qeuc_kr;
-  else if (strcmp (cs, "mac-roman") == 0)
+  else if (strcmp (cs, "mac-roman") == 0
+           || strcmp (cs, "mac-cyrillic") == 0
+           || strcmp (cs, "mac-centraleuropean") == 0
+           || strcmp (cs, "adobe-fontspecific") == 0)
     strcpy (mf, family);
   else
     sprintf (mf, "%s-%s-%s", foundry, family, cs);
@@ -6114,7 +6131,8 @@ init_font_name_table ()
           FMFont font;
           FMFontStyle style;
           FMFontSize size;
-          SInt16 sc;
+          TextEncoding encoding;
+          TextEncodingBase sc;
 
           if (FMGetFontFamilyName (ff, name) != noErr)
             break;
@@ -6122,9 +6140,11 @@ init_font_name_table ()
           if (*name == '.')
             continue;
 
-          sc = FontToScript (ff);
+          if (FMGetFontFamilyTextEncoding (ff, &encoding) != noErr)
+            break;
+          sc = GetTextEncodingBase (encoding);
           decode_mac_font_name (name, sizeof (name), sc);
-
+                                       
           /* Point the instance iterator at the current font family.  */
           if (FMResetFontFamilyInstanceIterator (ff, &ffii) != noErr)
             break;
@@ -8644,17 +8664,30 @@ XTread_socket (sd, expected, hold_quit)
                 {
                   unsigned char ch = inev.code;
                   ByteCount actual_input_length, actual_output_length;
-                  unsigned char outch;
-
-                  convert_status = TECConvertText (converter, &ch, 1,
-                                                   &actual_input_length,
-                                                   &outch, 1,
-                                                   &actual_output_length);
-                  if (convert_status == noErr
-                      && actual_input_length == 1
-                      && actual_output_length == 1)
-                    inev.code = outch;
-                }
+                  unsigned char outbuf[32];
+                  
+                  convert_status = TECConvertText (converter, &ch, 1,
+                                                   &actual_input_length,
+                                                   outbuf, 1,
+                                                   &actual_output_length);
+                  if (convert_status == noErr
+                      && actual_input_length == 1
+                      && actual_output_length == 1)
+                    inev.code = *outbuf;
+                  
+                  /* Reset internal states of the converter object.
+                   If it fails, create another one. */
+                  convert_status = TECFlushText (converter, outbuf,
+                                                 sizeof (outbuf),
+                                               &actual_output_length);
+                  if (convert_status != noErr)
+                    {
+                      TECDisposeConverter (converter);
+                      TECCreateConverter (&converter,
+                                          kTextEncodingMacRoman,
+                                          mac_keyboard_text_encoding);
+                    }
+                }
             }
 
 #if USE_CARBON_EVENTS
@@ -9173,7 +9206,7 @@ static struct redisplay_interface x_redisplay_interface =
   x_update_window_end,
   x_cursor_to,
   x_flush,
-  x_flush,
+  0, /* flush_display_optional */
   x_clear_window_mouse_face,
   x_get_glyph_overhangs,
   x_fix_overlapping_area,
diff --git a/src/macterm.h b/src/macterm.h
index f9bde772fcd..ff7110828b1 100644
--- a/src/macterm.h
+++ b/src/macterm.h
@@ -600,5 +600,9 @@ extern void mac_draw_line_to_pixmap P_ ((Display *, Pixmap, GC, int, int,
 #define FONT_TYPE_FOR_UNIBYTE(font, ch) 0
 #define FONT_TYPE_FOR_MULTIBYTE(font, ch) 0
 
+#if TARGET_API_MAC_CARBON
+extern CFStringRef cfstring_create_with_utf8_cstring P_ ((const char *));
+#endif
+
 /* arch-tag: 6b4ca125-5bef-476d-8ee8-31ed808b7e79
    (do not change this comment) */
diff --git a/src/minibuf.c b/src/minibuf.c
index 7aeb0283f2c..109b1fc1df0 100644
--- a/src/minibuf.c
+++ b/src/minibuf.c
@@ -218,7 +218,7 @@ static Lisp_Object read_minibuf P_ ((Lisp_Object, Lisp_Object,
                                      Lisp_Object, Lisp_Object,
                                      int, Lisp_Object,
                                      Lisp_Object, Lisp_Object,
-                                     int, int));
+                                     int, int, int));
 static Lisp_Object read_minibuf_noninteractive P_ ((Lisp_Object, Lisp_Object,
                                                     Lisp_Object, Lisp_Object,
                                                     int, Lisp_Object,
@@ -437,7 +437,8 @@ minibuffer_completion_contents ()
 
 static Lisp_Object
 read_minibuf (map, initial, prompt, backup_n, expflag,
-              histvar, histpos, defalt, allow_props, inherit_input_method)
+              histvar, histpos, defalt, allow_props, inherit_input_method,
+              keep_all)
      Lisp_Object map;
      Lisp_Object initial;
      Lisp_Object prompt;
@@ -448,6 +449,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
      Lisp_Object defalt;
      int allow_props;
      int inherit_input_method;
+     int keep_all;
 {
   Lisp_Object val;
   int count = SPECPDL_INDEX ();
@@ -722,7 +724,7 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
   last_minibuf_string = val;
 
   /* Choose the string to add to the history.  */
-  if (SCHARS (val) != 0)
+  if (SCHARS (val) != 0 || keep_all)
     histstring = val;
   else if (STRINGP (defalt))
     histstring = defalt;
@@ -749,7 +751,8 @@ read_minibuf (map, initial, prompt, backup_n, expflag,
       if (NILP (histval)
           || (CONSP (histval)
               /* Don't duplicate the most recent entry in the history.  */
-              && NILP (Fequal (histstring, Fcar (histval)))))
+              && (keep_all
+                  || NILP (Fequal (histstring, Fcar (histval))))))
         {
           Lisp_Object length;
 
@@ -911,7 +914,7 @@ read_minibuf_unwind (data)
 }
 
 
-DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 7, 0,
+DEFUN ("read-from-minibuffer", Fread_from_minibuffer, Sread_from_minibuffer, 1, 8, 0,
        doc: /* Read a string from the minibuffer, prompting with string PROMPT.
 The optional second arg INITIAL-CONTENTS is an obsolete alternative to
   DEFAULT-VALUE.  It normally should be nil in new code, except when
@@ -935,6 +938,8 @@ Sixth arg DEFAULT-VALUE is the default value.  If non-nil, it is available
   the empty string.
 Seventh arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
  the current input method and the setting of `enable-multibyte-characters'.
+Eight arg KEEP-ALL, if non-nil, says to put all inputs in the history list,
+ even empty or duplicate inputs.
 If the variable `minibuffer-allow-text-properties' is non-nil,
  then the string which is returned includes whatever text properties
  were present in the minibuffer.  Otherwise the value has no text properties.
@@ -950,9 +955,9 @@ POSITION in the minibuffer.  Any integer value less than or equal to
 one puts point at the beginning of the string.  *Note* that this
 behavior differs from the way such arguments are used in `completing-read'
 and some related functions, which use zero-indexing for POSITION.  */)
-     (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method)
+  (prompt, initial_contents, keymap, read, hist, default_value, inherit_input_method, keep_all)
      Lisp_Object prompt, initial_contents, keymap, read, hist, default_value;
-     Lisp_Object inherit_input_method;
+     Lisp_Object inherit_input_method, keep_all;
 {
   Lisp_Object histvar, histpos, val;
   struct gcpro gcpro1;
@@ -983,7 +988,8 @@ and some related functions, which use zero-indexing for POSITION.  */)
                       Qnil, !NILP (read),
                       histvar, histpos, default_value,
                       minibuffer_allow_text_properties,
-                      !NILP (inherit_input_method));
+                      !NILP (inherit_input_method),
+                      !NILP (keep_all));
   UNGCPRO;
   return val;
 }
@@ -1000,7 +1006,7 @@ arguments are used as in `read-from-minibuffer')  */)
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_map, initial_contents,
                        prompt, Qnil, 1, Qminibuffer_history,
-                       make_number (0), Qnil, 0, 0);
+                       make_number (0), Qnil, 0, 0, 0);
 }
 
 DEFUN ("eval-minibuffer", Feval_minibuffer, Seval_minibuffer, 1, 2, 0,
@@ -1038,7 +1044,7 @@ Fifth arg INHERIT-INPUT-METHOD, if non-nil, means the minibuffer inherits
   Lisp_Object val;
   val = Fread_from_minibuffer (prompt, initial_input, Qnil,
                                Qnil, history, default_value,
-                               inherit_input_method);
+                               inherit_input_method, Qnil);
   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (default_value))
     val = default_value;
   return val;
@@ -1060,7 +1066,7 @@ the current input method and the setting of`enable-multibyte-characters'.  */)
   CHECK_STRING (prompt);
   return read_minibuf (Vminibuffer_local_ns_map, initial, prompt, Qnil,
                        0, Qminibuffer_history, make_number (0), Qnil, 0,
-                       !NILP (inherit_input_method));
+                       !NILP (inherit_input_method), 0);
 }
 
 DEFUN ("read-command", Fread_command, Sread_command, 1, 2, 0,
@@ -1711,7 +1717,7 @@ Completion ignores case if the ambient value of
                       : Vminibuffer_local_must_match_map,
                       init, prompt, make_number (pos), 0,
                       histvar, histpos, def, 0,
-                      !NILP (inherit_input_method));
+                      !NILP (inherit_input_method), 0);
 
   if (STRINGP (val) && SCHARS (val) == 0 && ! NILP (def))
     val = def;
@@ -2076,10 +2082,28 @@ a repetition of this command will exit.  */)
   if (XINT (Fminibuffer_prompt_end ()) == ZV)
     goto exit;
 
-  if (!NILP (Ftest_completion (Fminibuffer_contents (),
+  val = Fminibuffer_contents ();
+  if (!NILP (Ftest_completion (val,
                                Vminibuffer_completion_table,
                                Vminibuffer_completion_predicate)))
-    goto exit;
+    {
+      if (completion_ignore_case)
+        { /* Fixup case of the field, if necessary. */
+          Lisp_Object compl
+            = Ftry_completion (val,
+                               Vminibuffer_completion_table,
+                               Vminibuffer_completion_predicate);
+          if (STRINGP (compl)
+              /* If it weren't for this piece of paranoia, I'd replace
+                 the whole thing with a call to do_completion. */
+              && EQ (Flength (val), Flength (compl)))
+            {
+              del_range (XINT (Fminibuffer_prompt_end ()), ZV);
+              Finsert (1, &compl);
+            }
+        }
+      goto exit;
+    }
 
   /* Call do_completion, but ignore errors.  */
   SET_PT (ZV);
diff --git a/src/regex.c b/src/regex.c
index 71a450f9b23..f21955a3c0e 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -1275,7 +1275,7 @@ reg_syntax_t re_syntax_options;
 
 reg_syntax_t
 re_set_syntax (syntax)
-    reg_syntax_t syntax;
+     reg_syntax_t syntax;
 {
   reg_syntax_t ret = re_syntax_options;
 
@@ -1283,6 +1283,17 @@ re_set_syntax (syntax)
   return ret;
 }
 WEAK_ALIAS (__re_set_syntax, re_set_syntax)
+
+/* Regexp to use to replace spaces, or NULL meaning don't.  */
+static re_char *whitespace_regexp;
+
+void
+re_set_whitespace_regexp (regexp)
+     re_char *regexp;
+{
+  whitespace_regexp = regexp;
+}
+WEAK_ALIAS (__re_set_syntax, re_set_syntax)
 
 /* This table gives an error message for each of the error codes listed
    in regex.h.  Obviously the order here has to be same as there.
@@ -1993,28 +2004,27 @@ struct range_table_work_area
 
 /* Get the next unsigned number in the uncompiled pattern.  */
 #define GET_UNSIGNED_NUMBER(num)                                        \
- do { if (p != pend)                                                    \
-     {                                                                  \
-       PATFETCH (c);                                                    \
-       if (c == ' ')                                                    \
-         FREE_STACK_RETURN (REG_BADBR);                                 \
-       while ('0' <= c && c <= '9')                                     \
-         {                                                              \
-           int prev;                                                    \
-           if (num < 0)                                                 \
-             num = 0;                                                   \
-           prev = num;                                                  \
-           num = num * 10 + c - '0';                                    \
-           if (num / 10 != prev)                                        \
-             FREE_STACK_RETURN (REG_BADBR);                             \
-           if (p == pend)                                               \
-             break;                                                     \
-           PATFETCH (c);                                                \
-         }                                                              \
-       if (c == ' ')                                                    \
-         FREE_STACK_RETURN (REG_BADBR);                                 \
-       }                                                                \
-    } while (0)
+  do {                                                                  \
+    if (p == pend)                                                      \
+      FREE_STACK_RETURN (REG_EBRACE);                                   \
+    else                                                                \
+      {                                                                 \
+        PATFETCH (c);                                                   \
+        while ('0' <= c && c <= '9')                                    \
+          {                                                             \
+            int prev;                                                   \
+            if (num < 0)                                                \
+              num = 0;                                                  \
+            prev = num;                                                 \
+            num = num * 10 + c - '0';                                   \
+            if (num / 10 != prev)                                       \
+              FREE_STACK_RETURN (REG_BADBR);                            \
+            if (p == pend)                                              \
+              FREE_STACK_RETURN (REG_EBRACE);                           \
+            PATFETCH (c);                                               \
+          }                                                             \
+      }                                                                 \
+  } while (0)
 
 #if ! WIDE_CHAR_SUPPORT
 
@@ -2495,6 +2505,15 @@ regex_compile (pattern, size, syntax, bufp)
   /* If a target of matching can contain multibyte characters.  */
   const boolean target_multibyte = RE_TARGET_MULTIBYTE_P (bufp);
 
+  /* Nonzero if we have pushed down into a subpattern.  */
+  int in_subpattern = 0;
+
+  /* These hold the values of p, pattern, and pend from the main
+     pattern when we have pushed into a subpattern.  */
+  re_char *main_p;
+  re_char *main_pattern;
+  re_char *main_pend;
+
 #ifdef DEBUG
   debug++;
   DEBUG_PRINT1 ("\nCompiling pattern: ");
@@ -2557,12 +2576,61 @@ regex_compile (pattern, size, syntax, bufp)
   begalt = b = bufp->buffer;
 
   /* Loop through the uncompiled pattern until we're at the end.  */
-  while (p != pend)
+  while (1)
     {
+      if (p == pend)
+        {
+          /* If this is the end of an included regexp,
+             pop back to the main regexp and try again.  */
+          if (in_subpattern)
+            {
+              in_subpattern = 0;
+              pattern = main_pattern;
+              p = main_p;
+              pend = main_pend;
+              continue;
+            }
+          /* If this is the end of the main regexp, we are done.  */
+          break;
+        }
+
       PATFETCH (c);
 
       switch (c)
         {
+        case ' ':
+          {
+            re_char *p1 = p;
+
+            /* If there's no special whitespace regexp, treat
+               spaces normally.  And don't try to do this recursively.  */
+            if (!whitespace_regexp || in_subpattern)
+              goto normal_char;
+
+            /* Peek past following spaces.  */
+            while (p1 != pend)
+              {
+                if (*p1 != ' ')
+                  break;
+                p1++;
+              }
+            /* If the spaces are followed by a repetition op,
+               treat them normally.  */
+            if (p1 != pend
+                && (*p1 == '*' || *p1 == '+' || *p1 == '?'
+                    || (*p1 == '\\' && p1 + 1 != pend && p1[1] == '{')))
+              goto normal_char;
+
+            /* Replace the spaces with the whitespace regexp.  */
+            in_subpattern = 1;
+            main_p = p1;
+            main_pend = pend;
+            main_pattern = pattern;
+            p = pattern = whitespace_regexp;
+            pend = p + strlen (p);
+            break;
+          }    
+
         case '^':
           {
             if (   /* If at start of pattern, it's an operator.  */
@@ -3231,9 +3299,6 @@ regex_compile (pattern, size, syntax, bufp)
 
                 beg_interval = p;
 
-                if (p == pend)
-                  FREE_STACK_RETURN (REG_EBRACE);
-
                 GET_UNSIGNED_NUMBER (lower_bound);
 
                 if (c == ',')
@@ -3250,7 +3315,8 @@ regex_compile (pattern, size, syntax, bufp)
                   {
                     if (c != '\\')
                       FREE_STACK_RETURN (REG_BADBR);
-
+                    if (p == pend)
+                      FREE_STACK_RETURN (REG_EESCAPE);
                     PATFETCH (c);
                   }
 
diff --git a/src/s/darwin.h b/src/s/darwin.h
index f854ed9380b..9f78405a43c 100644
--- a/src/s/darwin.h
+++ b/src/s/darwin.h
@@ -217,6 +217,13 @@ Boston, MA 02111-1307, USA.  */
 /* Define HAVE_SOCKETS if system supports 4.2-compatible sockets.  */
 #define HAVE_SOCKETS
 
+/* In Carbon, asynchronous I/O (using SIGIO) can't be used for window
+   events because they don't come from sockets, even though it works
+   fine on tty's.  */
+#ifdef HAVE_CARBON
+#define NO_SOCK_SIGIO
+#endif
+
 /* Extra initialization calls in main for Mac OS X system type.  */
 #ifdef HAVE_CARBON
 #define SYMS_SYSTEM syms_of_mac()
@@ -314,6 +321,10 @@ struct kboard;
 #define free unexec_free
 #endif
 
+/* This makes create_process in process.c save and restore signal
+   handlers correctly.  Suggested by Nozomu Ando.*/
+#define POSIX_SIGNALS
+
 /* Reroute calls to SELECT to the version defined in mac.c to fix the
    problem of Emacs requiring an extra return to be typed to start
    working when started from the command line.  */
diff --git a/src/s/gnu-linux.h b/src/s/gnu-linux.h
index 033ce49293a..3cf21756d7d 100644
--- a/src/s/gnu-linux.h
+++ b/src/s/gnu-linux.h
@@ -1,5 +1,5 @@
 /* This file is the configuration file for Linux-based GNU systems
-   Copyright (C) 1985, 86, 92, 94, 96, 1999, 2002 Free Software Foundation, Inc.
+   Copyright (C) 1985, 86, 92, 94, 96, 1999, 2002, 2004 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -355,12 +355,22 @@ Boston, MA 02111-1307, USA.  */
 
 #if defined __i386__ || defined __sparc__ || defined __mc68000__ \
     || defined __alpha__ || defined __mips__ || defined __s390__ \
-    || defined __arm__ || defined __powerpc__ || defined __amd64__
+    || defined __arm__ || defined __powerpc__ || defined __amd64__ \
+    || defined __ia64__
 #define GC_SETJMP_WORKS 1
 #define GC_MARK_STACK GC_MAKE_GCPROS_NOOPS
 #ifdef __mc68000__
 #define GC_LISP_OBJECT_ALIGNMENT 2
 #endif
+#ifdef __ia64__
+#define GC_MARK_SECONDARY_STACK()                               \
+  do {                                                          \
+    extern void *__libc_ia64_register_backing_store_base;       \
+    __builtin_ia64_flushrs ();                                  \
+    mark_memory (__libc_ia64_register_backing_store_base,       \
+                 __builtin_ia64_bsp ());                        \
+  } while (0)
+#endif
 #endif
 
 /* arch-tag: 6244ea2a-abd0-44ec-abec-ff3dcc9afea9
diff --git a/src/search.c b/src/search.c
index 59539de8768..41b71934e9f 100644
--- a/src/search.c
+++ b/src/search.c
@@ -41,7 +41,7 @@ Boston, MA 02111-1307, USA.  */
 struct regexp_cache
 {
   struct regexp_cache *next;
-  Lisp_Object regexp;
+  Lisp_Object regexp, whitespace_regexp;
   struct re_pattern_buffer buf;
   char fastmap[0400];
   /* Nonzero means regexp was compiled to do full POSIX backtracking.  */
@@ -83,6 +83,8 @@ static Lisp_Object last_thing_searched;
 
 Lisp_Object Qinvalid_regexp;
 
+Lisp_Object Vsearch_spaces_regexp;
+
 static void set_search_regs ();
 static void save_search_regs ();
 static int simple_search ();
@@ -1018,7 +1020,7 @@ search_buffer (string, pos, pos_byte, lim, lim_byte, n,
       return pos;
     }
 
-  if (RE && !trivial_regexp_p (string))
+  if (RE && !(trivial_regexp_p (string) && NILP (Vsearch_spaces_regexp)))
     {
       unsigned char *p1, *p2;
       int s1, s2;
@@ -2801,7 +2803,7 @@ LIST should have been created by calling `match-data' previously.  */)
         else
           {
             int from;
-            
+
             if (MARKERP (marker))
               {
                 if (XMARKER (marker)->buffer == 0)
@@ -2809,15 +2811,15 @@ LIST should have been created by calling `match-data' previously.  */)
                 else
                   XSETBUFFER (last_thing_searched, XMARKER (marker)->buffer);
               }
-            
+
             CHECK_NUMBER_COERCE_MARKER (marker);
             from = XINT (marker);
             list = Fcdr (list);
-            
+
             marker = Fcar (list);
             if (MARKERP (marker) && XMARKER (marker)->buffer == 0)
               XSETFASTINT (marker, 0);
-            
+
             CHECK_NUMBER_COERCE_MARKER (marker);
             search_regs.start[i] = from;
             search_regs.end[i] = XINT (marker);
@@ -2926,6 +2928,7 @@ syms_of_search ()
       searchbufs[i].buf.buffer = (unsigned char *) xmalloc (100);
       searchbufs[i].buf.fastmap = searchbufs[i].fastmap;
       searchbufs[i].regexp = Qnil;
+      searchbufs[i].whitespace_regexp = Qnil;
       staticpro (&searchbufs[i].regexp);
       searchbufs[i].next = (i == REGEXP_CACHE_SIZE-1 ? 0 : &searchbufs[i+1]);
     }
@@ -2952,6 +2955,14 @@ syms_of_search ()
   saved_last_thing_searched = Qnil;
   staticpro (&saved_last_thing_searched);
 
+  DEFVAR_LISP ("search-spaces-regexp", &Vsearch_spaces_regexp,
+      doc: /* Regexp to substitute for bunches of spaces in regexp search.
+Some commands use this for user-specified regexps.
+Spaces that occur inside character classes or repetition operators
+or other such regexp constructs are not replaced with this.
+A value of nil (which is the normal value) means treat spaces literally.  */);
+  Vsearch_spaces_regexp = Qnil;
+
   defsubr (&Slooking_at);
   defsubr (&Sposix_looking_at);
   defsubr (&Sstring_match);
diff --git a/src/sysdep.c b/src/sysdep.c
index b120dcd950d..6284774d092 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1,6 +1,6 @@
 /* Interfaces to system-dependent kernel and library entries.
-   Copyright (C) 1985, 86,87,88,93,94,95,1999,2000,01,2003
-   Free Software Foundation, Inc.
+   Copyright (C) 1985, 1986, 1987, 1988, 1993, 1994, 1995, 1999, 2000, 2001,
+     2003, 2004  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -2768,12 +2768,16 @@ sys_signal (int signal_number, signal_handler_t action)
   struct sigaction new_action, old_action;
   sigemptyset (&new_action.sa_mask);
   new_action.sa_handler = action;
-#if defined (SA_RESTART) && ! defined (BROKEN_SA_RESTART)
+#if defined (SA_RESTART) && ! defined (BROKEN_SA_RESTART) && !defined(SYNC_INPUT)
   /* Emacs mostly works better with restartable system services. If this
      flag exists, we probably want to turn it on here.
      However, on some systems this resets the timeout of `select'
      which means that `select' never finishes if it keeps getting signals.
      BROKEN_SA_RESTART is defined on those systems.  */
+  /* It's not clear why the comment above says "mostly works better".  --Stef
+     When SYNC_INPUT is set, we don't want SA_RESTART because we need to poll
+     for pending input so we need long-running syscalls to be interrupted
+     after a signal that sets the interrupt_input_pending flag.  */
   new_action.sa_flags = SA_RESTART;
 #else
   new_action.sa_flags = 0;
@@ -3225,7 +3229,8 @@ emacs_open (path, oflag, mode)
 #endif
 
   while ((rtnval = open (path, oflag, mode)) == -1
-         && (errno == EINTR));
+         && (errno == EINTR))
+    QUIT;
   return (rtnval);
 }
 
@@ -3258,7 +3263,8 @@ emacs_read (fildes, buf, nbyte)
   register int rtnval;
 
   while ((rtnval = read (fildes, buf, nbyte)) == -1
-         && (errno == EINTR));
+         && (errno == EINTR))
+    QUIT;
   return (rtnval);
 }
 
@@ -3279,7 +3285,15 @@ emacs_write (fildes, buf, nbyte)
       if (rtnval == -1)
         {
           if (errno == EINTR)
-            continue;
+            {
+#ifdef SYNC_INPUT
+              /* I originally used `QUIT' but that might causes files to
+                 be truncated if you hit C-g in the middle of it.  --Stef  */
+              if (interrupt_input_pending)
+                handle_async_input ();
+#endif
+              continue;
+            }
           else
             return (bytes_written ? bytes_written : -1);
         }
diff --git a/src/term.c b/src/term.c
index 609efcb8439..1520a96babd 100644
--- a/src/term.c
+++ b/src/term.c
@@ -954,9 +954,14 @@ write_glyphs (string, len)
 
   cmplus (len);
 
+  /* If terminal_coding does any conversion, use it, otherwise use
+     safe_terminal_coding.  We can't use CODING_REQUIRE_ENCODING here
+     because it always return 1 if the member src_multibyte is 1.  */
+  coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+            ? &terminal_coding : &safe_terminal_coding);
   /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
      the tail.  */
-  terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+  coding->mode &= ~CODING_MODE_LAST_BLOCK;
 
   while (len > 0)
     {
@@ -1006,6 +1011,9 @@ insert_glyphs (start, len)
   char *buf;
   struct glyph *glyph = NULL;
   struct frame *f, *sf;
+  unsigned char *conversion_buffer;
+  unsigned char space[1];
+  struct coding_system *coding;
 
   if (len <= 0)
     return;
@@ -2239,6 +2247,8 @@ term_init (terminal_type)
   int status;
   struct frame *sf = XFRAME (selected_frame);
 
+  encode_terminal_bufsize = 0;
+
 #ifdef WINDOWSNT
   initialize_w32_display ();
 
diff --git a/src/w32console.c b/src/w32console.c
index cd71f0ba6ad..170ce5508be 100644
--- a/src/w32console.c
+++ b/src/w32console.c
@@ -296,6 +296,9 @@ w32con_insert_glyphs (register struct glyph *start, register int len)
 
 extern unsigned char *terminal_encode_buffer;
 
+extern unsigned char *encode_terminal_code P_ ((struct glyph *, int, 
+                                                struct coding_system *));
+
 static void
 w32con_write_glyphs (register struct glyph *string, register int len)
 {
diff --git a/src/w32term.c b/src/w32term.c
index f50f5a49e8a..da24d2051ea 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -287,7 +287,7 @@ static void x_frame_rehighlight P_ ((struct w32_display_info *));
 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
                                    enum text_cursor_kinds));
-static void w32_clip_to_row P_ ((struct window *, struct glyph_row *, HDC));
+static void w32_clip_to_row P_ ((struct window *, struct glyph_row *, int, HDC));
 
 static Lisp_Object Qvendor_specific_keysyms;
 
@@ -718,12 +718,12 @@ w32_draw_fringe_bitmap (w, row, p)
       int oldVH = row->visible_height;
       row->visible_height = p->h;
       row->y -= rowY - p->y;
-      w32_clip_to_row (w, row, hdc);
+      w32_clip_to_row (w, row, -1, hdc);
       row->y = oldY;
       row->visible_height = oldVH;
     }
   else
-    w32_clip_to_row (w, row, hdc);
+    w32_clip_to_row (w, row, -1, hdc);
 
   if (p->bx >= 0 && !p->overlay_p)
     {
@@ -5063,18 +5063,19 @@ w32_read_socket (sd, expected, hold_quit)
    mode lines must be clipped to the whole window.  */
 
 static void
-w32_clip_to_row (w, row, hdc)
+w32_clip_to_row (w, row, area, hdc)
      struct window *w;
      struct glyph_row *row;
+     int area;
      HDC hdc;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   RECT clip_rect;
-  int window_y, window_width;
+  int window_x, window_y, window_width;
 
-  window_box (w, -1, 0, &window_y, &window_width, 0);
+  window_box (w, area, &window_x, &window_y, &window_width, 0);
 
-  clip_rect.left = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+  clip_rect.left = window_x;
   clip_rect.top = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
   clip_rect.top = max (clip_rect.top, window_y);
   clip_rect.right = clip_rect.left + window_width;
@@ -5134,7 +5135,7 @@ x_draw_hollow_cursor (w, row)
   rect.right = rect.left + wd;
   hdc = get_frame_dc (f);
   /* Set clipping, draw the rectangle, and reset clipping again.  */
-  w32_clip_to_row (w, row, hdc);
+  w32_clip_to_row (w, row, TEXT_AREA, hdc);
   FrameRect (hdc, &rect, hb);
   DeleteObject (hb);
   w32_set_clip_rectangle (hdc, NULL);
@@ -5200,7 +5201,7 @@ x_draw_bar_cursor (w, row, width, kind)
 
 
       hdc = get_frame_dc (f);
-      w32_clip_to_row (w, row, hdc);
+      w32_clip_to_row (w, row, TEXT_AREA, hdc);
 
       if (kind == BAR_CURSOR)
         {
diff --git a/src/window.c b/src/window.c
index 3f8fa513619..a07bd437faa 100644
--- a/src/window.c
+++ b/src/window.c
@@ -1611,7 +1611,7 @@ decode_next_window_args (window, minibuf, all_frames)
                    : Qnil);
   else if (EQ (*all_frames, Qvisible))
     ;
-  else if (XFASTINT (*all_frames) == 0)
+  else if (EQ (*all_frames, make_number (0)))
     ;
   else if (FRAMEP (*all_frames))
     ;
@@ -1885,7 +1885,7 @@ window_loop (type, obj, mini, frames)
 
   if (f)
     frame_arg = Qlambda;
-  else if (XFASTINT (frames) == 0)
+  else if (EQ (frames, make_number (0)))
     frame_arg = frames;
   else if (EQ (frames, Qvisible))
     frame_arg = frames;
@@ -2097,6 +2097,8 @@ DEFUN ("get-lru-window", Fget_lru_window, Sget_lru_window, 0, 1, 0,
        doc: /* Return the window least recently selected or used for display.
 Return a full-width window if possible.
 A minibuffer window is never a candidate.
+A dedicated window is never a candidate, so if all windows are dedicated,
+the value is nil.
 If optional argument FRAME is `visible', search all visible frames.
 If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
@@ -2117,6 +2119,8 @@ If FRAME is a frame, search only that frame.  */)
 DEFUN ("get-largest-window", Fget_largest_window, Sget_largest_window, 0, 1, 0,
        doc: /* Return the largest window in area.
 A minibuffer window is never a candidate.
+A dedicated window is never a candidate, so if all windows are dedicated,
+the value is nil.
 If optional argument FRAME is `visible', search all visible frames.
 If FRAME is 0, search all visible and iconified frames.
 If FRAME is t, search all frames.
@@ -2694,7 +2698,7 @@ shrink_windows (total, size, nchildren, shrinkable,
             ++nonzero_sizes;
             nonzero_idx = i;
           }
-      
+
       for (i = 0; i < nchildren; ++i)
         if (new_sizes[i] > min_size)
           {
@@ -3012,6 +3016,9 @@ set_window_buffer (window, buffer, run_hooks_p, keep_margins_p)
   if (EQ (window, selected_window))
     b->last_selected_window = window;
 
+  /* Let redisplay errors through.  */
+  b->display_error_modiff = 0;
+
   /* Update time stamps of buffer display.  */
   if (INTEGERP (b->display_count))
     XSETINT (b->display_count, XINT (b->display_count) + 1);
@@ -6178,10 +6185,12 @@ If TYPE is t, use the frame's scroll-bar type.  */)
   struct window *w = decode_window (window);
 
   if (!NILP (width))
-    CHECK_NATNUM (width);
+    {
+      CHECK_NATNUM (width);
 
-  if (XINT (width) == 0)
-    vertical_type = Qnil;
+      if (XINT (width) == 0)
+        vertical_type = Qnil;
+    }
 
   if (!(EQ (vertical_type, Qnil)
         || EQ (vertical_type, Qleft)
diff --git a/src/xdisp.c b/src/xdisp.c
index d4445cfec1a..c50edb98561 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -810,7 +810,7 @@ static struct glyph_slice null_glyph_slice = { 0, 0, 0, 0 };
 
 /* Function prototypes.  */
 
-static void setup_for_ellipsis P_ ((struct it *));
+static void setup_for_ellipsis P_ ((struct it *, int));
 static void mark_window_display_accurate_1 P_ ((struct window *, int));
 static int single_display_prop_string_p P_ ((Lisp_Object, Lisp_Object));
 static int display_prop_string_p P_ ((Lisp_Object, Lisp_Object));
@@ -3230,7 +3230,7 @@ handle_invisible_prop (it)
               it->stack[it->sp - 1].display_ellipsis_p = display_ellipsis_p;
             }
           else if (display_ellipsis_p)
-            setup_for_ellipsis (it);
+            setup_for_ellipsis (it, 0);
         }
     }
 
@@ -3238,14 +3238,17 @@ handle_invisible_prop (it)
 }
 
 
-/* Make iterator IT return `...' next.  */
+/* Make iterator IT return `...' next.
+   Replaces LEN characters from buffer.  */
 
 static void
-setup_for_ellipsis (it)
+setup_for_ellipsis (it, len)
      struct it *it;
+     int len;
 {
-  if (it->dp
-      && VECTORP (DISP_INVIS_VECTOR (it->dp)))
+  /* Use the display table definition for `...'.  Invalid glyphs
+     will be handled by the method returning elements from dpvec.  */
+  if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
     {
       struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
       it->dpvec = v->contents;
@@ -3258,12 +3261,12 @@ setup_for_ellipsis (it)
       it->dpend = default_invis_vector + 3;
     }
 
-  /* The ellipsis display does not replace the display of the
-     character at the new position.  Indicate this by setting
-     IT->dpvec_char_len to zero.  */
-  it->dpvec_char_len = 0;
-
+  it->dpvec_char_len = len;
   it->current.dpvec_index = 0;
+
+  /* Remember the current face id in case glyphs specify faces.
+     IT's face is restored in set_iterator_to_next.  */
+  it->saved_face_id = it->face_id;
   it->method = next_element_from_display_vector;
 }
 
@@ -3578,7 +3581,7 @@ handle_single_display_prop (it, prop, object, position,
               || EQ (XCAR (prop), Qright_fringe))
           && CONSP (XCDR (prop)))
         {
-          unsigned face_id = DEFAULT_FACE_ID;
+          int face_id = DEFAULT_FACE_ID;
           int fringe_bitmap;
 
           /* Save current settings of IT so that we can restore them
@@ -3597,10 +3600,9 @@ handle_single_display_prop (it, prop, object, position,
           if (CONSP (XCDR (XCDR (prop))))
             {
               Lisp_Object face_name = XCAR (XCDR (XCDR (prop)));
-
-              face_id = lookup_named_face (it->f, face_name);
-              if (face_id < 0)
-                return 0;
+              int face_id2 = lookup_named_face (it->f, face_name, 0);
+              if (face_id2 >= 0)
+                face_id = face_id2;
             }
 
           push_it (it);
@@ -4145,7 +4147,7 @@ next_overlay_string (it)
       /* If we have to display `...' for invisible text, set
          the iterator up for that.  */
       if (display_ellipsis_p)
-        setup_for_ellipsis (it);
+        setup_for_ellipsis (it, 0);
     }
   else
     {
@@ -4937,7 +4939,10 @@ get_next_display_element (it)
      we hit the end of what we iterate over.  Performance note: the
      function pointer `method' used here turns out to be faster than
      using a sequence of if-statements.  */
-  int success_p = (*it->method) (it);
+  int success_p;
+
+ get_next:
+  success_p = (*it->method) (it);
 
   if (it->what == IT_CHARACTER)
     {
@@ -4969,14 +4974,14 @@ get_next_display_element (it)
                   it->dpvec = v->contents;
                   it->dpend = v->contents + v->size;
                   it->current.dpvec_index = 0;
+                  it->saved_face_id = it->face_id;
                   it->method = next_element_from_display_vector;
-                  success_p = get_next_display_element (it);
                 }
               else
                 {
                   set_iterator_to_next (it, 0);
-                  success_p = get_next_display_element (it);
                 }
+              goto get_next;
             }
 
           /* Translate control characters into `\003' or `^C' form.
@@ -5008,6 +5013,7 @@ get_next_display_element (it)
                  IT->ctl_chars with glyphs for what we have to
                  display.  Then, set IT->dpvec to these glyphs.  */
               GLYPH g;
+              int ctl_len;
 
               if (it->c < 128 && it->ctl_arrow_p)
                 {
@@ -5022,14 +5028,7 @@ get_next_display_element (it)
 
                   g = FAST_MAKE_GLYPH (it->c ^ 0100, 0);
                   XSETINT (it->ctl_chars[1], g);
-
-                  /* Set up IT->dpvec and return first character from it.  */
-                  it->dpvec_char_len = it->len;
-                  it->dpvec = it->ctl_chars;
-                  it->dpend = it->dpvec + 2;
-                  it->current.dpvec_index = 0;
-                  it->method = next_element_from_display_vector;
-                  get_next_display_element (it);
+                  ctl_len = 2;
                 }
               else
                 {
@@ -5082,16 +5081,17 @@ get_next_display_element (it)
                       g = FAST_MAKE_GLYPH ((str[i] & 7) + '0', 0);
                       XSETINT (it->ctl_chars[i * 4 + 3], g);
                     }
-
-                  /* Set up IT->dpvec and return the first character
-                     from it.  */
-                  it->dpvec_char_len = it->len;
-                  it->dpvec = it->ctl_chars;
-                  it->dpend = it->dpvec + len * 4;
-                  it->current.dpvec_index = 0;
-                  it->method = next_element_from_display_vector;
-                  get_next_display_element (it);
+                  ctl_len = len * 4;
                 }
+
+              /* Set up IT->dpvec and return first character from it.  */
+              it->dpvec_char_len = it->len;
+              it->dpvec = it->ctl_chars;
+              it->dpend = it->dpvec + ctl_len;
+              it->current.dpvec_index = 0;
+              it->saved_face_id = it->face_id;
+              it->method = next_element_from_display_vector;
+              goto get_next;
             }
         }
 
@@ -5285,11 +5285,14 @@ set_iterator_to_next (it, reseat_p)
                && IT_STRING_CHARPOS (*it) >= 0));
 }
 
-
 /* Load IT's display element fields with information about the next
    display element which comes from a display table entry or from the
    result of translating a control character to one of the forms `^C'
-   or `\003'.  IT->dpvec holds the glyphs to return as characters.  */
+   or `\003'.
+
+   IT->dpvec holds the glyphs to return as characters.
+   IT->saved_face_id holds the face id before the display vector--
+   it is restored into IT->face_idin set_iterator_to_next.  */
 
 static int
 next_element_from_display_vector (it)
@@ -5298,10 +5301,6 @@ next_element_from_display_vector (it)
   /* Precondition.  */
   xassert (it->dpvec && it->current.dpvec_index >= 0);
 
-  /* Remember the current face id in case glyphs specify faces.
-     IT's face is restored in set_iterator_to_next.  */
-  it->saved_face_id = it->face_id;
-
   if (INTEGERP (*it->dpvec)
       && GLYPH_CHAR_VALID_P (XFASTINT (*it->dpvec)))
     {
@@ -5485,28 +5484,7 @@ next_element_from_ellipsis (it)
      struct it *it;
 {
   if (it->selective_display_ellipsis_p)
-    {
-      if (it->dp && VECTORP (DISP_INVIS_VECTOR (it->dp)))
-        {
-          /* Use the display table definition for `...'.  Invalid glyphs
-             will be handled by the method returning elements from dpvec.  */
-          struct Lisp_Vector *v = XVECTOR (DISP_INVIS_VECTOR (it->dp));
-          it->dpvec_char_len = it->len;
-          it->dpvec = v->contents;
-          it->dpend = v->contents + v->size;
-          it->current.dpvec_index = 0;
-          it->method = next_element_from_display_vector;
-        }
-      else
-        {
-          /* Use default `...' which is stored in default_invis_vector.  */
-          it->dpvec_char_len = it->len;
-          it->dpvec = default_invis_vector;
-          it->dpend = default_invis_vector + 3;
-          it->current.dpvec_index = 0;
-          it->method = next_element_from_display_vector;
-        }
-    }
+    setup_for_ellipsis (it, it->len);
   else
     {
       /* The face at the current position may be different from the
@@ -14633,7 +14611,9 @@ highlight_trailing_whitespace (f, row)
                   && glyph->u.ch == ' '))
           && trailing_whitespace_p (glyph->charpos))
         {
-          int face_id = lookup_named_face (f, Qtrailing_whitespace);
+          int face_id = lookup_named_face (f, Qtrailing_whitespace, 0);
+          if (face_id < 0)
+            return;
 
           while (glyph >= start
                  && BUFFERP (glyph->object)
@@ -14726,8 +14706,10 @@ display_line (it)
      hscrolled.  This may stop at an x-position < IT->first_visible_x
      if the first glyph is partially visible or if we hit a line end.  */
   if (it->current_x < it->first_visible_x)
-    move_it_in_display_line_to (it, ZV, it->first_visible_x,
-                                MOVE_TO_POS | MOVE_TO_X);
+    {
+      move_it_in_display_line_to (it, ZV, it->first_visible_x,
+                                  MOVE_TO_POS | MOVE_TO_X);
+    }
 
   /* Get the initial row height.  This is either the height of the
      text hscrolled, if there is any, or zero.  */
@@ -15056,12 +15038,10 @@ display_line (it)
                 {
                   if (!get_next_display_element (it))
                     {
-#ifdef HAVE_WINDOW_SYSTEM
                       it->continuation_lines_width = 0;
                       row->ends_at_zv_p = 1;
                       row->exact_window_width_line_p = 1;
                       break;
-#endif /* HAVE_WINDOW_SYSTEM */
                     }
                   if (ITERATOR_AT_END_OF_LINE_P (it))
                     {
@@ -18376,6 +18356,19 @@ draw_glyphs (w, x, row, area, start, end, hl, overlaps_p)
   return x_reached;
 }
 
+/* Expand row matrix if too narrow.  Don't expand if area
+   is not present.  */
+
+#define IT_EXPAND_MATRIX_WIDTH(it, area)                \
+  {                                                     \
+    if (!fonts_changed_p                                \
+        && (it->glyph_row->glyphs[area]                 \
+            < it->glyph_row->glyphs[area + 1]))         \
+      {                                                 \
+        it->w->ncols_scale_factor++;                    \
+        fonts_changed_p = 1;                            \
+      }                                                 \
+  }
 
 /* Store one glyph for IT->char_to_display in IT->glyph_row.
    Called from x_produce_glyphs when IT->glyph_row is non-null.  */
@@ -18413,11 +18406,8 @@ append_glyph (it)
       glyph->font_type = FONT_TYPE_UNKNOWN;
       ++it->glyph_row->used[area];
     }
-  else if (!fonts_changed_p)
-    {
-      it->w->ncols_scale_factor++;
-      fonts_changed_p = 1;
-    }
+  else
+    IT_EXPAND_MATRIX_WIDTH (it, area);
 }
 
 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
@@ -18455,11 +18445,8 @@ append_composite_glyph (it)
       glyph->font_type = FONT_TYPE_UNKNOWN;
       ++it->glyph_row->used[area];
     }
-  else if (!fonts_changed_p)
-    {
-      it->w->ncols_scale_factor++;
-      fonts_changed_p = 1;
-    }
+  else
+    IT_EXPAND_MATRIX_WIDTH (it, area);
 }
 
 
@@ -18629,11 +18616,8 @@ produce_image_glyph (it)
           glyph->font_type = FONT_TYPE_UNKNOWN;
           ++it->glyph_row->used[area];
         }
-      else if (!fonts_changed_p)
-        {
-          it->w->ncols_scale_factor++;
-          fonts_changed_p = 1;
-        }
+      else
+        IT_EXPAND_MATRIX_WIDTH (it, area);
     }
 }
 
@@ -18677,11 +18661,8 @@ append_stretch_glyph (it, object, width, height, ascent)
       glyph->font_type = FONT_TYPE_UNKNOWN;
       ++it->glyph_row->used[area];
     }
-  else if (!fonts_changed_p)
-    {
-      it->w->ncols_scale_factor++;
-      fonts_changed_p = 1;
-    }
+  else
+    IT_EXPAND_MATRIX_WIDTH (it, area);
 }
 
 
@@ -18912,7 +18893,7 @@ calc_line_height_property (it, prop, font, boff, total)
       struct face *face;
       struct font_info *font_info;
 
-      face_id = lookup_named_face (it->f, face_name);
+      face_id = lookup_named_face (it->f, face_name, 0);
       if (face_id < 0)
         return make_number (-1);
 
@@ -20264,6 +20245,7 @@ erase_phys_cursor (w)
     {
       int x, y;
       int header_line_height = WINDOW_HEADER_LINE_HEIGHT (w);
+      int width;
 
       cursor_glyph = get_phys_cursor_glyph (w);
       if (cursor_glyph == NULL)
@@ -20271,9 +20253,10 @@ erase_phys_cursor (w)
 
       x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
       y = WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height, cursor_row->y));
+      width = min (cursor_glyph->pixel_width,
+                   window_box_width (w, TEXT_AREA) - w->phys_cursor.x);
 
-      rif->clear_frame_area (f, x, y,
-                             cursor_glyph->pixel_width, cursor_row->visible_height);
+      rif->clear_frame_area (f, x, y, width, cursor_row->visible_height);
     }
 
   /* Erase the cursor by redrawing the character underneath it.  */
@@ -21094,13 +21077,16 @@ note_mode_line_or_margin_highlight (w, x, y, area)
       /* If we're on a string with `help-echo' text property, arrange
          for the help to be displayed.  This is done by setting the
          global variable help_echo_string to the help string.  */
-      help = Fget_text_property (pos, Qhelp_echo, string);
-      if (!NILP (help))
+      if (NILP (help))
         {
-          help_echo_string = help;
-          XSETWINDOW (help_echo_window, w);
-          help_echo_object = string;
-          help_echo_pos = charpos;
+          help = Fget_text_property (pos, Qhelp_echo, string);
+          if (!NILP (help))
+            {
+              help_echo_string = help;
+              XSETWINDOW (help_echo_window, w);
+              help_echo_object = string;
+              help_echo_pos = charpos;
+            }
         }
 
       if (NILP (pointer))
diff --git a/src/xfaces.c b/src/xfaces.c
index fc2cd6b0af4..1d20cc62a98 100644
--- a/src/xfaces.c
+++ b/src/xfaces.c
@@ -3069,7 +3069,7 @@ the WIDTH times as wide as FACE on FRAME.  */)
     {
       /* This is of limited utility since it works with character
          widths.  Keep it for compatibility.  --gerd.  */
-      int face_id = lookup_named_face (f, face);
+      int face_id = lookup_named_face (f, face, 0);
       struct face *face = (face_id < 0
                            ? NULL
                            : FACE_FROM_ID (f, face_id));
@@ -5015,7 +5015,7 @@ return the font name used for CHARACTER.  */)
   else
     {
       struct frame *f = frame_or_selected_frame (frame, 1);
-      int face_id = lookup_named_face (f, face);
+      int face_id = lookup_named_face (f, face, 1);
       struct face *face = FACE_FROM_ID (f, face_id);
 
       if (! face)
@@ -5753,9 +5753,10 @@ lookup_non_ascii_face (f, font_id, base_face)
    face isn't realized and cannot be realized.  */
 
 int
-lookup_named_face (f, symbol)
+lookup_named_face (f, symbol, signal_p)
      struct frame *f;
      Lisp_Object symbol;
+     int signal_p;
 {
   Lisp_Object attrs[LFACE_VECTOR_SIZE];
   Lisp_Object symbol_attrs[LFACE_VECTOR_SIZE];
@@ -5768,7 +5769,9 @@ lookup_named_face (f, symbol)
       default_face = FACE_FROM_ID (f, DEFAULT_FACE_ID);
     }
 
-  get_lface_attributes (f, symbol, symbol_attrs, 1);
+  if (!get_lface_attributes (f, symbol, symbol_attrs, signal_p))
+    return -1;
+
   bcopy (default_face->lface, attrs, sizeof attrs);
   merge_face_vectors (f, symbol_attrs, attrs, 0);
 
@@ -5789,7 +5792,7 @@ ascii_face_of_lisp_face (f, lface_id)
   if (lface_id >= 0 && lface_id < lface_id_to_name_size)
     {
       Lisp_Object face_name = lface_id_to_name[lface_id];
-      face_id = lookup_named_face (f, face_name);
+      face_id = lookup_named_face (f, face_name, 1);
     }
   else
     face_id = -1;
diff --git a/src/xfns.c b/src/xfns.c
index 1f9098b2d24..36ef3a76bcf 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -152,6 +152,10 @@ char *gray_bitmap_bits = gray_bits;
 
 int display_hourglass_p;
 
+/* Non-zero means prompt with the old GTK file selection dialog.  */
+
+int x_use_old_gtk_file_dialog;
+
 /* The background and shape of the mouse pointer, and shape when not
    over text or in the modeline.  */
 
@@ -5558,6 +5562,14 @@ such a font.  This is especially effective for such large fonts as
 Chinese, Japanese, and Korean.  */);
   Vx_pixel_size_width_font_regexp = Qnil;
 
+/* This is not ifdef:ed, so other builds than GTK can customize it.  */
+  DEFVAR_BOOL ("x-use-old-gtk-file-dialog", &x_use_old_gtk_file_dialog,
+    doc: /* *Non-nil means prompt with the old GTK file selection dialog.
+If nil or if the file selection dialog is not available, the new GTK file
+chooser is used instead.  To turn off all file dialogs set the
+variable `use-file-dialog'.  */);
+  x_use_old_gtk_file_dialog = 0;
+
 #ifdef USE_X_TOOLKIT
   Fprovide (intern ("x-toolkit"), Qnil);
 #ifdef USE_MOTIF
@@ -5577,14 +5589,6 @@ Chinese, Japanese, and Korean.  */);
   Fprovide (intern ("x-toolkit"), Qnil);
   Fprovide (intern ("gtk"), Qnil);
 
-#ifdef HAVE_GTK_FILE_BOTH
-  DEFVAR_BOOL ("use-old-gtk-file-dialog", &use_old_gtk_file_dialog,
-    doc: /* *Non-nil means that the old GTK file selection dialog is used.
-If nil the new GTK file chooser is used instead.  To turn off
-all file dialogs set the variable `use-file-dialog'.  */);
-  use_old_gtk_file_dialog = 0;
-#endif
-
   DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string,
                doc: /* Version info for GTK+.  */);
   {
diff --git a/src/xmenu.c b/src/xmenu.c
index 6899b91ebd7..e803680c6ec 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -741,8 +741,7 @@ POSITION is a position specification.  This is either a mouse button event
 or a list ((XOFFSET YOFFSET) WINDOW)
 where XOFFSET and YOFFSET are positions in pixels from the top left
 corner of WINDOW's frame.  (WINDOW may be a frame object instead of a window.)
-This controls the position of the center of the first line
-in the first pane of the menu, not the top left of the menu as a whole.
+This controls the position of the top left of the menu as a whole.
 If POSITION is t, it means to use the current mouse position.
 
 MENU is a specifier for a menu.  For the simplest case, MENU is a keymap.
@@ -3256,7 +3255,7 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
   char *datap;
   int ulx, uly, width, height;
   int dispwidth, dispheight;
-  int i, j;
+  int i, j, lines, maxlines;
   int maxwidth;
   int dummy_int;
   unsigned int dummy_uint;
@@ -3287,31 +3286,8 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
 
 #ifdef HAVE_X_WINDOWS
   /* Adjust coordinates to relative to the outer (window manager) window.  */
-  {
-    Window child;
-    int win_x = 0, win_y = 0;
-
-    /* Find the position of the outside upper-left corner of
-       the inner window, with respect to the outer window.  */
-    if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
-      {
-        BLOCK_INPUT;
-        XTranslateCoordinates (FRAME_X_DISPLAY (f),
-
-                               /* From-window, to-window.  */
-                               f->output_data.x->window_desc,
-                               f->output_data.x->parent_desc,
-
-                               /* From-position, to-position.  */
-                               0, 0, &win_x, &win_y,
-
-                               /* Child of window.  */
-                               &child);
-        UNBLOCK_INPUT;
-        x += win_x;
-        y += win_y;
-      }
-  }
+  x += FRAME_OUTER_TO_INNER_DIFF_X (f);
+  y += FRAME_OUTER_TO_INNER_DIFF_Y (f);
 #endif /* HAVE_X_WINDOWS */
 
   /* Adjust coordinates to be root-window-relative.  */
@@ -3319,7 +3295,7 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
   y += f->top_pos;
 
   /* Create all the necessary panes and their items.  */
-  i = 0;
+  maxlines = lines = i = 0;
   while (i < menu_items_used)
     {
       if (EQ (XVECTOR (menu_items)->contents[i], Qt))
@@ -3328,6 +3304,8 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
           Lisp_Object pane_name, prefix;
           char *pane_string;
 
+          maxlines = max (maxlines, lines);
+          lines = 0;
           pane_name = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_NAME];
           prefix = XVECTOR (menu_items)->contents[i + MENU_ITEMS_PANE_PREFIX];
           pane_string = (NILP (pane_name)
@@ -3420,9 +3398,12 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
               return Qnil;
             }
           i += MENU_ITEMS_ITEM_LENGTH;
+          lines++;
         }
     }
 
+  maxlines = max (maxlines, lines);
+
   /* All set and ready to fly.  */
   XMenuRecompute (FRAME_X_DISPLAY (f), menu);
   dispwidth = DisplayWidth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f));
@@ -3446,6 +3427,15 @@ xmenu_show (f, x, y, for_click, keymaps, title, error)
   if (ulx < 0) x -= ulx;
   if (uly < 0) y -= uly;
 
+  if (! for_click)
+    {
+      /* If position was not given by a mouse click, adjust so upper left
+         corner of the menu as a whole ends up at given coordinates.  This
+         is what x-popup-menu says in its documentation.  */
+      x += width/2;
+      y += 1.5*height/(maxlines+2);
+    }
+
   XMenuSetAEQ (menu, TRUE);
   XMenuSetFreeze (menu, TRUE);
   pane = selidx = 0;
diff --git a/src/xterm.c b/src/xterm.c
index c8c5d6e95c4..1f2b54272cc 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -358,7 +358,7 @@ static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int,
                                    enum text_cursor_kinds));
 
-static void x_clip_to_row P_ ((struct window *, struct glyph_row *, GC));
+static void x_clip_to_row P_ ((struct window *, struct glyph_row *, int, GC));
 static void x_flush P_ ((struct frame *f));
 static void x_update_begin P_ ((struct frame *));
 static void x_update_window_begin P_ ((struct window *));
@@ -710,12 +710,12 @@ x_draw_fringe_bitmap (w, row, p)
       int oldVH = row->visible_height;
       row->visible_height = p->h;
       row->y -= rowY - p->y;
-      x_clip_to_row (w, row, gc);
+      x_clip_to_row (w, row, -1, gc);
       row->y = oldY;
       row->visible_height = oldVH;
     }
   else
-    x_clip_to_row (w, row, gc);
+    x_clip_to_row (w, row, -1, gc);
 
   if (p->bx >= 0 && !p->overlay_p)
     {
@@ -7142,18 +7142,19 @@ XTread_socket (sd, expected, hold_quit)
    mode lines must be clipped to the whole window.  */
 
 static void
-x_clip_to_row (w, row, gc)
+x_clip_to_row (w, row, area, gc)
      struct window *w;
      struct glyph_row *row;
+     int area;
      GC gc;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   XRectangle clip_rect;
-  int window_y, window_width;
+  int window_x, window_y, window_width;
 
-  window_box (w, -1, 0, &window_y, &window_width, 0);
+  window_box (w, area, &window_x, &window_y, &window_width, 0);
 
-  clip_rect.x = WINDOW_TO_FRAME_PIXEL_X (w, 0);
+  clip_rect.x = window_x;
   clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
   clip_rect.y = max (clip_rect.y, window_y);
   clip_rect.width = window_width;
@@ -7219,7 +7220,7 @@ x_draw_hollow_cursor (w, row)
   gc = dpyinfo->scratch_cursor_gc;
 
   /* Set clipping, draw the rectangle, and reset clipping again.  */
-  x_clip_to_row (w, row, gc);
+  x_clip_to_row (w, row, TEXT_AREA, gc);
   XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
   XSetClipMask (dpy, gc, None);
 }
@@ -7291,7 +7292,7 @@ x_draw_bar_cursor (w, row, width, kind)
       width = min (cursor_glyph->pixel_width, width);
 
       w->phys_cursor_width = width;
-      x_clip_to_row (w, row, gc);
+      x_clip_to_row (w, row, TEXT_AREA, gc);
 
       if (kind == BAR_CURSOR)
           XFillRectangle (dpy, window, gc,