Merged in changes from CVS HEAD

Patches applied:

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

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

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

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

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

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

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

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

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-41
   Make fringe-drawing stuff compile without a window-system

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

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

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

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

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

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

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

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

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


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

19 files changed, 1099 insertions, 239 deletions

diff --git a/src/.gitignore b/src/.gitignore
index f1a15019c6f..406ff7cd5e2 100644
--- a/src/.gitignore
+++ b/src/.gitignore
@@ -1,18 +1,19 @@
+*-spd
 *.core
+*.pdb
+.gdb_history
 Makefile
 Makefile.c
 TAGS-LISP
+_gdbinit
 bootstrap-emacs
 config.h
 config.stamp
 emacs
 emacs-*
 epaths.h
+gdb.ini
 obj
 prefix-args
 stamp-oldxmenu
 temacs
-_gdbinit
-gdb.ini
-*-spd
-*.pdb
diff --git a/src/ChangeLog b/src/ChangeLog
index 9c21defd658..4fba5e166b3 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,164 @@
+2004-01-21  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * lisp.h [USE_LSB_TAG && !DECL_ALIGN]: Signal an error.
+
+2004-01-21  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * lisp.h: Add undef DECL_ALIGN.
+
+2004-01-21  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * process.c (wait_reading_process_input) [SYNC_INPUT]:
+        Check interrupt_input_pending explicitly.
+
+        * lisp.h (QUIT) [SYNC_INPUT]: Check interrupt_input_pending as well.
+
+        * keyboard.c (handle_async_input): New fun,
+        extracted from input_available_signal.
+        (input_available_signal, reinvoke_input_signal): Use it.
+
+2004-01-20  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * buffer.c (buffer_defaults, buffer_local_symbols): Use DECL_ALIGN.
+
+        * lisp.h [USE_LSB_TAG]: Add definitions for Lisp_Object value
+        manipulation macros for when tags are in the lower bits.
+        (struct Lisp_Free) [USE_LSB_TAG]: Add padding.
+        (DECL_ALIGN): New macro.
+        (DEFUN): Use it.
+
+        * lisp.h [ENABLE_CHECKING]: Don't force union type.
+
+        * s/darwin.h (__attribute__): Remove outdated workaround.
+
+        * macterm.c (main) [USE_LSB_TAG]: Don't range check the ram.
+
+        * alloc.c (lisp_malloc, lisp_align_malloc) [USE_LSB_TAG]:
+        Don't check range of malloc address.
+        (pure_alloc) [USE_LSB_TAG]: Enforce alignment.
+
+        * process.c (wait_reading_process_input): Lisp_Object/int mixup.
+
+        * dired.c (Ffile_attributes): Lisp_Object/int mixup.
+
+2004-01-19  Kenichi Handa  <handa@m17n.org>
+
+        * fontset.c (fontset_font_pattern): Fix previous change.
+
+2004-01-16  Miles Bader  <miles@gnu.ai.mit.edu>
+
+        * xdisp.c (Voverflow_newline_into_fringe)
+        (move_it_in_display_line_to, redisplay_internal)
+        (update_window_fringes, redisplay_window, display_line, window):
+        Add `#ifdef HAVE_WINDOW_SYSTEM' around fringe-drawing stuff, so
+        that it compiles without a window-system.
+        * dispnew.c (direct_output_for_insert, update_window): Likewise.
+
+2004-01-16  Kim F. Storm  <storm@cua.dk>
+
+        * buffer.h (struct buffer): New member indicate_buffer_boundaries.
+
+        * buffer.c (init_buffer_once):  Set buffer_defaults and
+        buffer_local_flags for indicate_buffer_boundaries.
+        (syms_of_buffer): Defvar_per_buffer it, and defvar_lisp_nopro
+        default- variable for it.
+
+        * dispextern.h (struct glyph_row): New members left_fringe_bitmap,
+        right_fringe_bitmap, redraw_fringe_bitmaps_p for new fringe handling.
+        New members exact_window_width_line_p and cursor_in_fringe_p for
+        overflowing newlines into right fringe.
+        New members indicate_bob_p, indicate_top_line_p, indicate_eob_p,
+        and indicate_bottom_line_p for buffer boundaries and scrolling.
+        (enum fringe_bitmap_type): Add UP_ARROW_BITMAP, DOWN_ARROW_BITMAP,
+        FIRST_LINE_BITMAP, LAST_LINE_BITMAP, FILLED_BOX_CURSOR_BITMAP,
+        HOLLOW_BOX_CURSOR_BITMAP, BAR_CURSOR_BITMAP, HBAR_CURSOR_BITMAP,
+        and HOLLOW_SQUARE_BITMAP.
+        (draw_fringe_bitmap, draw_window_fringes, update_window_fringes):
+        Add prototypes.
+
+        * dispnew.c (row_equal_p, update_window_line): Compare fringe bitmaps
+        instead of related indicator fields.
+        Compare exact_window_width_line_p and cursor_in_mouse_face_p indicators.
+        (direct_output_for_insert): Handle exact width lines like
+        contined lines.  Call update_window_fringes.
+        (update_window): Call update_window_fringes.
+        (scrolling_window): Don't skip desired rows with changed bitmaps.
+        Check if fringe bitmaps changes when assigning scrolled rows.
+
+        * xdisp.c (Voverflow_newline_into_fringe): New variable.
+        (IT_OVERFLOW_NEWLINE_INTO_FRINGE): New macro.
+        (move_it_in_display_line_to): Overflow newline into fringe for
+        rows that are exactly as wide as the window.
+        (up_arrow_bits, down_arrow_bits, first_line_bits, last_line_bits)
+        (filled_box_cursor_bits, hollow_box_cursor_bits, bar_cursor_bits)
+        (hbar_cursor_bits, hollow_square_bits): New fringe bitmaps.
+        (fringe_bitmaps): Add new bitmaps.
+        (draw_fringe_bitmap): Make extern.  Remove WHICH arg.
+        Select proper bitmap for cursor in fringe when appropriate.
+        Handle alignment of bitmap to top or bottom of row.
+        (draw_row_fringe_bitmaps): Don't select bitmaps here; that is now
+        done by update_window_fringes.
+        (update_window_fringes, draw_window_fringes): New functions.
+        (redisplay_internal): Call update_window_fringes in case only
+        cursor row is updated.
+        (redisplay_window): Call update_window_fringes.
+        Explicitly call draw_window_fringes if redisplay was done using
+        the current matrix or the overlay arrow is in the window.
+        (try_window_reusing_current_matrix): Mark scrolled rows for
+        fringe update (to update buffer-boundaries / scrolling icons).
+        (find_last_unchanged_at_beg_row): Handle exact width lines line
+        continued lines.
+        (display_line): Overflow newline into fringe for rows that are
+        exactly as wide as the window.  Don't append space for newline
+        in this case.
+        (notice_overwritten_cursor): Explicitly clear cursor bitmap
+        in fringe as if it had been overwritten.
+        (erase_phys_cursor): Erase cursor bitmap in fringe.
+        (syms_of_xdisp): Mark show-trailing-whitespace and
+        void-text-area-pointer as user options.
+        DEFVAR_LISP Voverflow_newline_into_fringe.  Enable by default.
+
+        * xterm.c (x_update_window_end): Call draw_window_fringes.
+        (x_after_update_window_line): Just set redraw_fringe_bitmaps_p
+        in row instead of actually drawing fringe bitmaps.
+        (x_draw_fringe_bitmap): Handle bottom aligned bitmaps.
+        (x_draw_window_cursor): Draw cursor in fringe.
+
+        * w32term.c (x_update_window_end): Call draw_window_fringes.
+        (x_after_update_window_line): Just set redraw_fringe_bitmaps_p
+        in row instead of actually drawing fringe bitmaps.
+        (w32_draw_fringe_bitmap): Handle bottom aligned bitmaps.
+        (w32_draw_window_cursor): Draw cursor in fringe.
+
+        * macterm.c (x_update_window_end): Call draw_window_fringes.
+        (x_after_update_window_line): Just set redraw_fringe_bitmaps_p
+        in row instead of actually drawing fringe bitmaps.
+        (x_draw_fringe_bitmap): Handle bottom aligned bitmaps.
+        (mac_draw_window_cursor): Draw cursor in fringe.
+
+2004-01-16  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * xterm.c (handle_one_xevent): Don't handle characters that are part
+        of an old style (XLookupString) compose sequence.
+
+2004-01-15  Kenichi Handa  <handa@m17n.org>
+
+        * search.c (Freplace_match): Use make_multibyte_string or
+        make_unibyte_string according to the buffer multibyteness.
+
+2004-01-14  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * alloc.c (struct interval_block, struct string_block)
+        (struct symbol_block, struct marker_block, live_string_p)
+        (live_cons_p, live_symbol_p, live_float_p, live_misc_p):
+        Better preserve alignment for objects in blocks.
+        (FLOAT_BLOCK_SIZE): Adjust for possible alignment padding.
+
+        * lread.c (defvar_per_buffer): Remove dead declaration.
+
+        * macterm.c (do_check_ram_size): Don't hardcode the lisp address
+        space size.
+
 2004-01-12  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
         * xmenu.c (popup_get_selection): Check new parameter down_on_keypress
@@ -61,7 +222,7 @@
         * xdisp.c (note_mode_line_or_margin_highlight): Use modified
         mode_line_string and marginal_area_string functions to handle
         both string object and image object properties.
-        
+
 2004-01-06  Andreas Schwab  <schwab@suse.de>
 
         * syntax.c (skip_chars): Treat '-' at end of string as ordinary
@@ -69,8 +230,8 @@
 
 2004-01-02  Andreas Schwab  <schwab@suse.de>
 
-        * macterm.c (emacs_options, x_initialized, same_x_server): Remove
-        unused (and duplicated) definitions.
+        * macterm.c (emacs_options, x_initialized, same_x_server):
+        Remove unused (and duplicated) definitions.
 
 2004-01-02  Kim F. Storm  <storm@cua.dk>
 
@@ -100,8 +261,7 @@
 
 2004-01-01  Jason Rumney  <jasonr@gnu.org>
 
-        * w32term.c (w32_text_out): Use s->font, for consistency with
-        callers.
+        * w32term.c (w32_text_out): Use s->font, for consistency with callers.
 
 2003-12-30  Luc Teirlinck  <teirllm@auburn.edu>
 
@@ -132,15 +292,13 @@
 
         * fontset.c (Voverriding_fontspec_alist): New variable.
         (lookup_overriding_fontspec): New function.
-        (fontset_ref_via_base): Call lookup_overriding_fontspec if
-        necessary.
+        (fontset_ref_via_base): Call lookup_overriding_fontspec if necessary.
         (fontset_font_pattern): Likewise.
         (regulalize_fontname): New function.
         (Fset_fontset_font): Call regulalize_fontname.
         (Fset_overriding_fontspec_internal): New function.
-        (syms_of_fontset): Initialize and staticprop
-        Voverriding_fontspec_alist. Defsubr
-        Sset_overriding_fontspec_internal.
+        (syms_of_fontset): Initialize and staticpro Voverriding_fontspec_alist.
+        Defsubr Sset_overriding_fontspec_internal.
 
         * xfaces.c (face_font_available_p): New function.
 
@@ -197,7 +355,7 @@
         (Vvoid_text_area_pointer): Replace Vshow_text_cursor_in_void.
         (QCmap, QCpointer, Qrect, Qcircle, Qpoly): New variables for
         image maps.
-        (x_y_to_hpos_vpos): Return glyph relative coordinates through 
+        (x_y_to_hpos_vpos): Return glyph relative coordinates through
         new dx and dy args.
         Remove buffer_only_p arg (always 0).  Simplify code accordingly.
         (get_glyph_string_clip_rect): Draw cursor using glyph's rather
@@ -207,9 +365,9 @@
         (produce_image_glyph): Adjust it.ascent to minimum row ascent if
         image glyph is alone on the last line.
         (append_glyph, append_composite_glyph, produce_image_glyph)
-        (append_stretch_glyph): Set glyph's ascent and descent. 
+        (append_stretch_glyph): Set glyph's ascent and descent.
         (on_hot_spot_p): New function to check if position is inside an
-        rectangular, circular, or polygon-shaped image hot-spot, 
+        rectangular, circular, or polygon-shaped image hot-spot,
         (find_hot_spot): New function to search for image hot-spot.
         (Flookup_image_map): New defun to search for image hot-spot.
         (define_frame_cursor1): New aux function to determine frame pointer.
@@ -277,8 +435,7 @@
         (Fread_minibuffer, Fread_no_blanks_input): Adapt to changes in
         read_minibuf.
         (Fcompleting_read): Delete code moved into read_minibuf.
-        (Ftest_completion): Make it handle obarrays and hash tables
-        correctly.
+        (Ftest_completion): Make it handle obarrays and hash tables correctly.
 
 2003-12-03  Kenichi Handa  <handa@m17n.org>
 
@@ -429,10 +586,8 @@
 
 2003-11-22  Lars Hansen <larsh@math.ku.dk>
 
-        * w32.c (struct the_group): Added.
-        (getgrgid): Added.
-        * mac.c (struct my_group): Added.
-        (getgrgid): Added.
+        * w32.c (struct the_group, getgrgid): Add.
+        * mac.c (struct my_group, getgrgid): Add.
 
 2003-11-21  Luc Teirlinck  <teirllm@auburn.edu>
 
@@ -440,18 +595,19 @@
 
 2003-11-21  Lars Hansen  <larsh@math.ku.dk>
 
-        * dired.c (Ffile_attributes): Parameter ID-FORMAT added and
-        included in call to file name handler. Numeric UID and GID
-        optionally translated to strings. Docstring updated.
-        (directory_files_internal): Parameter ID-FORMAT added.
-        (Fdirectory_files_and_attributes): Parameter ID-FORMAT added and
-        included in call to file name handler and call to
-        directory_files_internal. Docstring updated.  (Fdirectory_files):
-        Dummy parameter added in call to directory_files_internal.
-        * lisp.h (Qinteger): Added.  (Qinteger_or_floatp,
-        Qinteger_or_float_or_marker_p): Removed.  (Ffile_attributes):
-        Parameter added.
-        * data.c (Qinteger): Exported.
+        * dired.c (Ffile_attributes): Add parameter ID-FORMAT and
+        include in call to file name handler.  Optionally translate numeric
+        UID and GID to strings.  Update docstring.
+        (directory_files_internal): Add parameter ID-FORMAT.
+        (Fdirectory_files_and_attributes): Add parameter ID-FORMAT and
+        include in call to file name handler and call to
+        directory_files_internal.  Update Docstring.
+        (Fdirectory_files): Add dummy parameter in call to
+        directory_files_internal.
+        * lisp.h (Qinteger): Add.
+        (Qinteger_or_floatp, Qinteger_or_float_or_marker_p): Remove.
+        (Ffile_attributes): Add parameter.
+        * data.c (Qinteger): Export.
 
 2003-11-21  Luc Teirlinck  <teirllm@auburn.edu>
 
@@ -1788,7 +1944,7 @@
         * gtkutil.c: Include keyboard.h, charset.h, coding.h.
         (xg_create_frame_widgets): Use ENCODE_UTF_8.
 
-        * xterm.c (Qutf_8): Moved to coding.c
+        * xterm.c (Qutf_8): Move to coding.c
 
         * xmenu.c (ENCODE_MENU_STRING): New.
         (list_of_panes, list_of_items, digest_single_submenu, xmenu_show):
diff --git a/src/alloc.c b/src/alloc.c
index 616e264fbf1..4afcab2c20a 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -1,5 +1,5 @@
 /* Storage allocation and gc for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985, 86, 88, 93, 94, 95, 97, 98, 1999, 2000, 2001, 2002, 2003
+   Copyright (C) 1985,86,88,93,94,95,97,98,1999,2000,01,02,03,2004
       Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -599,6 +599,7 @@ lisp_malloc (nbytes, type)
 
   val = (void *) malloc (nbytes);
 
+#ifndef USE_LSB_TAG
   /* If the memory just allocated cannot be addressed thru a Lisp
      object's pointer, and it needs to be,
      that's equivalent to running out of memory.  */
@@ -613,6 +614,7 @@ lisp_malloc (nbytes, type)
           val = 0;
         }
     }
+#endif
 
 #if GC_MARK_STACK && !defined GC_MALLOC_CHECK
   if (val && type != MEM_TYPE_NON_LISP)
@@ -773,6 +775,7 @@ lisp_align_malloc (nbytes, type)
       mallopt (M_MMAP_MAX, MMAP_MAX_AREAS);
 #endif
 
+#ifndef USE_LSB_TAG
       /* If the memory just allocated cannot be addressed thru a Lisp
          object's pointer, and it needs to be, that's equivalent to
          running out of memory.  */
@@ -789,6 +792,7 @@ lisp_align_malloc (nbytes, type)
               memory_full ();
             }
         }
+#endif
 
       /* Initialize the blocks and put them on the free list.
          Is `base' was not properly aligned, we can't use the last block.  */
