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

Merge from emacs--cvs-trunk--0

Patches applied:

 * miles@gnu.org--gnu-2004/emacs--cvs-trunk--0--patch-581
   Fix exec-shield autoconf test

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

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

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

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

5 files changed, 147 insertions, 94 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index b71bffc5bce..266b62588ea 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,5 +1,41 @@
 2004-09-29  Kim F. Storm  <storm@cua.dk>
 
+        * fringe.c: Remove limit on number of bitmaps.
+        (fringe_bitmaps, fringe_faces): Change to pointers.
+        (max_fringe_bitmaps): New var.
+        (Fdefine_fringe_bitmap): Expand fringe_bitmaps and fringe_faces.
+        (init_fringe): Allocate fringe_bitmaps and fringe_faces.
+
+        * dispextern.h (FRINGE_ID_BITS): Increase to 16 bits (64K bitmaps).
+        (struct glyph_row): Reorder fringe_bitmap related fields.
+        (struct it): Likewise.
+
+        * w32term.c (fringe_bmp): Change to pointer.
+        (max_fringe_bmp): New var.
+        (w32_define_fringe_bitmap): Expand fringe_bmp.
+        (w32_draw_fringe_bitmap): Check max_fringe_bmp.
+        (w32_destroy_fringe_bitmap): Likewise.
+
+2004-09-29  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c: Simplify last change.
+        (lookup_fringe_bitmap): New function.
+        (valid_fringe_bitmap_p, resolve_fringe_bitmap): Remove.
+        (Fdestroy_fringe_bitmap): Use lookup_fringe_bitmap.
+        Keep standard bitmaps in Vfringe_bitmaps.
+        (Fdefine_fringe_bitmap): Use lookup_fringe_bitmap.
+        (Fset_fringe_bitmap_face): Likewise.
+
+        * dispextern.h (lookup_fringe_bitmap): Add prototype.
+        (valid_fringe_bitmap_p): Remove prototype.
+
+        * xdisp.c (handle_single_display_prop): Use lookup_fringe_bitmap.
+
+2004-09-29  Kim F. Storm  <storm@cua.dk>
+
+        * fringe.c (destroy_fringe_bitmap, init_fringe_bitmap)
+        (w32_init_fringe, w32_reset_fringes): Fix bootstrap (NULL rif).
+
         * dispextern.h (valid_fringe_bitmap_p): Fix prototype.
 
         * fringe.c (Vfringe_bitmaps): New variable.
diff --git a/src/dispextern.h b/src/dispextern.h
index 47454d5ba5a..f28b39f0c64 100644
--- a/src/dispextern.h
+++ b/src/dispextern.h
@@ -104,7 +104,7 @@ enum window_part
 };
 
 /* Number of bits allocated to store fringe bitmap numbers.  */
-#define FRINGE_ID_BITS  8
+#define FRINGE_ID_BITS  16
 
 
 
@@ -714,24 +714,24 @@ struct glyph_row
   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
 
-  /* Face of the left fringe glyph.  */
-  unsigned left_user_fringe_face_id : FACE_ID_BITS;
-
   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
 
-  /* Face of the right fringe glyph.  */
-  unsigned right_user_fringe_face_id : FACE_ID_BITS;
-
   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned left_fringe_bitmap : FRINGE_ID_BITS;
 
-  /* Face of the left fringe glyph.  */
-  unsigned left_fringe_face_id : FACE_ID_BITS;
-
   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned right_fringe_bitmap : FRINGE_ID_BITS;
 
+  /* Face of the left fringe glyph.  */
+  unsigned left_user_fringe_face_id : FACE_ID_BITS;
+
+  /* Face of the right fringe glyph.  */
+  unsigned right_user_fringe_face_id : FACE_ID_BITS;
+
+  /* Face of the left fringe glyph.  */
+  unsigned left_fringe_face_id : FACE_ID_BITS;
+
   /* Face of the right fringe glyph.  */
   unsigned right_fringe_face_id : FACE_ID_BITS;
 
@@ -2041,12 +2041,12 @@ struct it
   /* Left fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned left_user_fringe_bitmap : FRINGE_ID_BITS;
 
-  /* Face of the left fringe glyph.  */
-  unsigned left_user_fringe_face_id : FACE_ID_BITS;
-
   /* Right fringe bitmap number (enum fringe_bitmap_type).  */
   unsigned right_user_fringe_bitmap : FRINGE_ID_BITS;
 
