auto upstream

25 files changed, 287 insertions, 127 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 5c7e8c3e6a8..d4a81bffd9c 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,13 @@
+2013-01-14  Leo Liu  <sdl.web@gmail.com>
+
+        * calendar/calendar.el (calendar-redraw): Sync window-point and point.
+        (Bug#13420)
+
+2013-01-14  Glenn Morris  <rgm@gnu.org>
+
+        * progmodes/compile.el (compilation-error-regexp-alist-alist):
+        Fix interpretation of gnu line.col1-col2 format.  (Bug#13335)
+
 2013-01-13  Fabián Ezequiel Gallina  <fgallina@cuca>
 
         * progmodes/python.el (python-nav-end-of-statement): Fix
diff --git a/lisp/calendar/calendar.el b/lisp/calendar/calendar.el
index 9b0eb3e9bff..74d3ce80338 100644
--- a/lisp/calendar/calendar.el
+++ b/lisp/calendar/calendar.el
@@ -1562,11 +1562,13 @@ line."
 (defun calendar-redraw ()
   "Redraw the calendar display, if `calendar-buffer' is live."
   (interactive)
-  (if (get-buffer calendar-buffer)
-      (with-current-buffer calendar-buffer
-        (let ((cursor-date (calendar-cursor-to-nearest-date)))
-          (calendar-generate-window displayed-month displayed-year)
-          (calendar-cursor-to-visible-date cursor-date)))))
+  (when (get-buffer calendar-buffer)
+    (with-current-buffer calendar-buffer
+      (let ((cursor-date (calendar-cursor-to-nearest-date)))
+        (calendar-generate-window displayed-month displayed-year)
+        (calendar-cursor-to-visible-date cursor-date))
+      (when (window-live-p (get-buffer-window))
+        (set-window-point (get-buffer-window) (point))))))
 
 (defvar calendar-mode-map
   (let ((map (make-keymap)))
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 1524f000450..2b09a1f456c 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,8 @@
+2013-01-14  Julien Danjou  <julien@danjou.info>
+
+        * gnus-sum.el (gnus-summary-from-or-to-or-newsgroups): Compare
+        addresses against addresses, not against the full From field.
+
 2013-01-13  Richard Stallman  <rms@gnu.org>
 
         * message.el (message-forward-make-body-mime): New args BEG, END
@@ -7,10 +12,10 @@
 2013-01-11  Aaron S. Hawley  <Aaron.Hawley@vtinfo.com>
 
         * gnus-start.el (gnus-check-new-newsgroups): Fix ambiguous doc string
-         cross-reference(s).
+        cross-reference(s).
 
         * gnus-sum.el (gnus-summary-newsgroup-prefix): Fix ambiguous doc string
-         cross-reference(s).
+        cross-reference(s).
 
 2013-01-11  Dmitry Antipov  <dmantipov@yandex.ru>
 
diff --git a/lisp/gnus/gnus-sum.el b/lisp/gnus/gnus-sum.el
index 14597f031e1..ea68a6a2fa5 100644
--- a/lisp/gnus/gnus-sum.el
+++ b/lisp/gnus/gnus-sum.el
@@ -3651,17 +3651,18 @@ buffer that was in action when the last article was fetched."
   (or (car (funcall gnus-extract-address-components from))
       from))
 
-(defun gnus-summary-from-or-to-or-newsgroups (header gnus-tmp-from)
+(defun gnus-summary-from-or-to-or-newsgroups (header from)
   (let ((mail-parse-charset gnus-newsgroup-charset)
-        (ignored-from-addresses (gnus-ignored-from-addresses))
-        ; Is it really necessary to do this next part for each summary line?
-        ; Luckily, doesn't seem to slow things down much.
-        (mail-parse-ignored-charsets
-         (with-current-buffer gnus-summary-buffer
-           gnus-newsgroup-ignored-charsets)))
+        (ignored-from-addresses (gnus-ignored-from-addresses))
+        ;; Is it really necessary to do this next part for each summary line?
+        ;; Luckily, doesn't seem to slow things down much.
+        (mail-parse-ignored-charsets
+         (with-current-buffer gnus-summary-buffer
+           gnus-newsgroup-ignored-charsets))
+        (address (cadr (gnus-extract-address-components from))))
     (or
      (and ignored-from-addresses
-          (string-match ignored-from-addresses gnus-tmp-from)
+          (string-match ignored-from-addresses address)
           (let ((extra-headers (mail-header-extra header))
                 to
                 newsgroups)
@@ -3680,9 +3681,7 @@ buffer that was in action when the last article was fetched."
                                 gnus-newsgroup-name)) 'nntp)
                       (gnus-group-real-name gnus-newsgroup-name))))
               (concat gnus-summary-newsgroup-prefix newsgroups)))))