@@ -1105,8 +1109,9 @@ uninterrupt_malloc ()
 
 struct interval_block
 {
-  struct interval_block *next;
+  /* Place `intervals' first, to preserve alignment.  */
   struct interval intervals[INTERVAL_BLOCK_SIZE];
+  struct interval_block *next;
 };
 
 /* Current interval block.  Its `next' pointer points to older
@@ -1344,8 +1349,9 @@ struct sblock
 
 struct string_block
 {
-  struct string_block *next;
+  /* Place `strings' first, to preserve alignment.  */
   struct Lisp_String strings[STRING_BLOCK_SIZE];
+  struct string_block *next;
 };
 
 /* Head and tail of the list of sblock structures holding Lisp string
@@ -2126,8 +2132,10 @@ make_uninit_multibyte_string (nchars, nbytes)
    by GC are put on a free list to be reallocated before allocating
    any new float cells from the latest float_block.  */
 
-#define FLOAT_BLOCK_SIZE \
-  (((BLOCK_BYTES - sizeof (struct float_block *)) * CHAR_BIT) \
+#define FLOAT_BLOCK_SIZE                                        \
+  (((BLOCK_BYTES - sizeof (struct float_block *)                \
+     /* The compiler might add padding at the end.  */          \
+     - (sizeof (struct Lisp_Float) - sizeof (int))) * CHAR_BIT) \
    / (sizeof (struct Lisp_Float) * CHAR_BIT + 1))
 
 #define GETMARKBIT(block,n)                             \
@@ -2754,8 +2762,9 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
 
 struct symbol_block
 {
-  struct symbol_block *next;
+  /* Place `symbols' first, to preserve alignment.  */
   struct Lisp_Symbol symbols[SYMBOL_BLOCK_SIZE];
+  struct symbol_block *next;
 };
 
 /* Current symbol block and index of first unused Lisp_Symbol
@@ -2846,8 +2855,9 @@ Its value and function definition are void, and its property list is nil.  */)
 
 struct marker_block
 {
-  struct marker_block *next;
+  /* Place `markers' first, to preserve alignment.  */
   union Lisp_Misc markers[MARKER_BLOCK_SIZE];
+  struct marker_block *next;
 };
 
 struct marker_block *marker_block;
@@ -3428,6 +3438,7 @@ live_string_p (m, p)
          must not be on the free-list.  */
       return (offset >= 0
               && offset % sizeof b->strings[0] == 0
+              && offset < (STRING_BLOCK_SIZE * sizeof b->strings[0])
               && ((struct Lisp_String *) p)->data != NULL);
     }
   else
@@ -3452,8 +3463,8 @@ live_cons_p (m, p)
          one of the unused cells in the current cons block,
          and not be on the free-list.  */
       return (offset >= 0
-              && offset < (CONS_BLOCK_SIZE * sizeof b->conses[0])
               && offset % sizeof b->conses[0] == 0
+              && offset < (CONS_BLOCK_SIZE * sizeof b->conses[0])
               && (b != cons_block
                   || offset / sizeof b->conses[0] < cons_block_index)
               && !EQ (((struct Lisp_Cons *) p)->car, Vdead));
@@ -3481,6 +3492,7 @@ live_symbol_p (m, p)
          and not be on the free-list.  */
       return (offset >= 0
               && offset % sizeof b->symbols[0] == 0
+              && offset < (SYMBOL_BLOCK_SIZE * sizeof b->symbols[0])
               && (b != symbol_block
                   || offset / sizeof b->symbols[0] < symbol_block_index)
               && !EQ (((struct Lisp_Symbol *) p)->function, Vdead));
@@ -3506,8 +3518,8 @@ live_float_p (m, p)
       /* P must point to the start of a Lisp_Float and not be
          one of the unused cells in the current float block.  */
       return (offset >= 0
-              && offset < (FLOAT_BLOCK_SIZE * sizeof b->floats[0])
               && offset % sizeof b->floats[0] == 0
+              && offset < (FLOAT_BLOCK_SIZE * sizeof b->floats[0])
               && (b != float_block
                   || offset / sizeof b->floats[0] < float_block_index));
     }
@@ -3534,6 +3546,7 @@ live_misc_p (m, p)
          and not be on the free-list.  */
       return (offset >= 0
               && offset % sizeof b->markers[0] == 0
+              && offset < (MARKER_BLOCK_SIZE * sizeof b->markers[0])
               && (b != marker_block
                   || offset / sizeof b->markers[0] < marker_block_index)
               && ((union Lisp_Misc *) p)->u_marker.type != Lisp_Misc_Free);
@@ -4068,6 +4081,9 @@ pure_alloc (size, type)
      int type;
 {
   POINTER_TYPE *result;
+#ifdef USE_LSB_TAG
+  size_t alignment = (1 << GCTYPEBITS);
+#else
   size_t alignment = sizeof (EMACS_INT);
 
   /* Give Lisp_Floats an extra alignment.  */
@@ -4079,6 +4095,7 @@ pure_alloc (size, type)
       alignment = sizeof (struct Lisp_Float);
 #endif
     }
+#endif
 
  again:
   result = ALIGN (purebeg + pure_bytes_used, alignment);
diff --git a/src/buffer.c b/src/buffer.c
index d0830c83a51..d14db61c2a9 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -1,5 +1,5 @@
 /* Buffer manipulation primitives for GNU Emacs.
-   Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 02, 2003
+   Copyright (C) 1985,86,87,88,89,93,94,95,97,98, 1999, 2000, 2001, 02, 03, 2004
         Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -67,7 +67,7 @@ struct buffer *all_buffers;
    Setting the default value also goes through the alist of buffers
    and stores into each buffer that does not say it has a local value.  */
 
-struct buffer buffer_defaults;
+DECL_ALIGN (struct buffer, buffer_defaults);
 
 /* A Lisp_Object pointer to the above, used for staticpro */
 
@@ -97,7 +97,8 @@ struct buffer buffer_local_flags;
 /* This structure holds the names of symbols whose values may be
    buffer-local.  It is indexed and accessed in the same way as the above. */
 
