Merge from emacs-24; up to 2012-11-08T14:54:03Z!monnier@iro.umontreal.ca

4 files changed, 70 insertions, 38 deletions

diff --git a/src/ChangeLog b/src/ChangeLog
index da3e96bbcc3..46f086389fe 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,24 @@
+2012-11-10  Martin Rudalics  <rudalics@gmx.at>
+
+        * window.c (Fsplit_window_internal): Set combination limit of
+        new parent window to t iff Vwindow_combination_limit is t;
+        fixing a regression introduced with the change from 2012-09-22.
+        (Fset_window_combination_limit): Fix doc-string.
+
+2012-11-10  Eli Zaretskii  <eliz@gnu.org>
+
+        * xdisp.c (try_scrolling): Fix correction of aggressive-scroll
+        amount when the scroll margins are too large.  When scrolling
+        backwards in the buffer, give up if cannot reach point or the
+        scroll margin within a reasonable number of screen lines.  Fixes
+        point position in window under scroll-up/down-aggressively when
+        point is positioned many lines beyond the window top/bottom.
+        (Bug#12811)
+
+        * ralloc.c (relinquish): If real_morecore fails to return memory
+        to the system, don't crash; instead, leave the last heap
+        unchanged and return.  (Bug#12774)
+
 2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * lisp.h (AUTOLOADP): New macro.
diff --git a/src/ralloc.c b/src/ralloc.c
index 11897411930..e5bf76b0e6d 100644
--- a/src/ralloc.c
+++ b/src/ralloc.c
@@ -327,6 +327,8 @@ relinquish (void)
 
       if ((char *)last_heap->end - (char *)last_heap->bloc_start <= excess)
         {
+          heap_ptr lh_prev;
+
           /* This heap should have no blocs in it.  If it does, we
              cannot return it to the system.  */
           if (last_heap->first_bloc != NIL_BLOC
@@ -335,28 +337,26 @@ relinquish (void)
 
           /* Return the last heap, with its header, to the system.  */
           excess = (char *)last_heap->end - (char *)last_heap->start;
-          last_heap = last_heap->prev;
-          last_heap->next = NIL_HEAP;
+          lh_prev = last_heap->prev;
+          /* If the system doesn't want that much memory back, leave
+             last_heap unaltered to reflect that.  This can occur if
+             break_value is still within the original data segment.  */
+          if ((*real_morecore) (- excess) != 0)
+            {
+              last_heap = lh_prev;
+              last_heap->next = NIL_HEAP;
+            }
         }
       else
         {
           excess = (char *) last_heap->end
                         - (char *) ROUNDUP ((char *)last_heap->end - excess);
-          last_heap->end = (char *) last_heap->end - excess;
-        }
-
-      if ((*real_morecore) (- excess) == 0)
-        {
-          /* If the system didn't want that much memory back, adjust
-             the end of the last heap to reflect that.  This can occur
-             if break_value is still within the original data segment.  */
-          last_heap->end = (char *) last_heap->end + excess;
-          /* Make sure that the result of the adjustment is accurate.
-             It should be, for the else clause above; the other case,
-             which returns the entire last heap to the system, seems
-             unlikely to trigger this mode of failure.  */
-          if (last_heap->end != (*real_morecore) (0))
-            emacs_abort ();
+          /* If the system doesn't want that much memory back, leave
+             the end of the last heap unchanged to reflect that.  This
+             can occur if break_value is still within the original
+             data segment.  */
+          if ((*real_morecore) (- excess) != 0)
+            last_heap->end = (char *) last_heap->end - excess;
         }
     }
 }
diff --git a/src/window.c b/src/window.c
index 197f4916bc2..99498642710 100644
--- a/src/window.c
+++ b/src/window.c
@@ -618,11 +618,13 @@ internal windows only.  */)
 
 DEFUN ("set-window-combination-limit", Fset_window_combination_limit, Sset_window_combination_limit, 2, 2, 0,
        doc: /* Set combination limit of window WINDOW to LIMIT; return LIMIT.
-WINDOW must be a valid window and defaults to the selected one.
 If LIMIT is nil, child windows of WINDOW can be recombined with WINDOW's
 siblings.  LIMIT t means that child windows of WINDOW are never
 \(re-)combined with WINDOW's siblings.  Other values are reserved for
-future use.  */)
+future use.
+
+WINDOW must be a valid window.  Setting the combination limit is
+meaningful for internal windows only.  */)
   (Lisp_Object window, Lisp_Object limit)
 {
   wset_combination_limit (decode_valid_window (window), limit);
@@ -3869,9 +3871,10 @@ set correctly.  See the code of `split-window' for how this is done.  */)
 
       make_parent_window (old, horflag);
       p = XWINDOW (o->parent);
-      /* Store t in the new parent's combination_limit slot to avoid
-        that its children get merged into another window.  */
-      wset_combination_limit (p, Qt);
+      if (EQ (Vwindow_combination_limit, Qt))
+        /* Store t in the new parent's combination_limit slot to avoid
+           that its children get merged into another window.  */
+        wset_combination_limit (p, Qt);
       /* These get applied below.  */
       wset_new_total (p, horflag ? o->total_cols : o->total_lines);
       wset_new_normal (p, new_normal);
diff --git a/src/xdisp.c b/src/xdisp.c
index c01f5deab83..46d942ce441 100644
--- a/src/xdisp.c
+++ b/src/xdisp.c
@@ -14786,13 +14786,18 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
           if (NUMBERP (aggressive))
             {
               double float_amount = XFLOATINT (aggressive) * height;
-              amount_to_scroll = float_amount;
-              if (amount_to_scroll == 0 && float_amount > 0)
-                amount_to_scroll = 1;
+              int aggressive_scroll = float_amount;
+              if (aggressive_scroll == 0 && float_amount > 0)
+                aggressive_scroll = 1;
               /* Don't let point enter the scroll margin near top of
-                 the window.  */
-              if (amount_to_scroll > height - 2*this_scroll_margin + dy)
-                amount_to_scroll = height - 2*this_scroll_margin + dy;
+                 the window.  This could happen if the value of
+                 scroll_up_aggressively is too large and there are
+                 non-zero margins, because scroll_up_aggressively
+                 means put point that fraction of window height
+                 _from_the_bottom_margin_.  */
+              if (aggressive_scroll + 2*this_scroll_margin > height)
+                aggressive_scroll = height - 2*this_scroll_margin;
+              amount_to_scroll = dy + aggressive_scroll;
             }
         }
 
@@ -14852,7 +14857,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
           /* Compute the vertical distance from PT to the scroll
              margin position.  Move as far as scroll_max allows, or
              one screenful, or 10 screen lines, whichever is largest.
-             Give up if distance is greater than scroll_max.  */
+             Give up if distance is greater than scroll_max or if we
+             didn't reach the scroll margin position.  */
           SET_TEXT_POS (pos, PT, PT_BYTE);
           start_display (&it, w, pos);
           y0 = it.current_y;
@@ -14862,7 +14868,8 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
                       y_to_move, -1,
                       MOVE_TO_POS | MOVE_TO_X | MOVE_TO_Y);
           dy = it.current_y - y0;
-          if (dy > scroll_max)
+          if (dy > scroll_max
+              || IT_CHARPOS (it) < CHARPOS (scroll_margin_pos))
             return SCROLLING_FAILED;
 
           /* Compute new window start.  */
@@ -14880,15 +14887,16 @@ try_scrolling (Lisp_Object window, int just_this_one_p,
               if (NUMBERP (aggressive))
                 {
                   double float_amount = XFLOATINT (aggressive) * height;
-                  amount_to_scroll = float_amount;
-                  if (amount_to_scroll == 0 && float_amount > 0)
-                    amount_to_scroll = 1;
-                  amount_to_scroll -=
-                    this_scroll_margin - dy - FRAME_LINE_HEIGHT (f);
+                  int aggressive_scroll = float_amount;
+                  if (aggressive_scroll == 0 && float_amount > 0)
+                    aggressive_scroll = 1;
                   /* Don't let point enter the scroll margin near
-                     bottom of the window.  */
-                  if (amount_to_scroll > height - 2*this_scroll_margin + dy)
-                    amount_to_scroll = height - 2*this_scroll_margin + dy;
+                     bottom of the window, if the value of
+                     scroll_down_aggressively happens to be too
+                     large.  */
+                  if (aggressive_scroll + 2*this_scroll_margin > height)
+                    aggressive_scroll = height - 2*this_scroll_margin;
+                  amount_to_scroll = dy + aggressive_scroll;
                 }
             }