-     (gnus-string-mark-left-to-right
-      (inline
-       (gnus-summary-extract-address-component gnus-tmp-from))))))
+     (gnus-string-mark-left-to-right (gnus-summary-extract-address-component from)))))
 
 (defun gnus-summary-insert-line (gnus-tmp-header
                                  gnus-tmp-level gnus-tmp-current
diff --git a/lisp/progmodes/compile.el b/lisp/progmodes/compile.el
index 4e1cd4a24e3..eb73b77bf52 100644
--- a/lisp/progmodes/compile.el
+++ b/lisp/progmodes/compile.el
@@ -134,6 +134,7 @@ and a string describing how the process finished.")
 
 ;; If you make any changes to `compilation-error-regexp-alist-alist',
 ;; be sure to run the ERT test in test/automated/compile-tests.el.
+;; emacs -batch -l compile-tests.el -f ert-run-tests-batch-and-exit
 
 (defvar compilation-error-regexp-alist-alist
   '((absoft
@@ -261,11 +262,11 @@ of[ \t]+\"?\\([a-zA-Z]?:?[^\":\n]+\\)\"?:" 3 2 nil (1))
      ;; The "in \\|from " exception was added to handle messages from Ruby.
      "^\\(?:[[:alpha:]][-[:alnum:].]+: ?\\|[ \t]+\\(?:in \\|from \\)\\)?\
 \\([0-9]*[^0-9\n]\\(?:[^\n :]\\| [^-/\n]\\|:[^ \n]\\)*?\\): ?\
-\\([0-9]+\\)\\(?:[.:]\\([0-9]+\\)\\)?\
-\\(?:-\\([0-9]+\\)?\\(?:\\.\\([0-9]+\\)\\)?\\)?:\
+\\([0-9]+\\)\\(?:-\\(?4:[0-9]+\\)\\(?:\\.\\(?5:[0-9]+\\)\\)?\
+\\|[.:]\\(?3:[0-9]+\\)\\(?:-\\(?:\\(?4:[0-9]+\\)\\.\\)?\\(?5:[0-9]+\\)\\)?\\)?:\
 \\(?: *\\(\\(?:Future\\|Runtime\\)?[Ww]arning\\|W:\\)\\|\
  *\\([Ii]nfo\\(?:\\>\\|rmationa?l?\\)\\|I:\\|instantiated from\\|[Nn]ote\\)\\|\
- *[Ee]rror\\|\[0-9]?\\(?:[^0-9\n]\\|$\\)\\|[0-9][0-9][0-9]\\)"
+ *[Ee]rror\\|[0-9]?\\(?:[^0-9\n]\\|$\\)\\|[0-9][0-9][0-9]\\)"
      1 (2 . 4) (3 . 5) (6 . 7))
 
     (lcc
diff --git a/src/ChangeLog b/src/ChangeLog
index 9096b904171..80f5875ef16 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,48 @@
+2013-01-14  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Avoid needless casts with XSAVE_POINTER.
+        * alloc.c (mark_object) [GC_MARK_STACK]:
+        * dired.c (directory_files_internal_unwind):
+        * fileio.c (do_auto_save_unwind):
+        * gtkutil.c (pop_down_dialog):
+        * keymap.c (map_keymap_char_table_item):
+        * lread.c (load_unwind):
+        * nsmenu.m (pop_down_menu):
+        * print.c (print_object) [GC_MARK_STACK]:
+        * xfns.c (clean_up_file_dialog):
+        * xmenu.c (cleanup_widget_value_tree):
+        Omit casts between XSAVE_POINTER and a pointer type.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Fix compilation with GC_MARK_STACK == GC_USE_GCPROS_AS_BEFORE.
+        * eval.c (eval_sub): Protect `form' from being GCed before its
+        car and cdr becomes protected with the backtrace entry.
+
+2013-01-14  Dmitry Antipov  <dmantipov@yandex.ru>
+
+        Make Lisp_Save_Value more versatile storage for up to four objects.
+        * lisp.h (toplevel): Enumeration to describe types of saved objects.
+        (struct Lisp_Save_Value): New layout.  Adjust comments.
+        (XSAVE_POINTER): New macro.
+        (XSAVE_INTEGER): Likewise.
+        (allocate_misc): Add prototype.
+        (free_misc): Likewise.
+        * alloc.c (allocate_misc): Now global.
+        (free_misc): Likewise.  Adjust comment.
+        (make_save_value): Use new Lisp_Save_Value layout.  Adjust comment.
+        (free_save_value): Likewise.
+        (mark_object): Likewise.
+        * editfns.c (save_excursion_save): Pack everything within
+        Lisp_Save_Value and so avoid xmalloc.
+        (save_excursion_restore): Adjust to match new layout.  Use free_misc
+        because we do not allocate extra memory any more.  Add eassert.
+        * print.c (print_object): New code to print Lisp_Save_Value.  Do not
+        rely on valid_lisp_object_p if !GC_MARK_STACK.  Adjust comments.
+        * dired.c, fileio.c, font.c, ftfont.c, gtkutil.c, keymap.c,
+        * lread.c, nsmenu.m, nsterm.h, xfns.c, xmenu.c, xselect.c:
+        Use XSAVE_POINTER and XSAVE_INTEGER where appropriate.
+
 2013-01-13  Jan Djärv  <jan.h.d@swipnet.se>
 
         * nsfont.m (LCD_SMOOTHING_MARGIN): New define.
diff --git a/src/alloc.c b/src/alloc.c
index b147aa20723..3f1ccc82a58 100644
--- a/src/alloc.c
+++ b/src/alloc.c
@@ -219,7 +219,6 @@ static void refill_memory_reserve (void);
 #endif
 static void compact_small_strings (void);
 static void free_large_strings (void);
-static void free_misc (Lisp_Object);
 extern Lisp_Object which_symbols (Lisp_Object, EMACS_INT) EXTERNALLY_VISIBLE;
 
 /* When scanning the C stack for live Lisp objects, Emacs keeps track of
@@ -3303,7 +3302,7 @@ static union Lisp_Misc *marker_free_list;
 
 /* Return a newly allocated Lisp_Misc object of specified TYPE.  */
 
-static Lisp_Object
+Lisp_Object
 allocate_misc (enum Lisp_Misc_Type type)
 {
   Lisp_Object val;
@@ -3339,9 +3338,9 @@ allocate_misc (enum Lisp_Misc_Type type)
   return val;
 }
 
-/* Free a Lisp_Misc object */
+/* Free a Lisp_Misc object.  */
 
-static void
+void
 free_misc (Lisp_Object misc)
 {
   XMISCTYPE (misc) = Lisp_Misc_Free;
@@ -3351,9 +3350,10 @@ free_misc (Lisp_Object misc)
   total_free_markers++;
 }
 
-/* Return a Lisp_Misc_Save_Value object containing POINTER and
-   INTEGER.  This is used to package C values to call record_unwind_protect.
-   The unwind function can get the C values back using XSAVE_VALUE.  */
+/* Return a Lisp_Save_Value object containing POINTER and INTEGER.
+   Most code should use this to package C integers and pointers
+   to call record_unwind_protect.  The unwind function can get the
+   C values back using XSAVE_POINTER and XSAVE_INTEGER.  */
 
 Lisp_Object
 make_save_value (void *pointer, ptrdiff_t integer)
@@ -3363,22 +3363,22 @@ make_save_value (void *pointer, ptrdiff_t integer)
 
   val = allocate_misc (Lisp_Misc_Save_Value);
   p = XSAVE_VALUE (val);
-  p->pointer = pointer;
-  p->integer = integer;
-  p->dogc = 0;
+  p->type0 = SAVE_POINTER;
+  p->data[0].pointer = pointer;
+  p->type1 = SAVE_INTEGER;
+  p->data[1].integer = integer;
+  p->type2 = p->type3 = SAVE_UNUSED;
+  p->area = 0;
   return val;
 }
 
-/* Free a Lisp_Misc_Save_Value object.  */
+/* Free a Lisp_Save_Value object.  Do not use this function
+   if SAVE contains pointer other than returned by xmalloc.  */
 
 void
 free_save_value (Lisp_Object save)
 {
-  register struct Lisp_Save_Value *p = XSAVE_VALUE (save);
-
-  p->dogc = 0;
-  xfree (p->pointer);
-  p->pointer = NULL;
+  xfree (XSAVE_POINTER (save));
   free_misc (save);
 }
 
@@ -5935,20 +5935,33 @@ mark_object (Lisp_Object arg)
 
         case Lisp_Misc_Save_Value:
           XMISCANY (obj)->gcmarkbit = 1;
-#if GC_MARK_STACK
           {
             register struct Lisp_Save_Value *ptr = XSAVE_VALUE (obj);
-            /* If DOGC is set, POINTER is the address of a memory
-               area containing INTEGER potential Lisp_Objects.  */
-            if (ptr->dogc)
+            /* If `area' is nonzero, `data[0].pointer' is the address
+               of a memory area containing `data[1].integer' potential
+               Lisp_Objects.  */
+#if GC_MARK_STACK
+            if (ptr->area)
               {
-                Lisp_Object *p = (Lisp_Object *) ptr->pointer;
+                Lisp_Object *p = ptr->data[0].pointer;
                 ptrdiff_t nelt;
-                for (nelt = ptr->integer; nelt > 0; nelt--, p++)
+                for (nelt = ptr->data[1].integer; nelt > 0; nelt--, p++)
                   mark_maybe_object (*p);
               }
+            else
+#endif /* GC_MARK_STACK */
+              {
+                /* Find Lisp_Objects in `data[N]' slots and mark them.  */
+                if (ptr->type0 == SAVE_OBJECT)
+                  mark_object (ptr->data[0].object);
+                if (ptr->type1 == SAVE_OBJECT)
+                  mark_object (ptr->data[1].object);
+                if (ptr->type2 == SAVE_OBJECT)
+                  mark_object (ptr->data[2].object);
+                if (ptr->type3 == SAVE_OBJECT)
+                  mark_object (ptr->data[3].object);
+              }
           }
-#endif
           break;
 
         case Lisp_Misc_Overlay:
diff --git a/src/dired.c b/src/dired.c
index b4dc702112e..8483721401a 100644
--- a/src/dired.c
+++ b/src/dired.c
@@ -78,7 +78,7 @@ directory_files_internal_w32_unwind (Lisp_Object arg)
 static Lisp_Object
 directory_files_internal_unwind (Lisp_Object dh)
 {
-  DIR *d = (DIR *) XSAVE_VALUE (dh)->pointer;
+  DIR *d = XSAVE_POINTER (dh);
   block_input ();
   closedir (d);
   unblock_input ();
diff --git a/src/editfns.c b/src/editfns.c
index bf19acb42a8..feac17f64b8 100644
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -833,20 +833,30 @@ This function does not move point.  */)
 Lisp_Object
 save_excursion_save (void)
 {
-  Lisp_Object save, *data = xmalloc (word_size * 4);
+  Lisp_Object save = allocate_misc (Lisp_Misc_Save_Value);
+  register struct Lisp_Save_Value *v = XSAVE_VALUE (save);
+
+  /* Do not allocate extra space and pack everything in SAVE.  */
+  v->area = 0;
+
+  v->type0 = SAVE_OBJECT;
+  v->data[0].object = Fpoint_marker ();
 
-  data[0] = Fpoint_marker ();
   /* Do not copy the mark if it points to nowhere.  */
-  data[1] = (XMARKER (BVAR (current_buffer, mark))->buffer
-             ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
-             : Qnil);
+  v->type1 = SAVE_OBJECT;
+  v->data[1].object = (XMARKER (BVAR (current_buffer, mark))->buffer
+                       ? Fcopy_marker (BVAR (current_buffer, mark), Qnil)
+                       : Qnil);
+
   /* Selected window if current buffer is shown in it, nil otherwise.  */
-  data[2] = ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
-             ? selected_window : Qnil);
-  data[3] = BVAR (current_buffer, mark_active);
+  v->type2 = SAVE_OBJECT;
+  v->data[2].object
+    = ((XBUFFER (XWINDOW (selected_window)->buffer) == current_buffer)
+       ? selected_window : Qnil);
+
+  v->type3 = SAVE_OBJECT;
+  v->data[3].object = BVAR (current_buffer, mark_active);
 
-  save = make_save_value (data, 4);
-  XSAVE_VALUE (save)->dogc = 1;
   return save;
 }
 
