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

Merge from emacs--cvs-trunk--0

Patches applied:

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

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

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

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

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

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

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

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

6 files changed, 256 insertions, 100 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index f7e62c1ce21..b71bffc5bce 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,41 @@
+2004-09-29  Kim F. Storm  <storm@cua.dk>
+
+        * dispextern.h (valid_fringe_bitmap_p): Fix prototype.
+
+        * fringe.c (Vfringe_bitmaps): New variable.
+        (syms_of_fringe): DEFVAR_LISP it.
+        (valid_fringe_bitmap_p): Rename from valid_fringe_bitmap_id_p.
+        Change arg to Lisp_Object and fail if not an integer.
+        (get_fringe_bitmap_name, resolve_fringe_bitmap)
+        (destroy_fringe_bitmap): New functions.
+        (Fdestroy_fringe_bitmap): Change arg to bitmap symbol.  Use
+        destroy_fringe_bitmap.  Remove symbol from Vfringe_bitmaps and
+        clear its fringe property.
+        (init_fringe_bitmap): Use destroy_fringe_bitmap instead of
+        Fdestroy_fringe_bitmap.
+        (Fdefine_fringe_bitmap): Add BITMAP arg specifying new or existing
+        bitmap symbol; remove WHICH arg.  Add symbol to Vfringe_bitmaps
+        and set fringe property.  Signal error if no free slots.
+        (Fset_fringe_bitmap_face): Change arg to bitmap symbol.
+        (Ffringe_bitmaps_at_pos): Return bitmap symbols instead of numbers.
+
+        * xdisp.c (handle_single_display_prop): Fringe bitmaps are now
+        symbols with a fringe property.
+
+2004-09-27  Kim F. Storm  <storm@cua.dk>
+
+        * buffer.c (syms_of_buffer) <indicate-buffer-boundaries>:
+        Doc fix.  Format may now be a symbol or alist, not a cons.
+
+        * fringe.c (update_window_fringes): Handle new formats of
+        indicate-buffer-boundaries (symbol or alist).  No longer
+        allow a simple cons.
+        (Ffringe_bitmaps_at_pos): Use nil value for no bitmap.
+
+2004-09-25  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
+
+        * config.in: Rebuild
+
 2004-09-24  Jan Dj,Ad(Brv  <jan.h.d@swipnet.se>
 
         * config.in: Rebuild.
diff --git a/src/buffer.c b/src/buffer.c
index 75339c4fc85..b8aefcdbcca 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -5698,16 +5698,20 @@ If non-nil, the first and last line of the buffer are marked in the fringe
 of a window on window-systems with angle bitmaps, or if the window can be
 scrolled, the top and bottom line of the window are marked with up and down
 arrow bitmaps.
-If value is `left' or `right', both angle and arrow bitmaps are displayed in
-the left or right fringe, resp.  Any other non-nil value causes the
-bitmap on the top line to be displayed in the left fringe, and the
-bitmap on the bottom line in the right fringe.
-If value is a cons (ANGLES . ARROWS), the car specifies the position
-of the angle bitmaps, and the cdr specifies the position of the arrow
-bitmaps.  For example, (t . right) places the top angle bitmap in left
-fringe, the bottom angle bitmap in right fringe, and both arrow
+
+If value is a symbol `left' or `right', both angle and arrow bitmaps
+are displayed in the left or right fringe, resp.
+
+If value is an alist, each element (INDICATOR . POSITION) specifies
+the position of one of the indicators.  INDICATOR is one of `top',
+`bottom', `up', `down', or t, which specifies the default position,
+and POSITION is one of `left', `right', or nil, meaning do not show
+this indicator.
+
+For example, ((top . left) (t . right)) places the top angle bitmap in
+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 (left . nil).  */);
+fringe, but no arrow bitmaps, use ((top .  left) (bottom . left)).  */);
 
   DEFVAR_PER_BUFFER ("scroll-up-aggressively",
                      &current_buffer->scroll_up_aggressively, Qnil,
diff --git a/src/config.in b/src/config.in
index fac26db0a84..d87d235fe55 100644
--- a/src/config.in
+++ b/src/config.in
@@ -136,7 +136,7 @@ Boston, MA 02111-1307, USA.  */
 /* Define to 1 if you have the `euidaccess' function. */
 #undef HAVE_EUIDACCESS
 
-/* Define to 1 if this OS has exec shield. */
+/* Define to 1 if this OS has exec shield and we can handle it. */
 #undef HAVE_EXECSHIELD
 
 /* Define to 1 if you have the <fcntl.h> header file. */
diff --git a/src/dispextern.h b/src/dispextern.h
index 43ebe5c24d0..47454d5ba5a 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -2634,7 +2634,7 @@ extern int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
 
 /* Defined in fringe.c */
 
-int valid_fringe_bitmap_id_p (int);
+int valid_fringe_bitmap_p (Lisp_Object);
 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 *));
