Merge from trunk.

5 files changed, 122 insertions, 52 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index 37f2e39848f..2cb49cace00 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,14 +1,4 @@
-2011-09-29  Paul Eggert  <eggert@cs.ucla.edu>
-
-        * alloc.c: Do not assume sizeof (size_t) is a multiple of 8
-        when debugging.
-        (alignof, XMALLOC_BASE_ALIGNMENT, XMALLOC_HEADER_ALIGNMENT)
-        (XMALLOC_OVERRUN_SIZE_SIZE): New macros.
-        (XMALLOC_OVERRUN_CHECK_OVERHEAD, xmalloc_put_size, xmalloc_get_size)
-        (overrun_check_malloc, overrun_check_realloc, overrun_check_free):
-        Replace uses of sizeof (size_t) with XMALLOC_OVERRUN_SIZE_SIZE.
-
-2011-09-28  Paul Eggert  <eggert@cs.ucla.edu>
+2011-09-30  Paul Eggert  <eggert@cs.ucla.edu>
 
         * alloc.c (pure_bytes_used_lisp, pure_bytes_used_non_lisp):
         (allocate_vectorlike, buffer_memory_full, struct sdata, SDATA_SIZE)
@@ -785,6 +775,57 @@
         rather than rolling our own approximation.
         (SCROLL_BAR_VEC_SIZE): Remove; not used.
 