+  /* Face of the left fringe glyph.  */
+  unsigned left_user_fringe_face_id : FACE_ID_BITS;
+
   /* Face of the right fringe glyph.  */
   unsigned right_user_fringe_face_id : FACE_ID_BITS;
 };
@@ -2634,7 +2634,7 @@ extern int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
 
 /* Defined in fringe.c */
 
-int valid_fringe_bitmap_p (Lisp_Object);
+int lookup_fringe_bitmap (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 d731bf5eaa6..0bf830cbd8c 100644
--- a/src/fringe.c
+++ b/src/fringe.c
@@ -445,27 +445,34 @@ struct fringe_bitmap standard_bitmaps[MAX_STANDARD_FRINGE_BITMAPS] =
   { FRBITS (zv_bits),                 8, 3, ALIGN_BITMAP_TOP,    0 },
 };
 
-static struct fringe_bitmap *fringe_bitmaps[MAX_FRINGE_BITMAPS];
-static unsigned fringe_faces[MAX_FRINGE_BITMAPS];
+static struct fringe_bitmap **fringe_bitmaps;
+static unsigned *fringe_faces;
+static int max_fringe_bitmaps;
 
 static int max_used_fringe_bitmap = MAX_STANDARD_FRINGE_BITMAPS;
 
-/* Return 1 if FRINGE_ID is a valid fringe bitmap id.  */
+
+/* Lookup bitmap number for symbol BITMAP.
+   Return 0 if not a bitmap.  */
 
 int
-valid_fringe_bitmap_p (bitmap)
+lookup_fringe_bitmap (bitmap)
      Lisp_Object bitmap;
 {
   int bn;
 
+  bitmap = Fget (bitmap, Qfringe);
   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));
+  if (bn > NO_FRINGE_BITMAP
+      && bn < max_used_fringe_bitmap
+      && (bn < MAX_STANDARD_FRINGE_BITMAPS
+          || fringe_bitmaps[bn] != NULL))
+    return bn;
+
+  return 0;
 }
 
 /* Get fringe bitmap name for bitmap number BN.
@@ -501,42 +508,6 @@ get_fringe_bitmap_name (bn)
 }
 
 
-/* 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;
-{
-  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
@@ -1068,7 +1039,9 @@ compute_fringe_widths (f, redraw)
 }
 
 
-void
+/* Free resources used by a user-defined bitmap.  */
+
+int
 destroy_fringe_bitmap (n)
      int n;
 {
@@ -1079,7 +1052,7 @@ destroy_fringe_bitmap (n)
   fbp = &fringe_bitmaps[n];
   if (*fbp && (*fbp)->dynamic)
     {
-      if (rif->destroy_fringe_bitmap)
+      if (rif && rif->destroy_fringe_bitmap)
         rif->destroy_fringe_bitmap (n);
       xfree (*fbp);
       *fbp = NULL;
@@ -1099,20 +1072,21 @@ If BITMAP overrides a standard fringe bitmap, the original bitmap is restored.
      Lisp_Object bitmap;
 {
   int n;
-  Lisp_Object sym;
 
-  n = resolve_fringe_bitmap (bitmap, &sym);
-  if (n < 0)
+  CHECK_SYMBOL (bitmap);
+  n = lookup_fringe_bitmap (bitmap);
+  if (!n)
     return Qnil;
 
   destroy_fringe_bitmap (n);
 
-  if (SYMBOLP (sym))
+  if (n >= MAX_STANDARD_FRINGE_BITMAPS)
     {
-      Vfringe_bitmaps = Fdelq (sym, Vfringe_bitmaps);
+      Vfringe_bitmaps = Fdelq (bitmap, Vfringe_bitmaps);
       /* It would be better to remove the fringe property.  */
-      Fput (sym, Qfringe, Qnil);
+      Fput (bitmap, Qfringe, Qnil);
     }
+
   return Qnil;
 }
 
@@ -1185,7 +1159,7 @@ init_fringe_bitmap (which, fb, once_p)
     {
       destroy_fringe_bitmap (which);
 
-      if (rif->define_fringe_bitmap)
+      if (rif && rif->define_fringe_bitmap)
         rif->define_fringe_bitmap (which, fb->bits, fb->height, fb->width);
 
       fringe_bitmaps[which] = fb;
@@ -1216,12 +1190,8 @@ If BITMAP already exists, the existing definition is replaced.  */)
   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);
+  CHECK_SYMBOL (bitmap);
 
   if (!STRINGP (bits) && !VECTORP (bits))
     bits = wrong_type_argument (Qstringp, bits);
@@ -1274,23 +1244,42 @@ If BITMAP already exists, the existing definition is replaced.  */)
   else if (!NILP (align) && !EQ (align, Qcenter))
     error ("Bad align argument");
 
