13 files changed, 124 insertions, 89 deletions

diff --git a/etc/NEWS b/etc/NEWS
index 186dca19495..56a0c9bf95d 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -47,6 +47,8 @@ prompts for a column number.
 ** `C-M-f' and `C-M-b' will now move to the path name separator
 character when doing minibuffer filename prompts.
 
+** `goto-char' is now bound to `M-g c'.
+
 
 * Changes in Specialized Modes and Packages in Emacs 24.2
 
diff --git a/lib-src/ChangeLog b/lib-src/ChangeLog
index ac3e0a612e2..ea5f5a26627 100644
--- a/lib-src/ChangeLog
+++ b/lib-src/ChangeLog
@@ -1,3 +1,10 @@
+2012-04-16  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Assume less-ancient POSIX support.
+        * update-game-score.c: Include <getopt.h> rather than rolling our
+        own decls for optarg, optind, opterr.  See
+        <http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html>.
+
 2012-04-14  Juanma Barranquero  <lekktu@gmail.com>
 
         * emacsclient.c (decode_options) [WINDOWSNT]:
diff --git a/lib-src/update-game-score.c b/lib-src/update-game-score.c
index a32bd6d8d78..e0c940510be 100644
--- a/lib-src/update-game-score.c
+++ b/lib-src/update-game-score.c
@@ -46,10 +46,7 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #include <fcntl.h>
 #endif
 #include <sys/stat.h>
