Merged from emacs@sv.gnu.org

Patches applied:

 * emacs@sv.gnu.org/emacs--devo--0--patch-105
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-106
   Merge from gnus--rel--5.10

 * emacs@sv.gnu.org/emacs--devo--0--patch-107
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-108
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-109
   Update from CVS

 * emacs@sv.gnu.org/emacs--devo--0--patch-110
   Update from CVS

 * emacs@sv.gnu.org/gnus--rel--5.10--patch-37
   Update from CVS

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

8 files changed, 685 insertions, 275 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index f2a6e1e2752..c016dc46e4b 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,83 @@
+2006-02-21  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c (syms_of_fringe) <fringe-bitmaps>: Doc fix.
+
+2006-02-21  Zhang Wei <brep@newsmth.org>
+
+        * xfns.c (Fx_file_dialog, Motif and GTK): DECODE_FILE before
+        returning it.
+
+2006-02-21  Giorgos Keramidas  <keramida@ceid.upatras.gr>  (tiny change)
+
+        * fringe.c (horizontal_bar_bits): Rename from `horisontal_bar_bits'.
+        (standard_bitmaps): Use it.
+
+2006-02-21  YAMAMOTO Mitsuharu  <mituharu@math.s.chiba-u.ac.jp>
+
+        * macterm.c (mac_draw_string_common): Remove arg MODE.  New arg
+        BG_WIDTH.  All uses changed.  Draw background if BG_WIDTH is not zero.
+        (mac_draw_image_string, mac_draw_image_string_16): New arg BG_WIDTH.
+        [USE_CG_TEXT_DRAWING] (mac_draw_image_string_cg): Rename from
+        mac_draw_string_cg.  New arg BG_WIDTH.  All uses changed.  Draw
+        background if BG_WIDTH is not zero.  Use float constants as
+        divisors instead of double.  Use alloca instead of xmalloc/xfree.
+        (x_draw_glyph_string_background, x_draw_glyph_string_foreground)
+        [!MAC_OS8 || USE_ATSUI]: Background may be drawn using
+        mac_draw_image_string* functions.
+        (XLoadQueryFont) [MAC_OS8 && USE_ATSUI]: Don't adjust heights of
+        some fonts when srcCopy text transfer mode might be used.
+        (mac_begin_clip, mac_end_clip): Check if region is empty.
+        (mac_set_clip_rectangles): When resetting clip region, make it
+        empty instead of disposing of it.
+
+2006-02-20  Kim F. Storm  <storm@cua.dk>
+
+        * Makefile.in: Add fringe.elc to WINDOW_SUPPORT.
+
+        * buffer.h (struct buffer): New members fringe_indicator_alist and
+        fringe_cursor_alist.
+
+        * buffer.c (init_buffer_once): Set dummy default values for
+        fringe-indicator-alist and fringe-cursor-alist.  The proper
+        default values are set by pre-loading fringe.el.
+        (syms_of_buffer): defvar_per_buffer new fringe-indicator-alist and
+        fringe-cursor-alist buffer-local variables and defvar_lisp_nopro
+        corresponding default- variables.
+
+        * fringe.c (enum fringe_bitmap_type): Remove.  Change all uses
+        to use `int'.
+        (NO_FRINGE_BITMAP, UNDEF_FRINGE_BITMAP, MAX_STANDARD_FRINGE_BITMAPS):
+        Define explicitly.
+        (Qtruncation, Qcontinuation, Qempty_line, Qtop_bottom)
+        (Qhollow_small): New variables.
+        (syms_of_fringe): Intern and staticpro them.
+        (question_mark_bits): Rename from unknown_bits.
+        (left_curly_arrow_bits): Rename from continuation_bits.
+        (right_curly_arrow_bits): Rename from continued_bits.
+        (left_triangle_bits): Rename from ov_bits.
+        (right_triangle_bits): Added.
+        (filled_rectangle_bits): Rename from filled_box_cursor_bits.
+        (hollow_rectangle_bits): Rename from hollow_box_cursor_bits.
+        (filled_square_bits): Added.
+        (vertical_bar_bits): Rename from bar_cursor_bits.
+        (horizontal_bar_bits): Rename from hbar_cursor_bits.
+        (empty_line_bits): Rename from zv_bits.
+        (standard_bitmaps): Update to use new names.
+        (draw_fringe_bitmap_1): Make static.
+        (get_logical_cursor_bitmap, get_logical_fringe_bitmap): New functions
+        to map from logical cursors and indicators to physical bitmaps.
+        (draw_fringe_bitmap): Resolve fringe cursor and overlay-arrow
+        bitmaps using symbol names instead of bitmap numbers.
+        (update_window_fringes): Use logical indicator symbol names
+        instead of bitmap numbers for logical.  Add bitmap cache.
+        (LEFT_FRINGE, RIGHT_FRINGE): New helper macros.
+
+2006-02-20  Chong Yidong  <cyd@stupidchicken.com>
+
+        * regex.c: Revert 2006-02-19 change.
+        (xmalloc, xrealloc): Define these when not linked to Emacs.
+        Redefine malloc -> xmalloc, realloc -> xrealloc as in Emacs case.
+
 2006-02-19  Luc Teirlinck  <teirllm@auburn.edu>
 
         * regex.c (extend_range_table_work_area): Fix typo.
diff --git a/src/Makefile.in b/src/Makefile.in
index 32f339bb139..b63ae34aa2b 100644
--- a/src/Makefile.in
+++ b/src/Makefile.in
@@ -678,11 +678,11 @@ otherobj= $(termcapobj) lastfile.o $(mallocobj) $(allocaobj) $(widgetobj) $(LIBO
 
 #ifdef HAVE_WINDOW_SYSTEM
 #ifdef HAVE_X_WINDOWS
-#define WINDOW_SUPPORT ${lispsource}image.elc \
+#define WINDOW_SUPPORT ${lispsource}fringe.elc ${lispsource}image.elc \
  ${lispsource}international/fontset.elc ${lispsource}dnd.elc \
  ${lispsource}tool-bar.elc ${lispsource}mwheel.elc ${lispsource}x-dnd.elc
 #else
-#define WINDOW_SUPPORT ${lispsource}image.elc \
+#define WINDOW_SUPPORT ${lispsource}fringe.elc ${lispsource}image.elc \
  ${lispsource}international/fontset.elc ${lispsource}dnd.elc \
  ${lispsource}tool-bar.elc ${lispsource}mwheel.elc
 #endif
diff --git a/src/buffer.c b/src/buffer.c
index dae07edf359..e1caaac5f89 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5023,6 +5023,8 @@ init_buffer_once ()
   buffer_defaults.vertical_scroll_bar_type = Qt;
   buffer_defaults.indicate_empty_lines = Qnil;
   buffer_defaults.indicate_buffer_boundaries = Qnil;
+  buffer_defaults.fringe_indicator_alist = Qnil;
+  buffer_defaults.fringe_cursor_alist = Qnil;
   buffer_defaults.scroll_up_aggressively = Qnil;
   buffer_defaults.scroll_down_aggressively = Qnil;
   buffer_defaults.display_time = Qnil;
@@ -5094,6 +5096,8 @@ init_buffer_once ()
   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.fringe_indicator_alist, idx); ++idx;