@@ -855,10 +865,15 @@ save_excursion_save (void)
 Lisp_Object
 save_excursion_restore (Lisp_Object info)
 {
-  Lisp_Object tem, tem1, omark, nmark, *data = XSAVE_VALUE (info)->pointer;
+  Lisp_Object tem, tem1, omark, nmark;
   struct gcpro gcpro1, gcpro2, gcpro3;
+  register struct Lisp_Save_Value *v = XSAVE_VALUE (info);
+
+  /* Paranoid.  */
+  eassert (v->type0 == SAVE_OBJECT && v->type1 == SAVE_OBJECT
+           && v->type2 == SAVE_OBJECT && v->type3 == SAVE_OBJECT);
 
-  tem = Fmarker_buffer (data[0]);
+  tem = Fmarker_buffer (v->data[0].object);
   /* If we're unwinding to top level, saved buffer may be deleted.  This
      means that all of its markers are unchained and so tem is nil.  */
   if (NILP (tem))
@@ -870,12 +885,12 @@ save_excursion_restore (Lisp_Object info)
   Fset_buffer (tem);
 
   /* Point marker.  */
-  tem = data[0];
+  tem = v->data[0].object;
   Fgoto_char (tem);
   unchain_marker (XMARKER (tem));
 
   /* Mark marker.  */
-  tem = data[1];
+  tem = v->data[1].object;
   omark = Fmarker_position (BVAR (current_buffer, mark));
   if (NILP (tem))
     unchain_marker (XMARKER (BVAR (current_buffer, mark)));
@@ -887,7 +902,7 @@ save_excursion_restore (Lisp_Object info)
     }
 
   /* Mark active.  */