-
-/* Needed for SunOS4, for instance.  */
-extern char *optarg;
-extern int optind, opterr;
+#include <getopt.h>
 
 static int usage (int err) NO_RETURN;
 
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index b2a3f135109..a21d5841346 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,13 @@
+2012-04-15  Chong Yidong  <cyd@gnu.org>
+
+        * frame.el (scrolling): Remove nearly unused customization group.
+
+        * scroll-all.el (scroll-all-mode): Move to windows group.
+
+2012-04-15  Chong Yidong  <cyd@gnu.org>
+
+        * bindings.el (goto-map): Bind goto-char to M-g c (Bug#11240).
+
 2012-04-15  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         Avoid the use of ((lambda ...) ...) in lexical-binding code.
diff --git a/lisp/bindings.el b/lisp/bindings.el
index a87f321c936..8cfeecf5b40 100644
--- a/lisp/bindings.el
+++ b/lisp/bindings.el
@@ -868,6 +868,7 @@ if `inhibit-field-text-motion' is non-nil."
   "Keymap for navigation commands.")
 (define-key esc-map "g" goto-map)
 
+(define-key goto-map    "c" 'goto-char)
 (define-key goto-map    "g" 'goto-line)
 (define-key goto-map "\M-g" 'goto-line)
 (define-key goto-map    "n" 'next-error)
diff --git a/lisp/frame.el b/lisp/frame.el
index 1cd6c0cf181..79e1243c7af 100644
--- a/lisp/frame.el
+++ b/lisp/frame.el
@@ -1557,21 +1557,6 @@ left untouched.  FRAME nil or omitted means use the selected frame."
     'delete-frame-functions "22.1")
 
 
-;; Highlighting trailing whitespace.
-
-(make-variable-buffer-local 'show-trailing-whitespace)
-
-
-;; Scrolling
-
-(defgroup scrolling nil
-  "Scrolling windows."
-  :version "21.1"
-  :group 'frames)
-
-(defvaralias 'automatic-hscrolling 'auto-hscroll-mode)
-
-
 ;; Blinking cursor
 
 (defgroup cursor nil
@@ -1663,6 +1648,13 @@ terminals, cursor blinking is controlled by the terminal."
 (define-key ctl-x-5-map "0" 'delete-frame)
 (define-key ctl-x-5-map "o" 'other-frame)
 
+
+;; Misc.
+
+(defvaralias 'automatic-hscrolling 'auto-hscroll-mode)
+
+(make-variable-buffer-local 'show-trailing-whitespace)
+
 (provide 'frame)
 
 ;;; frame.el ends here
diff --git a/lisp/scroll-all.el b/lisp/scroll-all.el
index 9ff0a61db2f..fed886c2b55 100644
--- a/lisp/scroll-all.el
+++ b/lisp/scroll-all.el
@@ -111,7 +111,6 @@ one window apply to all visible windows in the same frame."
   nil " *SL*" nil
   :global t
   :group 'windows
-  :group 'scrolling
   (if scroll-all-mode
       (add-hook 'post-command-hook 'scroll-all-check-to-scroll)
     (remove-hook 'post-command-hook 'scroll-all-check-to-scroll)))
diff --git a/lisp/window.el b/lisp/window.el
index ca2cc9e7950..934b6067d08 100644
--- a/lisp/window.el
+++ b/lisp/window.el
@@ -5443,7 +5443,7 @@ A value of t means point moves to the beginning or the end of the buffer
 \(depending on scrolling direction) when no more scrolling possible.
 When point is already on that position, then signal an error."
   :type 'boolean
-  :group 'scrolling
+  :group 'windows
   :version "24.1")
 
 (defun scroll-up-command (&optional arg)
diff --git a/src/ChangeLog b/src/ChangeLog
index c58b87c7705..0fa21336900 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,29 @@
+2012-04-16  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Improve ralloc.c interface checking.
+        See http://lists.gnu.org/archive/html/emacs-devel/2011-12/msg00720.html
+        * buffer.c (ralloc_reset_variable, r_alloc, r_re_alloc)
+        (r_alloc_free) [REL_ALLOC]: Move decls from here ...
+        * lisp.h (r_alloc, r_alloc_free, r_re_alloc, r_alloc_reset_variable)
+        [REL_ALLOC]: ... to here, to check interface.
+        * m/ia64.h (r_alloc, r_alloc_free) [REL_ALLOC && !_MALLOC_INTERNAL]:
+        Remove decls.  This fixes an "It stinks!".
+
+        * alloc.c (which_symbols): Fix alignment issue / type clash.
+
+2012-04-15  Andreas Schwab  <schwab@linux-m68k.org>
+
+        * lisp.h (struct Lisp_Symbol): Remove explicit padding.
+        (struct Lisp_Misc_Any): Likewise.
+        (struct Lisp_Free): Likewise.
+        * alloc.c (union aligned_Lisp_Symbol): Define.
+        (SYMBOL_BLOCK_SIZE, struct symbol_block): Use union
+        aligned_Lisp_Symbol instead of struct Lisp_Symbol.
+        (union aligned_Lisp_Misc): Define.
+        (MARKER_BLOCK_SIZE, struct marker_block): Use union
+        aligned_Lisp_Misc instead of union Lisp_Misc.
+        (Fmake_symbol, allocate_misc, gc_sweep): Adjust
+
 2012-04-14  Paul Eggert  <eggert@cs.ucla.edu>
 
         Make GC_MAKE_GCPROS_NOOPS the default (Bug#9926).
diff --git a/src/alloc.c b/src/alloc.c
index 314438ba9f1..0e68817629c 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -3136,17 +3136,29 @@ usage: (make-byte-code ARGLIST BYTE-CODE CONSTANTS DEPTH &optional DOCSTRING INT
                            Symbol Allocation
  ***********************************************************************/
 
+/* Like struct Lisp_Symbol, but padded so that the size is a multiple
+   of the required alignment if LSB tags are used.  */
+
+union aligned_Lisp_Symbol
+{
+  struct Lisp_Symbol s;
+#ifdef USE_LSB_TAG
+  unsigned char c[(sizeof (struct Lisp_Symbol) + (1 << GCTYPEBITS) - 1)
+                  & -(1 << GCTYPEBITS)];
+#endif
+};
+
 /* Each symbol_block is just under 1020 bytes long, since malloc
    really allocates in units of powers of two and uses 4 bytes for its
    own overhead. */
 
 #define SYMBOL_BLOCK_SIZE \
-  ((1020 - sizeof (struct symbol_block *)) / sizeof (struct Lisp_Symbol))
+  ((1020 - sizeof (struct symbol_block *)) / sizeof (union aligned_Lisp_Symbol))
 
 struct symbol_block
 {
   /* Place `symbols' first, to preserve alignment.  */
-  struct Lisp_Symbol symbols[SYMBOL_BLOCK_SIZE];
+  union aligned_Lisp_Symbol symbols[SYMBOL_BLOCK_SIZE];
   struct symbol_block *next;
 };
 