-struct buffer buffer_local_symbols;
+DECL_ALIGN (struct buffer, buffer_local_symbols);
+
 /* A Lisp_Object pointer to the above, used for staticpro */
 static Lisp_Object Vbuffer_local_symbols;
 
@@ -4959,6 +4960,7 @@ init_buffer_once ()
   buffer_defaults.scroll_bar_width = Qnil;
   buffer_defaults.vertical_scroll_bar_type = Qt;
   buffer_defaults.indicate_empty_lines = Qnil;
+  buffer_defaults.indicate_buffer_boundaries = Qnil;
   buffer_defaults.scroll_up_aggressively = Qnil;
   buffer_defaults.scroll_down_aggressively = Qnil;
   buffer_defaults.display_time = Qnil;
@@ -5028,6 +5030,7 @@ init_buffer_once ()
   XSETFASTINT (buffer_local_flags.scroll_bar_width, idx); ++idx;
   XSETFASTINT (buffer_local_flags.vertical_scroll_bar_type, idx); ++idx;
   XSETFASTINT (buffer_local_flags.indicate_empty_lines, idx); ++idx;
+  XSETFASTINT (buffer_local_flags.indicate_buffer_boundaries, idx); ++idx;
   XSETFASTINT (buffer_local_flags.scroll_up_aggressively, idx); ++idx;
   XSETFASTINT (buffer_local_flags.scroll_down_aggressively, idx); ++idx;
   XSETFASTINT (buffer_local_flags.header_line_format, idx); ++idx;
@@ -5316,6 +5319,11 @@ This is the same as (default-value 'vertical-scroll-bar).  */);
                      doc: /* Default value of `indicate-empty-lines' for buffers that don't override it.
 This is the same as (default-value 'indicate-empty-lines).  */);
 
+  DEFVAR_LISP_NOPRO ("default-indicate-buffer-boundaries",
+                     &buffer_defaults.indicate_buffer_boundaries,
+                     doc: /* Default value of `indicate-buffer-boundaries' for buffers that don't override it.
+This is the same as (default-value 'indicate-buffer-boundaries).  */);
+
   DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
                      &buffer_defaults.scroll_up_aggressively,
                      doc: /* Default value of `scroll-up-aggressively'.
@@ -5626,6 +5634,14 @@ A value of t means to use the vertical scroll bar type from the window's frame.
 If non-nil, a bitmap is displayed in the left fringe of a window on
 window-systems.  */);
 
+  DEFVAR_PER_BUFFER ("indicate-buffer-boundaries",
+                     &current_buffer->indicate_buffer_boundaries, Qnil,
+                     doc: /* *Visually indicate buffer boundaries and scrolling.
+If non-nil, the first and last line of the buffer are marked in the left and
+right fringe of a window on window-systems.
+In addition, if value is t, the top and bottom line of the window are marked
+with up and down arrow bitmaps in the right fringe if window can be scrolled.  */);
+
   DEFVAR_PER_BUFFER ("scroll-up-aggressively",
                      &current_buffer->scroll_up_aggressively, Qnil,
                      doc: /* How far to scroll windows upward.
diff --git a/src/buffer.h b/src/buffer.h
index 930424b0b49..e2205a916e6 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -733,6 +733,9 @@ struct buffer
      like vi).  */
   Lisp_Object indicate_empty_lines;
 
+  /* Non-nil means indicate buffer boundaries and scrolling.  */
+  Lisp_Object indicate_buffer_boundaries;
+
   /* Time stamp updated each time this buffer is displayed in a window.  */
   Lisp_Object display_time;
 
diff --git a/src/dired.c b/src/dired.c
index 3bcd3051c25..f4102ff6edb 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -1,5 +1,5 @@
 /* Lisp functions for making directory listings.
-   Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001
+   Copyright (C) 1985, 1986, 1993, 1994, 1999, 2000, 2001, 2004
      Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -941,9 +941,9 @@ Elements of the attribute list are:
   else
     {
       pw = (struct passwd *) getpwuid (s.st_uid);
-      values[2] = (pw ? build_string (pw->pw_name) : s.st_uid);
+      values[2] = (pw ? build_string (pw->pw_name) : make_number (s.st_uid));
       gr = (struct group *) getgrgid (s.st_gid);
-      values[3] = (gr ? build_string (gr->gr_name) : s.st_gid);
+      values[3] = (gr ? build_string (gr->gr_name) : make_number (s.st_gid));
     }
   values[4] = make_time (s.st_atime);
   values[5] = make_time (s.st_mtime);
diff --git a/src/dispextern.h b/src/dispextern.h
index b93bbd1190d..79b949b6337 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -709,6 +709,15 @@ struct glyph_row
      position of the next row.  */
   struct display_pos end;
 
+  /* Left fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned left_fringe_bitmap : 4;
+
+  /* Right fringe bitmap number (enum fringe_bitmap_type).  */
+  unsigned right_fringe_bitmap : 4;
+
+  /* 1 means that we must draw the bitmaps of this row.  */
+  unsigned redraw_fringe_bitmaps_p : 1;
+
   /* In a desired matrix, 1 means that this row must be updated.  In a
      current matrix, 0 means that the row has been invalidated, i.e.
      the row's contents do not agree with what is visible on the
@@ -777,6 +786,29 @@ struct glyph_row
   /* 1 means this row was ended by a newline from a string.  */
   unsigned ends_in_newline_from_string_p : 1;
 
+  /* 1 means this row width is exactly the width of the window, and the
+     final newline character is hidden in the right fringe.  */
+  unsigned exact_window_width_line_p : 1;
+
+  /* 1 means this row currently shows the cursor in the right fringe.  */
+  unsigned cursor_in_fringe_p : 1;
+
+  /* Non-zero means display a bitmap on X frames indicating that this
+     the first line of the buffer.  */
+  unsigned indicate_bob_p : 1;
+
+  /* Non-zero means display a bitmap on X frames indicating that this
+     the top line of the window, but not start of the buffer.  */
+  unsigned indicate_top_line_p : 1;
+
+  /* Non-zero means display a bitmap on X frames indicating that this
+     the last line of the buffer.  */
+  unsigned indicate_eob_p : 1;
+
+  /* Non-zero means display a bitmap on X frames indicating that this
+     the bottom line of the window, but not end of the buffer.  */
+  unsigned indicate_bottom_line_p : 1;
+
   /* Continuation lines width at the start of the row.  */
   int continuation_lines_width;
 };
@@ -1582,10 +1614,19 @@ enum fringe_bitmap_type
   NO_FRINGE_BITMAP = 0,
   LEFT_TRUNCATION_BITMAP,
   RIGHT_TRUNCATION_BITMAP,
+  UP_ARROW_BITMAP,
+  DOWN_ARROW_BITMAP,
   CONTINUED_LINE_BITMAP,
   CONTINUATION_LINE_BITMAP,
   OVERLAY_ARROW_BITMAP,
+  FIRST_LINE_BITMAP,
+  LAST_LINE_BITMAP,
+  FILLED_BOX_CURSOR_BITMAP,
+  HOLLOW_BOX_CURSOR_BITMAP,
+  BAR_CURSOR_BITMAP,
+  HBAR_CURSOR_BITMAP,
   ZV_LINE_BITMAP,
+  HOLLOW_SQUARE_BITMAP,
   MAX_FRINGE_BITMAPS
 };
 
@@ -2485,7 +2526,10 @@ void move_it_past_eol P_ ((struct it *));
 int in_display_vector_p P_ ((struct it *));
 int frame_mode_line_height P_ ((struct frame *));
 void highlight_trailing_whitespace P_ ((struct frame *, struct glyph_row *));
+void draw_fringe_bitmap P_ ((struct window *, struct glyph_row *, int));
 void draw_row_fringe_bitmaps P_ ((struct window *, struct glyph_row *));
+void draw_window_fringes P_ ((struct window *));
+int update_window_fringes P_ ((struct window *, int));
 void compute_fringe_widths P_ ((struct frame *, int));
 extern Lisp_Object Qtool_bar;
 extern Lisp_Object Vshow_trailing_whitespace;
diff --git a/src/dispnew.c b/src/dispnew.c
index 81a0f1f5c8e..b62fd8f8b8f 100644
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1,5 +1,5 @@
 /* Updating of data structures for redisplay.
-   Copyright (C) 1985,86,87,88,93,94,95,97,98,1999,2000,01,02,2003
+   Copyright (C) 1985,86,87,88,93,94,95,97,98,1999,2000,01,02,03,04
        Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -1500,12 +1500,11 @@ row_equal_p (w, a, b, mouse_face_p)
             return 0;
         }
 
-      if (a->truncated_on_left_p != b->truncated_on_left_p
-          || a->fill_line_p != b->fill_line_p
-          || a->truncated_on_right_p != b->truncated_on_right_p
-          || a->overlay_arrow_p != b->overlay_arrow_p
-          || a->continued_p != b->continued_p
-          || a->indicate_empty_line_p != b->indicate_empty_line_p
+      if (a->fill_line_p != b->fill_line_p
+          || a->cursor_in_fringe_p != b->cursor_in_fringe_p
+          || a->left_fringe_bitmap != b->left_fringe_bitmap
+          || a->right_fringe_bitmap != b->right_fringe_bitmap
+          || a->exact_window_width_line_p != b->exact_window_width_line_p
           || a->overlapped_p != b->overlapped_p
           || (MATRIX_ROW_CONTINUATION_LINE_P (a)
               != MATRIX_ROW_CONTINUATION_LINE_P (b))
@@ -3442,6 +3441,7 @@ direct_output_for_insert (g)
           /* Can't do it in a continued line because continuation
              lines would change.  */
           (glyph_row->continued_p
+           || glyph_row->exact_window_width_line_p
            /* Can't use this method if the line overlaps others or is
               overlapped by others because these other lines would
               have to be redisplayed.  */
@@ -3647,6 +3647,10 @@ direct_output_for_insert (g)
       cursor_to (y, x);
     }
 
+#ifdef HAVE_WINDOW_SYSTEM
+  update_window_fringes (w, 0);
+#endif
+
   if (FRAME_RIF (f))
     FRAME_RIF (f)->update_window_end_hook (w, 1, 0);
   update_end (f);
@@ -4194,6 +4198,10 @@ update_window (w, force_p)
       strcpy (w->current_matrix->method, w->desired_matrix->method);
 #endif
 