diff --git a/src/fringe.c b/src/fringe.c
index 3f040699009..d731bf5eaa6 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -31,12 +31,22 @@ Boston, MA 02111-1307, USA.  */
 
 #ifdef HAVE_WINDOW_SYSTEM
 
+extern Lisp_Object Qfringe;
 extern Lisp_Object Qtop, Qbottom, Qcenter;
+extern Lisp_Object Qup, Qdown, Qleft, Qright;
 
 /* Non-nil means that newline may flow into the right fringe.  */
 
 Lisp_Object Voverflow_newline_into_fringe;
 
+/* List of known fringe bitmap symbols.
+
+   The fringe bitmap number is stored in the `fringe' property on
+   those symbols.  Names for the built-in bitmaps are installed by
+   loading fringe.el.
+ */
+
+Lisp_Object Vfringe_bitmaps;
 
 enum fringe_bitmap_type
 {
@@ -443,15 +453,90 @@ static int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
 /* Return 1 if FRINGE_ID is a valid fringe bitmap id.  */
 
 int
-valid_fringe_bitmap_id_p (fringe_id)
-     int fringe_id;
+valid_fringe_bitmap_p (bitmap)
+     Lisp_Object bitmap;
+{
+  int bn;
+
+  if (!INTEGERP (bitmap))
+    return 0;
+
+  bn = XINT (bitmap);
+  return (bn >= NO_FRINGE_BITMAP
+          && bn < max_used_fringe_bitmap
+          && (bn < MAX_STANDARD_FRINGE_BITMAPS
+              || fringe_bitmaps[bn] != NULL));
+}
+
+/* Get fringe bitmap name for bitmap number BN.
+
+   Found by traversing Vfringe_bitmaps comparing BN to the
+   fringe property for each symbol.
+
+   Return BN if not found in Vfringe_bitmaps.  */
+
+static Lisp_Object
+get_fringe_bitmap_name (bn)
+     int bn;
+{
+  Lisp_Object bitmaps;
+  Lisp_Object num;
+
+  /* Zero means no bitmap -- return nil.  */
+  if (bn <= 0)
+    return Qnil;
+
+  bitmaps = Vfringe_bitmaps;
+  num = make_number (bn);
+
+  while (CONSP (bitmaps))
+    {
+      Lisp_Object bitmap = XCAR (bitmaps);
+      if (EQ (num, Fget (bitmap, Qfringe)))
+        return bitmap;
+      bitmaps = XCDR (bitmaps);
+    }
+
+  return num;
+}
+
+
+/* Resolve a BITMAP parameter.
+
+   An INTEGER, corresponding to a bitmap number.
+   A STRING which is interned to a symbol.
+   A SYMBOL which has a fringe property which is a bitmap number.
+*/
+
+static int
+resolve_fringe_bitmap (bitmap, namep)
+     Lisp_Object bitmap;
+     Lisp_Object *namep;
 {
-  return (fringe_id >= NO_FRINGE_BITMAP
-          && fringe_id < max_used_fringe_bitmap
-          && (fringe_id < MAX_STANDARD_FRINGE_BITMAPS
-              || fringe_bitmaps[fringe_id] != NULL));
+  if (namep)
+    *namep = Qnil;
+
+  if (STRINGP (bitmap))
+    bitmap = intern (SDATA (bitmap));
+
+  if (SYMBOLP (bitmap))
+    {
+      if (namep)
+        *namep = bitmap;
+      bitmap = Fget (bitmap, Qfringe);
+    }
+
+  if (valid_fringe_bitmap_p (bitmap))
+    {
+      if (namep && NILP (*namep))
+        *namep = get_fringe_bitmap_name (XINT (bitmap));
+      return XINT (bitmap);
+    }
+
+  return -1;
 }
 
+
 /* 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
@@ -706,9 +791,10 @@ update_window_fringes (w, force_p)
   int rn, nrows = w->current_matrix->nrows;
   int y;
   int redraw_p = 0;
-  Lisp_Object ind;
-  int boundary_pos = 0, arrow_pos = 0;
-  int empty_pos = 0;
+  Lisp_Object boundary_top = Qnil, boundary_bot = Qnil;
+  Lisp_Object arrow_top = Qnil, arrow_bot = Qnil;
+  Lisp_Object empty_pos;
+  Lisp_Object ind = Qnil;
 
   if (w->pseudo_window_p)
     return 0;
@@ -716,23 +802,29 @@ update_window_fringes (w, force_p)
   if (!MINI_WINDOW_P (w)
       && (ind = XBUFFER (w->buffer)->indicate_buffer_boundaries, !NILP (ind)))
     {
-      int do_eob = 1, do_bob = 1;
-      Lisp_Object arrows;
-
-      if (CONSP (ind))
-        arrows = XCDR (ind), ind = XCAR (ind);
+      if (EQ (ind, Qleft) || EQ (ind, Qright))
+        boundary_top = boundary_bot = arrow_top = arrow_bot = ind;
+      else if (CONSP (ind) && CONSP (XCAR (ind)))
+        {
+          Lisp_Object pos;
+          if (pos = Fassq (Qt, ind), !NILP (pos))
+            boundary_top = boundary_bot = arrow_top = arrow_bot = XCDR (pos);
+          if (pos = Fassq (Qtop, ind), !NILP (pos))
+            boundary_top = XCDR (pos);
+          if (pos = Fassq (Qbottom, ind), !NILP (pos))
+            boundary_bot = XCDR (pos);
+          if (pos = Fassq (Qup, ind), !NILP (pos))
+            arrow_top = XCDR (pos);
+          if (pos = Fassq (Qdown, ind), !NILP (pos))
+            arrow_bot = XCDR (pos);
+        }
       else
-        arrows = ind;
-
-      if (EQ (ind, Qleft))
-        boundary_pos = -1;
-      else if (EQ (ind, Qright))
-        boundary_pos = 1;
+        ind = Qnil;
+    }
 
-      if (EQ (arrows, Qleft))
-        arrow_pos = -1;
-      else if (EQ (arrows, Qright))
-        arrow_pos = 1;
+  if (!NILP (ind))
+    {
+      int do_eob = 1, do_bob = 1;
 
       for (y = 0, rn = 0;
            y < yb && rn < nrows;
@@ -753,17 +845,17 @@ update_window_fringes (w, force_p)
           row->indicate_bob_p = row->indicate_top_line_p = 0;
           row->indicate_eob_p = row->indicate_bottom_line_p = 0;
 
-          if (!NILP (ind)
+          if (!NILP (boundary_top)
               && MATRIX_ROW_START_CHARPOS (row) <= BUF_BEGV (XBUFFER (w->buffer)))
             row->indicate_bob_p = do_bob, do_bob = 0;
-          else if (!NILP (arrows)
+          else if (!NILP (arrow_top)
                    && (WINDOW_WANTS_HEADER_LINE_P (w) ? 1 : 0) == rn)
             row->indicate_top_line_p = 1;
 
-          if (!NILP (ind)
+          if (!NILP (boundary_bot)
               && MATRIX_ROW_END_CHARPOS (row) >= BUF_ZV (XBUFFER (w->buffer)))
             row->indicate_eob_p = do_eob, do_eob = 0;
-          else if (!NILP (arrows)
+          else if (!NILP (arrow_bot)
                    && y + row->height >= yb)
             row->indicate_bottom_line_p = 1;
 
@@ -775,10 +867,9 @@ update_window_fringes (w, force_p)
         }
     }
 
-  if (EQ (XBUFFER (w->buffer)->indicate_empty_lines, Qright))
-    empty_pos = 1;
-  else if (EQ (XBUFFER (w->buffer)->indicate_empty_lines, Qleft))
-    empty_pos = -1;
+  empty_pos = XBUFFER (w->buffer)->indicate_empty_lines;
+  if (!NILP (empty_pos) && !EQ (empty_pos, Qright))
+    empty_pos = WINDOW_LEFT_FRINGE_WIDTH (w) == 0 ? Qright : Qleft;
 
   for (y = 0, rn = 0;
        y < yb && rn < nrows;
@@ -802,20 +893,20 @@ update_window_fringes (w, force_p)
           left = row->left_user_fringe_bitmap;
           left_face_id = row->left_user_fringe_face_id;
         }
-      else if (row->indicate_bob_p && boundary_pos <= 0)
-        left = ((row->indicate_eob_p && boundary_pos < 0)
+      else if (row->indicate_bob_p && EQ (boundary_top, Qleft))
+        left = ((row->indicate_eob_p && EQ (boundary_bot, Qleft))
                 ? LEFT_BRACKET_BITMAP : TOP_LEFT_ANGLE_BITMAP);
-      else if (row->indicate_eob_p && boundary_pos < 0)
+      else if (row->indicate_eob_p && EQ (boundary_bot, Qleft))
         left = BOTTOM_LEFT_ANGLE_BITMAP;
       else if (row->truncated_on_left_p)
         left = LEFT_TRUNCATION_BITMAP;
       else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
         left = CONTINUATION_LINE_BITMAP;
-      else if (row->indicate_empty_line_p && empty_pos <= 0)
+      else if (row->indicate_empty_line_p && EQ (empty_pos, Qleft))
         left = ZV_LINE_BITMAP;
-      else if (row->indicate_top_line_p && arrow_pos <= 0)
+      else if (row->indicate_top_line_p && EQ (arrow_top, Qleft))
         left = UP_ARROW_BITMAP;
-      else if (row->indicate_bottom_line_p && arrow_pos < 0)
+      else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qleft))
         left = DOWN_ARROW_BITMAP;
       else
         left = NO_FRINGE_BITMAP;
@@ -828,22 +919,20 @@ update_window_fringes (w, force_p)
           right = row->right_user_fringe_bitmap;
           right_face_id = row->right_user_fringe_face_id;
         }
-      else if (row->indicate_bob_p && boundary_pos > 0)
-        right = ((row->indicate_eob_p && boundary_pos >= 0)
+      else if (row->indicate_bob_p && EQ (boundary_top, Qright))
+        right = ((row->indicate_eob_p && EQ (boundary_bot, Qright))
                  ? RIGHT_BRACKET_BITMAP : TOP_RIGHT_ANGLE_BITMAP);
-      else if (row->indicate_eob_p && boundary_pos >= 0)
+      else if (row->indicate_eob_p && EQ (boundary_bot, Qright))
         right = BOTTOM_RIGHT_ANGLE_BITMAP;
       else if (row->truncated_on_right_p)
         right = RIGHT_TRUNCATION_BITMAP;
       else if (row->continued_p)
         right = CONTINUED_LINE_BITMAP;
-      else if (row->indicate_top_line_p && arrow_pos > 0)
+      else if (row->indicate_top_line_p && EQ (arrow_top, Qright))
         right = UP_ARROW_BITMAP;
-      else if (row->indicate_bottom_line_p && arrow_pos >= 0)
+      else if (row->indicate_bottom_line_p && EQ (arrow_bot, Qright))
         right = DOWN_ARROW_BITMAP;
-      else if (row->indicate_empty_line_p
-               && (empty_pos > 0
-                   || (WINDOW_LEFT_FRINGE_WIDTH (w) == 0 && empty_pos == 0)))
+      else if (row->indicate_empty_line_p && EQ (empty_pos, Qright))
         right = ZV_LINE_BITMAP;
       else
         right = NO_FRINGE_BITMAP;
@@ -978,20 +1067,13 @@ compute_fringe_widths (f, redraw)
       redraw_frame (f);
 }
 
-DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap, Sdestroy_fringe_bitmap,
-       1, 1, 0,
-       doc: /* Destroy fringe bitmap WHICH.
-If WHICH overrides a standard fringe bitmap, the original bitmap is restored.  */)
-  (which)
-     Lisp_Object which;
+
+void
+destroy_fringe_bitmap (n)
+     int n;
 {
-  int n;
   struct fringe_bitmap **fbp;
 
-  CHECK_NUMBER (which);
-  if (n = XINT (which), n >= max_used_fringe_bitmap)
-    return Qnil;
-
   fringe_faces[n] = FRINGE_FACE_ID;
 
   fbp = &fringe_bitmaps[n];
@@ -1006,7 +1088,31 @@ If WHICH overrides a standard fringe bitmap, the original bitmap is restored.  *
   while (max_used_fringe_bitmap > MAX_STANDARD_FRINGE_BITMAPS
          && fringe_bitmaps[max_used_fringe_bitmap - 1] == NULL)
     max_used_fringe_bitmap--;
+}
+
 