@@ -3202,7 +3214,7 @@ Its value and function definition are void, and its property list is nil.  */)
           symbol_block = new;
           symbol_block_index = 0;
         }
-      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index]);
+      XSETSYMBOL (val, &symbol_block->symbols[symbol_block_index].s);
       symbol_block_index++;
     }
 
@@ -3230,16 +3242,28 @@ Its value and function definition are void, and its property list is nil.  */)
                        Marker (Misc) Allocation
  ***********************************************************************/
 
+/* Like union Lisp_Misc, but padded so that its size is a multiple of
+   the required alignment when LSB tags are used.  */
+
+union aligned_Lisp_Misc
+{
+  union Lisp_Misc m;
+#ifdef USE_LSB_TAG
+  unsigned char c[(sizeof (union Lisp_Misc) + (1 << GCTYPEBITS) - 1)
+                  & -(1 << GCTYPEBITS)];
+#endif
+};
+
 /* Allocation of markers and other objects that share that structure.
    Works like allocation of conses. */
 
 #define MARKER_BLOCK_SIZE \
-  ((1020 - sizeof (struct marker_block *)) / sizeof (union Lisp_Misc))
+  ((1020 - sizeof (struct marker_block *)) / sizeof (union aligned_Lisp_Misc))
 
 struct marker_block
 {
   /* Place `markers' first, to preserve alignment.  */
-  union Lisp_Misc markers[MARKER_BLOCK_SIZE];
+  union aligned_Lisp_Misc markers[MARKER_BLOCK_SIZE];
   struct marker_block *next;
 };
 
@@ -3284,7 +3308,7 @@ allocate_misc (void)
           marker_block_index = 0;
           total_free_markers += MARKER_BLOCK_SIZE;
         }
-      XSETMISC (val, &marker_block->markers[marker_block_index]);
+      XSETMISC (val, &marker_block->markers[marker_block_index].m);
       marker_block_index++;
     }
 