+#ifdef HAVE_WINDOW_SYSTEM
+      update_window_fringes (w, 0);
+#endif
+
       /* End the update of window W.  Don't set the cursor if we
          paused updating the display because in this case,
          set_window_cursor_after_update hasn't been called, and
@@ -4515,13 +4523,10 @@ update_window_line (w, vpos, mouse_face_overwritten_p)
       if (!current_row->enabled_p
           || desired_row->y != current_row->y
           || desired_row->visible_height != current_row->visible_height
-          || desired_row->overlay_arrow_p != current_row->overlay_arrow_p
-          || desired_row->truncated_on_left_p != current_row->truncated_on_left_p
-          || desired_row->truncated_on_right_p != current_row->truncated_on_right_p
-          || desired_row->continued_p != current_row->continued_p
+          || desired_row->cursor_in_fringe_p != current_row->cursor_in_fringe_p
+          || current_row->redraw_fringe_bitmaps_p
           || desired_row->mode_line_p != current_row->mode_line_p
-          || (desired_row->indicate_empty_line_p
-              != current_row->indicate_empty_line_p)
+          || desired_row->exact_window_width_line_p != current_row->exact_window_width_line_p
           || (MATRIX_ROW_CONTINUATION_LINE_P (desired_row)
               != MATRIX_ROW_CONTINUATION_LINE_P (current_row)))
         rif->after_update_window_line_hook (desired_row);
@@ -4776,6 +4781,7 @@ scrolling_window (w, header_line_p)
 
       if (c->enabled_p
           && d->enabled_p
+          && !d->redraw_fringe_bitmaps_p
           && c->y == d->y
           && MATRIX_ROW_BOTTOM_Y (c) <= yb
           && MATRIX_ROW_BOTTOM_Y (d) <= yb
@@ -4831,6 +4837,7 @@ scrolling_window (w, header_line_p)
          && MATRIX_ROW (current_matrix, i - 1)->enabled_p
          && (MATRIX_ROW (current_matrix, i - 1)->y
              == MATRIX_ROW (desired_matrix, j - 1)->y)
+         && !MATRIX_ROW (desired_matrix, j - 1)->redraw_fringe_bitmaps_p
          && row_equal_p (w,
                          MATRIX_ROW (desired_matrix, i - 1),
                          MATRIX_ROW (current_matrix, j - 1), 1))
@@ -5023,6 +5030,10 @@ scrolling_window (w, header_line_p)
             to = MATRIX_ROW (current_matrix, r->desired_vpos + j);
             from = MATRIX_ROW (desired_matrix, r->desired_vpos + j);
             to_overlapped_p = to->overlapped_p;
+            if (!from->mode_line_p && !w->pseudo_window_p
+                && (to->left_fringe_bitmap != from->left_fringe_bitmap
+                    || to->right_fringe_bitmap != from->right_fringe_bitmap))
+              from->redraw_fringe_bitmaps_p = 1;
             assign_row (to, from);
             to->enabled_p = 1, from->enabled_p = 0;
             to->overlapped_p = to_overlapped_p;
diff --git a/src/fontset.c b/src/fontset.c
index 3cd76c3af1d..61e05b68c72 100644
--- a/src/fontset.c
+++ b/src/fontset.c
@@ -599,7 +599,8 @@ fontset_font_pattern (f, id, c)
       fontset = FONTSET_FROM_ID (id);
       xassert (!BASE_FONTSET_P (fontset));
       fontset = FONTSET_BASE (fontset);
-      elt = FONTSET_REF (fontset, c);
+      if (! EQ (fontset, Vdefault_fontset))
+        elt = FONTSET_REF (fontset, c);
     }
   if (NILP (elt))
     {
diff --git a/src/keyboard.c b/src/keyboard.c
index 1897fb5c0f8..cdf28bd5e66 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -1,5 +1,5 @@
 /* Keyboard and mouse input; editor command loop.
-   Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99,2000,01,02,03
+   Copyright (C) 1985,86,87,88,89,93,94,95,96,97,99,2000,01,02,03,04
      Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -470,36 +470,6 @@ extern char *pending_malloc_warning;
 
 static struct input_event kbd_buffer[KBD_BUFFER_SIZE];
 
-/* Vector to GCPRO the Lisp objects referenced from kbd_buffer.
-
-   The interrupt-level event handlers will never enqueue an event on a
-   frame which is not in Vframe_list, and once an event is dequeued,
-   internal_last_event_frame or the event itself points to the frame.
-   So that's all fine.
-
-   But while the event is sitting in the queue, it's completely
-   unprotected.  Suppose the user types one command which will run for
-   a while and then delete a frame, and then types another event at
-   the frame that will be deleted, before the command gets around to
-   it.  Suppose there are no references to this frame elsewhere in
-   Emacs, and a GC occurs before the second event is dequeued.  Now we
-   have an event referring to a freed frame, which will crash Emacs
-   when it is dequeued.
-
-   Similar things happen when an event on a scroll bar is enqueued; the
-   window may be deleted while the event is in the queue.
-
-   So, we use this vector to protect the Lisp_Objects in the event
-   queue.  That way, they'll be dequeued as dead frames or windows,
-   but still valid Lisp objects.
-
-   If kbd_buffer[i].kind != NO_EVENT, then
-
-   AREF (kbd_buffer_gcpro, 2 * i) == kbd_buffer[i].frame_or_window.
-   AREF (kbd_buffer_gcpro, 2 * i + 1) == kbd_buffer[i].arg.  */
-
-static Lisp_Object kbd_buffer_gcpro;
-
 /* Pointer to next available character in kbd_buffer.
    If kbd_fetch_ptr == kbd_store_ptr, the buffer is empty.
    This may be kbd_buffer + KBD_BUFFER_SIZE, meaning that the
@@ -3630,7 +3600,6 @@ kbd_buffer_store_event (event)
      Discard the event if it would fill the last slot.  */
   if (kbd_fetch_ptr - 1 != kbd_store_ptr)
     {
-      int idx;
 
 #if 0 /* The SELECTION_REQUEST_EVENT case looks bogus, and it's error
          prone to assign individual members for other events, in case
@@ -3660,9 +3629,6 @@ kbd_buffer_store_event (event)
       *kbd_store_ptr = *event;
 #endif
 
-      idx = 2 * (kbd_store_ptr - kbd_buffer);
-      ASET (kbd_buffer_gcpro, idx, event->frame_or_window);
-      ASET (kbd_buffer_gcpro, idx + 1, event->arg);
       ++kbd_store_ptr;
     }
 }
@@ -3778,9 +3744,6 @@ static INLINE void
 clear_event (event)
      struct input_event *event;
 {
-  int idx = 2 * (event - kbd_buffer);
-  ASET (kbd_buffer_gcpro, idx, Qnil);
-  ASET (kbd_buffer_gcpro, idx + 1, Qnil);
   event->kind = NO_EVENT;
 }
 
@@ -6805,6 +6768,30 @@ tty_read_avail_input (struct display *display,
 
 #endif /* not VMS */
 
+void
+handle_async_input ()
+{
+#ifdef BSD4_1
+  extern int select_alarmed;
+#endif
+  interrupt_input_pending = 0;
+
+  while (1)
+    {
+      int nread;
+      nread = read_avail_input (1);
+      /* -1 means it's not ok to read the input now.
+         UNBLOCK_INPUT will read it later; now, avoid infinite loop.
+         0 means there was no keyboard input available.  */
+      if (nread <= 0)
+        break;
+
+#ifdef BSD4_1
+      select_alarmed = 1;  /* Force the select emulator back to life */
+#endif
+    }
+}
+
 #ifdef SIGIO   /* for entire page */
 /* Note SIGIO has been undef'd if FIONREAD is missing.  */
 
@@ -6814,9 +6801,6 @@ input_available_signal (signo)
 {
   /* Must preserve main program's value of errno.  */
   int old_errno = errno;
-#ifdef BSD4_1
-  extern int select_alarmed;
-#endif
 
 #if defined (USG) && !defined (POSIX_SIGNALS)
   /* USG systems forget handlers when they are used;
@@ -6831,20 +6815,11 @@ input_available_signal (signo)
   if (input_available_clear_time)
     EMACS_SET_SECS_USECS (*input_available_clear_time, 0, 0);
 
-  while (1)
-    {
-      int nread;
-      nread = read_avail_input (1);
-      /* -1 means it's not ok to read the input now.
-         UNBLOCK_INPUT will read it later; now, avoid infinite loop.
-         0 means there was no keyboard input available.  */
-      if (nread <= 0)
-        break;
-
-#ifdef BSD4_1
-      select_alarmed = 1;  /* Force the select emulator back to life */
+#ifdef SYNC_INPUT
+  interrupt_input_pending = 1;
+#else
+  handle_async_input ();
 #endif
-    }
 
 #ifdef BSD4_1
   sigfree ();
@@ -6863,7 +6838,7 @@ void
 reinvoke_input_signal ()
 {
 #ifdef SIGIO
-  kill (getpid (), SIGIO);
+  handle_async_input ();
 #endif
 }
 
@@ -10123,7 +10098,6 @@ Also end any kbd macro being defined.  */)
   discard_tty_input ();
 
   kbd_fetch_ptr =  kbd_store_ptr;
-  Ffillarray (kbd_buffer_gcpro, Qnil);
   input_pending = 0;
 
   return Qnil;
@@ -10217,17 +10191,13 @@ stuff_buffered_input (stuffstring)
      Should we ignore anything that was typed in at the "wrong" kboard?  */
   for (; kbd_fetch_ptr != kbd_store_ptr; kbd_fetch_ptr++)
     {
-      int idx;
 
       if (kbd_fetch_ptr == kbd_buffer + KBD_BUFFER_SIZE)
         kbd_fetch_ptr = kbd_buffer;
       if (kbd_fetch_ptr->kind == ASCII_KEYSTROKE_EVENT)
         stuff_char (kbd_fetch_ptr->code);
 
-      kbd_fetch_ptr->kind = NO_EVENT;
-      idx = 2 * (kbd_fetch_ptr - kbd_buffer);
-      ASET (kbd_buffer_gcpro, idx, Qnil);
-      ASET (kbd_buffer_gcpro, idx + 1, Qnil);
+      clear_event (kbd_fetch_ptr);
     }
 
   input_pending = 0;
@@ -10679,7 +10649,6 @@ init_keyboard ()
   recent_keys_index = 0;
   kbd_fetch_ptr = kbd_buffer;
   kbd_store_ptr = kbd_buffer;
-  kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
 #ifdef HAVE_MOUSE
   do_mouse_tracking = Qnil;
 #endif
@@ -10976,9 +10945,6 @@ syms_of_keyboard ()
   Fset (Qextended_command_history, Qnil);
   staticpro (&Qextended_command_history);
 
-  kbd_buffer_gcpro = Fmake_vector (make_number (2 * KBD_BUFFER_SIZE), Qnil);
-  staticpro (&kbd_buffer_gcpro);
-
   accent_key_syms = Qnil;
   staticpro (&accent_key_syms);
 
diff --git a/src/lisp.h b/src/lisp.h
index 8c6374e6004..570d5ff9757 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1,5 +1,5 @@
 /* Fundamental definitions for GNU Emacs Lisp interpreter.
-   Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000, 2001, 2002, 2003
+   Copyright (C) 1985,86,87,93,94,95,97,98,1999,2000,01,02,03,2004
      Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -67,10 +67,6 @@ extern void die P_((const char *, const char *, int));
                            ? (void) 0                           \
                            : die ((msg), __FILE__, __LINE__)),  \
                           0)
-
-/* Let's get some compile-time checking too.  */
-#undef NO_UNION_TYPE
-
 #else
 
 /* Produce same side effects and result, but don't complain.  */
@@ -293,12 +289,55 @@ enum pvec_type
 /* For convenience, we also store the number of elements in these bits.  */
 #define PSEUDOVECTOR_SIZE_MASK 0x1ff
 
+/***** Select the tagging scheme.  *****/
+
+/* 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. */
+#if defined USE_LSB_TAG && !defined 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
+# else
+#  error "USE_LSB_TAG used without defining DECL_ALIGN"
+# endif
+#endif
+
+#ifndef USE_LSB_TAG
+/* Just remove the alignment annotation if we don't use it.  */
+#undef DECL_ALIGN
+#define DECL_ALIGN(type, var) type var
+#endif
+
+
 /* These macros extract various sorts of values from a Lisp_Object.
  For example, if tem is a Lisp_Object whose type is Lisp_Cons,
  XCONS (tem) is the struct Lisp_Cons * pointing to the memory for that cons.  */
 
 #ifdef NO_UNION_TYPE
 