+DEFUN ("destroy-fringe-bitmap", Fdestroy_fringe_bitmap, Sdestroy_fringe_bitmap,
+       1, 1, 0,
+       doc: /* Destroy fringe bitmap BITMAP.
+If BITMAP overrides a standard fringe bitmap, the original bitmap is restored.  */)
+  (bitmap)
+     Lisp_Object bitmap;
+{
+  int n;
+  Lisp_Object sym;
+
+  n = resolve_fringe_bitmap (bitmap, &sym);
+  if (n < 0)
+    return Qnil;
+
+  destroy_fringe_bitmap (n);
+
+  if (SYMBOLP (sym))
+    {
+      Vfringe_bitmaps = Fdelq (sym, Vfringe_bitmaps);
+      /* It would be better to remove the fringe property.  */
+      Fput (sym, Qfringe, Qnil);
+    }
   return Qnil;
 }
 
@@ -1077,7 +1183,7 @@ init_fringe_bitmap (which, fb, once_p)
 
   if (!once_p)
     {
-      Fdestroy_fringe_bitmap (make_number (which));
+      destroy_fringe_bitmap (which);
 
       if (rif->define_fringe_bitmap)
         rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
@@ -1090,26 +1196,32 @@ init_fringe_bitmap (which, fb, once_p)
 
 
 DEFUN ("define-fringe-bitmap", Fdefine_fringe_bitmap, Sdefine_fringe_bitmap,
-       1, 5, 0,
-       doc: /* Define a fringe bitmap from BITS of height HEIGHT and width WIDTH.
+       2, 5, 0,
+       doc: /* Define fringe bitmap BITMAP from BITS of size HEIGHT x WIDTH.
+BITMAP is a symbol or string naming the new fringe bitmap.
 BITS is either a string or a vector of integers.
 HEIGHT is height of bitmap.  If HEIGHT is nil, use length of BITS.
 WIDTH must be an integer between 1 and 16, or nil which defaults to 8.
-Optional fourth arg ALIGN may be one of `top', `center', or `bottom',
+Optional fifth arg ALIGN may be one of `top', `center', or `bottom',
 indicating the positioning of the bitmap relative to the rows where it
 is used; the default is to center the bitmap.  Fourth arg may also be a
 list (ALIGN PERIODIC) where PERIODIC non-nil specifies that the bitmap
 should be repeated.
-Optional fifth argument WHICH is bitmap number to redefine.
-Return new bitmap number, or nil of no more free bitmap slots.  */)
-  (bits, height, width, align, which)
-     Lisp_Object bits, height, width, align, which;
+If BITMAP already exists, the existing definition is replaced.  */)
+  (bitmap, bits, height, width, align)
+     Lisp_Object bitmap, bits, height, width, align;
 {
   Lisp_Object len;
   int n, h, i, j;
   unsigned short *b;
   struct fringe_bitmap fb, *xfb;
   int fill1 = 0, fill2 = 0;
+  Lisp_Object sym;
+
+  n = resolve_fringe_bitmap (bitmap, &sym);
+
+  if (NILP (sym) || INTEGERP (sym))
+    sym = wrong_type_argument (Qsymbolp, bitmap);
 
   if (!STRINGP (bits) && !VECTORP (bits))
     bits = wrong_type_argument (Qstringp, bits);
@@ -1162,7 +1274,7 @@ Return new bitmap number, or nil of no more free bitmap slots.  */)
   else if (!NILP (align) && !EQ (align, Qcenter))
     error ("Bad align argument");
 