@@ -6070,22 +6094,22 @@ gc_sweep (void)
     for (sblk = symbol_block; sblk; sblk = *sprev)
       {
         int this_free = 0;
-        struct Lisp_Symbol *sym = sblk->symbols;
-        struct Lisp_Symbol *end = sym + lim;
+        union aligned_Lisp_Symbol *sym = sblk->symbols;
+        union aligned_Lisp_Symbol *end = sym + lim;
 
         for (; sym < end; ++sym)
           {
             /* Check if the symbol was created during loadup.  In such a case
                it might be pointed to by pure bytecode which we don't trace,
                so we conservatively assume that it is live.  */
-            int pure_p = PURE_POINTER_P (XSTRING (sym->xname));
+            int pure_p = PURE_POINTER_P (XSTRING (sym->s.xname));
 
-            if (!sym->gcmarkbit && !pure_p)
+            if (!sym->s.gcmarkbit && !pure_p)
               {
-                if (sym->redirect == SYMBOL_LOCALIZED)
-                  xfree (SYMBOL_BLV (sym));
-                sym->next = symbol_free_list;
-                symbol_free_list = sym;
+                if (sym->s.redirect == SYMBOL_LOCALIZED)
+                  xfree (SYMBOL_BLV (&sym->s));
+                sym->s.next = symbol_free_list;
+                symbol_free_list = &sym->s;
 #if GC_MARK_STACK
                 symbol_free_list->function = Vdead;
 #endif
@@ -6095,8 +6119,8 @@ gc_sweep (void)
               {
                 ++num_used;
                 if (!pure_p)
-                  UNMARK_STRING (XSTRING (sym->xname));
-                sym->gcmarkbit = 0;
+                  UNMARK_STRING (XSTRING (sym->s.xname));
+                sym->s.gcmarkbit = 0;
               }
           }
 
@@ -6108,7 +6132,7 @@ gc_sweep (void)
           {
             *sprev = sblk->next;
             /* Unhook from the free list.  */
-            symbol_free_list = sblk->symbols[0].next;
+            symbol_free_list = sblk->symbols[0].s.next;
             lisp_free (sblk);
           }
         else
@@ -6138,22 +6162,22 @@ gc_sweep (void)
 
         for (i = 0; i < lim; i++)
           {
-            if (!mblk->markers[i].u_any.gcmarkbit)
+            if (!mblk->markers[i].m.u_any.gcmarkbit)
               {
-                if (mblk->markers[i].u_any.type == Lisp_Misc_Marker)
-                  unchain_marker (&mblk->markers[i].u_marker);
+                if (mblk->markers[i].m.u_any.type == Lisp_Misc_Marker)
+                  unchain_marker (&mblk->markers[i].m.u_marker);
                 /* Set the type of the freed object to Lisp_Misc_Free.
                    We could leave the type alone, since nobody checks it,
                    but this might catch bugs faster.  */
-                mblk->markers[i].u_marker.type = Lisp_Misc_Free;
-                mblk->markers[i].u_free.chain = marker_free_list;
-                marker_free_list = &mblk->markers[i];
+                mblk->markers[i].m.u_marker.type = Lisp_Misc_Free;
+                mblk->markers[i].m.u_free.chain = marker_free_list;
+                marker_free_list = &mblk->markers[i].m;
                 this_free++;
               }
             else
               {
                 num_used++;
-                mblk->markers[i].u_any.gcmarkbit = 0;
+                mblk->markers[i].m.u_any.gcmarkbit = 0;
               }
           }
         lim = MARKER_BLOCK_SIZE;
@@ -6164,7 +6188,7 @@ gc_sweep (void)
           {
             *mprev = mblk->next;
             /* Unhook from the free list.  */
-            marker_free_list = mblk->markers[0].u_free.chain;
+            marker_free_list = mblk->markers[0].m.u_free.chain;
             lisp_free (mblk);
           }
         else
@@ -6296,11 +6320,12 @@ which_symbols (Lisp_Object obj, EMACS_INT find_max)
      {
        for (sblk = symbol_block; sblk; sblk = sblk->next)
          {
-           struct Lisp_Symbol *sym = sblk->symbols;
+           union aligned_Lisp_Symbol *aligned_sym = sblk->symbols;
            int bn;
 
-           for (bn = 0; bn < SYMBOL_BLOCK_SIZE; bn++, sym++)
+           for (bn = 0; bn < SYMBOL_BLOCK_SIZE; bn++, aligned_sym++)
              {
+               struct Lisp_Symbol *sym = &aligned_sym->s;
                Lisp_Object val;
                Lisp_Object tem;
 
diff --git a/src/buffer.c b/src/buffer.c
index ca8d1ec5db3..9bac3ec742b 100644
--- a/src/buffer.c
+++ b/src/buffer.c
@@ -2006,10 +2006,6 @@ advance_to_char_boundary (EMACS_INT byte_pos)
   return byte_pos;
 }
 
-#ifdef REL_ALLOC
-extern void r_alloc_reset_variable (POINTER_TYPE *, POINTER_TYPE *);
-#endif /* REL_ALLOC */
-
 DEFUN ("buffer-swap-text", Fbuffer_swap_text, Sbuffer_swap_text,
        1, 1, 0,
        doc: /* Swap the text between current buffer and BUFFER.  */)
@@ -4771,13 +4767,6 @@ mmap_realloc (POINTER_TYPE **var, size_t nbytes)
                             Buffer-text Allocation
  ***********************************************************************/
 
-#ifdef REL_ALLOC
-extern POINTER_TYPE *r_alloc (POINTER_TYPE **, size_t);
-extern POINTER_TYPE *r_re_alloc (POINTER_TYPE **, size_t);
-extern void r_alloc_free (POINTER_TYPE **ptr);
-#endif /* REL_ALLOC */
-
-
 /* Allocate NBYTES bytes for buffer B's text buffer.  */
 
 static void
diff --git a/src/lisp.h b/src/lisp.h
index 0d66f57fdb1..37fa81b63f6 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1138,8 +1138,6 @@ struct Lisp_Symbol
      special (with `defvar' etc), and shouldn't be lexically bound.  */
   unsigned declared_special : 1;
 
-  unsigned spacer : 23;
-
   /* The symbol's name, as a Lisp string.
      The name "xname" is used to intentionally break code referring to
      the old field "name" of type pointer to struct Lisp_String.  */
@@ -1341,8 +1339,6 @@ struct Lisp_Misc_Any		/* Supertype of all Misc types.  */
   ENUM_BF (Lisp_Misc_Type) type : 16;           /* = Lisp_Misc_??? */
   unsigned gcmarkbit : 1;
   int spacer : 15;
-  /* Make it as long as "Lisp_Free without padding".  */
-  void *fill;
 };
 
 struct Lisp_Marker
@@ -1534,13 +1530,6 @@ struct Lisp_Free
     unsigned gcmarkbit : 1;
     int spacer : 15;
     union Lisp_Misc *chain;
-#ifdef USE_LSB_TAG
-    /* Try to make sure that sizeof(Lisp_Misc) preserves TYPEBITS-alignment.
-       This assumes that Lisp_Marker is the largest of the alternatives and
-       that Lisp_Misc_Any has the same size as "Lisp_Free w/o padding".  */
-    char padding[((((sizeof (struct Lisp_Marker) - 1) >> GCTYPEBITS) + 1)
-                  << GCTYPEBITS) - sizeof (struct Lisp_Misc_Any)];
-#endif
   };
 
 /* To get the type field of a union Lisp_Misc, use XMISCTYPE.
@@ -1549,19 +1538,19 @@ struct Lisp_Free
 union Lisp_Misc
   {
     struct Lisp_Misc_Any u_any;    /* Supertype of all Misc types.  */
-    struct Lisp_Free u_free;       /* Includes padding to force alignment.  */
-    struct Lisp_Marker u_marker;                         /* 5 */
-    struct Lisp_Overlay u_overlay;                       /* 5 */
-    struct Lisp_Save_Value u_save_value;                 /* 3 */
+    struct Lisp_Free u_free;
+    struct Lisp_Marker u_marker;
+    struct Lisp_Overlay u_overlay;
+    struct Lisp_Save_Value u_save_value;
   };
 
 union Lisp_Fwd
   {
-    struct Lisp_Intfwd u_intfwd;                         /* 2 */
-    struct Lisp_Boolfwd u_boolfwd;                       /* 2 */
-    struct Lisp_Objfwd u_objfwd;                         /* 2 */
-    struct Lisp_Buffer_Objfwd u_buffer_objfwd;           /* 2 */
-    struct Lisp_Kboard_Objfwd u_kboard_objfwd;           /* 2 */
+    struct Lisp_Intfwd u_intfwd;
+    struct Lisp_Boolfwd u_boolfwd;
+    struct Lisp_Objfwd u_objfwd;
+    struct Lisp_Buffer_Objfwd u_buffer_objfwd;
+    struct Lisp_Kboard_Objfwd u_kboard_objfwd;
   };
 
 /* Lisp floating point type */
@@ -2847,6 +2836,14 @@ extern void syms_of_alloc (void);
 extern struct buffer * allocate_buffer (void);
 extern int valid_lisp_object_p (Lisp_Object);
 
+#ifdef REL_ALLOC
+/* Defined in ralloc.c */
+extern void *r_alloc (void **, size_t);
+extern void r_alloc_free (void **);
+extern void *r_re_alloc (void **, size_t);
+extern void r_alloc_reset_variable (void **, void **);
+#endif
+
 /* Defined in chartab.c */
 EXFUN (Fmake_char_table, 2);
 EXFUN (Fset_char_table_parent, 2);
diff --git a/src/m/ia64.h b/src/m/ia64.h
index 2ddc2fdfb17..47df94cedd0 100644
--- a/src/m/ia64.h
+++ b/src/m/ia64.h
@@ -30,13 +30,3 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 #define EMACS_INT               long
 #define pI                      "l"
 #define EMACS_UINT              unsigned long
-
-#ifdef REL_ALLOC
-#ifndef _MALLOC_INTERNAL
-/* "char *" because ralloc.c defines it that way.  gmalloc.c thinks it
-   is allowed to prototype these as "void *" so we don't prototype in
-   that case.  You're right: it stinks!  */
-extern char *r_alloc (), *r_re_alloc ();
-extern void r_alloc_free ();
-#endif /* not _MALLOC_INTERNAL */
-#endif /* REL_ALLOC */