-  tem = data[3];
+  tem = v->data[3].object;
   tem1 = BVAR (current_buffer, mark_active);
   bset_mark_active (current_buffer, tem);
 
@@ -911,7 +926,7 @@ save_excursion_restore (Lisp_Object info)
   /* If buffer was visible in a window, and a different window was
      selected, and the old selected window is still showing this
      buffer, restore point in that window.  */
-  tem = data[2];
+  tem = v->data[2].object;
   if (WINDOWP (tem)
       && !EQ (tem, selected_window)
       && (tem1 = XWINDOW (tem)->buffer,
@@ -925,7 +940,7 @@ save_excursion_restore (Lisp_Object info)
 
  out:
 
-  free_save_value (info);
+  free_misc (info);
   return Qnil;
 }
 
@@ -4258,7 +4273,7 @@ usage: (format STRING &rest OBJECTS)  */)
             memcpy (buf, initial_buffer, used);
           }
         else
-          XSAVE_VALUE (buf_save_value)->pointer = buf = xrealloc (buf, bufsize);
+          XSAVE_POINTER (buf_save_value) = buf = xrealloc (buf, bufsize);
 
         p = buf + used;
       }
diff --git a/src/eval.c b/src/eval.c
index c49f8e85c2f..030bf14bcea 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1931,7 +1931,10 @@ eval_sub (Lisp_Object form)
     return form;
 
   QUIT;