-  if (NILP (which))
+  if (n < 0)
     {
       if (max_used_fringe_bitmap < MAX_FRINGE_BITMAPS)
         n = max_used_fringe_bitmap++;
@@ -1174,16 +1286,11 @@ Return new bitmap number, or nil of no more free bitmap slots.  */)
             if (fringe_bitmaps[n] == NULL)
               break;
           if (n == MAX_FRINGE_BITMAPS)
-            return Qnil;
+            error ("Cannot define more fringe bitmaps");
         }
-      which = make_number (n);
-    }
-  else
-    {
-      CHECK_NUMBER (which);
-      n = XINT (which);
-      if (n <= NO_FRINGE_BITMAP || n >= MAX_FRINGE_BITMAPS)
-        error ("Invalid fringe bitmap number");
+
+      Vfringe_bitmaps = Fcons (sym, Vfringe_bitmaps);
+      Fput (sym, Qfringe, make_number (n));
     }
 
   fb.dynamic = 1;
@@ -1211,21 +1318,22 @@ Return new bitmap number, or nil of no more free bitmap slots.  */)
 
   init_fringe_bitmap (n, xfb, 0);
 
-  return which;
+  return sym;
 }
 
 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
        1, 2, 0,
-       doc: /* Set face for fringe bitmap FRINGE-ID to FACE.
+       doc: /* Set face for fringe bitmap BITMAP to FACE.
 If FACE is nil, reset face to default fringe face.  */)