+#ifdef USE_LSB_TAG
+
+#define TYPEMASK ((((EMACS_INT) 1) << GCTYPEBITS) - 1)
+#define XTYPE(a) ((enum Lisp_Type) (((EMACS_UINT) (a)) & TYPEMASK))
+#define XINT(a) (((EMACS_INT) (a)) >> GCTYPEBITS)
+#define XUINT(a) (((EMACS_UINT) (a)) >> GCTYPEBITS)
+#define XSET(var, type, ptr)                                    \
+    (eassert (XTYPE (ptr) == 0), /* Check alignment.  */        \
+     (var) = ((EMACS_INT) (type)) | ((EMACS_INT) (ptr)))
+#define make_number(N) (((EMACS_INT) (N)) << GCTYPEBITS)
+
+/* XFASTINT and XSETFASTINT are for use when the integer is known to be
+   positive, in which case the implementation can sometimes be faster
+   depending on the tagging scheme.  With USE_LSB_TAG, there's no benefit.  */
+#define XFASTINT(a) XINT (a)
+#define XSETFASTINT(a, b) ((a) = make_number (b))
+
+#define XPNTR(a) ((EMACS_INT) ((a) & ~TYPEMASK))
+
+#else  /* not USE_LSB_TAG */
+
 #define VALMASK ((((EMACS_INT) 1) << VALBITS) - 1)
 
 /* One need to override this if there must be high bits set in data space
@@ -337,6 +376,8 @@ enum pvec_type
 #define make_number(N)          \
   ((((EMACS_INT) (N)) & VALMASK) | ((EMACS_INT) Lisp_Int) << VALBITS)
 
+#endif /* not USE_LSB_TAG */
+
 #define EQ(x, y) ((x) == (y))
 
 #else /* not NO_UNION_TYPE */
@@ -1150,6 +1191,13 @@ struct Lisp_Free
     unsigned gcmarkbit : 1;
     int spacer : 15;
     union Lisp_Misc *chain;
+#ifdef USE_LSB_TAG
+    /* Try to make sure that sizeof(Lisp_Misc) preserves TYPEBITS-alignment.
+       This assumes that Lisp_Marker is the largest of the alternatives and
+       that Lisp_Intfwd has the same size as "Lisp_Free w/o padding".  */
+    char padding[((((sizeof (struct Lisp_Marker) - 1) >> GCTYPEBITS) + 1)
+                  << GCTYPEBITS) - sizeof (struct Lisp_Intfwd)];
+#endif
   };
 
 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
@@ -1517,7 +1565,7 @@ typedef unsigned char UCHAR;
 
 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
   Lisp_Object fnname ();                                                \
-  struct Lisp_Subr sname =                                              \
+  DECL_ALIGN (struct Lisp_Subr, sname) =                                \
     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
       fnname, minargs, maxargs, lname, prompt, 0};                      \
   Lisp_Object fnname
@@ -1528,7 +1576,7 @@ typedef unsigned char UCHAR;
    arguments, so we can catch errors with maxargs at compile-time.  */
 #define DEFUN(lname, fnname, sname, minargs, maxargs, prompt, doc)      \
   Lisp_Object fnname DEFUN_ARGS_ ## maxargs ;                           \
-  struct Lisp_Subr sname =                                              \
+  DECL_ALIGN (struct Lisp_Subr, sname) =                                \
     { PVEC_SUBR | (sizeof (struct Lisp_Subr) / sizeof (EMACS_INT)),     \
       fnname, minargs, maxargs, lname, prompt, 0};                      \
   Lisp_Object fnname
@@ -1675,6 +1723,9 @@ extern char *stack_bottom;
    This is a good thing to do around a loop that has no side effects
    and (in particular) cannot call arbitrary Lisp code.  */
 
+#ifdef SYNC_INPUT
+extern void handle_async_input P_ ((void));
+extern int interrupt_input_pending;
 #define QUIT                                            \
   do {                                                  \
     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
@@ -1682,8 +1733,24 @@ extern char *stack_bottom;
         Vquit_flag = Qnil;                              \
         Fsignal (Qquit, Qnil);                          \
       }                                                 \
+    else if (interrupt_input_pending)                   \
+      handle_async_input ();                            \
   } while (0)
 
+#else  /* not SYNC_INPUT */
+
+#define QUIT                                            \
+  do {                                                  \
+    if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))     \
+      {                                                 \
+        Vquit_flag = Qnil;                              \
+        Fsignal (Qquit, Qnil);                          \
+      }                                                 \
+  } while (0)
+
+#endif  /* not SYNC_INPUT */
+
+
 /* Nonzero if ought to quit now.  */
 
 #define QUITP (!NILP (Vquit_flag) && NILP (Vinhibit_quit))
diff --git a/src/lread.c b/src/lread.c
index fae47300bd6..ac353c798dc 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1,5 +1,5 @@
 /* Lisp parsing and input streams.
-   Copyright (C) 1985, 86, 87, 88, 89, 93, 94, 95, 97, 98, 99, 2000, 01, 2003
+   Copyright (C) 1985,86,87,88,89,93,94,95,97,98,99,2000,01,03,2004
       Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -3496,7 +3496,6 @@ defvar_per_buffer (namestring, address, type, doc)
 {
   Lisp_Object sym, val;
   int offset;
-  extern struct buffer buffer_local_symbols;
 
   sym = intern (namestring);
   val = allocate_misc ();
diff --git a/src/macterm.c b/src/macterm.c
index 98e9354afe2..a4124a0c7bc 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -1143,6 +1143,9 @@ x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
                                 output_cursor.x, output_cursor.y);
 
       x_draw_vertical_border (w);
+
+      draw_window_fringes (w);
+
       UNBLOCK_INPUT;
     }
 
@@ -1239,11 +1242,7 @@ x_after_update_window_line (desired_row)
   xassert (w);
 
   if (!desired_row->mode_line_p && !w->pseudo_window_p)
-    {
-      BLOCK_INPUT;
-      draw_row_fringe_bitmaps (w, desired_row);
-      UNBLOCK_INPUT;
-    }
+    desired_row->redraw_fringe_bitmaps_p = 1;
 
   /* When a window has disappeared, make sure that no rest of
      full-width rows stays visible in the internal border.  Could
@@ -1295,9 +1294,24 @@ x_draw_fringe_bitmap (w, row, p)
   XGCValues gcv;
   GC gc = f->output_data.mac->normal_gc;
   struct face *face = p->face;
+  int rowY;
 
   /* Must clip because of partially visible lines.  */
-  x_clip_to_row (w, row, gc);
+  rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+  if (p->y < rowY)
+    {
+      /* Adjust position of "bottom aligned" bitmap on partially
+         visible last row.  */
+      int oldY = row->y;
+      int oldVH = row->visible_height;
+      row->visible_height = p->h;
+      row->y -= rowY - p->y;
+      x_clip_to_row (w, row, gc);
+      row->y = oldY;
+      row->visible_height = oldVH;
+    }
+  else
+    x_clip_to_row (w, row, gc);
 
   if (p->bx >= 0)
     {
@@ -4546,6 +4560,14 @@ mac_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, act
       w->phys_cursor_width = cursor_width;
       w->phys_cursor_on_p = 1;
 
+      if (glyph_row->exact_window_width_line_p
+          && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
+        {
+          glyph_row->cursor_in_fringe_p = 1;
+          draw_fringe_bitmap (w, glyph_row, 0);
+          return;
+        }
+
       switch (cursor_type)
         {
         case HOLLOW_BOX_CURSOR:
@@ -6643,8 +6665,8 @@ do_check_ram_size (void)
 
   if (Gestalt (gestaltPhysicalRAMSize, &physical_ram_size) != noErr
       || Gestalt (gestaltLogicalRAMSize, &logical_ram_size) != noErr
-      || physical_ram_size > 256 * 1024 * 1024
-      || logical_ram_size > 256 * 1024 * 1024)
+      || physical_ram_size > (1 << VALBITS)
+      || logical_ram_size > (1 << VALBITS))
     {
       StopAlert (RAM_TOO_LARGE_ALERT_ID, NULL);
       exit (1);
@@ -7443,7 +7465,9 @@ main (void)
 
   do_get_menus ();
 
+#ifndef USE_LSB_TAG
   do_check_ram_size ();
+#endif
 
   init_emacs_passwd_dir ();
 
diff --git a/src/process.c b/src/process.c
index 8181727bb79..22f482476cb 100644
--- a/src/process.c
+++ b/src/process.c
@@ -1,6 +1,6 @@
 /* Asynchronous subprocess control for GNU Emacs.
    Copyright (C) 1985, 86, 87, 88, 93, 94, 95, 96, 98, 1999,
-      2001, 2002, 2003 Free Software Foundation, Inc.
+      2001, 2002, 2003, 2004 Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -4080,6 +4080,10 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
          Otherwise, do pending quit if requested.  */
       if (XINT (read_kbd) >= 0)
         QUIT;
+#ifdef SYNC_INPUT
+      else if (interrupt_input_pending)
+        handle_async_input ();
+#endif
 
       /* Exit now if the cell we're waiting for became non-nil.  */
       if (! NILP (wait_for_cell) && ! NILP (XCAR (wait_for_cell)))
@@ -4296,7 +4300,7 @@ wait_reading_process_input (time_limit, microsecs, read_kbd, do_display)
                   proc = chan_process[channel];
                   if (NILP (proc))
                     continue;
-                  if (XPROCESS (proc)->read_output_delay > 0)
+                  if (XINT (XPROCESS (proc)->read_output_delay) > 0)
                     {
                       check_delay--;
                       if (NILP (XPROCESS (proc)->read_output_skip))
diff --git a/src/s/darwin.h b/src/s/darwin.h
index 32db3e3364b..abc56901e17 100644
--- a/src/s/darwin.h
+++ b/src/s/darwin.h
@@ -1,5 +1,5 @@
 /* System description header file for Darwin (Mac OS X).
-   Copyright (C) 2001, 2002 Free Software Foundation, Inc.
+   Copyright (C) 2001, 02, 2004  Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
 
@@ -203,9 +203,6 @@ Boston, MA 02111-1307, USA.  */
 /* Fix compilation problem for regex.c.  */
 #define __restrict
 
-/* Fix compilation problem for md5.c.  */
-#define __attribute__(x)
-
 /* Used in dispnew.c.  Copied from freebsd.h. */
 #define PENDING_OUTPUT_COUNT(FILE) ((FILE)->_p - (FILE)->_bf._base)
 
diff --git a/src/search.c b/src/search.c
index 538cb8dfa64..020573b75a1 100644
--- a/src/search.c
+++ b/src/search.c
@@ -2553,8 +2553,16 @@ since only regular expressions have distinguished subexpressions.  */)
         }
 
       if (really_changed)
-        newtext = make_string (substed, substed_len);
+        {
+          if (buf_multibyte)
+            {
+              int nchars = multibyte_chars_in_text (substed, substed_len);
 
+              newtext = make_multibyte_string (substed, nchars, substed_len);
+            }
+          else
+            newtext = make_unibyte_string (substed, substed_len);
+        }
       xfree (substed);
     }
 
diff --git a/src/w32term.c b/src/w32term.c
index bee1a1913ff..834df6ef88f 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -540,6 +540,9 @@ x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
                                 output_cursor.x, output_cursor.y);
 
       x_draw_vertical_border (w);
+
+      draw_window_fringes (w);
+
       UNBLOCK_INPUT;
     }
 
@@ -624,11 +627,7 @@ x_after_update_window_line (desired_row)
   xassert (w);
 
   if (!desired_row->mode_line_p && !w->pseudo_window_p)
-    {
-      BLOCK_INPUT;
-      draw_row_fringe_bitmaps (w, desired_row);
-      UNBLOCK_INPUT;
-    }
+    desired_row->redraw_fringe_bitmaps_p = 1;
 
   /* When a window has disappeared, make sure that no rest of
      full-width rows stays visible in the internal border.  Could
@@ -678,11 +677,26 @@ w32_draw_fringe_bitmap (w, row, p)
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   HDC hdc;
   struct face *face = p->face;
+  int rowY;
 
   hdc = get_frame_dc (f);
 
   /* Must clip because of partially visible lines.  */