+
+  GCPRO1 (form);
   maybe_gc ();
+  UNGCPRO;
 
   if (++lisp_eval_depth > max_lisp_eval_depth)
     {
diff --git a/src/fileio.c b/src/fileio.c
index 5e9b36ee44a..d468576d639 100644
--- a/src/fileio.c
+++ b/src/fileio.c
@@ -5507,7 +5507,7 @@ static Lisp_Object
 do_auto_save_unwind (Lisp_Object arg)  /* used as unwind-protect function */
 
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg);
   auto_saving = 0;
   if (stream != NULL)
     {
diff --git a/src/font.c b/src/font.c
index a3a41006f9b..c4153428147 100644
--- a/src/font.c
+++ b/src/font.c
@@ -1857,7 +1857,7 @@ otf_open (Lisp_Object file)
   OTF *otf;
 
   if (! NILP (val))
-    otf = XSAVE_VALUE (XCDR (val))->pointer;
+    otf = XSAVE_POINTER (XCDR (val));
   else
     {
       otf = STRINGP (file) ? OTF_open (SSDATA (file)) : NULL;
diff --git a/src/ftfont.c b/src/ftfont.c
index 1ada95d377c..1d7678bfe09 100644
--- a/src/ftfont.c
+++ b/src/ftfont.c
@@ -393,16 +393,14 @@ ftfont_lookup_cache (Lisp_Object key, enum ftfont_cache_for cache_for)
       cache_data = xmalloc (sizeof *cache_data);
       cache_data->ft_face = NULL;
       cache_data->fc_charset = NULL;
-      val = make_save_value (NULL, 0);
-      XSAVE_VALUE (val)->integer = 0;
-      XSAVE_VALUE (val)->pointer = cache_data;
+      val = make_save_value (cache_data, 0);
       cache = Fcons (Qnil, val);
       Fputhash (key, cache, ft_face_cache);
     }
   else
     {
       val = XCDR (cache);
-      cache_data = XSAVE_VALUE (val)->pointer;
+      cache_data = XSAVE_POINTER (val);
     }
 
   if (cache_for == FTFONT_CACHE_FOR_ENTITY)
@@ -468,7 +466,7 @@ ftfont_get_fc_charset (Lisp_Object entity)
 
   cache = ftfont_lookup_cache (entity, FTFONT_CACHE_FOR_CHARSET);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (val)->pointer;
+  cache_data = XSAVE_POINTER (val);
   return cache_data->fc_charset;
 }
 
@@ -1200,9 +1198,9 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
   filename = XCAR (val);
   idx = XCDR (val);
   val = XCDR (cache);
-  cache_data = XSAVE_VALUE (XCDR (cache))->pointer;
+  cache_data = XSAVE_POINTER (XCDR (cache));
   ft_face = cache_data->ft_face;
-  if (XSAVE_VALUE (val)->integer > 0)
+  if (XSAVE_INTEGER (val) > 0)
     {
       /* FT_Face in this cache is already used by the different size.  */
       if (FT_New_Size (ft_face, &ft_size) != 0)
@@ -1213,13 +1211,13 @@ ftfont_open (FRAME_PTR f, Lisp_Object entity, int pixel_size)
           return Qnil;
         }
     }
-  XSAVE_VALUE (val)->integer++;
+  XSAVE_INTEGER (val)++;
   size = XINT (AREF (entity, FONT_SIZE_INDEX));
   if (size == 0)
     size = pixel_size;
   if (FT_Set_Pixel_Sizes (ft_face, size, size) != 0)
     {
-      if (XSAVE_VALUE (val)->integer == 0)
+      if (XSAVE_INTEGER (val) == 0)
         FT_Done_Face (ft_face);
       return Qnil;
     }
@@ -1328,10 +1326,10 @@ ftfont_close (FRAME_PTR f, struct font *font)
   cache = ftfont_lookup_cache (val, FTFONT_CACHE_FOR_FACE);
   eassert (CONSP (cache));
   val = XCDR (cache);