-  (fringe_id, face)
-     Lisp_Object fringe_id, face;
+  (bitmap, face)
+     Lisp_Object bitmap, face;
 {
+  int bn;
   int face_id;
 
-  CHECK_NUMBER (fringe_id);
-  if (!valid_fringe_bitmap_id_p (XINT (fringe_id)))
-    error ("Invalid fringe id");
+  bn = resolve_fringe_bitmap (bitmap, 0);
+  if (bn < 0)
+    error ("Undefined fringe bitmap");
 
   if (!NILP (face))
     {
@@ -1236,7 +1344,7 @@ If FACE is nil, reset face to default fringe face.  */)
   else
     face_id = FRINGE_FACE_ID;
 
-  fringe_faces [XINT (fringe_id)] = face_id;
+  fringe_faces [bn] = face_id;
 
   return Qnil;
 }
@@ -1247,7 +1355,8 @@ DEFUN ("fringe-bitmaps-at-pos", Ffringe_bitmaps_at_pos, Sfringe_bitmaps_at_pos,
 If WINDOW is nil, use selected window.  If POS is nil, use value of point
 in that window.  Return value is a cons (LEFT . RIGHT) where LEFT and RIGHT
 are the fringe bitmap numbers for the bitmaps in the left and right fringe,
-resp.  Return nil if POS is not visible in WINDOW.  */)
+resp.  If left or right fringe is empty, the corresponding element is nil.
+Return nil if POS is not visible in WINDOW.  */)
   (pos, window)
      Lisp_Object pos, window;
 {
@@ -1274,8 +1383,8 @@ resp.  Return nil if POS is not visible in WINDOW.  */)
   row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
   row = row_containing_pos (w, textpos, row, NULL, 0);
   if (row)