-  if (n < 0)
+  n = lookup_fringe_bitmap (bitmap);
+  if (!n)
     {
-      if (max_used_fringe_bitmap < MAX_FRINGE_BITMAPS)
+      if (max_used_fringe_bitmap < max_fringe_bitmaps)
         n = max_used_fringe_bitmap++;
       else
         {
           for (n = MAX_STANDARD_FRINGE_BITMAPS;
-               n < MAX_FRINGE_BITMAPS;
+               n < max_fringe_bitmaps;
                n++)
             if (fringe_bitmaps[n] == NULL)
               break;
-          if (n == MAX_FRINGE_BITMAPS)
-            error ("Cannot define more fringe bitmaps");
+
+          if (n == max_fringe_bitmaps)
+            {
+              if ((max_fringe_bitmaps + 20) > MAX_FRINGE_BITMAPS)
+                error ("No free fringe bitmap slots");
+
+              i = max_fringe_bitmaps;
+              max_fringe_bitmaps += 20;
+              fringe_bitmaps
+                = ((struct fringe_bitmap **)
+                   xrealloc (fringe_bitmaps, max_fringe_bitmaps * sizeof (struct fringe_bitmap *)));
+              fringe_faces
+                = (unsigned *) xrealloc (fringe_faces, max_fringe_bitmaps * sizeof (unsigned));
+
+              for (; i < max_fringe_bitmaps; i++)
+                {
+                  fringe_bitmaps[i] = NULL;
+                  fringe_faces[i] = FRINGE_FACE_ID;
+                }
+            }
         }
 
-      Vfringe_bitmaps = Fcons (sym, Vfringe_bitmaps);
-      Fput (sym, Qfringe, make_number (n));
+      Vfringe_bitmaps = Fcons (bitmap, Vfringe_bitmaps);
+      Fput (bitmap, Qfringe, make_number (n));
     }
 
   fb.dynamic = 1;
@@ -1318,7 +1307,7 @@ If BITMAP already exists, the existing definition is replaced.  */)
 
   init_fringe_bitmap (n, xfb, 0);
 
-  return sym;
+  return bitmap;
 }
 
 DEFUN ("set-fringe-bitmap-face", Fset_fringe_bitmap_face, Sset_fringe_bitmap_face,
@@ -1328,11 +1317,12 @@ If FACE is nil, reset face to default fringe face.  */)
   (bitmap, face)
      Lisp_Object bitmap, face;
 {
-  int bn;
+  int n;
   int face_id;
 
-  bn = resolve_fringe_bitmap (bitmap, 0);
-  if (bn < 0)
+  CHECK_SYMBOL (bitmap);
+  n = lookup_fringe_bitmap (bitmap);
+  if (!n)
     error ("Undefined fringe bitmap");
 
   if (!NILP (face))
@@ -1344,7 +1334,7 @@ If FACE is nil, reset face to default fringe face.  */)
   else
     face_id = FRINGE_FACE_ID;
 
-  fringe_faces [bn] = face_id;
+  fringe_faces[n] = face_id;
 
   return Qnil;
 }
@@ -1433,9 +1423,18 @@ init_fringe ()
 {
   int i;
 
-  bzero (fringe_bitmaps, sizeof fringe_bitmaps);
-  for (i = 0; i < MAX_FRINGE_BITMAPS; i++)
-    fringe_faces[i] = FRINGE_FACE_ID;
+  max_fringe_bitmaps = MAX_STANDARD_FRINGE_BITMAPS + 20;
+
+  fringe_bitmaps
+    = (struct fringe_bitmap **) xmalloc (max_fringe_bitmaps * sizeof (struct fringe_bitmap *));
+  fringe_faces
+    = (unsigned *) xmalloc (max_fringe_bitmaps * sizeof (unsigned));
+
+  for (i = 0; i < max_fringe_bitmaps; i++)
+    {
+      fringe_bitmaps[i] = NULL;
+      fringe_faces[i] = FRINGE_FACE_ID;
+    }
 }
 
 #ifdef HAVE_NTGUI