-  (XSAVE_VALUE (val)->integer)--;
-  if (XSAVE_VALUE (val)->integer == 0)
+  (XSAVE_INTEGER (val))--;
+  if (XSAVE_INTEGER (val) == 0)
     {
-      struct ftfont_cache_data *cache_data = XSAVE_VALUE (val)->pointer;
+      struct ftfont_cache_data *cache_data = XSAVE_POINTER (val);
 
       FT_Done_Face (cache_data->ft_face);
 #ifdef HAVE_LIBOTF
diff --git a/src/gtkutil.c b/src/gtkutil.c
index af845f69e62..259e0e971fd 100644
--- a/src/gtkutil.c
+++ b/src/gtkutil.c
@@ -1650,8 +1650,7 @@ xg_dialog_response_cb (GtkDialog *w,
 static Lisp_Object
 pop_down_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct xg_dialog_data *dd = (struct xg_dialog_data *) p->pointer;
+  struct xg_dialog_data *dd = XSAVE_POINTER (arg);
 
   block_input ();
   if (dd->w) gtk_widget_destroy (dd->w);
diff --git a/src/keymap.c b/src/keymap.c
index d1ddd55a358..82c9e980221 100644
--- a/src/keymap.c
+++ b/src/keymap.c
@@ -565,15 +565,14 @@ map_keymap_char_table_item (Lisp_Object args, Lisp_Object key, Lisp_Object val)
 {
   if (!NILP (val))
     {
-      map_keymap_function_t fun
-        = (map_keymap_function_t) XSAVE_VALUE (XCAR (args))->pointer;
+      map_keymap_function_t fun = XSAVE_POINTER (XCAR (args));
       args = XCDR (args);
       /* If the key is a range, make a copy since map_char_table modifies
          it in place.  */
       if (CONSP (key))
         key = Fcons (XCAR (key), XCDR (key));
       map_keymap_item (fun, XCDR (args), key, val,
-                       XSAVE_VALUE (XCAR (args))->pointer);
+                       XSAVE_POINTER (XCAR (args)));
     }
 }
 
diff --git a/src/lisp.h b/src/lisp.h
index d4d34ac19ba..3ac2bda94c5 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -1383,20 +1383,48 @@ struct Lisp_Overlay
     Lisp_Object plist;
   };
 
-/* Hold a C pointer for later use.
-   This type of object is used in the arg to record_unwind_protect.  */
+/* Types of data which may be saved in a Lisp_Save_Value.  */
+
+enum
+  {
+    SAVE_UNUSED,
+    SAVE_INTEGER,
+    SAVE_POINTER,
+    SAVE_OBJECT
+  };
+
+/* Special object used to hold a different values for later use.  */
+
 struct Lisp_Save_Value
   {
     ENUM_BF (Lisp_Misc_Type) type : 16; /* = Lisp_Misc_Save_Value */
     unsigned gcmarkbit : 1;
-    int spacer : 14;
-    /* If DOGC is set, POINTER is the address of a memory
-       area containing INTEGER potential Lisp_Objects.  */
-    unsigned int dogc : 1;
-    void *pointer;
-    ptrdiff_t integer;
+    int spacer : 6;
+    /* If `area' is nonzero, `data[0].pointer' is the address of a memory area
+       containing `data[1].integer' potential Lisp_Objects.  The rest of `data'
+       fields are unused.  */
+    unsigned area : 1;
+    /* If `area' is zero, `data[N]' may hold different objects which type is
+       encoded in `typeN' fields as described by the anonymous enum above.
+       E.g. if `type0' is SAVE_INTEGER, `data[0].integer' is in use.  */
+    unsigned type0 : 2;
+    unsigned type1 : 2;
+    unsigned type2 : 2;
+    unsigned type3 : 2;
+    union {
+      void *pointer;
+      ptrdiff_t integer;
+      Lisp_Object object;
+    } data[4];
   };
 
+/* Compatibility macro to set and extract saved pointer.  */
+
+#define XSAVE_POINTER(obj) XSAVE_VALUE (obj)->data[0].pointer
+
+/* Likewise for the saved integer.  */
+
+#define XSAVE_INTEGER(obj) XSAVE_VALUE (obj)->data[1].integer
 
 /* A miscellaneous object, when it's on the free list.  */
 struct Lisp_Free
@@ -2898,6 +2926,8 @@ extern void memory_warnings (void *, void (*warnfun) (const char *));
 
 /* Defined in alloc.c.  */
 extern void check_pure_size (void);
+extern Lisp_Object allocate_misc (enum Lisp_Misc_Type);
+extern void free_misc (Lisp_Object);
 extern void allocate_string_data (struct Lisp_String *, EMACS_INT, EMACS_INT);
 extern void malloc_warning (const char *);
 extern _Noreturn void memory_full (size_t);
@@ -3700,7 +3730,7 @@ extern void *record_xmalloc (size_t);
         Lisp_Object arg_;                                      \
         buf = xmalloc ((nelt) * word_size);                    \
         arg_ = make_save_value (buf, nelt);                    \
-        XSAVE_VALUE (arg_)->dogc = 1;                          \
+        XSAVE_VALUE (arg_)->area = 1;                          \
         sa_must_free = 1;                                      \
         record_unwind_protect (safe_alloca_unwind, arg_);      \
       }                                                        \
diff --git a/src/lread.c b/src/lread.c
index 2b96dc16359..ced690a77b0 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -1357,7 +1357,7 @@ Return t if the file exists and loads successfully.  */)
 static Lisp_Object
 load_unwind (Lisp_Object arg)  /* Used as unwind-protect function in load.  */
 {
-  FILE *stream = (FILE *) XSAVE_VALUE (arg)->pointer;
+  FILE *stream = XSAVE_POINTER (arg);
   if (stream != NULL)
     {
       block_input ();
diff --git a/src/nsmenu.m b/src/nsmenu.m
index 39797d414f0..3e6fa54b047 100644
--- a/src/nsmenu.m
+++ b/src/nsmenu.m
@@ -1347,8 +1347,7 @@ struct Popdown_data
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  struct Popdown_data *unwind_data = (struct Popdown_data *) p->pointer;
+  struct Popdown_data *unwind_data = XSAVE_POINTER (arg);
 
   block_input ();
   if (popup_activated_flag)
diff --git a/src/nsterm.h b/src/nsterm.h
index e58b8493c94..7732e6d27cc 100644
--- a/src/nsterm.h
+++ b/src/nsterm.h
@@ -675,9 +675,9 @@ struct x_output
 #define FRAME_FONT(f) ((f)->output_data.ns->font)
 
 #ifdef __OBJC__
-#define XNS_SCROLL_BAR(vec) ((id) XSAVE_VALUE (vec)->pointer)
+#define XNS_SCROLL_BAR(vec) ((id) XSAVE_POINTER (vec))
 #else
-#define XNS_SCROLL_BAR(vec) XSAVE_VALUE (vec)->pointer
+#define XNS_SCROLL_BAR(vec) XSAVE_POINTER (vec)
 #endif
 
 /* Compute pixel size for vertical scroll bars */
diff --git a/src/print.c b/src/print.c
index b5e45438577..8420f8075a5 100644
--- a/src/print.c
+++ b/src/print.c
@@ -2036,8 +2036,9 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
           PRINTCHAR ('>');
           break;
 
-      /* Remaining cases shouldn't happen in normal usage, but let's print
-         them anyway for the benefit of the debugger.  */
+          /* Remaining cases shouldn't happen in normal usage, but let's
+             print them anyway for the benefit of the debugger.  */
+
         case Lisp_Misc_Free:
           strout ("#<misc free cell>", -1, -1, printcharfun);
           break;
@@ -2048,20 +2049,28 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
             struct Lisp_Save_Value *v = XSAVE_VALUE (obj);
 
             strout ("#<save-value ", -1, -1, printcharfun);
-            if (v->dogc)
+
+            if (v->area)
               {
-                int lim = min (v->integer, 8);
-                
-                /* Try to print up to 8 objects we have saved.  Although
-                   valid_lisp_object_p is slow, this shouldn't be a real
-                   bottleneck because such a saved values are quite rare.  */
+                ptrdiff_t amount = v->data[1].integer;
+
+#if GC_MARK_STACK
+
+                /* If GC_MARK_STACK, valid_lisp_object_p is quite reliable,
+                   and so we try to print up to 8 objects we have saved.
+                   Although valid_lisp_object_p is slow, this shouldn't be
+                   a real bottleneck because we do not use this code under
+                   normal circumstances.  */
 
-                i = sprintf (buf, "with %"pD"d objects", v->integer);
+                int limit = min (amount, 8);
+                Lisp_Object *area = v->data[0].pointer;
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
                 strout (buf, i, i, printcharfun);
 
-                for (i = 0; i < lim; i++)
+                for (i = 0; i < limit; i++)
                   {
-                    Lisp_Object maybe = ((Lisp_Object *) v->pointer)[i];
+                    Lisp_Object maybe = area[i];
 
                     if (valid_lisp_object_p (maybe) > 0)
                       {
@@ -2071,13 +2080,49 @@ print_object (Lisp_Object obj, register Lisp_Object printcharfun, int escapeflag
                     else
                       strout (" <invalid>", -1, -1, printcharfun);
                   }
-                if (i == lim && i < v->integer)
+                if (i == limit && i < amount)
                   strout (" ...", 4, 4, printcharfun);
+
+#else /* not GC_MARK_STACK */
+
+                /* If !GC_MARK_STACK, we have no reliable way to find
+                   whether Lisp_Object pointers points to an initialized
+                   objects, and so we do not ever trying to print them.  */
+
+                i = sprintf (buf, "with %"pD"d objects", amount);
+                strout (buf, i, i, printcharfun);
+
+#endif /* GC_MARK_STACK */
               }
             else
               {
-                i = sprintf (buf, "ptr=%p int=%"pD"d", v->pointer, v->integer);
-                strout (buf, i, i, printcharfun);
+                /* Print each `data[N]' slot according to its type.  */
+
+#define PRINTX(index)                                                   \
+  do {                                                                  \
+    i = 0;                                                              \
+    if (v->type ## index == SAVE_UNUSED)                                \
+      i = sprintf (buf, "<unused>");                                    \
+    else if (v->type ## index == SAVE_INTEGER)                          \
+      i = sprintf (buf, "<integer %"pD"d>", v->data[index].integer);    \
+    else if (v->type ## index == SAVE_POINTER)                          \
+      i = sprintf (buf, "<pointer %p>", v->data[index].pointer);        \
+    else /* SAVE_OBJECT */                                              \
+      print_object (v->data[index].object, printcharfun, escapeflag);   \
+    if (i)                                                              \
+      strout (buf, i, i, printcharfun);                                 \
+  } while (0)
+
+                PRINTX (0);
+                PRINTCHAR (' ');
+                PRINTX (1);
+                PRINTCHAR (' ');
+                PRINTX (2);
+                PRINTCHAR (' ');
+                PRINTX (3);
+
+#undef PRINTX
+
               }
             PRINTCHAR ('>');
           }
diff --git a/src/xfns.c b/src/xfns.c
index 315d5093716..fe99d36f9f4 100644
--- a/src/xfns.c
+++ b/src/xfns.c
@@ -5292,8 +5292,7 @@ file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
 static Lisp_Object
 clean_up_file_dialog (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  Widget dialog = (Widget) p->pointer;
+  Widget dialog = XSAVE_POINTER (arg);
 
   /* Clean up.  */
   block_input ();
diff --git a/src/xmenu.c b/src/xmenu.c
index 3d76070c336..6d880993d19 100644
--- a/src/xmenu.c
+++ b/src/xmenu.c
@@ -1411,11 +1411,9 @@ popup_selection_callback (GtkWidget *widget, gpointer client_data)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-
   popup_activated_flag = 0;
   block_input ();
-  gtk_widget_destroy (GTK_WIDGET (p->pointer));
+  gtk_widget_destroy (GTK_WIDGET (XSAVE_POINTER (arg)));
   unblock_input ();
   return Qnil;
 }
@@ -1612,11 +1610,7 @@ create_and_show_popup_menu (FRAME_PTR f, widget_value *first_wv,
 static Lisp_Object
 cleanup_widget_value_tree (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
-  widget_value *wv = p->pointer;
-
-  free_menubar_widget_value_tree (wv);
-
+  free_menubar_widget_value_tree (XSAVE_POINTER (arg));
   return Qnil;
 }
 
@@ -2242,11 +2236,8 @@ menu_help_callback (char const *help_string, int pane, int item)
 static Lisp_Object
 pop_down_menu (Lisp_Object arg)
 {
-  struct Lisp_Save_Value *p1 = XSAVE_VALUE (Fcar (arg));
-  struct Lisp_Save_Value *p2 = XSAVE_VALUE (Fcdr (arg));
-
-  FRAME_PTR f = p1->pointer;
-  XMenu *menu = p2->pointer;
+  FRAME_PTR f = XSAVE_POINTER (Fcar (arg));
+  XMenu *menu = XSAVE_POINTER (Fcdr (arg));
 
   block_input ();
 #ifndef MSDOS
diff --git a/src/xselect.c b/src/xselect.c
index f43efab827b..9abfb2931f8 100644
--- a/src/xselect.c
+++ b/src/xselect.c
@@ -1120,7 +1120,7 @@ unexpect_property_change (struct prop_location *location)
 static Lisp_Object
 wait_for_property_change_unwind (Lisp_Object loc)
 {
-  struct prop_location *location = XSAVE_VALUE (loc)->pointer;
+  struct prop_location *location = XSAVE_POINTER (loc);
 
   unexpect_property_change (location);
   if (location == property_change_reply_object)
diff --git a/test/ChangeLog b/test/ChangeLog
index 7b058c1d2bd..472a6073884 100644
--- a/test/ChangeLog
+++ b/test/ChangeLog
@@ -1,3 +1,8 @@
+2013-01-14  Glenn Morris  <rgm@gnu.org>
+
+        * automated/compile-tests.el (compile-tests--test-regexps-data):
+        Fix interpretation of gnu line.col1-col2 format.  (Bug#13335)
+
 2013-01-10  Wolfgang Jenkner  <wjenkner@inode.at>
 
         * automated/man-tests.el: New file.
diff --git a/test/automated/compile-tests.el b/test/automated/compile-tests.el
index f976efe72de..682867d1178 100644
--- a/test/automated/compile-tests.el
+++ b/test/automated/compile-tests.el
@@ -176,8 +176,10 @@
     ("foo.c:8.23: note: message" 1 23 8 "foo.c")
     ("foo.c:8.23: info: message" 1 23 8 "foo.c")
     ("foo.c:8:23:information: message" 1 23 8 "foo.c")
-    ("foo.c:8.23-45: Informational: message" 1 (23 . nil) (8 . 45) "foo.c")
+    ("foo.c:8.23-45: Informational: message" 1 (23 . 46) (8 . nil) "foo.c")
     ("foo.c:8-23: message" 1 nil (8 . 23) "foo.c")
+    ;; The next one is not in the GNU standards AFAICS.
+    ;; Here we seem to interpret it as LINE1-LINE2.COL2.
     ("foo.c:8-45.3: message" 1 (nil . 4) (8 . 45) "foo.c")
     ("foo.c:8.23-9.1: message" 1 (23 . 2) (8 . 9) "foo.c")
     ("jade:dbcommon.dsl:133:17:E: missing argument for function call"