+2011-09-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Remove dependency on glibc malloc internals.
+        * alloc.c (XMALLOC_OVERRUN_CHECK_OVERHEAD, XMALLOC_OVERRUN_CHECK_SIZE):
+        Move back here from lisp.h, but with their new implementations.
+        (XMALLOC_BASE_ALIGNMENT, COMMON_MULTIPLE, XMALLOC_HEADER_ALIGNMENT)
+        (XMALLOC_OVERRUN_SIZE_SIZE): Move these new lisp.h macros here.
+        * charset.c (charset_table_init): New static var.
+        (syms_of_charset): Use it instead of xmalloc.  This removes a
+        dependency on glibc malloc internals.  See Eli Zaretskii's comment in
+        <http://lists.gnu.org/archive/html/emacs-devel/2011-09/msg00815.html>.
+        * lisp.h (XMALLOC_OVERRUN_CHECK_OVERHEAD, XMALLOC_OVERRUN_CHECK_SIZE):
+        Move back to alloc.c.
+        (XMALLOC_BASE_ALIGNMENT, COMMON_MULTIPLE, XMALLOC_HEADER_ALIGNMENT)
+        (XMALLOC_OVERRUN_SIZE_SIZE): Move to alloc.c.
+
+2011-09-30  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * nsterm.m (windowDidResize): Call x_set_window_size only when
+        ns_in_resize is true.  Otherwise set pixelwidth/height and
+        call change_frame_size (Bug#9628).
+
+2011-09-30  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Port --enable-checking=all to Fedora 14 x86-64.
+        * charset.c (syms_of_charset): Also account for glibc malloc's
+        internal overhead when calculating the initial malloc maximum.
+
+        Port --enable-checking=all to Fedora 14 x86.
+        * alloc.c (XMALLOC_OVERRUN_CHECK_OVERHEAD, XMALLOC_OVERRUN_CHECK_SIZE):
+        Move to lisp.h.
+        (xmalloc_put_size, xmalloc_get_size, overrun_check_malloc)
+        (overrun_check_realloc, overrun_check_free):
+        Use XMALLOC_OVERRUN_SIZE_SIZE, not sizeof (size_t).
+        That way, xmalloc returns a properly-aligned pointer even if
+        XMALLOC_OVERRUN_CHECK is defined.  The old debugging code happened
+        to align OK on typical 64-bit hosts, but not on Fedora 14 x86.
+        * charset.c (syms_of_charset): Take XMALLOC_OVERRUN_CHECK_OVERHEAD
+        into account when calculating the initial malloc maximum.
+        * lisp.h (XMALLOC_OVERRUN_CHECK_OVERHEAD, XMALLOC_OVERRUN_CHECK_SIZE):
+        Move here from alloc.c, so that charset.c can use it too.
+        Properly align; the old code wasn't right for common 32-bit hosts
+        when configured with --enable-checking=all.
+        (XMALLOC_BASE_ALIGNMENT, COMMON_MULTIPLE, XMALLOC_HEADER_ALIGNMENT)
+        (XMALLOC_OVERRUN_SIZE_SIZE): New macros.
+
+2011-09-29  Eli Zaretskii  <eliz@gnu.org>
+
+        * sysdep.c (snprintf) [!EOVERFLOW]: If EOVERFLOW is not defined,
+        use EDOM.
+
 2011-09-28  Eli Zaretskii  <eliz@gnu.org>
 
         * xdisp.c (compute_display_string_end): If there's no display
@@ -803,8 +844,8 @@
         * xdisp.c (handle_invisible_prop): If invisible text ends on a
         newline, reseat the iterator instead of bidi-iterating there one
         character at a time.  (Bug#9610)
-        (BUFFER_POS_REACHED_P, move_it_in_display_line_to): Bail when past
-        TO_CHARPOS if the bidi iterator is at base embedding level.
+        (BUFFER_POS_REACHED_P, move_it_in_display_line_to): Bail out when
+        past TO_CHARPOS if the bidi iterator is at base embedding level.
 
 2011-09-27  Andreas Schwab  <schwab@linux-m68k.org>
 
@@ -841,9 +882,9 @@
         value is now t.  Doc fix.
 
         * indent.c (Fvertical_motion): Compute and apply the overshoot
-        logic when moving up, not only when moving down.  Fix the
+        logic also when moving up, not only when moving down.  Fix the
         confusing name and values of the it_overshoot_expected variable;
-        logic changes accordingly.  (Bug#9254) (Bug#9549)
+        logic changed accordingly.  (Bug#9254) (Bug#9549)
 
         * xdisp.c (pos_visible_p): Produce correct pixel coordinates when
         CHARPOS is covered by a display string which includes newlines.
@@ -859,7 +900,7 @@
 
 2011-09-24  Jim Meyering  <meyering@redhat.com>
 
-        do not ignore write error for any output size
+        Do not ignore write error for any output size.
         The previous change was incomplete.
         While it makes emacs --batch detect the vast majority of stdout
         write failures, errors were still ignored whenever the output size is
diff --git a/src/alloc.c b/src/alloc.c
index 286421ebe47..bfb40e6c09a 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -490,36 +490,45 @@ buffer_memory_full (ptrdiff_t nbytes)
 /* Check for overrun in malloc'ed buffers by wrapping a header and trailer
    around each block.
 
-   The header consists of 16 fixed bytes followed by
-   XMALLOC_OVERRUN_SIZE_SIZE bytes containing the original block size
-   in little-endian order.  The trailer consists of 16 fixed bytes.
+   The header consists of XMALLOC_OVERRUN_CHECK_SIZE fixed bytes
+   followed by XMALLOC_OVERRUN_SIZE_SIZE bytes containing the original
+   block size in little-endian order.  The trailer consists of
+   XMALLOC_OVERRUN_CHECK_SIZE fixed bytes.
 
    The header is used to detect whether this block has been allocated
-   through these functions -- as it seems that some low-level libc
-   functions may bypass the malloc hooks.
-*/
-
+   through these functions, as some low-level libc functions may
+   bypass the malloc hooks.  */
 
 #define XMALLOC_OVERRUN_CHECK_SIZE 16
 #define XMALLOC_OVERRUN_CHECK_OVERHEAD \
   (2 * XMALLOC_OVERRUN_CHECK_SIZE + XMALLOC_OVERRUN_SIZE_SIZE)
 
 /* Define XMALLOC_OVERRUN_SIZE_SIZE so that (1) it's large enough to
-   hold a size_t value and (2) so that the header size is a multiple
-   of the alignment that Emacs needs.  */
-#define alignof(type) offsetof (struct { char c; type x; }, x)
-#define XMALLOC_BASE_ALIGNMENT \
-  max (max (alignof (double), alignof (long double)), alignof (intmax_t))
+   hold a size_t value and (2) the header size is a multiple of the
+   alignment that Emacs needs for C types and for USE_LSB_TAG.  */
+#define XMALLOC_BASE_ALIGNMENT                          \
+  offsetof (                                            \
+    struct {                                            \
+      union { long double d; intmax_t i; void *p; } u;  \
+      char c;                                           \
+    },                                                  \
+    c)
 #ifdef USE_LSB_TAG
-# define XMALLOC_HEADER_ALIGNMENT max (1 << GCTYPEBITS, XMALLOC_BASE_ALIGNMENT)
+/* A common multiple of the positive integers A and B.  Ideally this
+   would be the least common multiple, but there's no way to do that
+   as a constant expression in C, so do the best that we can easily do.  */
+# define COMMON_MULTIPLE(a, b) \
+    ((a) % (b) == 0 ? (a) : (b) % (a) == 0 ? (b) : (a) * (b))
+# define XMALLOC_HEADER_ALIGNMENT \
+    COMMON_MULTIPLE (1 << GCTYPEBITS, XMALLOC_BASE_ALIGNMENT)
 #else
 # define XMALLOC_HEADER_ALIGNMENT XMALLOC_BASE_ALIGNMENT
 #endif
 #define XMALLOC_OVERRUN_SIZE_SIZE                               \
-  (((XMALLOC_OVERRUN_CHECK_SIZE + sizeof (size_t)               \
-     + XMALLOC_HEADER_ALIGNMENT - 1)                            \
-    / XMALLOC_HEADER_ALIGNMENT * XMALLOC_HEADER_ALIGNMENT)      \
-   - XMALLOC_OVERRUN_CHECK_SIZE)
+   (((XMALLOC_OVERRUN_CHECK_SIZE + sizeof (size_t)              \
+      + XMALLOC_HEADER_ALIGNMENT - 1)                           \
+     / XMALLOC_HEADER_ALIGNMENT * XMALLOC_HEADER_ALIGNMENT)     \
+    - XMALLOC_OVERRUN_CHECK_SIZE)
 
 static char const xmalloc_overrun_check_header[XMALLOC_OVERRUN_CHECK_SIZE] =
   { '\x9a', '\x9b', '\xae', '\xaf',
diff --git a/src/charset.c b/src/charset.c
index 2451c55e92a..299655b2cf8 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -1154,10 +1154,10 @@ usage: (define-charset-internal ...)  */)
                      sizeof *charset_table);
           memcpy (new_table, charset_table, old_size * sizeof *new_table);
           charset_table = new_table;
-          /* FIXME: Doesn't this leak memory?  The old charset_table becomes
-             unreachable.  It could be that this is intentional, because the
-             old charset table may be in a dumped emacs, and reallocating such
-             a table may not work.  If the memory leak is intentional, a
+          /* FIXME: This leaks memory, as the old charset_table becomes
+             unreachable.  If the old charset table is charset_table_init
+             then this leak is intentional; otherwise, it's unclear.
+             If the latter memory leak is intentional, a
              comment should be added to explain this.  If not, the old
              charset_table should be freed, by passing it as the 1st argument
              to xpalloc and removing the memcpy.  */
@@ -2318,20 +2318,21 @@ init_charset_once (void)
 
 #ifdef emacs
 
+/* Allocate an initial charset table that is large enough to handle
+   Emacs while it is bootstrapping.  As of September 2011, the size
+   needs to be at least 166; make it a bit bigger to allow for future
+   expansion.
+
+   Don't make the value so small that the table is reallocated during
+   bootstrapping, as glibc malloc calls larger than just under 64 KiB
+   during an initial bootstrap wreak havoc after dumping; see the
+   M_MMAP_THRESHOLD value in alloc.c, plus there is a extra overhead
+   internal to glibc malloc and perhaps to Emacs malloc debugging.  */
+static struct charset charset_table_init[180];
+
 void
 syms_of_charset (void)
 {
-  /* Allocate an initial charset table that is just under 64 KiB in size.
-     This should be large enough so that the charset table need not be
-     reallocated during an initial bootstrap.  Allocating anything larger than
-     64 KiB in an initial run may not work, because glibc malloc might use
-     mmap for larger allocations, and these don't work well across dumped
-     systems.  */
-  enum {
-    initial_malloc_max = (1 << 16) - 1,
-    charset_table_size_init = initial_malloc_max / sizeof (struct charset)
-  };
-
   DEFSYM (Qcharsetp, "charsetp");
 
   DEFSYM (Qascii, "ascii");
@@ -2364,9 +2365,8 @@ syms_of_charset (void)
     Vcharset_hash_table = Fmake_hash_table (2, args);
   }
 
-  charset_table = (struct charset *) xmalloc (sizeof (struct charset)
-                                              * charset_table_size_init);
-  charset_table_size = charset_table_size_init;
+  charset_table = charset_table_init;
+  charset_table_size = sizeof charset_table_init / sizeof *charset_table_init;
   charset_table_used = 0;
 
   defsubr (&Scharsetp);
diff --git a/src/nsterm.m b/src/nsterm.m
index 827404a2974..a2ae5e69512 100644
--- a/src/nsterm.m
+++ b/src/nsterm.m
@@ -5357,7 +5357,23 @@ ns_term_shutdown (int sig)
      a "windowDidResize" which calls x_set_window_size).  */
 #ifndef NS_IMPL_GNUSTEP
   if (cols > 0 && rows > 0)
-    x_set_window_size (emacsframe, 0, cols, rows);
+    {
+      if (ns_in_resize)
+        x_set_window_size (emacsframe, 0, cols, rows);
+      else
+        {
+          NSWindow *window = [self window];
+          NSRect wr = [window frame];
+          FRAME_PIXEL_WIDTH (emacsframe) = (int)wr.size.width
+            - emacsframe->border_width;
+          FRAME_PIXEL_HEIGHT (emacsframe) = (int)wr.size.height
+            - FRAME_NS_TITLEBAR_HEIGHT (emacsframe)
+            - FRAME_TOOLBAR_HEIGHT (emacsframe);
+          change_frame_size (emacsframe, rows, cols, 0, 0, 1);
+          SET_FRAME_GARBAGED (emacsframe);
+          cancel_mouse_face (emacsframe);
+        }
+    }
 #endif
 
   ns_send_appdefined (-1);
diff --git a/src/sysdep.c b/src/sysdep.c
index ba296a2d094..d2ce5a8cc1b 100644
--- a/src/sysdep.c
+++ b/src/sysdep.c
@@ -1844,7 +1844,11 @@ snprintf (char *buf, size_t bufsize, char const *format, ...)
 
   if (INT_MAX < nbytes)
     {
+#ifdef EOVERFLOW
       errno = EOVERFLOW;
+#else
+      errno = EDOM;
+#endif
       return -1;
     }
   return nbytes;