-  w32_clip_to_row (w, row, hdc);
+  rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+  if (p->y < rowY)
+    {
+      /* Adjust position of "bottom aligned" bitmap on partially
+         visible last row.  */
+      int oldY = row->y;
+      int oldVH = row->visible_height;
+      row->visible_height = p->h;
+      row->y -= rowY - p->y;
+      w32_clip_to_row (w, row, hdc);
+      row->y = oldY;
+      row->visible_height = oldVH;
+    }
+  else
+    w32_clip_to_row (w, row, hdc);
 
   if (p->bx >= 0)
     {
@@ -5120,6 +5134,14 @@ w32_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, act
           PostMessage (hwnd, WM_EMACS_TRACK_CARET, 0, 0);
         }
 
+      if (glyph_row->exact_window_width_line_p
+          && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
+        {
+          glyph_row->cursor_in_fringe_p = 1;
+          draw_fringe_bitmap (w, glyph_row, 0);
+          return;
+        }
+
       switch (cursor_type)
         {
         case HOLLOW_BOX_CURSOR:
diff --git a/src/xdisp.c b/src/xdisp.c
index 675aa696a59..fc09df3b49a 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -1,5 +1,5 @@
 /* Display generation from window structure and buffer text.
-   Copyright (C) 1985,86,87,88,93,94,95,97,98,99,2000,01,02,03
+   Copyright (C) 1985,86,87,88,93,94,95,97,98,99,2000,01,02,03,04
    Free Software Foundation, Inc.
 
 This file is part of GNU Emacs.
@@ -310,6 +310,21 @@ extern Lisp_Object Qscroll_bar;
 
 Lisp_Object Vshow_trailing_whitespace;
 
+#ifdef HAVE_WINDOW_SYSTEM
+/* Non-nil means that newline may flow into the right fringe.  */
+
+Lisp_Object Voverflow_newline_into_fringe;
+#endif /* HAVE_WINDOW_SYSTEM */
+
+/* Test if overflow newline into fringe.  Called with iterator IT
+   at or past right window margin, and with IT->current_x set.  */ 
+
+#define IT_OVERFLOW_NEWLINE_INTO_FRINGE(it)     \
+  (!NILP (Voverflow_newline_into_fringe)        \
+   && FRAME_WINDOW_P (it->f)                    \
+   && WINDOW_RIGHT_FRINGE_WIDTH (it->w) > 0     \
+   && it->current_x == it->last_visible_x)
+
 /* Non-nil means show the text cursor in void text areas
    i.e. in blank areas after eol and eob.  This used to be
    the default in 21.3.  */
@@ -5590,7 +5605,20 @@ move_it_in_display_line_to (it, to_charpos, to_x, op)
                       ++it->hpos;
                       it->current_x = new_x;
                       if (i == it->nglyphs - 1)
-                        set_iterator_to_next (it, 1);
+                        {
+                          set_iterator_to_next (it, 1);
+#ifdef HAVE_WINDOW_SYSTEM
+                          if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+                            {
+                              get_next_display_element (it);
+                              if (ITERATOR_AT_END_OF_LINE_P (it))
+                                {
+                                  result = MOVE_NEWLINE_OR_CR;
+                                  break;
+                                }
+                            }
+#endif /* HAVE_WINDOW_SYSTEM */
+                        }
                     }
                   else
                     {
@@ -5647,6 +5675,17 @@ move_it_in_display_line_to (it, to_charpos, to_x, op)
       if (it->truncate_lines_p
           && it->current_x >= it->last_visible_x)
         {
+#ifdef HAVE_WINDOW_SYSTEM
+          if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+            {
+              get_next_display_element (it);
+              if (ITERATOR_AT_END_OF_LINE_P (it))
+                {
+                  result = MOVE_NEWLINE_OR_CR;
+                  break;
+                }
+            }
+#endif /* HAVE_WINDOW_SYSTEM */
           result = MOVE_LINE_TRUNCATED;
           break;
         }
@@ -8895,26 +8934,205 @@ note_tool_bar_highlight (f, x, y)
 
 #ifdef HAVE_WINDOW_SYSTEM
 
+/* Notice that all bitmaps bits are "mirrored".  */
+
 /* An arrow like this: `<-'.  */
+/*
+  ...xx...
+  ....xx..
+  .....xx.
+  ..xxxxxx
+  ..xxxxxx
+  .....xx.
+  ....xx..
+  ...xx...
+*/
 static unsigned char left_bits[] = {
    0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
 
+
 /* Right truncation arrow bitmap `->'.  */
+/*
+  ...xx...
+  ..xx....
+  .xx.....
+  xxxxxx..
+  xxxxxx..
+  .xx.....
+  ..xx....
+  ...xx...
+*/
 static unsigned char right_bits[] = {
    0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
 
+
+/* Up arrow bitmap.  */
+/*
+  ...xx...
+  ..xxxx..
+  .xxxxxx.
+  xxxxxxxx
+  ...xx...
+  ...xx...
+  ...xx...
+  ...xx...
+*/
+static unsigned char up_arrow_bits[] = {
+   0x18, 0x3c, 0x7e, 0xff, 0x18, 0x18, 0x18, 0x18};
+
+
+/* Down arrow bitmap.  */
+/*
+  ...xx...
+  ...xx...
+  ...xx...
+  ...xx...
+  xxxxxxxx
+  .xxxxxx.
+  ..xxxx..
+  ...xx...
+*/
+static unsigned char down_arrow_bits[] = {
+   0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
+
 /* Marker for continued lines.  */
+/*
+  ..xxxx..
+  .xxxxx..
+  xx......
+  xxx..x..
+  xxxxxx..
+  .xxxxx..
+  ..xxxx..
+  .xxxxx..
+*/
 static unsigned char continued_bits[] = {
    0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
 
 /* Marker for continuation lines.  */
+/*
+  ..xxxx..
+  ..xxxxx.
+  ......xx
+  ..x..xxx
+  ..xxxxxx
+  ..xxxxx.
+  ..xxxx..
+  ..xxxxx.
+*/
 static unsigned char continuation_bits[] = {
    0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
 
 /* Overlay arrow bitmap.  A triangular arrow.  */
+/*
+  ......xx
+  ....xxxx
+  ...xxxxx
+  ..xxxxxx
+  ..xxxxxx
+  ...xxxxx
+  ....xxxx
+  ......xx
+*/
 static unsigned char ov_bits[] = {
    0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
 
+
+/* First line bitmap.  An left-up angle.  */
+/*
+  ..xxxxxx
+  ..xxxxxx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ........
+*/
+static unsigned char first_line_bits[] = {
+   0x3f, 0x3f, 0x03, 0x03, 0x03, 0x03, 0x03, 0x00};
+
+
+/* Last line bitmap.  An left-down angle.  */
+/*
+  ........
+  xx......
+  xx......
+  xx......
+  xx......
+  xx......
+  xxxxxx..
+  xxxxxx..
+*/
+static unsigned char last_line_bits[] = {
+   0x00, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xfc, 0xfc};
+
+/* Filled box cursor bitmap.  A filled box; max 13 pixels high.  */
+/*
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+  .xxxxxxx
+*/
+static unsigned char filled_box_cursor_bits[] = {
+   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f};
+
+/* Hollow box cursor bitmap.  A hollow box; max 13 pixels high.  */
+/*
+  .xxxxxxx
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .x.....x
+  .xxxxxxx
+*/
+static unsigned char hollow_box_cursor_bits[] = {
+   0x7f, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x41, 0x7f};
+
+/* Bar cursor bitmap.  A vertical bar; max 13 pixels high.  */
+/*
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+  ......xx
+*/
+static unsigned char bar_cursor_bits[] = {
+   0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03};
+
+/* HBar cursor bitmap.  A horisontal bar; 2 pixels high.  */
+/*
+  .xxxxxxx
+  .xxxxxxx
+*/
+static unsigned char hbar_cursor_bits[] = {
+  0x7f, 0x7f};
+
+
 /* Bitmap drawn to indicate lines not displaying text if
    `indicate-empty-lines' is non-nil.  */
 static unsigned char zv_bits[] = {
@@ -8927,32 +9145,89 @@ static unsigned char zv_bits[] = {
   0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
   0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00};
 
+/* Hollow square bitmap.  */
+/*
+  .xxxxxx.
+  .x....x.
+  .x....x.
+  .x....x.
+  .x....x.
+  .xxxxxx.
+*/
+static unsigned char hollow_square_bits[] = {
+   0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
+
+
 struct fringe_bitmap fringe_bitmaps[MAX_FRINGE_BITMAPS] =
 {
   { 0, 0, 0, NULL /* NO_FRINGE_BITMAP */ },
   { 8, sizeof (left_bits), 0, left_bits },
   { 8, sizeof (right_bits), 0, right_bits },
+  { 8, sizeof (up_arrow_bits), -1, up_arrow_bits },
+  { 8, sizeof (down_arrow_bits), -2, down_arrow_bits },
   { 8, sizeof (continued_bits), 0, continued_bits },
   { 8, sizeof (continuation_bits), 0, continuation_bits },
   { 8, sizeof (ov_bits), 0, ov_bits },
-  { 8, sizeof (zv_bits), 3, zv_bits }
+  { 8, sizeof (first_line_bits), -1, first_line_bits },
+  { 8, sizeof (last_line_bits), -2, last_line_bits },
+  { 8, sizeof (filled_box_cursor_bits), 0, filled_box_cursor_bits },
+  { 8, sizeof (hollow_box_cursor_bits), 0, hollow_box_cursor_bits },
+  { 8, sizeof (bar_cursor_bits), 0, bar_cursor_bits },
+  { 8, sizeof (hbar_cursor_bits), -2, hbar_cursor_bits },
+  { 8, sizeof (zv_bits), 3, zv_bits },
+  { 8, sizeof (hollow_square_bits), 0, hollow_square_bits },
 };
 
 
 /* Draw the bitmap WHICH in one of the left or right fringes of
    window W.  ROW is the glyph row for which to display the bitmap; it
    determines the vertical position at which the bitmap has to be
-   drawn.  */
+   drawn.
+   LEFT_P is 1 for left fringe, 0 for right fringe.
+*/
 
-static void
-draw_fringe_bitmap (w, row, which, left_p)
+void
+draw_fringe_bitmap (w, row, left_p)
      struct window *w;
      struct glyph_row *row;
-     enum fringe_bitmap_type which;
      int left_p;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   struct draw_fringe_bitmap_params p;
+  enum fringe_bitmap_type which;
+  int period;
+
+  if (left_p)
+    which = row->left_fringe_bitmap;
+  else if (!row->cursor_in_fringe_p)
+    which = row->right_fringe_bitmap;
+  else
+    switch (w->phys_cursor_type)
+      {
+      case HOLLOW_BOX_CURSOR:
+        if (row->visible_height >= sizeof(hollow_box_cursor_bits))
+          which = HOLLOW_BOX_CURSOR_BITMAP;
+        else
+          which = HOLLOW_SQUARE_BITMAP;
+        break;
+      case FILLED_BOX_CURSOR:
+        which = FILLED_BOX_CURSOR_BITMAP;
+        break;
+      case BAR_CURSOR:
+        which = BAR_CURSOR_BITMAP;
+        break;
+      case HBAR_CURSOR:
+        which = HBAR_CURSOR_BITMAP;
+        break;
+      case NO_CURSOR:
+      default:
+        w->phys_cursor_on_p = 0;
+        row->cursor_in_fringe_p = 0;
+        which = row->right_fringe_bitmap;
+        break;
+      }
+
+  period = fringe_bitmaps[which].period;
 
   /* Convert row to frame coordinates.  */
   p.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
@@ -8961,9 +9236,7 @@ draw_fringe_bitmap (w, row, which, left_p)
   p.wd = fringe_bitmaps[which].width;
 
   p.h = fringe_bitmaps[which].height;
-  p.dh = (fringe_bitmaps[which].period
-          ? (p.y % fringe_bitmaps[which].period)
-          : 0);
+  p.dh = (period > 0 ? (p.y % period) : 0);
   p.h -= p.dh;
   /* Clip bitmap if too high.  */
   if (p.h > row->height)
@@ -9023,7 +9296,13 @@ draw_fringe_bitmap (w, row, which, left_p)
     }
 
   /* Adjust y to the offset in the row to start drawing the bitmap.  */
-  p.y += (row->height - p.h) / 2;
+  if (period == 0)
+    p.y += (row->height - p.h) / 2;
+  else if (period == -2)
+    {
+      p.h = fringe_bitmaps[which].height;
+      p.y += (row->visible_height - p.h);
+    }
 
   FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
 }
@@ -9036,8 +9315,6 @@ draw_row_fringe_bitmaps (w, row)
      struct window *w;
      struct glyph_row *row;
 {
-  enum fringe_bitmap_type bitmap;
-
   xassert (interrupt_input_blocked);
 
   /* If row is completely invisible, because of vscrolling, we
@@ -9046,35 +9323,35 @@ draw_row_fringe_bitmaps (w, row)
     return;
 
   if (WINDOW_LEFT_FRINGE_WIDTH (w) != 0)
-    {
-      /* Decide which bitmap to draw in the left fringe.  */
-      if (row->overlay_arrow_p)
-        bitmap = OVERLAY_ARROW_BITMAP;
-      else if (row->truncated_on_left_p)
-        bitmap = LEFT_TRUNCATION_BITMAP;
-      else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
-        bitmap = CONTINUATION_LINE_BITMAP;
-      else if (row->indicate_empty_line_p)
-        bitmap = ZV_LINE_BITMAP;
-      else
-        bitmap = NO_FRINGE_BITMAP;
-
-      draw_fringe_bitmap (w, row, bitmap, 1);
-    }
+    draw_fringe_bitmap (w, row, 1);
 
   if (WINDOW_RIGHT_FRINGE_WIDTH (w) != 0)
-    {
-      /* Decide which bitmap to draw in the right fringe.  */
-      if (row->truncated_on_right_p)
-        bitmap = RIGHT_TRUNCATION_BITMAP;
-      else if (row->continued_p)
-        bitmap = CONTINUED_LINE_BITMAP;
-      else if (row->indicate_empty_line_p && WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
-        bitmap = ZV_LINE_BITMAP;
-      else
-        bitmap = NO_FRINGE_BITMAP;
+    draw_fringe_bitmap (w, row, 0);
+}
+
+/* Draw the fringes of window W.  Only fringes for rows marked for
+   update in redraw_fringe_bitmaps_p are drawn.  */
+
+void
+draw_window_fringes (w)
+     struct window *w;
+{
+  struct glyph_row *row;
+  int yb = window_text_bottom_y (w);
+  int nrows = w->current_matrix->nrows;
+  int y = 0, rn;
 
-      draw_fringe_bitmap (w, row, bitmap, 0);
+  if (w->pseudo_window_p)
+    return;
+
+  for (y = 0, rn = 0, row = w->current_matrix->rows;
+       y < yb && rn < nrows;
+       y += row->height, ++row, ++rn)
+    {
+      if (!row->redraw_fringe_bitmaps_p)
+        continue;
+      draw_row_fringe_bitmaps (w, row);
+      row->redraw_fringe_bitmaps_p = 0;
     }
 }
 
@@ -9982,6 +10259,9 @@ redisplay_internal (preserve_echo_area)
               *w->desired_matrix->method = 0;
               debug_method_add (w, "optimization 1");
 #endif
+#ifdef HAVE_WINDOW_SYSTEM
+              update_window_fringes (w, 0);
+#endif
               goto update;
             }
           else
@@ -11394,6 +11674,137 @@ set_vertical_scroll_bar (w)
       (w, end - start, whole, start);
 }
 
+#ifdef HAVE_WINDOW_SYSTEM
+
+/* Recalculate the bitmaps to show in the fringes of window W.
+   If FORCE_P is 0, only mark rows with modified bitmaps for update in
+   redraw_fringe_bitmaps_p; else mark all rows for update.  */
+
+int
+update_window_fringes (w, force_p)
+     struct window *w;
+     int force_p;
+{
+  struct glyph_row *row, *cur = 0;
+  int yb = window_text_bottom_y (w);
+  int rn, nrows = w->current_matrix->nrows;
+  int y;
+  int redraw_p = 0;
+  Lisp_Object ind;
+
+  if (w->pseudo_window_p)
+    return 0;
+
+  if (!MINI_WINDOW_P (w)
+      && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
+    {
+      int do_eob = 1, do_bob = 1;
+
+      for (y = 0, rn = 0;
+           y < yb && rn < nrows;
+           y += row->height, ++rn)
+        {
+          unsigned indicate_bob_p, indicate_top_line_p;
+          unsigned indicate_eob_p, indicate_bottom_line_p;
+          
+          row = w->desired_matrix->rows + rn;
+          if (!row->enabled_p)
+            row = w->current_matrix->rows + rn;
+
+          indicate_bob_p = row->indicate_bob_p;
+          indicate_top_line_p = row->indicate_top_line_p;
+          indicate_eob_p = row->indicate_eob_p;
+          indicate_bottom_line_p = row->indicate_bottom_line_p;
+          
+          row->indicate_bob_p = row->indicate_top_line_p = 0;
+          row->indicate_eob_p = row->indicate_bottom_line_p = 0;
+
+          if (MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
+            row->indicate_bob_p = do_bob, do_bob = 0;
+          else if (EQ (ind, Qt)
+                   && (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0) == rn)
+            row->indicate_top_line_p = 1;
+
+          if (MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
+            row->indicate_eob_p = do_eob, do_eob = 0;
+          else if (EQ (ind, Qt)
+                   && y + row->height >= yb)
+            row->indicate_bottom_line_p = 1;
+
+          if (indicate_bob_p != row->indicate_bob_p
+              || indicate_top_line_p != row->indicate_top_line_p
+              || indicate_eob_p != row->indicate_eob_p
+              || indicate_bottom_line_p != row->indicate_bottom_line_p)
+            row->redraw_fringe_bitmaps_p = 1;
+        }
+    }
+
+  for (y = 0, rn = 0;
+       y < yb && rn < nrows;
+       y += row->height, rn++)
+    {
+      enum fringe_bitmap_type left, right;
+
+      row = w->desired_matrix->rows + rn;
+      cur = w->current_matrix->rows + rn;
+      if (!row->enabled_p)
+        row = cur;
+
+      /* Decide which bitmap to draw in the left fringe.  */
+      if (WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
+        left = NO_FRINGE_BITMAP;
+      else if (row->overlay_arrow_p)
+        left = OVERLAY_ARROW_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)
+        left = ZV_LINE_BITMAP;
+      else if (row->indicate_bob_p)
+        left = FIRST_LINE_BITMAP;
+      else
+        left = NO_FRINGE_BITMAP;
+
+      /* Decide which bitmap to draw in the right fringe.  */
+      if (WINDOW_RIGHT_FRINGE_WIDTH (w) == 0)
+        right = NO_FRINGE_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_eob_p)
+        right = LAST_LINE_BITMAP;
+      else if (row->indicate_top_line_p) 
+        right = UP_ARROW_BITMAP;
+      else if (row->indicate_bottom_line_p)
+        right = DOWN_ARROW_BITMAP;
+      else if (row->indicate_empty_line_p && WINDOW_LEFT_FRINGE_WIDTH (w) == 0)
+        right = ZV_LINE_BITMAP;
+      else
+        right = NO_FRINGE_BITMAP;
+
+      if (force_p
+          || row->y != cur->y
+          || row->visible_height != cur->visible_height
+          || left != cur->left_fringe_bitmap
+          || right != cur->right_fringe_bitmap
+          || cur->redraw_fringe_bitmaps_p)
+        {
+          redraw_p = row->redraw_fringe_bitmaps_p = cur->redraw_fringe_bitmaps_p = 1;
+          cur->left_fringe_bitmap = left;
+          cur->right_fringe_bitmap = right;
+        }
+
+      row->left_fringe_bitmap = left;
+      row->right_fringe_bitmap = right;
+    }
+
+  return redraw_p;
+}
+
+#endif /* HAVE_WINDOW_SYSTEM */
+
 /* Redisplay leaf window WINDOW.  JUST_THIS_ONE_P non-zero means only
    selected_window is redisplayed.
 
@@ -11416,6 +11827,7 @@ redisplay_window (window, just_this_one_p)
   struct it it;
   /* Record it now because it's overwritten.  */
   int current_matrix_up_to_date_p = 0;
+  int used_current_matrix_p = 0;
   /* This is less strict than current_matrix_up_to_date_p.
      It indictes that the buffer contents and narrowing are unchanged.  */
   int buffer_unchanged_p = 0;
@@ -11722,6 +12134,7 @@ redisplay_window (window, just_this_one_p)
       switch (rc)
         {
         case CURSOR_MOVEMENT_SUCCESS:
+          used_current_matrix_p = 1;
           goto done;
 
 #if 0  /* try_cursor_movement never returns this value.  */
@@ -11786,7 +12199,8 @@ redisplay_window (window, just_this_one_p)
              buffer.  */
           || !NILP (Vwindow_scroll_functions)
           || MINI_WINDOW_P (w)
-          || !try_window_reusing_current_matrix (w))
+          || !(used_current_matrix_p =
+               try_window_reusing_current_matrix (w)))
         {
           IF_DEBUG (debug_method_add (w, "1"));
           try_window (window, startp);
@@ -11915,7 +12329,8 @@ redisplay_window (window, just_this_one_p)
       || !NILP (Vwindow_scroll_functions)
       || !just_this_one_p
       || MINI_WINDOW_P (w)
-      || !try_window_reusing_current_matrix (w))
+      || !(used_current_matrix_p =
+           try_window_reusing_current_matrix (w)))
     try_window (window, startp);
 
   /* If new fonts have been loaded (due to fontsets), give up.  We
@@ -12077,6 +12492,19 @@ redisplay_window (window, just_this_one_p)
 #endif
     }
 
+#ifdef HAVE_WINDOW_SYSTEM
+  if (update_window_fringes (w, 0)
+      && (used_current_matrix_p || overlay_arrow_seen)
+      && !w->pseudo_window_p)
+    {
+      update_begin (f);
+      BLOCK_INPUT;
+      draw_window_fringes (w);
+      UNBLOCK_INPUT;
+      update_end (f);
+    }
+#endif /* HAVE_WINDOW_SYSTEM */
+
   /* We go to this label, with fonts_changed_p nonzero,
      if it is necessary to try again using larger glyph matrices.
      We have to redeem the scroll bar even in this case,
@@ -12334,6 +12762,7 @@ try_window_reusing_current_matrix (w)
                 row->visible_height -= min_y - row->y;
               if (row->y + row->height > max_y)
                 row->visible_height -= row->y + row->height - max_y;
+              row->redraw_fringe_bitmaps_p = 1;
 
               it.current_y += row->height;
 
@@ -12473,7 +12902,6 @@ try_window_reusing_current_matrix (w)
 
       if (run.height)
         {
-          struct frame *f = XFRAME (WINDOW_FRAME (w));
           update_begin (f);
           FRAME_RIF (f)->update_window_begin_hook (w);
           FRAME_RIF (f)->clear_window_mouse_face (w);
@@ -12494,6 +12922,7 @@ try_window_reusing_current_matrix (w)
             row->visible_height -= min_y - row->y;
           if (row->y + row->height > max_y)
             row->visible_height -= row->y + row->height - max_y;
+          row->redraw_fringe_bitmaps_p = 1;
         }
 
       /* Scroll the current matrix.  */
@@ -12616,7 +13045,8 @@ find_last_unchanged_at_beg_row (w)
              row is not unchanged because it may be no longer
              continued.  */
           && !(MATRIX_ROW_END_CHARPOS (row) == first_changed_pos
-               && row->continued_p))
+               && (row->continued_p
+                   || row->exact_window_width_line_p)))
         row_found = row;
 
       /* Stop if last visible row.  */
@@ -14512,7 +14942,20 @@ display_line (it)
                       it->continuation_lines_width += new_x;
                       ++it->hpos;
                       if (i == nglyphs - 1)
-                        set_iterator_to_next (it, 1);
+                        {
+                          set_iterator_to_next (it, 1);
+#ifdef HAVE_WINDOW_SYSTEM
+                          if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+                            {
+                              get_next_display_element (it);
+                              if (ITERATOR_AT_END_OF_LINE_P (it))
+                                {
+                                  row->continued_p = 0;
+                                  row->exact_window_width_line_p = 1;
+                                }
+                            }
+#endif /* HAVE_WINDOW_SYSTEM */
+                        }
                     }
                   else if (CHAR_GLYPH_PADDING_P (*glyph)
                            && !FRAME_WINDOW_P (it->f))
@@ -14614,6 +15057,7 @@ display_line (it)
             break;
         }
 
+    at_end_of_line:
       /* Is this a line end?  If yes, we're also done, after making
          sure that a non-default face is extended up to the right
          margin of the window.  */
@@ -14623,9 +15067,12 @@ display_line (it)
 
           row->ends_in_newline_from_string_p = STRINGP (it->object);
 
+#ifdef HAVE_WINDOW_SYSTEM
           /* Add a space at the end of the line that is used to
              display the cursor there.  */
-          append_space (it, 0);
+          if (!IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+            append_space (it, 0);
+#endif /* HAVE_WINDOW_SYSTEM */
 
           /* Extend the face to the end of the line.  */
           extend_face_to_end_of_line (it);
@@ -14666,6 +15113,21 @@ display_line (it)
                   produce_special_glyphs (it, IT_TRUNCATION);
                 }
             }
+#ifdef HAVE_WINDOW_SYSTEM
+          else
+            {
+              /* Don't truncate if we can overflow newline into fringe.  */
+              if (IT_OVERFLOW_NEWLINE_INTO_FRINGE (it))
+                {
+                  get_next_display_element (it);
+                  if (ITERATOR_AT_END_OF_LINE_P (it))
+                    {
+                      row->exact_window_width_line_p = 1;
+                      goto at_end_of_line;
+                    }
+                }
+            }
+#endif /* HAVE_WINDOW_SYSTEM */
 
           row->truncated_on_right_p = 1;
           it->continuation_lines_width = 0;
@@ -19213,36 +19675,53 @@ notice_overwritten_cursor (w, area, x0, x1, y0, y1)
      enum glyph_row_area area;
      int x0, y0, x1, y1;
 {
-  if (area == TEXT_AREA && w->phys_cursor_on_p)
-    {
-      int cx0 = w->phys_cursor.x;
-      int cx1 = cx0 + w->phys_cursor_width;
-      int cy0 = w->phys_cursor.y;
-      int cy1 = cy0 + w->phys_cursor_height;
+  int cx0, cx1, cy0, cy1;
+  struct glyph_row *row;
 
-      if (x0 <= cx0 && (x1 < 0 || x1 >= cx1))
-        {
-          /* The cursor image will be completely removed from the
-             screen if the output area intersects the cursor area in
-             y-direction.  When we draw in [y0 y1[, and some part of
-             the cursor is at y < y0, that part must have been drawn
-             before.  When scrolling, the cursor is erased before
-             actually scrolling, so we don't come here.  When not
-             scrolling, the rows above the old cursor row must have
-             changed, and in this case these rows must have written
-             over the cursor image.
+  if (!w->phys_cursor_on_p)
+    return;
+  if (area != TEXT_AREA)
+    return;
 
-             Likewise if part of the cursor is below y1, with the
-             exception of the cursor being in the first blank row at
-             the buffer and window end because update_text_area
-             doesn't draw that row.  (Except when it does, but
-             that's handled in update_text_area.)  */
+  row = w->current_matrix->rows + w->phys_cursor.vpos;
+  if (!row->displays_text_p)
+    return;
 
-          if (((y0 >= cy0 && y0 < cy1) || (y1 > cy0 && y1 < cy1))
-              && w->current_matrix->rows[w->phys_cursor.vpos].displays_text_p)
-            w->phys_cursor_on_p = 0;
-        }
+  if (row->cursor_in_fringe_p)
+    {
+      row->cursor_in_fringe_p = 0;
+      draw_fringe_bitmap (w, row, 0);
+      w->phys_cursor_on_p = 0;
+      return;
     }
+
+  cx0 = w->phys_cursor.x;
+  cx1 = cx0 + w->phys_cursor_width;
+  if (x0 > cx0 || (x1 >= 0 && x1 < cx1))
+    return;
+
+  /* The cursor image will be completely removed from the
+     screen if the output area intersects the cursor area in
+     y-direction.  When we draw in [y0 y1[, and some part of
+     the cursor is at y < y0, that part must have been drawn
+     before.  When scrolling, the cursor is erased before
+     actually scrolling, so we don't come here.  When not
+     scrolling, the rows above the old cursor row must have
+     changed, and in this case these rows must have written
+     over the cursor image.
+
+     Likewise if part of the cursor is below y1, with the
+     exception of the cursor being in the first blank row at
+     the buffer and window end because update_text_area
+     doesn't draw that row.  (Except when it does, but
+     that's handled in update_text_area.)  */
+
+  cy0 = w->phys_cursor.y;
+  cy1 = cy0 + w->phys_cursor_height;
+  if ((y0 < cy0 || y0 >= cy1) && (y1 <= cy0 || y1 >= cy1))
+    return;
+
+  w->phys_cursor_on_p = 0;
 }
 
 #endif /* HAVE_WINDOW_SYSTEM */
@@ -19377,6 +19856,14 @@ erase_phys_cursor (w)
   if (cursor_row->visible_height <= 0)
     goto mark_cursor_off;
 
+  /* If cursor is in the fringe, erase by drawing actual bitmap there.  */
+  if (cursor_row->cursor_in_fringe_p)
+    {
+      cursor_row->cursor_in_fringe_p = 0;
+      draw_fringe_bitmap (w, cursor_row, 0);
+      goto mark_cursor_off;
+    }
+
   /* This can happen when the new row is shorter than the old one.
      In this case, either draw_glyphs or clear_end_of_line
      should have cleared the cursor.  Note that we wouldn't be
@@ -21533,12 +22020,23 @@ wide as that tab on the display.  */);
 #endif
 
   DEFVAR_LISP ("show-trailing-whitespace", &Vshow_trailing_whitespace,
-    doc: /* Non-nil means highlight trailing whitespace.
+    doc: /* *Non-nil means highlight trailing whitespace.
 The face used for trailing whitespace is `trailing-whitespace'.  */);
   Vshow_trailing_whitespace = Qnil;
 
+#ifdef HAVE_WINDOW_SYSTEM
+  DEFVAR_LISP ("overflow-newline-into-fringe", &Voverflow_newline_into_fringe,
+    doc: /* *Non-nil means that newline may flow into the right fringe.
+This means that display lines which are exactly as wide as the window
+(not counting the final newline) will only occupy one screen line, by
+showing (or hiding) the final newline in the right fringe; when point
+is at the final newline, the cursor is shown in the right fringe.
+If nil, also continue lines which are exactly as wide as the window.  */);
+  Voverflow_newline_into_fringe = Qt;
+#endif
+
   DEFVAR_LISP ("void-text-area-pointer", &Vvoid_text_area_pointer,
-    doc: /* The pointer shape to show in void text areas.
+    doc: /* *The pointer shape to show in void text areas.
 Nil means to show the text pointer.  Other options are `arrow', `text',
 `hand', `vdrag', `hdrag', `modeline', and `hourglass'.  */); 
   Vvoid_text_area_pointer = Qarrow;
diff --git a/src/xterm.c b/src/xterm.c
index f03f99d0246..8832991156d 100644
--- a/src/xterm.c
+++ b/src/xterm.c
@@ -571,6 +571,9 @@ x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
                                 output_cursor.x, output_cursor.y);
 
       x_draw_vertical_border (w);