-    return Fcons (make_number (row->left_fringe_bitmap),
-                  make_number (row->right_fringe_bitmap));
+    return Fcons (get_fringe_bitmap_name (row->left_fringe_bitmap),
+                  get_fringe_bitmap_name (row->right_fringe_bitmap));
   else
     return Qnil;
 }
@@ -1288,7 +1397,6 @@ resp.  Return nil if POS is not visible in WINDOW.  */)
 void
 syms_of_fringe ()
 {
-
   defsubr (&Sdestroy_fringe_bitmap);
   defsubr (&Sdefine_fringe_bitmap);
   defsubr (&Sfringe_bitmaps_at_pos);
@@ -1303,6 +1411,10 @@ 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;
 
+  DEFVAR_LISP ("fringe-bitmaps", &Vfringe_bitmaps,
+    doc: /* List of fringe bitmap symbols.
+You must (require 'fringe) to use fringe bitmap symbols in your programs." */);
+  Vfringe_bitmaps = Qnil;
 }
 
 /* Initialize this module when Emacs starts.  */
diff --git a/src/xdisp.c b/src/xdisp.c
index d8166a30df5..353a72f65b6 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -308,6 +308,7 @@ extern Lisp_Object Qheight;
 extern Lisp_Object QCwidth, QCheight, QCascent;
 extern Lisp_Object Qscroll_bar;
 extern Lisp_Object Qcursor;
+extern Lisp_Object Qfringe;
 
 /* Non-nil means highlight trailing whitespace.  */
 
@@ -3581,8 +3582,9 @@ handle_single_display_prop (it, prop, object, position,
 
 #ifdef HAVE_WINDOW_SYSTEM
           value = XCAR (XCDR (prop));
-          if (!NUMBERP (value)
-              || !valid_fringe_bitmap_id_p (XINT (value)))
+          if (!SYMBOLP (value)
+              || (value = Fget (value, Qfringe),
+                  !valid_fringe_bitmap_p (value)))
             return 0;
 
           if (CONSP (XCDR (XCDR (prop))))