@@ -1445,6 +1444,9 @@ w32_init_fringe ()
 {
   enum fringe_bitmap_type bt;
 
+  if (!rif)
+    return;
+
   for (bt = NO_FRINGE_BITMAP + 1; bt < MAX_STANDARD_FRINGE_BITMAPS; bt++)
     {
       struct fringe_bitmap *fb = &standard_bitmaps[bt];
@@ -1458,6 +1460,9 @@ w32_reset_fringes ()
   /* Destroy row bitmaps.  */
   int bt;
 
+  if (!rif)
+    return;
+
   for (bt = NO_FRINGE_BITMAP + 1; bt < max_used_fringe_bitmap; bt++)
     rif->destroy_fringe_bitmap (bt);
 }
diff --git a/src/w32term.c b/src/w32term.c
index 50a777f2002..1d6b4ec7535 100644
--- a/src/w32term.c
+++ b/src/w32term.c
@@ -64,7 +64,8 @@ Boston, MA 02111-1307, USA.  */
 
 /* Fringe bitmaps.  */
 
-static HBITMAP fringe_bmp[MAX_FRINGE_BITMAPS];
+static int max_fringe_bmp = 0;
+static HBITMAP *fringe_bmp = 0;
 
 /* Non-nil means Emacs uses toolkit scroll bars.  */
 
@@ -731,7 +732,7 @@ w32_draw_fringe_bitmap (w, row, p)
                      p->bx, p->by, p->nx, p->ny);
     }
 
-  if (p->which)
+  if (p->which && p->which < max_fringe_bmp)
     {
       HBITMAP pixmap = fringe_bmp[p->which];
       HDC compat_hdc;
@@ -794,6 +795,15 @@ w32_define_fringe_bitmap (which, bits, h, wd)
      unsigned short *bits;
      int h, wd;
 {
+  if (which >= max_fringe_bmp)
+    {
+      int i = max_fringe_bmp;
+      max_fringe_bmp = which + 20;
+      fringe_bmp = (HBITMAP *) xrealloc (fringe_bmp, max_fringe_bmp * sizeof (HBITMAP));
+      while (i < max_fringe_bmp)
+        fringe_bmp[i++] = 0;
+    }
+
   fringe_bmp[which] = CreateBitmap (wd, h, 1, 1, bits);
 }
 
@@ -801,6 +811,9 @@ static void
 w32_destroy_fringe_bitmap (which)
      int which;
 {
+  if (which >= max_fringe_bmp)
+    return;
+
   if (fringe_bmp[which])
     DeleteObject (fringe_bmp[which]);
   fringe_bmp[which] = 0;
diff --git a/src/xdisp.c b/src/xdisp.c
index 353a72f65b6..11eab6532bb 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -308,7 +308,6 @@ 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.  */
 
@@ -3572,6 +3571,7 @@ handle_single_display_prop (it, prop, object, position,
           && CONSP (XCDR (prop)))
         {
           unsigned face_id = DEFAULT_FACE_ID;
+          int fringe_bitmap;
 
           /* Save current settings of IT so that we can restore them
              when we are finished with the glyph property value.  */
@@ -3583,8 +3583,7 @@ handle_single_display_prop (it, prop, object, position,
 #ifdef HAVE_WINDOW_SYSTEM
           value = XCAR (XCDR (prop));
           if (!SYMBOLP (value)
-              || (value = Fget (value, Qfringe),
-                  !valid_fringe_bitmap_p (value)))
+              || !(fringe_bitmap = lookup_fringe_bitmap (value)))
             return 0;
 
           if (CONSP (XCDR (XCDR (prop))))
@@ -3613,12 +3612,12 @@ handle_single_display_prop (it, prop, object, position,
 
           if (EQ (XCAR (prop), Qleft_fringe))
             {
-              it->left_user_fringe_bitmap = XINT (value);
+              it->left_user_fringe_bitmap = fringe_bitmap;
               it->left_user_fringe_face_id = face_id;
             }
           else
             {
-              it->right_user_fringe_bitmap = XINT (value);
+              it->right_user_fringe_bitmap = fringe_bitmap;
               it->right_user_fringe_face_id = face_id;
             }
 #endif /* HAVE_WINDOW_SYSTEM */