+
+      draw_window_fringes (w);
+
       UNBLOCK_INPUT;
     }
 
@@ -650,11 +653,7 @@ x_after_update_window_line (desired_row)
   xassert (w);
 
   if (!desired_row->mode_line_p && !w->pseudo_window_p)
-    {
-      BLOCK_INPUT;
-      draw_row_fringe_bitmaps (w, desired_row);
-      UNBLOCK_INPUT;
-    }
+    desired_row->redraw_fringe_bitmaps_p = 1;
 
   /* When a window has disappeared, make sure that no rest of
      full-width rows stays visible in the internal border.  Could
@@ -698,9 +697,24 @@ x_draw_fringe_bitmap (w, row, p)
   Window window = FRAME_X_WINDOW (f);
   GC gc = f->output_data.x->normal_gc;
   struct face *face = p->face;
+  int rowY;
 
   /* Must clip because of partially visible lines.  */
-  x_clip_to_row (w, row, gc);
+  rowY = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
+  if (p->y < rowY)
+    {
+      /* Adjust position of "bottom aligned" bitmap on partially
+         visible last row.  */
+      int oldY = row->y;
+      int oldVH = row->visible_height;
+      row->visible_height = p->h;
+      row->y -= rowY - p->y;
+      x_clip_to_row (w, row, gc);
+      row->y = oldY;
+      row->visible_height = oldVH;
+    }
+  else
+    x_clip_to_row (w, row, gc);
 
   if (p->bx >= 0)
     {
@@ -6314,6 +6328,11 @@ handle_one_xevent (dpyinfo, eventp, bufp_r, numcharsp, finish)
                                   &compose_status);
 #endif
 
+          /* If not using XIM/XIC, and a compose sequence is in progress,
+             we break here.  Otherwise, chars_matched is always 0.  */
+          if (compose_status.chars_matched > 0 && nbytes == 0)
+            break;
+
           orig_keysym = keysym;
 
           if (numchars > 1)
@@ -7452,6 +7471,13 @@ x_draw_window_cursor (w, glyph_row, x, y, cursor_type, cursor_width, on_p, activ
       w->phys_cursor_type = cursor_type;
       w->phys_cursor_on_p = 1;
 
+      if (glyph_row->exact_window_width_line_p
+          && w->phys_cursor.hpos >= glyph_row->used[TEXT_AREA])
+        {
+          glyph_row->cursor_in_fringe_p = 1;
+          draw_fringe_bitmap (w, glyph_row, 0);
+        }
+      else
       switch (cursor_type)
         {
         case HOLLOW_BOX_CURSOR: