Import a stock copy of ncurses 5.8 into the vendor space.vendor/ncurses/5.8-20110226

It seems both local changes we made to 5.7 have already been fixed
upstream properly, so there is no need to preserve the changes. Also,
with SVN we import full source trees. Unlike CVS, where we removed
unneeded cruft.

1 files changed, 129 insertions, 69 deletions

diff --git a/ncurses/base/resizeterm.c b/ncurses/base/resizeterm.c
index a94cfc3aaaa8..3f1d36e89d7a 100644
--- a/ncurses/base/resizeterm.c
+++ b/ncurses/base/resizeterm.c
@@ -1,5 +1,5 @@
 /****************************************************************************
- * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *
+ * Copyright (c) 1998-2009,2011 Free Software Foundation, Inc.              *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
@@ -28,6 +28,7 @@
 
 /****************************************************************************
  *  Author: Thomas E. Dickey                                                *
+ *     and: Juergen Pfeifer                                                 *
  ****************************************************************************/
 
 /*
@@ -39,11 +40,12 @@
  */
 
 #include <curses.priv.h>
-#include <term.h>
 
-MODULE_ID("$Id: resizeterm.c,v 1.34 2008/06/07 13:58:40 tom Exp $")
+#ifndef CUR
+#define CUR SP_TERMTYPE
+#endif
 
-#define stolen_lines (screen_lines - SP->_lines_avail)
+MODULE_ID("$Id: resizeterm.c,v 1.43 2011/01/10 01:34:49 tom Exp $")
 
 /*
  * If we're trying to be reentrant, do not want any local statics.
@@ -64,18 +66,23 @@ static int current_cols;
 static void
 show_window_sizes(const char *name)
 {
+    SCREEN *sp;
     WINDOWLIST *wp;
 
     _nc_lock_global(curses);
-    _tracef("%s resizing: %2d x %2d (%2d x %2d)", name, LINES, COLS,
-	    screen_lines, screen_columns);
-    for (each_window(wp)) {
-	_tracef("  window %p is %2ld x %2ld at %2ld,%2ld",
-		&(wp->win),
-		(long) wp->win._maxy + 1,
-		(long) wp->win._maxx + 1,
-		(long) wp->win._begy,
-		(long) wp->win._begx);
+    for (each_screen(sp)) {
+	_tracef("%s resizing: %p: %2d x %2d (%2d x %2d)", name, (void *) sp,
+		*(ptrLines(sp)),
+		*(ptrCols(sp)),
+		screen_lines(sp), screen_columns(sp));
+	for (each_window(sp, wp)) {
+	    _tracef("  window %p is %2ld x %2ld at %2ld,%2ld",
+		    (void *) &(wp->win),
+		    (long) wp->win._maxy + 1,
+		    (long) wp->win._maxx + 1,
+		    (long) wp->win._begy,
+		    (long) wp->win._begx);
+	}
     }
     _nc_unlock_global(curses);
 }
@@ -86,15 +93,23 @@ show_window_sizes(const char *name)
  * structure's size.
  */
 NCURSES_EXPORT(bool)
-is_term_resized(int ToLines, int ToCols)
+NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_DCLx int ToLines, int ToCols)
 {
-    T((T_CALLED("is_term_resized(%d, %d)"), ToLines, ToCols));
+    T((T_CALLED("is_term_resized(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
     returnCode(ToLines > 0
 	       && ToCols > 0
-	       && (ToLines != screen_lines
-		   || ToCols != screen_columns));
+	       && (ToLines != screen_lines(SP_PARM)
+		   || ToCols != screen_columns(SP_PARM)));
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(bool)
+is_term_resized(int ToLines, int ToCols)
+{
+    return NCURSES_SP_NAME(is_term_resized) (CURRENT_SCREEN, ToLines, ToCols);
+}
+#endif
+
 /*
  */
 static ripoff_t *
@@ -104,6 +119,9 @@ ripped_window(WINDOW *win)
     ripoff_t *rop;
 
     if (win != 0) {
+#ifdef USE_SP_RIPOFF
+	SCREEN *sp = _nc_screen_of(win);
+#endif
 	for (each_ripoff(rop)) {
 	    if (rop->win == win && rop->line != 0) {
 		result = rop;
@@ -125,6 +143,9 @@ ripped_bottom(WINDOW *win)
     ripoff_t *rop;
 
     if (win != 0) {
+#ifdef USE_SP_RIPOFF
+	SCREEN *sp = _nc_screen_of(win);
+#endif
 	for (each_ripoff(rop)) {
 	    if (rop->line < 0) {
 		result -= rop->line;
@@ -146,9 +167,12 @@ child_depth(WINDOW *cmp)
     int depth = 0;
 
     if (cmp != 0) {
+#ifdef USE_SP_WINDOWLIST
+	SCREEN *sp = _nc_screen_of(cmp);
+#endif
 	WINDOWLIST *wp;
 
-	for (each_window(wp)) {
+	for (each_window(sp, wp)) {
 	    WINDOW *tst = &(wp->win);
 	    if (tst->_parent == cmp) {
 		depth = 1 + child_depth(tst);
@@ -184,13 +208,13 @@ static int
 adjust_window(WINDOW *win, int ToLines, int ToCols, int stolen EXTRA_DCLS)
 {
     int result;
-    int bottom = CurLines + SP->_topstolen - stolen;
+    int bottom = CurLines + _nc_screen_of(win)->_topstolen - stolen;
     int myLines = win->_maxy + 1;
     int myCols = win->_maxx + 1;
     ripoff_t *rop = ripped_window(win);
 
     T((T_CALLED("adjust_window(%p,%d,%d)%s depth %d/%d currently %ldx%ld at %ld,%ld"),
-       win, ToLines, ToCols,
+       (void *) win, ToLines, ToCols,
        (rop != 0) ? " (rip)" : "",
        parent_depth(win),
        child_depth(win),
@@ -202,13 +226,19 @@ adjust_window(WINDOW *win, int ToLines, int ToCols, int stolen EXTRA_DCLS)
 	 * If it is a ripped-off window at the bottom of the screen, simply
 	 * move it to the same relative position.
 	 */
-	win->_begy = ToLines - ripped_bottom(win) - 0 - win->_yoffset;
+	win->_begy = (NCURSES_SIZE_T) (ToLines - ripped_bottom(win) - 0 - win->_yoffset);
+	if (rop->hook == _nc_slk_initialize)
+	    _nc_format_slks(
+#if NCURSES_SP_FUNCS
+			       _nc_screen_of(win),
+#endif
+			       ToCols);
     } else if (win->_begy >= bottom) {
 	/*
 	 * If it is below the bottom of the new screen, move up by the same
 	 * amount that the screen shrank.
 	 */
-	win->_begy += (ToLines - CurLines);
+	win->_begy = (NCURSES_SIZE_T) (win->_begy + (ToLines - CurLines));
     } else {
 	if (myLines == (CurLines - stolen)
 	    && ToLines != CurLines) {
@@ -239,19 +269,19 @@ adjust_window(WINDOW *win, int ToLines, int ToCols, int stolen EXTRA_DCLS)
  * children, decrease those to fit, then decrease the containing window, etc.
  */
 static int
-decrease_size(int ToLines, int ToCols, int stolen EXTRA_DCLS)
+decrease_size(NCURSES_SP_DCLx int ToLines, int ToCols, int stolen EXTRA_DCLS)
 {
     bool found;
     int depth = 0;
     WINDOWLIST *wp;
 
-    T((T_CALLED("decrease_size(%d, %d)"), ToLines, ToCols));
+    T((T_CALLED("decrease_size(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
 
     do {
 	found = FALSE;
 	TR(TRACE_UPDATE, ("decreasing size of windows to %dx%d, depth=%d",
 			  ToLines, ToCols, depth));
-	for (each_window(wp)) {
+	for (each_window(SP_PARM, wp)) {
 	    WINDOW *win = &(wp->win);
 
 	    if (!(win->_flags & _ISPAD)) {
@@ -273,19 +303,19 @@ decrease_size(int ToLines, int ToCols, int stolen EXTRA_DCLS)
  * parent, increase those to fit, then increase the contained window, etc.
  */
 static int
-increase_size(int ToLines, int ToCols, int stolen EXTRA_DCLS)
+increase_size(NCURSES_SP_DCLx int ToLines, int ToCols, int stolen EXTRA_DCLS)
 {
     bool found;
     int depth = 0;
     WINDOWLIST *wp;
 
-    T((T_CALLED("increase_size(%d, %d)"), ToLines, ToCols));
+    T((T_CALLED("increase_size(%p, %d, %d)"), (void *) SP_PARM, ToLines, ToCols));
 
     do {
 	found = FALSE;
 	TR(TRACE_UPDATE, ("increasing size of windows to %dx%d, depth=%d",
 			  ToLines, ToCols, depth));
-	for (each_window(wp)) {
+	for (each_window(SP_PARM, wp)) {
 	    WINDOW *win = &(wp->win);
 
 	    if (!(win->_flags & _ISPAD)) {
@@ -307,25 +337,26 @@ increase_size(int ToLines, int ToCols, int stolen EXTRA_DCLS)
  * such as ungetch().
  */
 NCURSES_EXPORT(int)
-resize_term(int ToLines, int ToCols)
+NCURSES_SP_NAME(resize_term) (NCURSES_SP_DCLx int ToLines, int ToCols)
 {
     int result = OK EXTRA_ARGS;
     int was_stolen;
 
-    T((T_CALLED("resize_term(%d,%d) old(%d,%d)"),
-       ToLines, ToCols,
-       screen_lines, screen_columns));
+    T((T_CALLED("resize_term(%p,%d,%d) old(%d,%d)"),
+       (void *) SP_PARM, ToLines, ToCols,
+       (SP_PARM == 0) ? -1 : screen_lines(SP_PARM),
+       (SP_PARM == 0) ? -1 : screen_columns(SP_PARM)));
 
-    if (SP == 0) {
+    if (SP_PARM == 0) {
 	returnCode(ERR);
     }
 
-    _nc_lock_global(curses);
+    _nc_nonsp_lock_global(curses);
 
-    was_stolen = (screen_lines - SP->_lines_avail);
-    if (is_term_resized(ToLines, ToCols)) {
-	int myLines = CurLines = screen_lines;
-	int myCols = CurCols = screen_columns;
+    was_stolen = (screen_lines(SP_PARM) - SP_PARM->_lines_avail);
+    if (NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_ARGx ToLines, ToCols)) {
+	int myLines = CurLines = screen_lines(SP_PARM);
+	int myCols = CurCols = screen_columns(SP_PARM);
 
 #ifdef TRACE
 	if (USE_TRACEF(TRACE_UPDATE)) {
@@ -333,33 +364,42 @@ resize_term(int ToLines, int ToCols)
 	    _nc_unlock_global(tracef);
 	}
 #endif
-	if (ToLines > screen_lines) {
-	    increase_size(myLines = ToLines, myCols, was_stolen EXTRA_ARGS);
+	if (ToLines > screen_lines(SP_PARM)) {
+	    increase_size(NCURSES_SP_ARGx
+			  myLines = ToLines, myCols, was_stolen EXTRA_ARGS);
 	    CurLines = myLines;
 	    CurCols = myCols;
 	}
 
-	if (ToCols > screen_columns) {
-	    increase_size(myLines, myCols = ToCols, was_stolen EXTRA_ARGS);
+	if (ToCols > screen_columns(SP_PARM)) {
+	    increase_size(NCURSES_SP_ARGx
+			  myLines, myCols = ToCols, was_stolen EXTRA_ARGS);
 	    CurLines = myLines;
 	    CurCols = myCols;
 	}
 
 	if (ToLines < myLines ||
 	    ToCols < myCols) {
-	    decrease_size(ToLines, ToCols, was_stolen EXTRA_ARGS);
+	    decrease_size(NCURSES_SP_ARGx ToLines, ToCols, was_stolen EXTRA_ARGS);
 	}
 
-	screen_lines = lines = ToLines;
-	screen_columns = columns = ToCols;
+	screen_lines(SP_PARM) = (NCURSES_SIZE_T) ToLines;
+	screen_columns(SP_PARM) = (NCURSES_SIZE_T) ToCols;
 
-	SP->_lines_avail = lines - was_stolen;
+#ifdef USE_TERM_DRIVER
+	CallDriver_2(SP_PARM, setsize, ToLines, ToCols);
+#else
+	lines = (NCURSES_SIZE_T) ToLines;
+	columns = (NCURSES_SIZE_T) ToCols;
+#endif
 
-	if (SP->oldhash) {
-	    FreeAndNull(SP->oldhash);
+	SP_PARM->_lines_avail = (NCURSES_SIZE_T) (ToLines - was_stolen);
+
+	if (SP_PARM->oldhash) {
+	    FreeAndNull(SP_PARM->oldhash);
 	}
-	if (SP->newhash) {
-	    FreeAndNull(SP->newhash);
+	if (SP_PARM->newhash) {
+	    FreeAndNull(SP_PARM->newhash);
 	}
 #ifdef TRACE
 	if (USE_TRACEF(TRACE_UPDATE)) {
@@ -378,11 +418,23 @@ resize_term(int ToLines, int ToCols)
     SET_LINES(ToLines - was_stolen);
     SET_COLS(ToCols);
 
-    _nc_unlock_global(curses);
+    _nc_nonsp_unlock_global(curses);
 
     returnCode(result);
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+resize_term(int ToLines, int ToCols)
+{
+    int res = ERR;
+    _nc_sp_lock_global(curses);
+    res = NCURSES_SP_NAME(resize_term) (CURRENT_SCREEN, ToLines, ToCols);
+    _nc_sp_unlock_global(curses);
+    return (res);
+}
+#endif
+
 /*
  * This function reallocates NCURSES window structures.  It is invoked in
  * response to a SIGWINCH interrupt.  Other user-defined windows may also need
@@ -392,34 +444,35 @@ resize_term(int ToLines, int ToCols)
  * invoked directly from the signal handler.
  */
 NCURSES_EXPORT(int)
-resizeterm(int ToLines, int ToCols)
+NCURSES_SP_NAME(resizeterm) (NCURSES_SP_DCLx int ToLines, int ToCols)
 {
     int result = ERR;
 
-    T((T_CALLED("resizeterm(%d,%d) old(%d,%d)"),
-       ToLines, ToCols,
-       screen_lines, screen_columns));
+    T((T_CALLED("resizeterm(%p, %d,%d) old(%d,%d)"),
+       (void *) SP_PARM, ToLines, ToCols,
+       (SP_PARM == 0) ? -1 : screen_lines(SP_PARM),
+       (SP_PARM == 0) ? -1 : screen_columns(SP_PARM)));
 
-    if (SP != 0) {
+    if (SP_PARM != 0) {
 	result = OK;
-	SP->_sig_winch = FALSE;
+	SP_PARM->_sig_winch = FALSE;
 
-	if (is_term_resized(ToLines, ToCols)) {
+	if (NCURSES_SP_NAME(is_term_resized) (NCURSES_SP_ARGx ToLines, ToCols)) {
 #if USE_SIGWINCH
 	    ripoff_t *rop;
-	    bool slk_visible = (SP != 0
-				&& SP->_slk != 0
-				&& !(SP->_slk->hidden));
+	    bool slk_visible = (SP_PARM != 0
+				&& SP_PARM->_slk != 0
+				&& !(SP_PARM->_slk->hidden));
 
 	    if (slk_visible) {
 		slk_clear();
 	    }
 #endif
-	    result = resize_term(ToLines, ToCols);
+	    result = NCURSES_SP_NAME(resize_term) (NCURSES_SP_ARGx ToLines, ToCols);
 
 #if USE_SIGWINCH
-	    _nc_ungetch(SP, KEY_RESIZE);	/* so application can know this */
-	    clearok(curscr, TRUE);	/* screen contents are unknown */
+	    safe_ungetch(SP_PARM, KEY_RESIZE);	/* so application can know this */
+	    clearok(CurScreen(SP_PARM), TRUE);	/* screen contents are unknown */
 
 	    /* ripped-off lines are a special case: if we did not lengthen
 	     * them, we haven't moved them either.  repaint them, too.
@@ -429,7 +482,7 @@ resizeterm(int ToLines, int ToCols)
 	     * not know which are really on top.
 	     */
 	    for (each_ripoff(rop)) {
-		if (rop->win != stdscr
+		if (rop->win != StdScreen(SP_PARM)
 		    && rop->win != 0
 		    && rop->line < 0) {
 
@@ -442,10 +495,9 @@ resizeterm(int ToLines, int ToCols)
 
 	    /* soft-keys are a special case: we _know_ how to repaint them */
 	    if (slk_visible) {
-		slk_restore();
-		slk_touch();
-
-		slk_refresh();
+		NCURSES_SP_NAME(slk_restore) (NCURSES_SP_ARG);
+		NCURSES_SP_NAME(slk_touch) (NCURSES_SP_ARG);
+		NCURSES_SP_NAME(slk_refresh) (NCURSES_SP_ARG);
 	    }
 #endif
 	}
@@ -453,3 +505,11 @@ resizeterm(int ToLines, int ToCols)
 
     returnCode(result);
 }
+
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+resizeterm(int ToLines, int ToCols)
+{
+    return NCURSES_SP_NAME(resizeterm) (CURRENT_SCREEN, ToLines, ToCols);
+}
+#endif