+  XSETFASTINT (buffer_local_flags.fringe_cursor_alist, 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;
@@ -5387,6 +5391,16 @@ This is the same as (default-value 'indicate-empty-lines).  */);
                      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-fringe-indicator-alist",
+                     &buffer_defaults.fringe_indicator_alist,
+                     doc: /* Default value of `fringe-indicator-alist' for buffers that don't override it.
+This is the same as (default-value 'fringe-indicator-alist').  */);
+
+  DEFVAR_LISP_NOPRO ("default-fringe-cursor-alist",
+                     &buffer_defaults.fringe_cursor_alist,
+                     doc: /* Default value of `fringe-cursor-alist' for buffers that don't override it.
+This is the same as (default-value 'fringe-cursor-alist').  */);
+
   DEFVAR_LISP_NOPRO ("default-scroll-up-aggressively",
                      &buffer_defaults.scroll_up_aggressively,
                      doc: /* Default value of `scroll-up-aggressively'.
@@ -5732,6 +5746,40 @@ left fringe, the bottom angle bitmap in right fringe, and both arrow
 bitmaps in right fringe.  To show just the angle bitmaps in the left
 fringe, but no arrow bitmaps, use ((top .  left) (bottom . left)).  */);
 
+  DEFVAR_PER_BUFFER ("fringe-indicator-alist",
+                     &current_buffer->fringe_indicator_alist, Qnil,
+                     doc: /* *Mapping from logical to physical fringe indicator bitmaps.
+The value is an alist where each element (INDICATOR . BITMAPS)
+specifies the fringe bitmaps used to display a specific logical
+fringe indicator.
+
+INDICATOR specifies the logical indicator type which is one of the
+following symbols: `truncation' , `continuation', `overlay-arrow',
+`top', `bottom', `up', `down', `one-line', `empty-line', or `unknown'.
+
+BITMAPS is list of symbols (LEFT RIGHT [LEFT1 RIGHT1]) which specifies
+the actual bitmap shown in the left or right fringe for the logical
+indicator.  LEFT and RIGHT are the bitmaps shown in the left and/or
+right fringe for the specific indicator.  The LEFT1 or RIGHT1 bitmaps
+are used only for the `bottom' and `one-line' indicators when the last
+(only) line in has no final newline.  BITMAPS may also be a single
+symbol which is used in both left and right fringes.  */);
+
+  DEFVAR_PER_BUFFER ("fringe-cursor-alist",
+                     &current_buffer->fringe_cursor_alist, Qnil,
+                     doc: /* *Mapping from logical to physical fringe cursor bitmaps.
+The value is an alist where each element (CURSOR . BITMAP)
+specifies the fringe bitmaps used to display a specific logical
+cursor type in the fringe.
+
+CURSOR specifies the logical cursor type which is one of the following
+symbols: `box' , `hollow', `bar', `hbar', or `hollow-small'.  The last
+one is used to show a hollow cursor on narrow lines display lines
+where the normal hollow cursor will not fit.
+
+BITMAP is the corresponding fringe bitmap shown for the logical
+cursor type.  */);
+
   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 737877f15de..60aa3e7aaed 100644
--- a/src/buffer.h
+++ b/src/buffer.h
@@ -739,6 +739,12 @@ struct buffer
   /* Non-nil means indicate buffer boundaries and scrolling.  */
   Lisp_Object indicate_buffer_boundaries;
 
+  /* Logical to physical fringe bitmap mappings.  */
+  Lisp_Object fringe_indicator_alist;
+
+  /* Logical to physical cursor bitmap mappings.  */
+  Lisp_Object fringe_cursor_alist;
+
   /* Time stamp updated each time this buffer is displayed in a window.  */
   Lisp_Object display_time;
 
diff --git a/src/fringe.c b/src/fringe.c
index 991df3bd60d..6a98b852e3e 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -50,31 +50,45 @@ Lisp_Object Voverflow_newline_into_fringe;
 
 Lisp_Object Vfringe_bitmaps;
 
-enum fringe_bitmap_type
-{
-  NO_FRINGE_BITMAP = 0,
-  UNDEF_FRINGE_BITMAP,
-  LEFT_TRUNCATION_BITMAP,
-  RIGHT_TRUNCATION_BITMAP,
-  UP_ARROW_BITMAP,
-  DOWN_ARROW_BITMAP,
-  CONTINUED_LINE_BITMAP,
-  CONTINUATION_LINE_BITMAP,
-  OVERLAY_ARROW_BITMAP,
-  TOP_LEFT_ANGLE_BITMAP,
-  TOP_RIGHT_ANGLE_BITMAP,
-  BOTTOM_LEFT_ANGLE_BITMAP,
-  BOTTOM_RIGHT_ANGLE_BITMAP,
-  LEFT_BRACKET_BITMAP,
-  RIGHT_BRACKET_BITMAP,
-  FILLED_BOX_CURSOR_BITMAP,
-  HOLLOW_BOX_CURSOR_BITMAP,
-  HOLLOW_SQUARE_BITMAP,
-  BAR_CURSOR_BITMAP,
-  HBAR_CURSOR_BITMAP,
-  ZV_LINE_BITMAP,
-  MAX_STANDARD_FRINGE_BITMAPS
-};
+/* Fringe bitmaps are represented in three different ways:
+
+   Logical bitmaps are used internally to denote things like
+   'end-of-buffer', 'left-truncation', 'overlay-arrow', etc.
+
+   Physical bitmaps specify the visual appearence of the bitmap,
+   e.g. 'bottom-left-angle', 'left-arrow', 'left-triangle', etc.
+   User defined bitmaps are physical bitmaps.
+
+   Internally, fringe bitmaps for a specific display row are
+   represented as a simple integer that is used as an index
+   into the table of all defined bitmaps.  This index is stored
+   in the `fringe' property of the physical bitmap symbol.
+
+   Logical bitmaps are mapped to physical bitmaps through the
+   buffer-local `fringe-indicator-alist' variable.
+
+   Each element of this alist is a cons (LOGICAL . PHYSICAL)
+   mapping a logical bitmap to a physical bitmap.
+   PHYSICAL is either a symbol to use in both left and right fringe,
+   or a cons of two symbols (LEFT . RIGHT) denoting different
+   bitmaps to use in left and right fringe.
+
+   LOGICAL is first looked up in the window's buffer's buffer-local
+   value of the fringe-indicator-alist variable, and if not present,
+   in the global value of fringe-indicator-alist.
+
+   If LOGICAL is not present in either alist, or the PHYSICAL value
+   found is nil, no bitmap is shown for the logical bitmap.
+
+   The `left-fringe' and `right-fringe' display properties
+   must specify physical bitmap symbols.
+*/
+
+extern Lisp_Object Qunknown;
+Lisp_Object Qtruncation, Qcontinuation, Qoverlay_arrow;
+Lisp_Object Qempty_line, Qtop_bottom;
+extern Lisp_Object Qbar, Qhbar, Qbox, Qhollow;
+Lisp_Object Qhollow_small;
 
 enum fringe_bitmap_align
 {
@@ -111,7 +125,7 @@ struct fringe_bitmap
   ...xx...
   ...xx...
 */
-static unsigned short unknown_bits[] = {
+static unsigned short question_mark_bits[] = {
   0x3c, 0x7e, 0x7e, 0x0c, 0x18, 0x18, 0x00, 0x18, 0x18};
 
 /* An arrow like this: `<-'.  */
@@ -173,20 +187,6 @@ static unsigned short up_arrow_bits[] = {
 static unsigned short down_arrow_bits[] = {
    0x18, 0x18, 0x18, 0x18, 0xff, 0x7e, 0x3c, 0x18};
 
-/* Marker for continued lines.  */
-/*
-  ..xxxx..
-  ..xxxxx.
-  ......xx
-  ..x..xxx
-  ..xxxxxx
-  ..xxxxx.
-  ..xxxx..
-  ..xxxxx.
-*/
-static unsigned short continued_bits[] = {
-   0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
-
 /* Marker for continuation lines.  */
 /*
   ..xxxx..
@@ -198,24 +198,23 @@ static unsigned short continued_bits[] = {
   ..xxxx..
   .xxxxx..
 */
-static unsigned short continuation_bits[] = {
+static unsigned short left_curly_arrow_bits[] = {
    0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
 
-/* Overlay arrow bitmap.  A triangular arrow.  */
+/* Marker for continued lines.  */
 /*
-  xx......
-  xxxx....
-  xxxxx...
-  xxxxxx..
-  xxxxxx..
-  xxxxx...
-  xxxx....
-  xx......
+  ..xxxx..
+  ..xxxxx.
+  ......xx
+  ..x..xxx
+  ..xxxxxx
+  ..xxxxx.
+  ..xxxx..
+  ..xxxxx.
 */
-static unsigned short ov_bits[] = {
-   0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
+static unsigned short right_curly_arrow_bits[] = {
+   0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
 
-#if 0
 /* Reverse Overlay arrow bitmap.  A triangular arrow.  */
 /*
   ......xx
@@ -227,9 +226,22 @@ static unsigned short ov_bits[] = {
   ....xxxx
   ......xx
 */
-static unsigned short rev_ov_bits[] = {
+static unsigned short left_triangle_bits[] = {
    0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
-#endif
+
+/* Overlay arrow bitmap.  A triangular arrow.  */
+/*
+  xx......
+  xxxx....
+  xxxxx...
+  xxxxxx..
+  xxxxxx..
+  xxxxx...
+  xxxx....
+  xx......
+*/
+static unsigned short right_triangle_bits[] = {
+   0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
 
 /* First line bitmap.  An top-left angle.  */
 /*
@@ -335,7 +347,7 @@ static unsigned short right_bracket_bits[] = {
   xxxxxxx.
   xxxxxxx.
 */
-static unsigned short filled_box_cursor_bits[] = {
+static unsigned short filled_rectangle_bits[] = {
    0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe, 0xfe};
 
 /* Hollow box cursor bitmap.  A hollow box; max 13 pixels high.  */
@@ -354,9 +366,33 @@ static unsigned short filled_box_cursor_bits[] = {
   x.....x.
   xxxxxxx.
 */
-static unsigned short hollow_box_cursor_bits[] = {
+static unsigned short hollow_rectangle_bits[] = {
    0xfe, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0x82, 0xfe};
 
+/* Hollow square bitmap.  */
+/*
+  .xxxxxx.
+  .x....x.
+  .x....x.
+  .x....x.
+  .x....x.
+  .xxxxxx.
+*/
+static unsigned short hollow_square_bits[] = {
+   0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
+
+/* Filled square bitmap.  */
+/*
+  .xxxxxx.
+  .xxxxxx.
+  .xxxxxx.
+  .xxxxxx.
+  .xxxxxx.
+  .xxxxxx.
+*/
+static unsigned short filled_square_bits[] = {
+   0x7e, 0x7e, 0x7e, 0x7e, 0x7e, 0x7e};
+
 /* Bar cursor bitmap.  A vertical bar; max 13 pixels high.  */
 /*
   xx......
@@ -373,15 +409,15 @@ static unsigned short hollow_box_cursor_bits[] = {
   xx......
   xx......
 */
-static unsigned short bar_cursor_bits[] = {
+static unsigned short vertical_bar_bits[] = {
    0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0, 0xc0};
 
-/* HBar cursor bitmap.  A horisontal bar; 2 pixels high.  */
+/* HBar cursor bitmap.  A horizontal bar; 2 pixels high.  */
 /*
   xxxxxxx.
   xxxxxxx.
 */
-static unsigned short hbar_cursor_bits[] = {
+static unsigned short horizontal_bar_bits[] = {
   0xfe, 0xfe};
 
 
@@ -395,7 +431,7 @@ static unsigned short hbar_cursor_bits[] = {
   ..xxxx..
   ........
 */
-static unsigned short zv_bits[] = {
+static unsigned short empty_line_bits[] = {
   0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
   0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
   0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x3c, 0x00,
@@ -405,48 +441,45 @@ static unsigned short 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 short hollow_square_bits[] = {
-   0x7e, 0x42, 0x42, 0x42, 0x42, 0x7e};
-
 
 #define BYTES_PER_BITMAP_ROW  (sizeof (unsigned short))
 #define STANDARD_BITMAP_HEIGHT(bits) (sizeof (bits)/BYTES_PER_BITMAP_ROW)
 #define FRBITS(bits)  bits, STANDARD_BITMAP_HEIGHT (bits)
 
-struct fringe_bitmap standard_bitmaps[MAX_STANDARD_FRINGE_BITMAPS] =
+/* NOTE:  The order of these bitmaps must match the sequence
+   used in fringe.el to define the corresponding symbols.  */
+
+struct fringe_bitmap standard_bitmaps[] =
 {
   { NULL, 0, 0, 0, 0, 0 }, /* NO_FRINGE_BITMAP */
-  { FRBITS (unknown_bits),            8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (question_mark_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (left_arrow_bits),         8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (right_arrow_bits),        8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (up_arrow_bits),           8, 0, ALIGN_BITMAP_TOP,    0 },
   { FRBITS (down_arrow_bits),         8, 0, ALIGN_BITMAP_BOTTOM, 0 },
-  { FRBITS (continued_bits),          8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (continuation_bits),       8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (ov_bits),                 8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (left_curly_arrow_bits),   8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (right_curly_arrow_bits),  8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (left_triangle_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (right_triangle_bits),     8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (top_left_angle_bits),     8, 0, ALIGN_BITMAP_TOP,    0 },
   { FRBITS (top_right_angle_bits),    8, 0, ALIGN_BITMAP_TOP,    0 },
   { FRBITS (bottom_left_angle_bits),  8, 0, ALIGN_BITMAP_BOTTOM, 0 },
   { FRBITS (bottom_right_angle_bits), 8, 0, ALIGN_BITMAP_BOTTOM, 0 },
   { FRBITS (left_bracket_bits),       8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (right_bracket_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (filled_box_cursor_bits),  8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (hollow_box_cursor_bits),  8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (filled_rectangle_bits),   8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (hollow_rectangle_bits),   8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (filled_square_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
   { FRBITS (hollow_square_bits),      8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (bar_cursor_bits),         8, 0, ALIGN_BITMAP_CENTER, 0 },
-  { FRBITS (hbar_cursor_bits),        8, 0, ALIGN_BITMAP_BOTTOM, 0 },
-  { FRBITS (zv_bits),                 8, 3, ALIGN_BITMAP_TOP,    0 },
+  { FRBITS (vertical_bar_bits),       8, 0, ALIGN_BITMAP_CENTER, 0 },
+  { FRBITS (horizontal_bar_bits),     8, 0, ALIGN_BITMAP_BOTTOM, 0 },
+  { FRBITS (empty_line_bits),         8, 3, ALIGN_BITMAP_TOP,    0 },
 };
 
+#define NO_FRINGE_BITMAP 0
+#define UNDEF_FRINGE_BITMAP 1
+#define MAX_STANDARD_FRINGE_BITMAPS (sizeof(standard_bitmaps)/sizeof(standard_bitmaps[0]))
+
 static struct fringe_bitmap **fringe_bitmaps;
 static Lisp_Object *fringe_faces;
 static int max_fringe_bitmaps;
@@ -517,12 +550,12 @@ get_fringe_bitmap_name (bn)
    LEFT_P is 1 for left fringe, 0 for right fringe.
 */
 
-void
+static void
 draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
      struct window *w;
      struct glyph_row *row;
      int left_p, overlay;
-     enum fringe_bitmap_type which;
+     int which;
 {
   struct frame *f = XFRAME (WINDOW_FRAME (w));
   struct draw_fringe_bitmap_params p;
@@ -657,6 +690,134 @@ draw_fringe_bitmap_1 (w, row, left_p, overlay, which)
   FRAME_RIF (f)->draw_fringe_bitmap (w, row, &p);
 }
 
+static int
+get_logical_cursor_bitmap (w, cursor)
+     struct window *w;
+     Lisp_Object cursor;
+{
+  Lisp_Object cmap, bm = Qnil;
+
+  if ((cmap = XBUFFER (w->buffer)->fringe_cursor_alist), !NILP (cmap))
+    {
+      bm = Fassq (cursor, cmap);
+      if (CONSP (bm))
+        {
+          if ((bm = XCDR (bm)), NILP (bm))
+            return NO_FRINGE_BITMAP;
+          return lookup_fringe_bitmap (bm);
+        }
+    }
+  if (EQ (cmap, buffer_defaults.fringe_cursor_alist))
+    return NO_FRINGE_BITMAP;
+  bm = Fassq (cursor, buffer_defaults.fringe_cursor_alist);
+  if (!CONSP (bm) || ((bm = XCDR (bm)), NILP (bm)))
+    return NO_FRINGE_BITMAP;
+  return lookup_fringe_bitmap (bm);
+}
+
+static int
+get_logical_fringe_bitmap (w, bitmap, right_p, partial_p)
+     struct window *w;
+     Lisp_Object bitmap;
+     int right_p, partial_p;
+{
+  Lisp_Object cmap, bm1 = Qnil, bm2 = Qnil, bm;
+  int ln1 = 0, ln2 = 0;
+  int ix1 = right_p;
+  int ix2 = ix1 + (partial_p ? 2 : 0);
+
+  /* Lookup in buffer-local fringe-indicator-alist before global alist.
+
+     Elements are:
+        BITMAP          -- use for all
+        (L R)           -- use for left right (whether partial or not)
+        (L R PL PR)     -- use for left rigth partial-left partial-right
+        If any value in local binding is not present or t, use global value.
+
+     If partial, lookup partial bitmap in default value if not found here.
+     If not partial, or no partial spec is present, use non-partial bitmap.  */
+
+  if ((cmap = XBUFFER (w->buffer)->fringe_indicator_alist), !NILP (cmap))
+    {
+      bm1 = Fassq (bitmap, cmap);
+      if (CONSP (bm1))
+        {
+          if ((bm1 = XCDR (bm1)), NILP (bm1))
+            return NO_FRINGE_BITMAP;
+          if (CONSP (bm1))
+            {
+              ln1 = XINT (Flength (bm1));
+              if (partial_p)
+                {
+                  if (ln1 > ix2)
+                    {
+                      bm = Fnth (make_number (ix2), bm1);
+                      if (!EQ (bm, Qt))
+                        goto found;
+                    }
+                }
+              else
+                {
+                  if (ln1 > ix1)
+                    {
+                      bm = Fnth (make_number (ix1), bm1);
+                      if (!EQ (bm, Qt))
+                        goto found;
+                    }
+                }
+            }
+          else if ((bm = bm1, !EQ (bm, Qt)))
+            goto found;
+        }
+    }
+
+  if (!EQ (cmap, buffer_defaults.fringe_indicator_alist)
+      && !NILP (buffer_defaults.fringe_indicator_alist))
+    {
+      bm2 = Fassq (bitmap, buffer_defaults.fringe_indicator_alist);
+      if (CONSP (bm2))
+        {
+          if ((bm2 = XCDR (bm2)), !NILP (bm2))
+            {
+              if (CONSP (bm2))
+                {
+                  ln2 = XINT (Flength (bm2));
+                  if (partial_p)
+                    {
+                      if (ln2 > ix2)
+                        {
+                          bm = Fnth (make_number (ix2), bm2);
+                          if (!EQ (bm, Qt))
+                            goto found;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+  if (ln1 > ix1)
+    {
+      bm = Fnth (make_number (ix1), bm1);
+      if (!EQ (bm, Qt))
+        goto found;
+    }
+
+  if (ln2 > ix1)
+    {
+      bm = Fnth (make_number (ix1), bm2);
+      if (!EQ (bm, Qt))
+        goto found;
+      return NO_FRINGE_BITMAP;
+    }
+  else if ((bm = bm2, NILP (bm)))
+    return NO_FRINGE_BITMAP;
+
+ found:
+  return lookup_fringe_bitmap (bm);
+}
+
+
 void
 draw_fringe_bitmap (w, row, left_p)
      struct window *w;
@@ -667,24 +828,24 @@ draw_fringe_bitmap (w, row, left_p)
 
   if (!left_p && row->cursor_in_fringe_p)
     {
-      int cursor = NO_FRINGE_BITMAP;
+      Lisp_Object cursor = Qnil;
 
       switch (w->phys_cursor_type)
         {
         case HOLLOW_BOX_CURSOR:
-          if (row->visible_height >= STANDARD_BITMAP_HEIGHT (hollow_box_cursor_bits))
-            cursor = HOLLOW_BOX_CURSOR_BITMAP;
+          if (row->visible_height >= STANDARD_BITMAP_HEIGHT (hollow_rectangle_bits))
+            cursor = Qhollow;
           else
-            cursor = HOLLOW_SQUARE_BITMAP;
+            cursor = Qhollow_small;
           break;
         case FILLED_BOX_CURSOR:
-          cursor = FILLED_BOX_CURSOR_BITMAP;
+          cursor = Qbox;
           break;
         case BAR_CURSOR:
-          cursor = BAR_CURSOR_BITMAP;
+          cursor = Qbar;
           break;
         case HBAR_CURSOR:
-          cursor = HBAR_CURSOR_BITMAP;
+          cursor = Qhbar;
           break;
         case NO_CURSOR:
         default:
@@ -692,10 +853,14 @@ draw_fringe_bitmap (w, row, left_p)
           row->cursor_in_fringe_p = 0;
           break;
         }
-      if (cursor != NO_FRINGE_BITMAP)
+      if (!NILP (cursor))
         {
-          draw_fringe_bitmap_1 (w, row, 0, 2, cursor);
-          overlay = cursor == FILLED_BOX_CURSOR_BITMAP ? 3 : 1;
+          int bm = get_logical_cursor_bitmap (w, cursor);
+          if (bm != NO_FRINGE_BITMAP)
+            {
+              draw_fringe_bitmap_1 (w, row, 0, 2, bm);
+              overlay = EQ (cursor, Qbox) ? 3 : 1;
+            }
         }
     }
 
@@ -704,7 +869,7 @@ draw_fringe_bitmap (w, row, left_p)
   if (left_p && row->overlay_arrow_bitmap != NO_FRINGE_BITMAP)
     draw_fringe_bitmap_1 (w, row, 1, 1,
                           (row->overlay_arrow_bitmap < 0
-                           ? OVERLAY_ARROW_BITMAP
+                           ? get_logical_cursor_bitmap (w, Qoverlay_arrow)
                            : row->overlay_arrow_bitmap));
 }
 
@@ -796,6 +961,8 @@ update_window_fringes (w, keep_current_p)
   Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
   Lisp_Object empty_pos;
   Lisp_Object ind = Qnil;
+#define MAX_BITMAP_CACHE (8*4)
+  int bitmap_cache[MAX_BITMAP_CACHE];
 
   if (w->pseudo_window_p)
     return 0;
@@ -881,11 +1048,27 @@ update_window_fringes (w, keep_current_p)
   if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
     empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
 
+  for (y = 0; y < MAX_BITMAP_CACHE; y++)
+    bitmap_cache[y] = -1;
+
+#define LEFT_FRINGE(cache, which, partial_p)                    \
+  (bitmap_cache[cache*4+partial_p] >= 0                         \
+   ? bitmap_cache[cache*4+partial_p]                            \
+   : (bitmap_cache[cache*4+partial_p] =                         \
+      get_logical_fringe_bitmap (w, which, 0, partial_p)))
+
+#define RIGHT_FRINGE(cache, which, partial_p)                   \
+  (bitmap_cache[cache*4+2+partial_p] >= 0                       \
+   ? bitmap_cache[cache*4+2+partial_p]                          \
+   : (bitmap_cache[cache*4+2+partial_p] =                       \
+      get_logical_fringe_bitmap (w, which, 1, partial_p)))
+
+
   for (y = 0, rn = 0;
        y < yb && rn < nrows;
        y += row->height, rn++)
     {
-      enum fringe_bitmap_type left, right;
+      int left, right;
       unsigned left_face_id, right_face_id;
 
       row = w->desired_matrix->rows + rn;
@@ -904,23 +1087,21 @@ update_window_fringes (w, keep_current_p)
           left_face_id = row->left_user_fringe_face_id;
         }
       else if (row->truncated_on_left_p)
-        left = LEFT_TRUNCATION_BITMAP;
+        left = LEFT_FRINGE(0, Qtruncation, 0);
       else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
         left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
-                ? (row->ends_at_zv_p
-                   ? TOP_RIGHT_ANGLE_BITMAP : LEFT_BRACKET_BITMAP)
-                : TOP_LEFT_ANGLE_BITMAP);
+                ? LEFT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
+                : LEFT_FRINGE (2, Qtop, 0));
       else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
-        left = (row->ends_at_zv_p
-                ? TOP_RIGHT_ANGLE_BITMAP : BOTTOM_LEFT_ANGLE_BITMAP);
+        left = LEFT_FRINGE (3, Qbottom, row->ends_at_zv_p);
       else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
-        left = CONTINUATION_LINE_BITMAP;
+        left = LEFT_FRINGE (4, Qcontinuation, 0);
       else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
-        left = ZV_LINE_BITMAP;
+        left = LEFT_FRINGE (5, Qempty_line, 0);
       else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
-        left = UP_ARROW_BITMAP;
+        left = LEFT_FRINGE (6, Qup, 0);
       else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
-        left = DOWN_ARROW_BITMAP;
+        left = LEFT_FRINGE (7, Qdown, 0);
       else
         left = NO_FRINGE_BITMAP;
 
@@ -933,23 +1114,21 @@ update_window_fringes (w, keep_current_p)
           right_face_id = row->right_user_fringe_face_id;
         }
       else if (row->truncated_on_right_p)
-        right = RIGHT_TRUNCATION_BITMAP;
+        right = RIGHT_FRINGE (0, Qtruncation, 0);
       else if (row->indicate_bob_p && EQ (boundary_top, Qright))
         right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
-                 ? (row->ends_at_zv_p
-                    ? TOP_LEFT_ANGLE_BITMAP : RIGHT_BRACKET_BITMAP)
-                 : TOP_RIGHT_ANGLE_BITMAP);
+                 ? RIGHT_FRINGE (1, Qtop_bottom, row->ends_at_zv_p)
+                 : RIGHT_FRINGE (2, Qtop, 0));
       else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
-        right = (row->ends_at_zv_p
-                 ? TOP_LEFT_ANGLE_BITMAP : BOTTOM_RIGHT_ANGLE_BITMAP);
+        right = RIGHT_FRINGE (3, Qbottom, row->ends_at_zv_p);
       else if (row->continued_p)
-        right = CONTINUED_LINE_BITMAP;
+        right = RIGHT_FRINGE (4, Qcontinuation, 0);
       else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
-        right = UP_ARROW_BITMAP;
+        right = RIGHT_FRINGE (6, Qup, 0);
       else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
-        right = DOWN_ARROW_BITMAP;
+        right = RIGHT_FRINGE (7, Qdown, 0);
       else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
-        right = ZV_LINE_BITMAP;
+        right = RIGHT_FRINGE (5, Qempty_line, 0);
       else
         right = NO_FRINGE_BITMAP;
 
@@ -1153,7 +1332,7 @@ If BITMAP overrides a standard fringe bitmap, the original bitmap is restored.
 
 void
 init_fringe_bitmap (which, fb, once_p)
-     enum fringe_bitmap_type which;
+     int which;
      struct fringe_bitmap *fb;
      int once_p;
 {
@@ -1442,6 +1621,19 @@ Return nil if POS is not visible in WINDOW.  */)
 void
 syms_of_fringe ()
 {
+  Qtruncation = intern ("truncation");
+  staticpro (&Qtruncation);
+  Qcontinuation = intern ("continuation");
+  staticpro (&Qcontinuation);
+  Qoverlay_arrow = intern ("overlay-arrow");
+  staticpro (&Qoverlay_arrow);
+  Qempty_line = intern ("empty-line");
+  staticpro (&Qempty_line);
+  Qtop_bottom = intern ("top-bottom");
+  staticpro (&Qtop_bottom);
+  Qhollow_small = intern ("hollow-small");
+  staticpro (&Qhollow_small);
+
   defsubr (&Sdestroy_fringe_bitmap);
   defsubr (&Sdefine_fringe_bitmap);
   defsubr (&Sfringe_bitmaps_at_pos);
@@ -1457,8 +1649,7 @@ If nil, also continue lines which are exactly as wide as the window.  */);
   Voverflow_newline_into_fringe = Qt;
 
   DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps,
-    doc: /* List of fringe bitmap symbols.
-You must (require 'fringe) to use fringe bitmap symbols in your programs." */);
+    doc: /* List of fringe bitmap symbols.  */);
   Vfringe_bitmaps = Qnil;
 }
 
@@ -1479,7 +1670,7 @@ mark_fringe_data ()
 void
 init_fringe_once ()
 {
-  enum fringe_bitmap_type bt;
+  int bt;
 
   for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
     init_fringe_bitmap(bt, &standard_bitmaps[bt], 1);
@@ -1509,7 +1700,7 @@ init_fringe ()
 void
 w32_init_fringe ()
 {
-  enum fringe_bitmap_type bt;
+  int bt;
 
   if (!rif)
     return;
diff --git a/src/macterm.c b/src/macterm.c
index a0c4f298e66..5e341a4eeae 100644
--- a/src/macterm.c
+++ b/src/macterm.c
@@ -283,7 +283,7 @@ mac_begin_clip (region)
   if (new_region == NULL)
     new_region = NewRgn ();
 
-  if (region)
+  if (region && !EmptyRgn (region))
     {
       GetClip (saved_port_clip_region);
       SectRgn (saved_port_clip_region, region, new_region);
@@ -295,7 +295,7 @@ static void
 mac_end_clip (region)
      RgnHandle region;
 {
-  if (region)
+  if (region && !EmptyRgn (region))
     SetClip (saved_port_clip_region);
 }
 
@@ -682,27 +682,15 @@ mac_invert_rectangle (f, x, y, width, height)
 
 
 static void
-mac_draw_string_common (f, gc, x, y, buf, nchars, mode, bytes_per_char)
+mac_draw_string_common (f, gc, x, y, buf, nchars, bg_width, bytes_per_char)
      struct frame *f;
      GC gc;
      int x, y;
      char *buf;
-     int nchars, mode, bytes_per_char;
+     int nchars, bg_width, bytes_per_char;
 {
-#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
-  UInt32 textFlags, savedFlags;
-  if (mac_use_core_graphics) {
-    textFlags = kQDUseCGTextRendering;
-    savedFlags = SwapQDTextFlags(textFlags);
-  }
-#endif
-
   SetPortWindowPort (FRAME_MAC_WINDOW (f));
 
-  RGBForeColor (GC_FORE_COLOR (gc));
-  if (mode != srcOr)
-    RGBBackColor (GC_BACK_COLOR (gc));
-
 #if USE_ATSUI
   if (GC_FONT (gc)->mac_style)
     {
@@ -724,91 +712,144 @@ mac_draw_string_common (f, gc, x, y, buf, nchars, mode, bytes_per_char)
                                                 nchars,
                                                 GC_FONT (gc)->mac_style,
                                                 &text_layout);
-      if (err == noErr)
-        {
+      if (err != noErr)
+        return;
 #ifdef MAC_OSX
-          if (!mac_use_core_graphics)
-            {
+      if (!mac_use_core_graphics)
+        {
 #endif
-              mac_begin_clip (GC_CLIP_REGION (gc));
-              MoveTo (x, y);
-              ATSUDrawText (text_layout,
-                            kATSUFromTextBeginning, kATSUToTextEnd,
-                            kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc);
-              mac_end_clip (GC_CLIP_REGION (gc));
-#ifdef MAC_OSX
+          mac_begin_clip (GC_CLIP_REGION (gc));
+          RGBForeColor (GC_FORE_COLOR (gc));
+          if (bg_width)
+            {
+              Rect r;
+
+              SetRect (&r, x, y - FONT_BASE (GC_FONT (gc)),
+                       x + bg_width, y + FONT_DESCENT (GC_FONT (gc)));
+              RGBBackColor (GC_BACK_COLOR (gc));
+              EraseRect (&r);
+              RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f)));
             }
-          else
+          MoveTo (x, y);
+          ATSUDrawText (text_layout,
+                        kATSUFromTextBeginning, kATSUToTextEnd,
+                        kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc);
+          mac_end_clip (GC_CLIP_REGION (gc));
+#ifdef MAC_OSX
+        }
+      else
+        {
+          CGrafPtr port;
+          CGContextRef context;
+          float port_height = FRAME_PIXEL_HEIGHT (f);
+          ATSUAttributeTag tags[] = {kATSUCGContextTag};
+          ByteCount sizes[] = {sizeof (CGContextRef)};
+          ATSUAttributeValuePtr values[] = {&context};
+
+          GetPort (&port);
+          QDBeginCGContext (port, &context);
+          if (gc->n_clip_rects || bg_width)
             {
-              CGrafPtr port;
-              CGContextRef context;
-              float port_height = FRAME_PIXEL_HEIGHT (f);
-              ATSUAttributeTag tags[] = {kATSUCGContextTag};
-              ByteCount sizes[] = {sizeof (CGContextRef)};
-              ATSUAttributeValuePtr values[] = {&context};
-
-              GetPort (&port);
-              QDBeginCGContext (port, &context);
+              CGContextTranslateCTM (context, 0, port_height);
+              CGContextScaleCTM (context, 1, -1);
               if (gc->n_clip_rects)
+                CGContextClipToRects (context, gc->clip_rects,
+                                      gc->n_clip_rects);
+              if (bg_width)
                 {
-                  CGContextTranslateCTM (context, 0, port_height);
-                  CGContextScaleCTM (context, 1, -1);
-                  CGContextClipToRects (context, gc->clip_rects,
-                                        gc->n_clip_rects);
-                  CGContextScaleCTM (context, 1, -1);
-                  CGContextTranslateCTM (context, 0, -port_height);
+                  CGContextSetRGBFillColor
+                    (context,
+                     RED_FROM_ULONG (gc->xgcv.background) / 255.0f,
+                     GREEN_FROM_ULONG (gc->xgcv.background) / 255.0f,
+                     BLUE_FROM_ULONG (gc->xgcv.background) / 255.0f,
+                     1.0);
+                  CGContextFillRect
+                    (context,
+                     CGRectMake (x, y - FONT_BASE (GC_FONT (gc)),
+                                 bg_width, FONT_HEIGHT (GC_FONT (gc))));
                 }
-              CGContextSetRGBFillColor
-                (context,
-                 RED_FROM_ULONG (gc->xgcv.foreground) / 255.0,
-                 GREEN_FROM_ULONG (gc->xgcv.foreground) / 255.0,
-                 BLUE_FROM_ULONG (gc->xgcv.foreground) / 255.0,
-                 1.0);
-              err = ATSUSetLayoutControls (text_layout,
-                                           sizeof (tags) / sizeof (tags[0]),
-                                           tags, sizes, values);
-              if (err == noErr)
-                ATSUDrawText (text_layout,
-                              kATSUFromTextBeginning, kATSUToTextEnd,
-                              Long2Fix (x), Long2Fix (port_height - y));
-              CGContextSynchronize (context);
-              QDEndCGContext (port, &context);
-#if 0
-              /* This doesn't work on Mac OS X 10.1.  */
-              ATSUClearLayoutControls (text_layout,
+              CGContextScaleCTM (context, 1, -1);
+              CGContextTranslateCTM (context, 0, -port_height);
+            }
+          CGContextSetRGBFillColor
+            (context,
+             RED_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
+             GREEN_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
+             BLUE_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
+             1.0);
+          err = ATSUSetLayoutControls (text_layout,
                                        sizeof (tags) / sizeof (tags[0]),
-                                       tags);
+                                       tags, sizes, values);
+          if (err == noErr)
+            ATSUDrawText (text_layout,
+                          kATSUFromTextBeginning, kATSUToTextEnd,
+                          Long2Fix (x), Long2Fix (port_height - y));
+          CGContextSynchronize (context);
+          QDEndCGContext (port, &context);
+#if 0
+          /* This doesn't work on Mac OS X 10.1.  */
+          ATSUClearLayoutControls (text_layout,
+                                   sizeof (tags) / sizeof (tags[0]), tags);
 #else
-              ATSUSetLayoutControls (text_layout,
-                                     sizeof (tags) / sizeof (tags[0]),
-                                     tags, sizes, values);
-#endif
-            }
+          ATSUSetLayoutControls (text_layout,
+                                 sizeof (tags) / sizeof (tags[0]),
+                                 tags, sizes, values);
 #endif
         }
+#endif  /* MAC_OSX */
     }
   else
+#endif  /* USE_ATSUI */
     {
+#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
+      UInt32 savedFlags;
+
+      if (mac_use_core_graphics)
+        savedFlags = SwapQDTextFlags (kQDUseCGTextRendering);
 #endif
-  TextFont (GC_FONT (gc)->mac_fontnum);
-  TextSize (GC_FONT (gc)->mac_fontsize);
-  TextFace (GC_FONT (gc)->mac_fontface);
-  TextMode (mode);
+      mac_begin_clip (GC_CLIP_REGION (gc));
+      RGBForeColor (GC_FORE_COLOR (gc));
+#ifdef MAC_OS8
+      if (bg_width)
+        {
+          RGBBackColor (GC_BACK_COLOR (gc));
+          TextMode (srcCopy);
+        }
+      else
+        TextMode (srcOr);
+#else
+      /* We prefer not to use 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.  */
+      if (bg_width)
+        {
+          Rect r;
 
-  mac_begin_clip (GC_CLIP_REGION (gc));
-  MoveTo (x, y);
-  DrawText (buf, 0, nchars * bytes_per_char);
-  mac_end_clip (GC_CLIP_REGION (gc));
-#if USE_ATSUI
-    }
+          RGBBackColor (GC_BACK_COLOR (gc));
+          SetRect (&r, x, y - FONT_BASE (GC_FONT (gc)),
+                   x + bg_width, y + FONT_DESCENT (GC_FONT (gc)));
+          EraseRect (&r);
+        }
+      TextMode (srcOr);
 #endif
+      TextFont (GC_FONT (gc)->mac_fontnum);
+      TextSize (GC_FONT (gc)->mac_fontsize);
+      TextFace (GC_FONT (gc)->mac_fontface);
+      MoveTo (x, y);
+      DrawText (buf, 0, nchars * bytes_per_char);
+      if (bg_width)
+        RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f)));
+      mac_end_clip (GC_CLIP_REGION (gc));
 
-  if (mode != srcOr)
-    RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f)));
 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
-  if (mac_use_core_graphics)
-    SwapQDTextFlags(savedFlags);
+      if (mac_use_core_graphics)
+        SwapQDTextFlags(savedFlags);
 #endif
+    }
 }
 
 
@@ -822,7 +863,7 @@ mac_draw_string (f, gc, x, y, buf, nchars)
      char *buf;
      int nchars;
 {
-  mac_draw_string_common (f, gc, x, y, buf, nchars, srcOr, 1);
+  mac_draw_string_common (f, gc, x, y, buf, nchars, 0, 1);
 }
 
 
@@ -836,35 +877,35 @@ mac_draw_string_16 (f, gc, x, y, buf, nchars)
      XChar2b *buf;
      int nchars;
 {
-  mac_draw_string_common (f, gc, x, y, (char *) buf, nchars, srcOr, 2);
+  mac_draw_string_common (f, gc, x, y, (char *) buf, nchars, 0, 2);
 }
 
 
 /* Mac replacement for XDrawImageString.  */
 
 static void
-mac_draw_image_string (f, gc, x, y, buf, nchars)
+mac_draw_image_string (f, gc, x, y, buf, nchars, bg_width)
      struct frame *f;
      GC gc;
      int x, y;
      char *buf;
-     int nchars;
+     int nchars, bg_width;
 {
-  mac_draw_string_common (f, gc, x, y, buf, nchars, srcCopy, 1);
+  mac_draw_string_common (f, gc, x, y, buf, nchars, bg_width, 1);
 }
 
 
 /* Mac replacement for XDrawString16.  */
 
 static void
-mac_draw_image_string_16 (f, gc, x, y, buf, nchars)
+mac_draw_image_string_16 (f, gc, x, y, buf, nchars, bg_width)
      struct frame *f;
      GC gc;
      int x, y;
      XChar2b *buf;
-     int nchars;
+     int nchars, bg_width;
 {
-  mac_draw_string_common (f, gc, x, y, (char *) buf, nchars, srcCopy, 2);
+  mac_draw_string_common (f, gc, x, y, (char *) buf, nchars, bg_width, 2);
 }
 
 
@@ -1038,12 +1079,12 @@ init_cg_text_anti_aliasing_threshold ()
 }
 
 static int
-mac_draw_string_cg (f, gc, x, y, buf, nchars)
+mac_draw_image_string_cg (f, gc, x, y, buf, nchars, bg_width)
      struct frame *f;
      GC gc;
      int x, y;
      XChar2b *buf;
-     int nchars;
+     int nchars, bg_width;
 {
   CGrafPtr port;
   float port_height, gx, gy;
@@ -1060,7 +1101,9 @@ mac_draw_string_cg (f, gc, x, y, buf, nchars)
   gx = x;
   gy = port_height - y;
   glyphs = (CGGlyph *)buf;
-  advances = xmalloc (sizeof (CGSize) * nchars);
+  advances = alloca (sizeof (CGSize) * nchars);
+  if (advances == NULL)
+    return 0;
   for (i = 0; i < nchars; i++)
     {
       XCharStruct *pcm = mac_per_char_metric (GC_FONT (gc), buf, 0);
@@ -1072,18 +1115,32 @@ mac_draw_string_cg (f, gc, x, y, buf, nchars)
     }
 
   QDBeginCGContext (port, &context);
-  if (gc->n_clip_rects)
+  if (gc->n_clip_rects || bg_width)
     {
       CGContextTranslateCTM (context, 0, port_height);
       CGContextScaleCTM (context, 1, -1);
-      CGContextClipToRects (context, gc->clip_rects, gc->n_clip_rects);
+      if (gc->n_clip_rects)
+        CGContextClipToRects (context, gc->clip_rects, gc->n_clip_rects);
+      if (bg_width)
+        {
+          CGContextSetRGBFillColor
+            (context,
+             RED_FROM_ULONG (gc->xgcv.background) / 255.0f,
+             GREEN_FROM_ULONG (gc->xgcv.background) / 255.0f,
+             BLUE_FROM_ULONG (gc->xgcv.background) / 255.0f,
+             1.0);
+          CGContextFillRect
+            (context,
+             CGRectMake (gx, y - FONT_BASE (GC_FONT (gc)),
+                         bg_width, FONT_HEIGHT (GC_FONT (gc))));
+        }
       CGContextScaleCTM (context, 1, -1);
       CGContextTranslateCTM (context, 0, -port_height);
     }
   CGContextSetRGBFillColor (context,
-                            RED_FROM_ULONG (gc->xgcv.foreground) / 255.0,
-                            GREEN_FROM_ULONG (gc->xgcv.foreground) / 255.0,
-                            BLUE_FROM_ULONG (gc->xgcv.foreground) / 255.0,
+                            RED_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
+                            GREEN_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
+                            BLUE_FROM_ULONG (gc->xgcv.foreground) / 255.0f,
                             1.0);
   CGContextSetFont (context, GC_FONT (gc)->cg_font);
   CGContextSetFontSize (context, GC_FONT (gc)->mac_fontsize);
@@ -1102,8 +1159,6 @@ mac_draw_string_cg (f, gc, x, y, buf, nchars)
   CGContextSynchronize (context);
   QDEndCGContext (port, &context);
 
-  xfree (advances);
-
   return 1;
 }
 #endif
@@ -1375,10 +1430,7 @@ mac_set_clip_rectangles (display, gc, rectangles, n)
   if (n == 0)
     {
       if (gc->clip_region)
-        {
-          DisposeRgn (gc->clip_region);
-          gc->clip_region = NULL;
-        }
+        SetEmptyRgn (gc->clip_region);
     }
   else
     {
@@ -2322,14 +2374,6 @@ 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
@@ -2361,12 +2405,10 @@ x_draw_glyph_string_background (s, force_p)
         }
       else
 #endif
-#if defined (MAC_OS8) && !USE_ATSUI
         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,
@@ -2383,7 +2425,7 @@ static void
 x_draw_glyph_string_foreground (s)
      struct glyph_string *s;
 {
-  int i, x;
+  int i, x, bg_width;
 
   /* If first glyph of S has a left box line, start drawing the text
      of S to the right of that box line.  */
@@ -2422,7 +2464,6 @@ x_draw_glyph_string_foreground (s)
         for (i = 0; i < s->nchars; ++i)
           char1b[i] = s->char2b[i].byte2;
 
-#if defined (MAC_OS8) && !USE_ATSUI
       /* Draw text with XDrawString if background has already been
          filled.  Otherwise, use XDrawImageString.  (Note that
          XDrawImageString is usually faster than XDrawString.)  Always
@@ -2430,38 +2471,27 @@ x_draw_glyph_string_foreground (s)
          no chance that characters under a box cursor are invisible.  */
       if (s->for_overlaps
           || (s->background_filled_p && s->hl != DRAW_CURSOR))
-#endif
-        {
-          /* Draw characters with 16-bit or 8-bit functions.  */
-          if (s->two_byte_p
+        bg_width = 0;           /* Corresponds to XDrawString.  */
+      else
+        bg_width = s->background_width; /* Corresponds to XDrawImageString.  */
+
+      if (s->two_byte_p
 #if USE_ATSUI
-              || GC_FONT (s->gc)->mac_style
+          || GC_FONT (s->gc)->mac_style
 #endif
-              )
+          )
 #if USE_CG_TEXT_DRAWING
-            if (!s->two_byte_p
-                && mac_draw_string_cg (s->f, s->gc, x, s->ybase - boff,
-                                       s->char2b, s->nchars))
-              ;
-            else
+        if (!s->two_byte_p
+            && mac_draw_image_string_cg (s->f, s->gc, x, s->ybase - boff,
+                                         s->char2b, s->nchars, bg_width))
+          ;
+        else
 #endif
-            mac_draw_string_16 (s->f, s->gc, x, s->ybase - boff,
-                                s->char2b, s->nchars);
-          else
-            mac_draw_string (s->f, s->gc, x, s->ybase - boff,
-                             char1b, s->nchars);
-        }
-#if defined (MAC_OS8) && !USE_ATSUI
+          mac_draw_image_string_16 (s->f, s->gc, x, s->ybase - boff,
+                                    s->char2b, s->nchars, bg_width);
       else
-        {
-          if (s->two_byte_p)
-            mac_draw_image_string_16 (s->f, s->gc, x, s->ybase - boff,
-                                      s->char2b, s->nchars);
-          else
-            mac_draw_image_string (s->f, s->gc, x, s->ybase - boff,
-                                   char1b, s->nchars);
-        }
-#endif
+        mac_draw_image_string (s->f, s->gc, x, s->ybase - boff,
+                               char1b, s->nchars, bg_width);
     }
 }
 
@@ -7837,9 +7867,13 @@ XLoadQueryFont (Display *dpy, char *fontname)
 #if !defined (MAC_OS8) || USE_ATSUI
   /* AppKit and WebKit do some adjustment to the heights of Courier,
      Helvetica, and Times.  This only works on the environments where
-     the XDrawImageString counterpart is never used.  */
-  if (strcmp (family, "courier") == 0 || strcmp (family, "helvetica") == 0
-      || strcmp (family, "times") == 0)
+     srcCopy text transfer mode is never used.  */
+  if (
+#ifdef MAC_OS8                  /* implies USE_ATSUI */
+      font->mac_style &&
+#endif
+      (strcmp (family, "courier") == 0 || strcmp (family, "helvetica") == 0
+       || strcmp (family, "times") == 0))
     font->ascent += (font->ascent + font->descent) * .15 + 0.5;
 #endif
 
diff --git a/src/regex.c b/src/regex.c
index cd6301938a7..846c87041b1 100644
--- a/src/regex.c
+++ b/src/regex.c
@@ -181,6 +181,51 @@ char *malloc ();
 char *realloc ();
 # endif
 
+/* When used in Emacs's lib-src, we need xmalloc and xrealloc. */
+
+void *
+xmalloc (size)
+     size_t size;
+{
+  register void *val;
+  val = (void *) malloc (size);
+  if (!val && size)
+    {
+      write (2, "virtual memory exhausted\n", 25);
+      exit (1);
+    }
+  return val;
+}
+
+void *
+xrealloc (block, size)
+     void *block;
+     size_t size;
+{
+  register void *val;
+  /* We must call malloc explicitly when BLOCK is 0, since some
+     reallocs don't do this.  */
+  if (! block)
+    val = (void *) malloc (size);
+  else
+    val = (void *) realloc (block, size);
+  if (!val && size)
+    {
+      write (2, "virtual memory exhausted\n", 25);
+      exit (1);
+    }
+  return val;
+}
+
+# ifdef malloc
+#  undef malloc
+# endif
+# define malloc xmalloc
+# ifdef realloc
+#  undef realloc
+# endif
+# define realloc xrealloc
+
 /* When used in Emacs's lib-src, we need to get bzero and bcopy somehow.
    If nothing else has been done, use the method below.  */
 # ifdef INHIBIT_STRING_HEADER
@@ -3609,12 +3654,12 @@ regex_compile (pattern, size, syntax, bufp)
         if (! fail_stack.stack)
           fail_stack.stack
             = (fail_stack_elt_t *) malloc (fail_stack.size
-                                            * sizeof (fail_stack_elt_t));
+                                           * sizeof (fail_stack_elt_t));
         else
           fail_stack.stack
             = (fail_stack_elt_t *) realloc (fail_stack.stack,
-                                             (fail_stack.size
-                                              * sizeof (fail_stack_elt_t)));
+                                            (fail_stack.size
+                                             * sizeof (fail_stack_elt_t)));
       }
 
     regex_grow_registers (num_regs);
@@ -6300,7 +6345,7 @@ regcomp (preg, pattern, cflags)
 
       preg->translate
         = (RE_TRANSLATE_TYPE) malloc (CHAR_SET_SIZE
-                                       * sizeof (*(RE_TRANSLATE_TYPE)0));
+                                      * sizeof (*(RE_TRANSLATE_TYPE)0));
       if (preg->translate == NULL)
         return (int) REG_ESPACE;
 
diff --git a/src/xfns.c b/src/xfns.c
index eb790263867..b9b1a8fe3fc 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -5332,6 +5332,7 @@ or directory must exist.  ONLY-DIR-P is ignored."  */)
   int result;
   struct frame *f = SELECTED_FRAME ();
   Lisp_Object file = Qnil;
+  Lisp_Object decoded_file;
   Widget dialog, text, help;
   Arg al[10];
   int ac = 0;
@@ -5472,7 +5473,9 @@ or directory must exist.  ONLY-DIR-P is ignored."  */)
   if (NILP (file))
     Fsignal (Qquit, Qnil);
 
-  return unbind_to (count, file);
+  decoded_file = DECODE_FILE (file);
+
+  return unbind_to (count, decoded_file);
 }
 
 #endif /* USE_MOTIF */
@@ -5500,6 +5503,7 @@ directories.  */)
   FRAME_PTR f = SELECTED_FRAME ();
   char *fn;
   Lisp_Object file = Qnil;
+  Lisp_Object decoded_file;
   int count = SPECPDL_INDEX ();
   struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
   char *cdef_file;
@@ -5540,7 +5544,9 @@ directories.  */)
   if (NILP (file))
     Fsignal (Qquit, Qnil);
 
-  return unbind_to (count, file);
+  decoded_file = DECODE_FILE (file);
+
+  return unbind_to (count, decoded_file);
 }
 
 #endif /* USE_GTK */