(current_minor_maps): Fixed resizing of cmm_maps;

only update cmm_size if realloc actually succeeds.
Testing with initial size of 2 elements revealed that using
realloc on GNU/Linux would cause a random trap in xmalloc
later on, so I rewrote the code to use malloc/bcopy/free instead
of realloc.

diff --git a/src/keymap.c b/src/keymap.c
index 60d1b41d2c46e40861e283731d9afb9483fd61da..a119a2fa49d1d7f3eac29db309a9b1e7483b3a3f 100644 (file)
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -1248,8 +1248,8 @@ silly_event_symbol_error (c)
 /* We can't put these variables inside current_minor_maps, since under
    some systems, static gets macro-defined to be the empty string.
    Ickypoo.  */
-static Lisp_Object *cmm_modes, *cmm_maps;
-static int cmm_size;
+static Lisp_Object *cmm_modes = NULL, *cmm_maps = NULL;
+static int cmm_size = 0;
 
 /* Error handler used in current_minor_maps.  */
 static Lisp_Object
@@ -1321,40 +1321,41 @@ current_minor_maps (modeptr, mapptr)
 
            if (i >= cmm_size)
              {
+               int newsize, allocsize;
                Lisp_Object *newmodes, *newmaps;
 
-               /* Use malloc/realloc here.  See the comment above
-                  this function.  */
-               if (cmm_maps)
-                 {
-                   BLOCK_INPUT;
-                   cmm_size *= 2;
-                   newmodes
-                     = (Lisp_Object *) realloc (cmm_modes,
-                                                cmm_size * sizeof *newmodes);
-                   newmaps
-                     = (Lisp_Object *) realloc (cmm_maps,
-                                                cmm_size * sizeof *newmaps);
-                   UNBLOCK_INPUT;
-                 }
-               else
+               newsize = cmm_size == 0 ? 30 : cmm_size * 2;
+               allocsize = newsize * sizeof *newmodes;
+
+               /* Use malloc here.  See the comment above this function. 
+                  Avoid realloc here; it causes spurious traps on GNU/Linux [KFS] */
+               BLOCK_INPUT;
+               newmodes = (Lisp_Object *) malloc (allocsize);
+               if (newmodes)
                  {
-                   BLOCK_INPUT;
-                   cmm_size = 30;
-                   newmodes
-                     = (Lisp_Object *) malloc (cmm_size * sizeof *newmodes);
-                   newmaps
-                     = (Lisp_Object *) malloc (cmm_size * sizeof *newmaps);
-                   UNBLOCK_INPUT;
+                   if (cmm_modes)
+                     {
+                       bcopy (cmm_modes, newmodes, cmm_size * sizeof cmm_modes[0]);
+                       free (cmm_modes);
+                     }
+                   cmm_modes = newmodes;
                  }
 
-               if (newmodes)
-                 cmm_modes = newmodes;
+               newmaps = (Lisp_Object *) malloc (allocsize);
                if (newmaps)
-                 cmm_maps = newmaps;
+                 {
+                   if (cmm_maps)
+                     {
+                       bcopy (cmm_maps, newmaps, cmm_size * sizeof cmm_maps[0]);
+                       free (cmm_maps);
+                     }
+                   cmm_maps = newmaps;
+                 }
+               UNBLOCK_INPUT;
              
                if (newmodes == NULL || newmaps == NULL)
                  break;
+               cmm_size = newsize;
              }
 
            /* Get the keymap definition--or nil if it is not defined.  */