ncurses 5.7 - patch 20090425
authorThomas E. Dickey <dickey@invisible-island.net>
Sun, 26 Apr 2009 01:00:20 +0000 (01:00 +0000)
committerThomas E. Dickey <dickey@invisible-island.net>
Sun, 26 Apr 2009 01:00:20 +0000 (01:00 +0000)
+ continue integrating "sp-funcs" by Juergen Pfeifer (incomplete).

NEWS
dist.mk
include/MKterm.h.awk.in
include/curses.h.in
ncurses/curses.priv.h
ncurses/tty/lib_mvcur.c
ncurses/tty/tty_update.c

diff --git a/NEWS b/NEWS
index 4f64d6134e09955586e5bc669e014ce8580c2002..b5c9782a89be6b7ca42d3bb229d5e31a85f80770 100644 (file)
--- a/NEWS
+++ b/NEWS
@@ -25,7 +25,7 @@
 -- sale, use or other dealings in this Software without prior written        --
 -- authorization.                                                            --
 -------------------------------------------------------------------------------
--- $Id: NEWS,v 1.1382 2009/04/19 14:39:28 tom Exp $
+-- $Id: NEWS,v 1.1383 2009/04/25 21:28:43 tom Exp $
 -------------------------------------------------------------------------------
 
 This is a log of changes that ncurses has gone through since Zeyd started
@@ -45,6 +45,9 @@ See the AUTHORS file for the corresponding full names.
 Changes through 1.9.9e did not credit all contributions;
 it is not possible to add this information.
 
+20090425
+       + continue integrating "sp-funcs" by Juergen Pfeifer (incomplete).
+
 20090419
        + build fix for _nc_free_and_exit() change in 20090418 (report by
          Christian Ebert).
diff --git a/dist.mk b/dist.mk
index b872947cd9353e9cb482fe96882bec1eaecc2a55..99811e412d9c04b9043c86202d67dbdf58de7238 100644 (file)
--- a/dist.mk
+++ b/dist.mk
@@ -25,7 +25,7 @@
 # use or other dealings in this Software without prior written               #
 # authorization.                                                             #
 ##############################################################################
-# $Id: dist.mk,v 1.695 2009/04/19 14:38:20 tom Exp $
+# $Id: dist.mk,v 1.696 2009/04/25 17:43:20 tom Exp $
 # Makefile for creating ncurses distributions.
 #
 # This only needs to be used directly as a makefile by developers, but
@@ -37,7 +37,7 @@ SHELL = /bin/sh
 # These define the major/minor/patch versions of ncurses.
 NCURSES_MAJOR = 5
 NCURSES_MINOR = 7
-NCURSES_PATCH = 20090419
+NCURSES_PATCH = 20090425
 
 # We don't append the patch to the version, since this only applies to releases
 VERSION = $(NCURSES_MAJOR).$(NCURSES_MINOR)
index 31ee34c9feda3a93fd6aa5cbb1d9bb1de94369e8..9f635d65bc865bc7b315c93db60b87ac391a0c01 100644 (file)
@@ -34,7 +34,7 @@ BEGIN         {
                    print  "/*    and: Thomas E. Dickey                        1995-on                  */"
                    print  "/****************************************************************************/"
                    print  ""
-                   print  "/* $Id: MKterm.h.awk.in,v 1.54 2009/04/18 20:44:15 tom Exp $ */"
+                   print  "/* $Id: MKterm.h.awk.in,v 1.55 2009/04/25 18:02:27 tom Exp $ */"
                    print  ""
                    print  "/*"
                    print  "**  term.h -- Definition of struct term"
@@ -130,11 +130,15 @@ BEGIN             {
                    print  ""
                    print  "#else /* !HAVE_TERMIO_H */"
                    print  ""
+                   print  "#if __MINGW32__"
+                   print  "#  include <ncurses_mingw.h>"
+                   print  "#  define TTY struct termios"
+                   print  "#else"
                    print  "#undef TERMIOS"
                    print  "#include <sgtty.h>"
                    print  "#include <sys/ioctl.h>"
                    print  "#define TTY struct sgttyb"
-                   print  ""
+                   print  "#endif /* MINGW32 */"
                    print  "#endif /* HAVE_TERMIO_H */"
                    print  ""
                    print  "#endif /* HAVE_TERMIOS_H */"
index 0c722bdd4922a1e809379ebacf259a87fe580916..7adcb62261df2acfeea765f9a859046452b21c2f 100644 (file)
@@ -32,7 +32,7 @@
  *     and: Thomas E. Dickey                        1996-on                 *
  ****************************************************************************/
 
-/* $Id: curses.h.in,v 1.196 2009/04/18 19:57:58 tom Exp $ */
+/* $Id: curses.h.in,v 1.197 2009/04/25 21:03:34 tom Exp $ */
 
 #ifndef __NCURSES_H
 #define __NCURSES_H
@@ -965,9 +965,12 @@ extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(keybound) (SCREEN*, int, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(assume_default_colors) (SCREEN*, int, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(define_key) (SCREEN*, const char *, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(get_escdelay) (SCREEN*);
+extern NCURSES_EXPORT(bool) NCURSES_SP_NAME(is_term_resized) (SCREEN*, int, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(key_defined)(SCREEN*, const char *);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(keyok) (SCREEN*, int, bool);
 extern NCURSES_EXPORT(void) NCURSES_SP_NAME(nofilter) (SCREEN*); /* implemented */
+extern NCURSES_EXPORT(int) NCURSES_SP_NAME(resize_term) (SCREEN*, int, int);
+extern NCURSES_EXPORT(int) NCURSES_SP_NAME(resizeterm) (SCREEN*, int, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(set_escdelay) (SCREEN*, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(set_tabsize) (SCREEN*, int);
 extern NCURSES_EXPORT(int) NCURSES_SP_NAME(use_default_colors) (SCREEN*);
index a8e0c0bf87fcd94b82f0bda189009b7ee234f09c..acc94be24d0ed6e545f6b1a04063e9ec4b208ece 100644 (file)
@@ -35,7 +35,7 @@
 
 
 /*
- * $Id: curses.priv.h,v 1.408 2009/04/19 14:32:33 tom Exp $
+ * $Id: curses.priv.h,v 1.410 2009/04/25 23:38:37 tom Exp $
  *
  *     curses.priv.h
  *
@@ -1163,7 +1163,7 @@ extern NCURSES_EXPORT_VAR(SIG_ATOMIC_T) _nc_have_sigwinch;
                                AttrOf(dst) |= (ext + 1)
 
 #define if_WIDEC(code)  code
-#define Charable(ch)   ((SP != 0 && SP->_legacy_coding)                \
+#define Charable(ch)   ((SP_PARM != 0 && SP_PARM->_legacy_coding)      \
                         || (AttrOf(ch) & A_ALTCHARSET)                 \
                         || (!isWidecExt(ch) &&                         \
                             (ch).chars[1] == L'\0' &&                  \
@@ -1418,37 +1418,37 @@ extern  NCURSES_EXPORT(void) name (void); \
    }\
    TR(TRACE_ATTRS, ("new attribute is %s", _traceattr((S))));}
 
-#define DelCharCost(count) \
+#define DelCharCost(sp,count) \
                ((parm_dch != 0) \
-               ? SP->_dch_cost \
+               ? sp->_dch_cost \
                : ((delete_character != 0) \
-                       ? (SP->_dch1_cost * count) \
+                       ? (sp->_dch1_cost * count) \
                        : INFINITY))
 
-#define InsCharCost(count) \
+#define InsCharCost(sp,count) \
                ((parm_ich != 0) \
-               ? SP->_ich_cost \
+               ? sp->_ich_cost \
                : ((enter_insert_mode && exit_insert_mode) \
-                 ? SP->_smir_cost + SP->_rmir_cost + (SP->_ip_cost * count) \
+                 ? sp->_smir_cost + sp->_rmir_cost + (sp->_ip_cost * count) \
                  : ((insert_character != 0) \
-                   ? ((SP->_ich1_cost + SP->_ip_cost) * count) \
+                   ? ((sp->_ich1_cost + sp->_ip_cost) * count) \
                    : INFINITY)))
 
 #if USE_XMC_SUPPORT
-#define UpdateAttrs(c) if (!SameAttrOf(SCREEN_ATTRS(SP), c)) { \
-                               attr_t chg = AttrOf(SCREEN_ATTRS(SP)); \
+#define UpdateAttrs(sp,c)      if (!SameAttrOf(SCREEN_ATTRS(sp), c)) { \
+                               attr_t chg = AttrOf(SCREEN_ATTRS(sp)); \
                                VIDATTR(AttrOf(c), GetPair(c)); \
                                if (magic_cookie_glitch > 0 \
-                                && XMC_CHANGES((chg ^ AttrOf(SCREEN_ATTRS(SP))))) { \
+                                && XMC_CHANGES((chg ^ AttrOf(SCREEN_ATTRS(sp))))) { \
                                        T(("%s @%d before glitch %d,%d", \
                                                __FILE__, __LINE__, \
-                                               SP->_cursrow, \
-                                               SP->_curscol)); \
+                                               sp->_cursrow, \
+                                               sp->_curscol)); \
                                        _nc_do_xmc_glitch(chg); \
                                } \
                        }
 #else
-#define UpdateAttrs(c) if (!SameAttrOf(SCREEN_ATTRS(SP), c)) \
+#define UpdateAttrs(sp,c)      if (!SameAttrOf(SCREEN_ATTRS(sp), c)) \
                                VIDATTR(AttrOf(c), GetPair(c));
 #endif
 
@@ -1721,13 +1721,13 @@ extern NCURSES_EXPORT_VAR(int *) _nc_oldnums;
 #if BROKEN_LINKER
 #define SP _nc_screen()
 extern NCURSES_EXPORT(SCREEN *) _nc_screen (void);
-extern NCURSES_EXPORT(int) _nc_alloc_screen (void);
-extern NCURSES_EXPORT(void) _nc_set_screen (SCREEN *);
+extern NCURSES_EXPORT(int)      _nc_alloc_screen (void);
+extern NCURSES_EXPORT(void)     _nc_set_screen (SCREEN *);
 #else
 /* current screen is private data; avoid possible linking conflicts too */
 extern NCURSES_EXPORT_VAR(SCREEN *) SP;
-#define _nc_alloc_screen() ((SP = typeCalloc(SCREEN, 1)) != 0)
-#define _nc_set_screen(sp) SP = sp
+#define _nc_alloc_screen()      ((SP = typeCalloc(SCREEN, 1)) != 0)
+#define _nc_set_screen(sp)      SP = sp
 #endif
 
 #define CURRENT_SCREEN SP
@@ -1739,8 +1739,8 @@ extern NCURSES_EXPORT_VAR(SCREEN *) SP;
  * if the application is running multiple screens under X, it's quite possible
  * they could all have type xterm but have different sizes!  So...
  */
-#define screen_lines(sp)       (sp)->_lines
-#define screen_columns(sp)     (sp)->_columns
+#define screen_lines(sp)        (sp)->_lines
+#define screen_columns(sp)      (sp)->_columns
 
 extern NCURSES_EXPORT(int) _nc_slk_initialize (WINDOW *, int);
 
@@ -1802,45 +1802,52 @@ extern NCURSES_EXPORT(chtype)   NCURSES_SP_NAME(_nc_acs_char)(SCREEN*,int);
  */
 extern NCURSES_EXPORT(SCREEN*)  _nc_SP(void);
 
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_vidputs)(SCREEN*,chtype,int(*) (SCREEN*, int));
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_vidattr)(SCREEN *, chtype);
-
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scr_restore)(SCREEN*, const char*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scr_init)(SCREEN*,const char*);
-
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_restartterm)(SCREEN*,NCURSES_CONST char*,int,int*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_ripoffline)(SCREEN*, int, int (*)(WINDOW *,int));
+extern NCURSES_EXPORT(WINDOW *) NCURSES_SP_NAME(_nc_makenew) (SCREEN*, int, int, int, int, int);
 extern NCURSES_EXPORT(bool)     NCURSES_SP_NAME(_nc_is_term_resized)(SCREEN*,int,int);
+extern NCURSES_EXPORT(char *)   NCURSES_SP_NAME(_nc_printf_string)(SCREEN*, const char *, va_list);
+extern NCURSES_EXPORT(chtype)   NCURSES_SP_NAME(_nc_acs_char)(SCREEN*,int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_curs_set)(SCREEN*,int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_get_tty_mode)(SCREEN*,TTY*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_mcprint)(SCREEN*,char*, int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_msec_cost)(SCREEN*, const char *, int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_outch)(SCREEN*, int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_putp)(SCREEN*, const char *, const char *);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_putp_flush)(SCREEN*, const char *, const char *);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_resetty)(SCREEN*);
 extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_resize_term)(SCREEN*,int,int);
 extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_resizeterm)(SCREEN*,int,int);
-
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(_nc_outch)(SCREEN*, int);
-extern NCURSES_EXPORT(void)    NCURSES_SP_NAME(_nc_flush)(SCREEN*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_restartterm)(SCREEN*,NCURSES_CONST char*,int,int*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_ripoffline)(SCREEN*, int, int (*)(WINDOW *,int));
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_savetty)(SCREEN*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scr_init)(SCREEN*,const char*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scr_restore)(SCREEN*, const char*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scrolln)(SCREEN*, int, int, int, int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_set_tty_mode)(SCREEN*,TTY*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_setupscreen)(SCREEN**, int, int, FILE *, bool, int);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tgetent)(SCREEN*,char*,const char *);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tigetnum)(SCREEN*,NCURSES_CONST char*);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tputs)(SCREEN*,const char*,int,int(*)(SCREEN*, int));
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_vid_attr)(SCREEN *, attr_t, short, void *);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_vidattr)(SCREEN *, chtype);
+extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_vidputs)(SCREEN*,chtype,int(*) (SCREEN*, int));
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_do_color)(SCREEN*, short, short, bool, int (*)(SCREEN*,int));
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_do_xmc_glitch)(SCREEN*, attr_t);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_flush)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_free_and_exit)(SCREEN*,int) GCC_NORETURN;
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_freeall)(SCREEN*);
-extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_free_and_exit)(SCREEN*, int);
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_hash_map)(SCREEN*);
-extern NCURSES_EXPORT(WINDOW *) NCURSES_SP_NAME(_nc_makenew) (SCREEN*, int, int, int, int, int);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_init_acs)(SCREEN*);
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_make_oldhash)(SCREEN*, int i);
-extern NCURSES_EXPORT(char *)   NCURSES_SP_NAME(_nc_printf_string)(SCREEN*, const char *, va_list);
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(_nc_putp)(SCREEN*, const char *, const char *);
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(_nc_putp_flush)(SCREEN*, const char *, const char *);
-extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_set_buffer)(SCREEN*, FILE *, bool);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tgetent)(SCREEN*,char*,const char *);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tputs)(SCREEN*,const char*,int,int(*)(SCREEN*, int));
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_savetty)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_mvcur_init)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_mvcur_resume)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_mvcur_wrap)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_screen_init)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_screen_resume)(SCREEN*);
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_screen_wrap)(SCREEN*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_resetty)(SCREEN*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_scrolln)(SCREEN*, int, int, int, int);
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_scroll_oldhash)(SCREEN*, int n, int top, int bot);
 extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_scroll_optimize)(SCREEN*);
+extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_set_buffer)(SCREEN*, FILE *, bool);
 
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_mcprint)(SCREEN*,char*, int);
-extern NCURSES_EXPORT(char *)   NCURSES_SP_NAME(_nc_tgetstr)(SCREEN*,NCURSES_CONST char*,char**);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tgetflag)(SCREEN*,NCURSES_CONST char*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tgetnum)(SCREEN*,NCURSES_CONST char*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tigetflag)(SCREEN*,NCURSES_CONST char*);
-extern NCURSES_EXPORT(int)      NCURSES_SP_NAME(_nc_tigetnum)(SCREEN*,NCURSES_CONST char*);
-extern NCURSES_EXPORT(char *)   NCURSES_SP_NAME(_nc_tigetstr)(SCREEN*, NCURSES_CONST char*);
 extern NCURSES_EXPORT(void)     _nc_cookie_init(SCREEN *sp);
 extern NCURSES_EXPORT(int)      _nc_tinfo_doupdate(SCREEN *sp);
 extern NCURSES_EXPORT(int)      _nc_tinfo_mcprint(SCREEN*,char*,int);
@@ -1853,12 +1860,6 @@ extern NCURSES_EXPORT(void)     NCURSES_SP_NAME(_nc_linedump)(SCREEN*);
 extern NCURSES_EXPORT(wchar_t *) NCURSES_SP_NAME(_nc_wunctrl)(SCREEN*, cchar_t *);
 #endif
 
-/* FIXME - move these to curses.h.in */
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(getmouse) (SCREEN*, MEVENT *);
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(ungetmouse) (SCREEN*, MEVENT *);
-extern NCURSES_EXPORT(mmask_t) NCURSES_SP_NAME(mousemask) (SCREEN*, mmask_t, mmask_t *);
-extern NCURSES_EXPORT(int)     NCURSES_SP_NAME(mouseinterval) (SCREEN*, int);
-extern NCURSES_EXPORT(bool)    NCURSES_SP_NAME(has_mouse) (SCREEN*);
 #endif /* NCURSES_SP_FUNCS */
 
 #if NCURSES_SP_FUNCS
index 3961f4571fa1d77c89211d8567b5a0fe08723bfd..157f7eb67e92e9023e5b0c259f55a89bea8bc2a6 100644 (file)
  * LONG_DIST and (b) further inward from the right or left edge than LONG_DIST,
  * we'll consider nonlocal.
  */
-#define NOT_LOCAL(fy, fx, ty, tx)      ((tx > LONG_DIST) \
-                && (tx < screen_columns(CURRENT_SCREEN) - 1 - LONG_DIST) \
+#define NOT_LOCAL(sp, fy, fx, ty, tx)  ((tx > LONG_DIST) \
+                && (tx < screen_columns(sp) - 1 - LONG_DIST) \
                 && (abs(ty-fy) + abs(tx-fx) > LONG_DIST))
 
 /****************************************************************************
 #include <term.h>
 #include <ctype.h>
 
-MODULE_ID("$Id: lib_mvcur.c,v 1.115 2009/04/18 19:03:05 tom Exp $")
+MODULE_ID("$Id: lib_mvcur.c,v 1.117 2009/04/26 00:15:22 tom Exp $")
 
-#define WANT_CHAR(y, x)        SP->_newscr->_line[y].text[x]   /* desired state */
-#define BAUDRATE       cur_term->_baudrate     /* bits per second */
+#define WANT_CHAR(sp, y, x) (sp)->_newscr->_line[y].text[x]    /* desired state */
+#define BAUDRATE(sp)   cur_term->_baudrate     /* bits per second */
 
 #if defined(MAIN) || defined(NCURSES_TEST)
 #include <sys/time.h>
@@ -170,7 +170,7 @@ static float diff;
 
 #define OPT_SIZE 512
 
-static int normalized_cost(const char *const cap, int affcnt);
+static int normalized_cost(NCURSES_SP_DCLx const char *const cap, int affcnt);
 
 /****************************************************************************
  *
@@ -180,34 +180,34 @@ static int normalized_cost(const char *const cap, int affcnt);
 
 #ifdef TRACE
 static int
-trace_cost_of(const char *capname, const char *cap, int affcnt)
+trace_cost_of(NCURSES_SP_DCLx const char *capname, const char *cap, int affcnt)
 {
-    int result = _nc_msec_cost(cap, affcnt);
+    int result = NCURSES_SP_NAME(_nc_msec_cost) (NCURSES_SP_ARGx cap, affcnt);
     TR(TRACE_CHARPUT | TRACE_MOVE,
        ("CostOf %s %d %s", capname, result, _nc_visbuf(cap)));
     return result;
 }
-#define CostOf(cap,affcnt) trace_cost_of(#cap,cap,affcnt);
+#define CostOf(cap,affcnt) trace_cost_of(NCURSES_SP_ARGx #cap, cap, affcnt)
 
 static int
-trace_normalized_cost(const char *capname, const char *cap, int affcnt)
+trace_normalized_cost(NCURSES_SP_DCLx const char *capname, const char *cap, int affcnt)
 {
-    int result = normalized_cost(cap, affcnt);
+    int result = normalized_cost(NCURSES_SP_ARGx cap, affcnt);
     TR(TRACE_CHARPUT | TRACE_MOVE,
        ("NormalizedCost %s %d %s", capname, result, _nc_visbuf(cap)));
     return result;
 }
-#define NormalizedCost(cap,affcnt) trace_normalized_cost(#cap,cap,affcnt);
+#define NormalizedCost(cap,affcnt) trace_normalized_cost(NCURSES_SP_ARGx #cap, cap, affcnt)
 
 #else
 
-#define CostOf(cap,affcnt) _nc_msec_cost(cap,affcnt);
-#define NormalizedCost(cap,affcnt) normalized_cost(cap,affcnt);
+#define CostOf(cap,affcnt) NCURSES_SP_NAME(_nc_msec_cost)(NCURSES_SP_ARGx cap, affcnt)
+#define NormalizedCost(cap,affcnt) normalized_cost(NCURSES_SP_ARGx cap, affcnt)
 
 #endif
 
 NCURSES_EXPORT(int)
-_nc_msec_cost(const char *const cap, int affcnt)
+NCURSES_SP_NAME(_nc_msec_cost) (NCURSES_SP_DCLx const char *const cap, int affcnt)
 /* compute the cost of a given operation */
 {
     if (cap == 0)
@@ -231,29 +231,37 @@ _nc_msec_cost(const char *const cap, int affcnt)
                }
 
 #if NCURSES_NO_PADDING
-               if (!GetNoPadding(SP))
+               if (!GetNoPadding(SP_PARM))
 #endif
                    cum_cost += number * 10;
            } else
-               cum_cost += SP->_char_padding;
+               cum_cost += SP_PARM->_char_padding;
        }
 
        return ((int) cum_cost);
     }
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+_nc_msec_cost(const char *const cap, int affcnt)
+{
+    return NCURSES_SP_NAME(_nc_msec_cost) (CURRENT_SCREEN, cap, affcnt);
+}
+#endif
+
 static int
-normalized_cost(const char *const cap, int affcnt)
+normalized_cost(NCURSES_SP_DCLx const char *const cap, int affcnt)
 /* compute the effective character-count for an operation (round up) */
 {
     int cost = _nc_msec_cost(cap, affcnt);
     if (cost != INFINITY)
-       cost = (cost + SP->_char_padding - 1) / SP->_char_padding;
+       cost = (cost + SP_PARM->_char_padding - 1) / SP_PARM->_char_padding;
     return cost;
 }
 
 static void
-reset_scroll_region(void)
+reset_scroll_region(NCURSES_SP_DCL0)
 /* Set the scroll-region to a known state (the default) */
 {
     if (change_scroll_region) {
@@ -263,7 +271,7 @@ reset_scroll_region(void)
 }
 
 NCURSES_EXPORT(void)
-_nc_mvcur_resume(void)
+NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_DCL0)
 /* what to do at initialization time and after each shellout */
 {
     /* initialize screen for cursor access */
@@ -281,53 +289,63 @@ _nc_mvcur_resume(void)
      * they know the screen size.  This is useful when you're running
      * a vt100 emulation through xterm.
      */
-    reset_scroll_region();
-    SP->_cursrow = SP->_curscol = -1;
+    reset_scroll_region(NCURSES_SP_ARG);
+    SP_PARM->_cursrow = SP_PARM->_curscol = -1;
 
     /* restore cursor shape */
-    if (SP->_cursor != -1) {
-       int cursor = SP->_cursor;
-       SP->_cursor = -1;
+    if (SP_PARM->_cursor != -1) {
+       int cursor = SP_PARM->_cursor;
+       SP_PARM->_cursor = -1;
        curs_set(cursor);
     }
 }
 
+#if NCURSES_SP_FUNCS
 NCURSES_EXPORT(void)
-_nc_mvcur_init(void)
+_nc_mvcur_resume(void)
+{
+    NCURSES_SP_NAME(_nc_mvcur_resume) (CURRENT_SCREEN);
+}
+#endif
+
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
 /* initialize the cost structure */
 {
-    if (isatty(fileno(SP->_ofp)))
-       SP->_char_padding = ((BAUDBYTE * 1000 * 10)
-                            / (BAUDRATE > 0 ? BAUDRATE : 9600));
+    if (isatty(fileno(SP_PARM->_ofp)))
+       SP_PARM->_char_padding = ((BAUDBYTE * 1000 * 10)
+                                 / (BAUDRATE(SP_PARM) > 0
+                                    ? BAUDRATE(SP_PARM)
+                                    : 9600));
     else
-       SP->_char_padding = 1;  /* must be nonzero */
-    if (SP->_char_padding <= 0)
-       SP->_char_padding = 1;  /* must be nonzero */
-    TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP->_char_padding));
+       SP_PARM->_char_padding = 1;     /* must be nonzero */
+    if (SP_PARM->_char_padding <= 0)
+       SP_PARM->_char_padding = 1;     /* must be nonzero */
+    TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP_PARM->_char_padding));
 
     /* non-parameterized local-motion strings */
-    SP->_cr_cost = CostOf(carriage_return, 0);
-    SP->_home_cost = CostOf(cursor_home, 0);
-    SP->_ll_cost = CostOf(cursor_to_ll, 0);
+    SP_PARM->_cr_cost = CostOf(carriage_return, 0);
+    SP_PARM->_home_cost = CostOf(cursor_home, 0);
+    SP_PARM->_ll_cost = CostOf(cursor_to_ll, 0);
 #if USE_HARD_TABS
     if (getenv("NCURSES_NO_HARD_TABS") == 0) {
-       SP->_ht_cost = CostOf(tab, 0);
-       SP->_cbt_cost = CostOf(back_tab, 0);
+       SP_PARM->_ht_cost = CostOf(tab, 0);
+       SP_PARM->_cbt_cost = CostOf(back_tab, 0);
     } else {
-       SP->_ht_cost = INFINITY;
-       SP->_cbt_cost = INFINITY;
+       SP_PARM->_ht_cost = INFINITY;
+       SP_PARM->_cbt_cost = INFINITY;
     }
 #endif /* USE_HARD_TABS */
-    SP->_cub1_cost = CostOf(cursor_left, 0);
-    SP->_cuf1_cost = CostOf(cursor_right, 0);
-    SP->_cud1_cost = CostOf(cursor_down, 0);
-    SP->_cuu1_cost = CostOf(cursor_up, 0);
-
-    SP->_smir_cost = CostOf(enter_insert_mode, 0);
-    SP->_rmir_cost = CostOf(exit_insert_mode, 0);
-    SP->_ip_cost = 0;
+    SP_PARM->_cub1_cost = CostOf(cursor_left, 0);
+    SP_PARM->_cuf1_cost = CostOf(cursor_right, 0);
+    SP_PARM->_cud1_cost = CostOf(cursor_down, 0);
+    SP_PARM->_cuu1_cost = CostOf(cursor_up, 0);
+
+    SP_PARM->_smir_cost = CostOf(enter_insert_mode, 0);
+    SP_PARM->_rmir_cost = CostOf(exit_insert_mode, 0);
+    SP_PARM->_ip_cost = 0;
     if (insert_padding) {
-       SP->_ip_cost = CostOf(insert_padding, 0);
+       SP_PARM->_ip_cost = CostOf(insert_padding, 0);
     }
 
     /*
@@ -336,7 +354,7 @@ _nc_mvcur_init(void)
      * can treat it like absolute screen addressing.  This seems to be true
      * for all cursor_mem_address terminal types in the terminfo database.
      */
-    SP->_address_cursor = cursor_address ? cursor_address : cursor_mem_address;
+    SP_PARM->_address_cursor = cursor_address ? cursor_address : cursor_mem_address;
 
     /*
      * Parametrized local-motion strings.  This static cost computation
@@ -362,40 +380,42 @@ _nc_mvcur_init(void)
      * All these averages depend on the assumption that all parameter values
      * are equally probable.
      */
-    SP->_cup_cost = CostOf(TPARM_2(SP->_address_cursor, 23, 23), 1);
-    SP->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1);
-    SP->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1);
-    SP->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1);
-    SP->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1);
-    SP->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1);
-    SP->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1);
+    SP_PARM->_cup_cost = CostOf(TPARM_2(SP_PARM->_address_cursor, 23, 23), 1);
+    SP_PARM->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1);
+    SP_PARM->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1);
+    SP_PARM->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1);
+    SP_PARM->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1);
+    SP_PARM->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1);
+    SP_PARM->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1);
 
     /* non-parameterized screen-update strings */
-    SP->_ed_cost = NormalizedCost(clr_eos, 1);
-    SP->_el_cost = NormalizedCost(clr_eol, 1);
-    SP->_el1_cost = NormalizedCost(clr_bol, 1);
-    SP->_dch1_cost = NormalizedCost(delete_character, 1);
-    SP->_ich1_cost = NormalizedCost(insert_character, 1);
+    SP_PARM->_ed_cost = NormalizedCost(clr_eos, 1);
+    SP_PARM->_el_cost = NormalizedCost(clr_eol, 1);
+    SP_PARM->_el1_cost = NormalizedCost(clr_bol, 1);
+    SP_PARM->_dch1_cost = NormalizedCost(delete_character, 1);
+    SP_PARM->_ich1_cost = NormalizedCost(insert_character, 1);
 
     /*
      * If this is a bce-terminal, we want to bias the choice so we use clr_eol
      * rather than spaces at the end of a line.
      */
     if (back_color_erase)
-       SP->_el_cost = 0;
+       SP_PARM->_el_cost = 0;
 
     /* parameterized screen-update strings */
-    SP->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1);
-    SP->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1);
-    SP->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1);
-    SP->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1);
-
-    SP->_cup_ch_cost = NormalizedCost(TPARM_2(SP->_address_cursor, 23, 23), 1);
-    SP->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1);
-    SP->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1);
-    SP->_inline_cost = min(SP->_cup_ch_cost,
-                          min(SP->_hpa_ch_cost,
-                              SP->_cuf_ch_cost));
+    SP_PARM->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1);
+    SP_PARM->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1);
+    SP_PARM->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1);
+    SP_PARM->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1);
+
+    SP_PARM->_cup_ch_cost = NormalizedCost(
+                                             TPARM_2(SP_PARM->_address_cursor,
+                                                     23, 23), 1);
+    SP_PARM->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1);
+    SP_PARM->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1);
+    SP_PARM->_inline_cost = min(SP_PARM->_cup_ch_cost,
+                               min(SP_PARM->_hpa_ch_cost,
+                                   SP_PARM->_cuf_ch_cost));
 
     /*
      * If save_cursor is used within enter_ca_mode, we should not use it for
@@ -412,25 +432,34 @@ _nc_mvcur_init(void)
     }
 
     /*
-     * A different, possibly better way to arrange this would be to set
-     * SP->_endwin = TRUE at window initialization time and let this be
+     * A different, possibly better way to arrange this would be to set the
+     * SCREEN's _endwin to TRUE at window initialization time and let this be
      * called by doupdate's return-from-shellout code.
      */
     _nc_mvcur_resume();
 }
 
+#if NCURSES_SP_FUNCS
 NCURSES_EXPORT(void)
-_nc_mvcur_wrap(void)
+_nc_mvcur_init(void)
+{
+    NCURSES_SP_NAME(_nc_mvcur_init) (CURRENT_SCREEN);
+    _nc_mvcur_resume();
+}
+#endif
+
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_mvcur_wrap) (NCURSES_SP_DCL0)
 /* wrap up cursor-addressing mode */
 {
     /* leave cursor at screen bottom */
     mvcur(-1, -1, screen_lines(CURRENT_SCREEN) - 1, 0);
 
     /* set cursor to normal mode */
-    if (SP->_cursor != -1) {
-       int cursor = SP->_cursor;
+    if (SP_PARM->_cursor != -1) {
+       int cursor = SP_PARM->_cursor;
        curs_set(1);
-       SP->_cursor = cursor;
+       SP_PARM->_cursor = cursor;
     }
 
     if (exit_ca_mode) {
@@ -448,6 +477,14 @@ _nc_mvcur_wrap(void)
     _nc_outch('\r');
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_mvcur_wrap(void)
+{
+    NCURSES_SP_NAME(_nc_mvcur_wrap) (CURRENT_SCREEN);
+}
+#endif
+
 /****************************************************************************
  *
  * Optimized cursor movement
@@ -487,8 +524,13 @@ repeated_append(string_desc * target, int total, int num, int repeat, const char
 #define LASTTAB(fr)    ((fr > 0) ? ((fr - 1) / init_tabs) * init_tabs : -1)
 
 static int
-relative_move(string_desc * target, int from_y, int from_x, int to_y, int
-             to_x, bool ovw)
+relative_move(NCURSES_SP_DCLx
+             string_desc * target,
+             int from_y,
+             int from_x,
+             int to_y,
+             int to_x,
+             bool ovw)
 /* move via local motions (cuu/cuu1/cud/cud1/cub1/cub/cuf1/cuf/vpa/hpa) */
 {
     string_desc save;
@@ -501,38 +543,38 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
 
        if (row_address != 0
            && _nc_safe_strcat(target, TPARM_1(row_address, to_y))) {
-           vcost = SP->_vpa_cost;
+           vcost = SP_PARM->_vpa_cost;
        }
 
        if (to_y > from_y) {
            n = (to_y - from_y);
 
            if (parm_down_cursor
-               && SP->_cud_cost < vcost
+               && SP_PARM->_cud_cost < vcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
                                   TPARM_1(parm_down_cursor, n))) {
-               vcost = SP->_cud_cost;
+               vcost = SP_PARM->_cud_cost;
            }
 
            if (cursor_down
-               && (*cursor_down != '\n' || SP->_nl)
-               && (n * SP->_cud1_cost < vcost)) {
+               && (*cursor_down != '\n' || SP_PARM->_nl)
+               && (n * SP_PARM->_cud1_cost < vcost)) {
                vcost = repeated_append(_nc_str_copy(target, &save), 0,
-                                       SP->_cud1_cost, n, cursor_down);
+                                       SP_PARM->_cud1_cost, n, cursor_down);
            }
        } else {                /* (to_y < from_y) */
            n = (from_y - to_y);
 
            if (parm_up_cursor
-               && SP->_cuu_cost < vcost
+               && SP_PARM->_cuu_cost < vcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
                                   TPARM_1(parm_up_cursor, n))) {
-               vcost = SP->_cuu_cost;
+               vcost = SP_PARM->_cuu_cost;
            }
 
-           if (cursor_up && (n * SP->_cuu1_cost < vcost)) {
+           if (cursor_up && (n * SP_PARM->_cuu1_cost < vcost)) {
                vcost = repeated_append(_nc_str_copy(target, &save), 0,
-                                       SP->_cuu1_cost, n, cursor_up);
+                                       SP_PARM->_cuu1_cost, n, cursor_up);
            }
        }
 
@@ -551,17 +593,17 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
        if (column_address
            && _nc_safe_strcat(_nc_str_copy(target, &save),
                               TPARM_1(column_address, to_x))) {
-           hcost = SP->_hpa_cost;
+           hcost = SP_PARM->_hpa_cost;
        }
 
        if (to_x > from_x) {
            n = to_x - from_x;
 
            if (parm_right_cursor
-               && SP->_cuf_cost < hcost
+               && SP_PARM->_cuf_cost < hcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
                                   TPARM_1(parm_right_cursor, n))) {
-               hcost = SP->_cuf_cost;
+               hcost = SP_PARM->_cuf_cost;
            }
 
            if (cursor_right) {
@@ -576,7 +618,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
 
                    for (fr = from_x; (nxt = NEXTTAB(fr)) <= to_x; fr = nxt) {
                        lhcost = repeated_append(&check, lhcost,
-                                                SP->_ht_cost, 1, tab);
+                                                SP_PARM->_ht_cost, 1, tab);
                        if (lhcost == INFINITY)
                            break;
                    }
@@ -600,7 +642,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
                    && n < (int) check.s_size
                    && vcost == 0
                    && str[0] == '\0') {
-                   int wanted = CharOf(WANT_CHAR(to_y, from_x));
+                   int wanted = CharOf(WANT_CHAR(SP_PARM, to_y, from_x));
                    if (is8bits(wanted) && isdigit(wanted))
                        ovw = FALSE;
                }
@@ -617,8 +659,8 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
                    int i;
 
                    for (i = 0; i < n; i++) {
-                       NCURSES_CH_T ch = WANT_CHAR(to_y, from_x + i);
-                       if (!SameAttrOf(ch, SCREEN_ATTRS(SP))
+                       NCURSES_CH_T ch = WANT_CHAR(SP_PARM, to_y, from_x + i);
+                       if (!SameAttrOf(ch, SCREEN_ATTRS(SP_PARM))
 #if USE_WIDEC_SUPPORT
                            || !Charable(ch)
 #endif
@@ -632,13 +674,13 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
                    int i;
 
                    for (i = 0; i < n; i++)
-                       *check.s_tail++ = (char) CharOf(WANT_CHAR(to_y,
+                       *check.s_tail++ = (char) CharOf(WANT_CHAR(SP_PARM, to_y,
                                                                  from_x + i));
                    *check.s_tail = '\0';
                    check.s_size -= n;
-                   lhcost += n * SP->_char_padding;
+                   lhcost += n * SP_PARM->_char_padding;
                } else {
-                   lhcost = repeated_append(&check, lhcost, SP->_cuf1_cost,
+                   lhcost = repeated_append(&check, lhcost, SP_PARM->_cuf1_cost,
                                             n, cursor_right);
                }
 
@@ -651,10 +693,10 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
            n = from_x - to_x;
 
            if (parm_left_cursor
-               && SP->_cub_cost < hcost
+               && SP_PARM->_cub_cost < hcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
                                   TPARM_1(parm_left_cursor, n))) {
-               hcost = SP->_cub_cost;
+               hcost = SP_PARM->_cub_cost;
            }
 
            if (cursor_left) {
@@ -668,7 +710,8 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
 
                    for (fr = from_x; (nxt = LASTTAB(fr)) >= to_x; fr = nxt) {
                        lhcost = repeated_append(&check, lhcost,
-                                                SP->_cbt_cost, 1, back_tab);
+                                                SP_PARM->_cbt_cost,
+                                                1, back_tab);
                        if (lhcost == INFINITY)
                            break;
                    }
@@ -677,7 +720,9 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
                }
 #endif /* USE_HARD_TABS */
 
-               lhcost = repeated_append(&check, lhcost, SP->_cub1_cost, n, cursor_left);
+               lhcost = repeated_append(&check, lhcost,
+                                        SP_PARM->_cub1_cost,
+                                        n, cursor_left);
 
                if (lhcost < hcost
                    && _nc_safe_strcat(_nc_str_copy(target, &save), str)) {
@@ -706,7 +751,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int
  */
 
 static NCURSES_INLINE int
-onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
+onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw)
 /* onscreen move from (yold, xold) to (ynew, xnew) */
 {
     string_desc result;
@@ -724,9 +769,9 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
 #define InitResult _nc_str_init(&result, buffer, sizeof(buffer))
 
     /* tactic #0: use direct cursor addressing */
-    if (_nc_safe_strcpy(InitResult, TPARM_2(SP->_address_cursor, ynew, xnew))) {
+    if (_nc_safe_strcpy(InitResult, TPARM_2(SP_PARM->_address_cursor, ynew, xnew))) {
        tactic = 0;
-       usecost = SP->_cup_cost;
+       usecost = SP_PARM->_cup_cost;
 
 #if defined(TRACE) || defined(NCURSES_TEST)
        if (!(_nc_optimize_enable & OPTIMIZE_MVCUR))
@@ -741,7 +786,7 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
         * (like, say, local-movement \n getting mapped to some obscure
         * character because A_ALTCHARSET is on).
         */
-       if (yold == -1 || xold == -1 || NOT_LOCAL(yold, xold, ynew, xnew)) {
+       if (yold == -1 || xold == -1 || NOT_LOCAL(SP_PARM, yold, xold, ynew, xnew)) {
 #if defined(MAIN) || defined(NCURSES_TEST)
            if (!profiling) {
                (void) fputs("nonlocal\n", stderr);
@@ -755,7 +800,8 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
 #ifndef NO_OPTIMIZE
     /* tactic #1: use local movement */
     if (yold != -1 && xold != -1
-       && ((newcost = relative_move(NullResult, yold, xold, ynew, xnew,
+       && ((newcost = relative_move(NCURSES_SP_ARGx
+                                    NullResult, yold, xold, ynew, xnew,
                                     ovw)) != INFINITY)
        && newcost < usecost) {
        tactic = 1;
@@ -764,47 +810,50 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
 
     /* tactic #2: use carriage-return + local movement */
     if (yold != -1 && carriage_return
-       && ((newcost = relative_move(NullResult, yold, 0, ynew, xnew, ovw))
+       && ((newcost = relative_move(NCURSES_SP_ARGx
+                                    NullResult, yold, 0, ynew, xnew, ovw))
            != INFINITY)
-       && SP->_cr_cost + newcost < usecost) {
+       && SP_PARM->_cr_cost + newcost < usecost) {
        tactic = 2;
-       usecost = SP->_cr_cost + newcost;
+       usecost = SP_PARM->_cr_cost + newcost;
     }
 
     /* tactic #3: use home-cursor + local movement */
     if (cursor_home
-       && ((newcost = relative_move(NullResult, 0, 0, ynew, xnew, ovw)) != INFINITY)
-       && SP->_home_cost + newcost < usecost) {
+       && ((newcost = relative_move(NCURSES_SP_ARGx
+                                    NullResult, 0, 0, ynew, xnew, ovw)) != INFINITY)
+       && SP_PARM->_home_cost + newcost < usecost) {
        tactic = 3;
-       usecost = SP->_home_cost + newcost;
+       usecost = SP_PARM->_home_cost + newcost;
     }
 
     /* tactic #4: use home-down + local movement */
     if (cursor_to_ll
-       && ((newcost = relative_move(NullResult,
-                                    screen_lines(CURRENT_SCREEN) - 1, 0, ynew,
+       && ((newcost = relative_move(NCURSES_SP_ARGx
+                                    NullResult,
+                                    screen_lines(SP_PARM) - 1, 0, ynew,
                                     xnew, ovw)) != INFINITY)
-       && SP->_ll_cost + newcost < usecost) {
+       && SP_PARM->_ll_cost + newcost < usecost) {
        tactic = 4;
-       usecost = SP->_ll_cost + newcost;
+       usecost = SP_PARM->_ll_cost + newcost;
     }
 
     /*
      * tactic #5: use left margin for wrap to right-hand side,
      * unless strange wrap behavior indicated by xenl might hose us.
      */
-    t5_cr_cost = (xold > 0 ? SP->_cr_cost : 0);
+    t5_cr_cost = (xold > 0 ? SP_PARM->_cr_cost : 0);
     if (auto_left_margin && !eat_newline_glitch
        && yold > 0 && cursor_left
-       && ((newcost = relative_move(NullResult,
+       && ((newcost = relative_move(NCURSES_SP_ARGx NullResult,
                                     yold - 1,
-                                    screen_columns(CURRENT_SCREEN) - 1,
+                                    screen_columns(SP_PARM) - 1,
                                     ynew,
                                     xnew,
                                     ovw)) != INFINITY)
-       && t5_cr_cost + SP->_cub1_cost + newcost < usecost) {
+       && t5_cr_cost + SP_PARM->_cub1_cost + newcost < usecost) {
        tactic = 5;
-       usecost = t5_cr_cost + SP->_cub1_cost + newcost;
+       usecost = t5_cr_cost + SP_PARM->_cub1_cost + newcost;
     }
 
     /*
@@ -814,35 +863,35 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
        InitResult;
     switch (tactic) {
     case 1:
-       (void) relative_move(&result, yold, xold, ynew, xnew, ovw);
+       (void) relative_move(NCURSES_SP_ARGx
+                            &result, yold, xold,
+                            ynew, xnew, ovw);
        break;
     case 2:
        (void) _nc_safe_strcpy(&result, carriage_return);
-       (void) relative_move(&result, yold, 0, ynew, xnew, ovw);
+       (void) relative_move(NCURSES_SP_ARGx
+                            &result, yold, 0,
+                            ynew, xnew, ovw);
        break;
     case 3:
        (void) _nc_safe_strcpy(&result, cursor_home);
-       (void) relative_move(&result, 0, 0, ynew, xnew, ovw);
+       (void) relative_move(NCURSES_SP_ARGx
+                            &result, 0, 0,
+                            ynew, xnew, ovw);
        break;
     case 4:
        (void) _nc_safe_strcpy(&result, cursor_to_ll);
-       (void) relative_move(&result,
-                            screen_lines(CURRENT_SCREEN) - 1,
-                            0,
-                            ynew,
-                            xnew,
-                            ovw);
+       (void) relative_move(NCURSES_SP_ARGx &result,
+                            screen_lines(SP_PARM) - 1, 0,
+                            ynew, xnew, ovw);
        break;
     case 5:
        if (xold > 0)
            (void) _nc_safe_strcat(&result, carriage_return);
        (void) _nc_safe_strcat(&result, cursor_left);
-       (void) relative_move(&result,
-                            yold - 1,
-                            screen_columns(CURRENT_SCREEN) - 1,
-                            ynew,
-                            xnew,
-                            ovw);
+       (void) relative_move(NCURSES_SP_ARGx &result,
+                            yold - 1, screen_columns(SP_PARM) - 1,
+                            ynew, xnew, ovw);
        break;
     }
 #endif /* !NO_OPTIMIZE */
@@ -861,8 +910,8 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw)
     if (usecost != INFINITY) {
        TPUTS_TRACE("mvcur");
        tputs(buffer, 1, _nc_outch);
-       SP->_cursrow = ynew;
-       SP->_curscol = xnew;
+       SP_PARM->_cursrow = ynew;
+       SP_PARM->_curscol = xnew;
        return (OK);
     } else
        return (ERR);
@@ -890,9 +939,9 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx
         * column position implied by wraparound or the lack thereof and
         * rolling up the screen to get ynew on the screen.
         */
-       if (xnew >= screen_columns(CURRENT_SCREEN)) {
-           ynew += xnew / screen_columns(CURRENT_SCREEN);
-           xnew %= screen_columns(CURRENT_SCREEN);
+       if (xnew >= screen_columns(SP_PARM)) {
+           ynew += xnew / screen_columns(SP_PARM);
+           xnew %= screen_columns(SP_PARM);
        }
 
        /*
@@ -909,14 +958,14 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx
            (void) VIDATTR(A_NORMAL, 0);
        }
 
-       if (xold >= screen_columns(CURRENT_SCREEN)) {
+       if (xold >= screen_columns(SP_PARM)) {
            int l;
 
            if (SP_PARM->_nl) {
-               l = (xold + 1) / screen_columns(CURRENT_SCREEN);
+               l = (xold + 1) / screen_columns(SP_PARM);
                yold += l;
-               if (yold >= screen_lines(CURRENT_SCREEN))
-                   l -= (yold - screen_lines(CURRENT_SCREEN) - 1);
+               if (yold >= screen_lines(SP_PARM))
+                   l -= (yold - screen_lines(SP_PARM) - 1);
 
                if (l > 0) {
                    if (carriage_return) {
@@ -945,13 +994,13 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx
            }
        }
 
-       if (yold > screen_lines(CURRENT_SCREEN) - 1)
-           yold = screen_lines(CURRENT_SCREEN) - 1;
-       if (ynew > screen_lines(CURRENT_SCREEN) - 1)
-           ynew = screen_lines(CURRENT_SCREEN) - 1;
+       if (yold > screen_lines(SP_PARM) - 1)
+           yold = screen_lines(SP_PARM) - 1;
+       if (ynew > screen_lines(SP_PARM) - 1)
+           ynew = screen_lines(SP_PARM) - 1;
 
        /* destination location is on screen now */
-       code = onscreen_mvcur(yold, xold, ynew, xnew, TRUE);
+       code = onscreen_mvcur(NCURSES_SP_ARGx yold, xold, ynew, xnew, TRUE);
 
        /*
         * Restore attributes if we disabled them before moving.
@@ -1236,25 +1285,25 @@ main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
                           speeds[i], overhead, totalest);
            }
        } else if (buf[0] == 'c') {
-           (void) printf("char padding: %d\n", SP->_char_padding);
-           (void) printf("cr cost: %d\n", SP->_cr_cost);
-           (void) printf("cup cost: %d\n", SP->_cup_cost);
-           (void) printf("home cost: %d\n", SP->_home_cost);
-           (void) printf("ll cost: %d\n", SP->_ll_cost);
+           (void) printf("char padding: %d\n", CURRENT_SCREEN->_char_padding);
+           (void) printf("cr cost: %d\n", CURRENT_SCREEN->_cr_cost);
+           (void) printf("cup cost: %d\n", CURRENT_SCREEN->_cup_cost);
+           (void) printf("home cost: %d\n", CURRENT_SCREEN->_home_cost);
+           (void) printf("ll cost: %d\n", CURRENT_SCREEN->_ll_cost);
 #if USE_HARD_TABS
-           (void) printf("ht cost: %d\n", SP->_ht_cost);
-           (void) printf("cbt cost: %d\n", SP->_cbt_cost);
+           (void) printf("ht cost: %d\n", CURRENT_SCREEN->_ht_cost);
+           (void) printf("cbt cost: %d\n", CURRENT_SCREEN->_cbt_cost);
 #endif /* USE_HARD_TABS */
-           (void) printf("cub1 cost: %d\n", SP->_cub1_cost);
-           (void) printf("cuf1 cost: %d\n", SP->_cuf1_cost);
-           (void) printf("cud1 cost: %d\n", SP->_cud1_cost);
-           (void) printf("cuu1 cost: %d\n", SP->_cuu1_cost);
-           (void) printf("cub cost: %d\n", SP->_cub_cost);
-           (void) printf("cuf cost: %d\n", SP->_cuf_cost);
-           (void) printf("cud cost: %d\n", SP->_cud_cost);
-           (void) printf("cuu cost: %d\n", SP->_cuu_cost);
-           (void) printf("hpa cost: %d\n", SP->_hpa_cost);
-           (void) printf("vpa cost: %d\n", SP->_vpa_cost);
+           (void) printf("cub1 cost: %d\n", CURRENT_SCREEN->_cub1_cost);
+           (void) printf("cuf1 cost: %d\n", CURRENT_SCREEN->_cuf1_cost);
+           (void) printf("cud1 cost: %d\n", CURRENT_SCREEN->_cud1_cost);
+           (void) printf("cuu1 cost: %d\n", CURRENT_SCREEN->_cuu1_cost);
+           (void) printf("cub cost: %d\n", CURRENT_SCREEN->_cub_cost);
+           (void) printf("cuf cost: %d\n", CURRENT_SCREEN->_cuf_cost);
+           (void) printf("cud cost: %d\n", CURRENT_SCREEN->_cud_cost);
+           (void) printf("cuu cost: %d\n", CURRENT_SCREEN->_cuu_cost);
+           (void) printf("hpa cost: %d\n", CURRENT_SCREEN->_hpa_cost);
+           (void) printf("vpa cost: %d\n", CURRENT_SCREEN->_vpa_cost);
        } else if (buf[0] == 'x' || buf[0] == 'q')
            break;
        else
index 7a0636f2d9617628aacb8a3cd7adbab5885da797..5ba824b7b78baa9b02179510dcedced99fad115d 100644 (file)
@@ -39,7 +39,7 @@
  *
  *     The routine doupdate() and its dependents.
  *     All physical output is concentrated here (except _nc_outch()
 *    in lib_tputs.c).
    in lib_tputs.c).
  *
  *-----------------------------------------------------------------*/
 
@@ -77,9 +77,8 @@
 #endif
 
 #include <ctype.h>
-#include <term.h>
 
-MODULE_ID("$Id: tty_update.c,v 1.250 2009/04/18 23:32:17 tom Exp $")
+MODULE_ID("$Id: tty_update.c,v 1.251 2009/04/25 23:46:09 tom Exp $")
 
 /*
  * This define controls the line-breakout optimization.  Every once in a
@@ -92,7 +91,7 @@ MODULE_ID("$Id: tty_update.c,v 1.250 2009/04/18 23:32:17 tom Exp $")
  */
 #define CHECK_INTERVAL 5
 
-#define FILL_BCE() (SP->_coloron && !SP->_default_color && !back_color_erase)
+#define FILL_BCE(sp) (sp->_coloron && !sp->_default_color && !back_color_erase)
 
 static const NCURSES_CH_T blankchar = NewChar(BLANK_TEXT);
 static NCURSES_CH_T normal = NewChar(BLANK_TEXT);
@@ -105,18 +104,20 @@ static NCURSES_CH_T normal = NewChar(BLANK_TEXT);
 /* #define POSITION_DEBUG */
 
 static NCURSES_INLINE NCURSES_CH_T ClrBlank(WINDOW *win);
-static void DelChar(int count);
-static void InsStr(NCURSES_CH_T * line, int count);
 
 #if NCURSES_SP_FUNCS
-static void ClearScreen(SCREEN *, NCURSES_CH_T blank);
 static int ClrBottom(SCREEN *, int total);
+static void ClearScreen(SCREEN *, NCURSES_CH_T blank);
 static void ClrUpdate(SCREEN *);
+static void DelChar(SCREEN *, int count);
+static void InsStr(SCREEN *, NCURSES_CH_T * line, int count);
 static void TransformLine(SCREEN *, int const lineno);
 #else
-static void ClearScreen(NCURSES_CH_T blank);
 static int ClrBottom(int total);
+static void ClearScreen(NCURSES_CH_T blank);
 static void ClrUpdate(void);
+static void DelChar(int count);
+static void InsStr(NCURSES_CH_T * line, int count);
 static void TransformLine(int const lineno);
 #endif
 
@@ -128,7 +129,7 @@ static void TransformLine(int const lineno);
  ****************************************************************************/
 
 static void
-position_check(int expected_y, int expected_x, char *legend)
+position_check(SCREEN *sp, int expected_y, int expected_x, char *legend)
 /* check to see if the real cursor position matches the virtual */
 {
     char buf[20];
@@ -138,10 +139,10 @@ position_check(int expected_y, int expected_x, char *legend)
     if (!_nc_tracing || (expected_y < 0 && expected_x < 0))
        return;
 
-    _nc_flush();
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
     memset(buf, '\0', sizeof(buf));
     putp("\033[6n");           /* only works on ANSI-compatibles */
-    _nc_flush();
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
     *(s = buf) = 0;
     do {
        int ask = sizeof(buf) - 1 - (s - buf);
@@ -171,7 +172,7 @@ position_check(int expected_y, int expected_x, char *legend)
     }
 }
 #else
-#define position_check(expected_y, expected_x, legend) /* nothing */
+#define position_check(sp, expected_y, expected_x, legend)     /* nothing */
 #endif /* POSITION_DEBUG */
 
 /****************************************************************************
@@ -181,19 +182,19 @@ position_check(int expected_y, int expected_x, char *legend)
  ****************************************************************************/
 
 static NCURSES_INLINE void
-GoTo(int const row, int const col)
+GoTo(NCURSES_SP_DCLx int const row, int const col)
 {
     TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",
-                   row, col, SP->_cursrow, SP->_curscol));
+                   row, col, SP_PARM->_cursrow, SP_PARM->_curscol));
 
-    position_check(SP->_cursrow, SP->_curscol, "GoTo");
+    position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo");
 
-    mvcur(SP->_cursrow, SP->_curscol, row, col);
-    position_check(SP->_cursrow, SP->_curscol, "GoTo2");
+    mvcur(SP_PARM->_cursrow, SP_PARM->_curscol, row, col);
+    position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo2");
 }
 
 static NCURSES_INLINE void
-PutAttrChar(CARG_CH_T ch)
+PutAttrChar(NCURSES_SP_DCLx CARG_CH_T ch)
 {
     int chlen = 1;
     NCURSES_CH_T my_ch;
@@ -203,7 +204,7 @@ PutAttrChar(CARG_CH_T ch)
 
     TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",
                       _tracech_t(ch),
-                      SP->_cursrow, SP->_curscol));
+                      SP_PARM->_cursrow, SP_PARM->_curscol));
 #if USE_WIDEC_SUPPORT
     /*
      * If this is not a valid character, there is nothing more to do.
@@ -233,12 +234,12 @@ PutAttrChar(CARG_CH_T ch)
         */
        if (is8bits(CharOf(CHDEREF(ch)))
            && (isprint(CharOf(CHDEREF(ch)))
-               || (SP->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
-               || (SP->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
+               || (SP_PARM->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
+               || (SP_PARM->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
                || (AttrOf(attr) & A_ALTCHARSET
                    && ((CharOfD(ch) < ACS_LEN
-                        && SP->_acs_map != 0
-                        && SP->_acs_map[CharOfD(ch)] != 0)
+                        && SP_PARM->_acs_map != 0
+                        && SP_PARM->_acs_map[CharOfD(ch)] != 0)
                        || (CharOfD(ch) >= 128))))) {
            ;
        } else {
@@ -250,7 +251,7 @@ PutAttrChar(CARG_CH_T ch)
 #endif
 
     if ((AttrOf(attr) & A_ALTCHARSET)
-       && SP->_acs_map != 0
+       && SP_PARM->_acs_map != 0
        && CharOfD(ch) < ACS_LEN) {
        my_ch = CHDEREF(ch);    /* work around const param */
 #if USE_WIDEC_SUPPORT
@@ -260,8 +261,8 @@ PutAttrChar(CARG_CH_T ch)
         * character, and uses the wide-character mapping when we expect the
         * normal one to be broken (by mis-design ;-).
         */
-       if (SP->_screen_acs_fix
-           && SP->_screen_acs_map[CharOf(my_ch)]) {
+       if (SP_PARM->_screen_acs_fix
+           && SP_PARM->_screen_acs_map[CharOf(my_ch)]) {
            RemAttr(attr, A_ALTCHARSET);
            my_ch = _nc_wacs[CharOf(my_ch)];
        }
@@ -274,9 +275,9 @@ PutAttrChar(CARG_CH_T ch)
         */
        if (AttrOf(attr) & A_ALTCHARSET) {
            int j = CharOfD(ch);
-           chtype temp = UChar(SP->_acs_map[j]);
+           chtype temp = UChar(SP_PARM->_acs_map[j]);
 
-           if (!(SP->_screen_acs_map[j])) {
+           if (!(SP_PARM->_screen_acs_map[j])) {
                RemAttr(attr, A_ALTCHARSET);
                if (temp == 0)
                    temp = ' ';
@@ -291,20 +292,20 @@ PutAttrChar(CARG_CH_T ch)
        ch = CHREF(tilde);
     }
 
-    UpdateAttrs(attr);
+    UpdateAttrs(SP_PARM, attr);
 #if !USE_WIDEC_SUPPORT
     /* FIXME - we do this special case for signal handling, should see how to
      * make it work for wide characters.
      */
-    if (SP->_outch != 0) {
-       SP->_outch(UChar(ch));
+    if (SP_PARM->_outch != 0) {
+       SP_PARM->_outch(UChar(ch));
     } else
 #endif
     {
-       PUTC(CHDEREF(ch), SP->_ofp);    /* macro's fastest... */
+       PUTC(CHDEREF(ch), SP_PARM->_ofp);       /* macro's fastest... */
        COUNT_OUTCHARS(1);
     }
-    SP->_curscol += chlen;
+    SP_PARM->_curscol += chlen;
     if (char_padding) {
        TPUTS_TRACE("char_padding");
        putp(char_padding);
@@ -312,7 +313,7 @@ PutAttrChar(CARG_CH_T ch)
 }
 
 static bool
-check_pending(void)
+check_pending(NCURSES_SP_DCL0)
 /* check for pending input */
 {
     bool have_pending = FALSE;
@@ -322,13 +323,13 @@ check_pending(void)
      * have the refreshing slow down drastically (or stop) if there's an
      * unread character available.
      */
-    if (SP->_fifohold != 0)
+    if (SP_PARM->_fifohold != 0)
        return FALSE;
 
-    if (SP->_checkfd >= 0) {
+    if (SP_PARM->_checkfd >= 0) {
 #if USE_FUNC_POLL
        struct pollfd fds[1];
-       fds[0].fd = SP->_checkfd;
+       fds[0].fd = SP_PARM->_checkfd;
        fds[0].events = POLLIN;
        if (poll(fds, 1, 0) > 0) {
            have_pending = TRUE;
@@ -356,15 +357,15 @@ check_pending(void)
            ktimeout.tv_usec = 0;
 
        FD_ZERO(&fdset);
-       FD_SET(SP->_checkfd, &fdset);
-       if (select(SP->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
+       FD_SET(SP_PARM->_checkfd, &fdset);
+       if (select(SP_PARM->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
            have_pending = TRUE;
        }
 #endif
     }
     if (have_pending) {
-       SP->_fifohold = 5;
-       _nc_flush();
+       SP_PARM->_fifohold = 5;
+       NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
     }
     return FALSE;
 }
@@ -375,26 +376,33 @@ PutCharLR(NCURSES_SP_DCLx const ARG_CH_T ch)
 {
     if (!auto_right_margin) {
        /* we can put the char directly */
-       PutAttrChar(ch);
+       PutAttrChar(NCURSES_SP_ARGx ch);
     } else if (enter_am_mode && exit_am_mode) {
        /* we can suppress automargin */
        TPUTS_TRACE("exit_am_mode");
        putp(exit_am_mode);
 
-       PutAttrChar(ch);
+       PutAttrChar(NCURSES_SP_ARGx ch);
        SP_PARM->_curscol--;
-       position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "exit_am_mode");
+       position_check(SP_PARM,
+                      SP_PARM->_cursrow,
+                      SP_PARM->_curscol,
+                      "exit_am_mode");
 
        TPUTS_TRACE("enter_am_mode");
        putp(enter_am_mode);
     } else if ((enter_insert_mode && exit_insert_mode)
               || insert_character || parm_ich) {
-       GoTo(screen_lines(SP_PARM) - 1, screen_columns(SP_PARM) - 2);
-       PutAttrChar(ch);
-       GoTo(screen_lines(SP_PARM) - 1, screen_columns(SP_PARM) - 2);
-       InsStr(newscr->_line[screen_lines(SP_PARM) - 1].text
-              + screen_columns(SP_PARM) - 2,
-              1);
+       GoTo(NCURSES_SP_ARGx
+            screen_lines(SP_PARM) - 1,
+            screen_columns(SP_PARM) - 2);
+       PutAttrChar(NCURSES_SP_ARGx ch);
+       GoTo(NCURSES_SP_ARGx
+            screen_lines(SP_PARM) - 1,
+            screen_columns(SP_PARM) - 2);
+       InsStr(NCURSES_SP_ARGx
+              newscr->_line[screen_lines(SP_PARM) - 1].text +
+              screen_columns(SP_PARM) - 2, 1);
     }
 }
 
@@ -402,7 +410,7 @@ PutCharLR(NCURSES_SP_DCLx const ARG_CH_T ch)
  * Wrap the cursor position, i.e., advance to the beginning of the next line.
  */
 static void
-wrap_cursor(void)
+wrap_cursor(NCURSES_SP_DCL0)
 {
     if (eat_newline_glitch) {
        /*
@@ -418,41 +426,45 @@ wrap_cursor(void)
         * it's safe to just tell the code that the cursor is in hyperspace and
         * let the next mvcur() call straighten things out.
         */
-       SP->_curscol = -1;
-       SP->_cursrow = -1;
+       SP_PARM->_curscol = -1;
+       SP_PARM->_cursrow = -1;
     } else if (auto_right_margin) {
-       SP->_curscol = 0;
-       SP->_cursrow++;
+       SP_PARM->_curscol = 0;
+       SP_PARM->_cursrow++;
        /*
         * We've actually moved - but may have to work around problems with
         * video attributes not working.
         */
-       if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP))) {
+       if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP_PARM))) {
            TR(TRACE_CHARPUT, ("turning off (%#lx) %s before wrapping",
-                              (unsigned long) AttrOf(SCREEN_ATTRS(SP)),
-                              _traceattr(AttrOf(SCREEN_ATTRS(SP)))));
+                              (unsigned long) AttrOf(SCREEN_ATTRS(SP_PARM)),
+                              _traceattr(AttrOf(SCREEN_ATTRS(SP_PARM)))));
            (void) VIDATTR(A_NORMAL, 0);
        }
     } else {
-       SP->_curscol--;
+       SP_PARM->_curscol--;
     }
-    position_check(SP->_cursrow, SP->_curscol, "wrap_cursor");
+    position_check(SP_PARM,
+                  SP_PARM->_cursrow,
+                  SP_PARM->_curscol,
+                  "wrap_cursor");
 }
 
 static NCURSES_INLINE void
 PutChar(NCURSES_SP_DCLx const ARG_CH_T ch)
 /* insert character, handling automargin stuff */
 {
-    if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1
-       && SP_PARM->_curscol == screen_columns(SP_PARM) - 1)
+    if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1 &&
+       SP_PARM->_curscol == screen_columns(SP_PARM) - 1) {
        PutCharLR(NCURSES_SP_ARGx ch);
-    else
-       PutAttrChar(ch);
+    } else {
+       PutAttrChar(NCURSES_SP_ARGx ch);
+    }
 
     if (SP_PARM->_curscol >= screen_columns(SP_PARM))
-       wrap_cursor();
+       wrap_cursor(NCURSES_SP_ARG);
 
-    position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
+    position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
 }
 
 /*
@@ -462,19 +474,19 @@ PutChar(NCURSES_SP_DCLx const ARG_CH_T ch)
  * or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.
  */
 static NCURSES_INLINE bool
-can_clear_with(ARG_CH_T ch)
+can_clear_with(NCURSES_SP_DCLx ARG_CH_T ch)
 {
-    if (!back_color_erase && SP->_coloron) {
+    if (!back_color_erase && SP_PARM->_coloron) {
 #if NCURSES_EXT_FUNCS
        int pair;
 
-       if (!SP->_default_color)
+       if (!SP_PARM->_default_color)
            return FALSE;
-       if (SP->_default_fg != C_MASK || SP->_default_bg != C_MASK)
+       if (SP_PARM->_default_fg != C_MASK || SP_PARM->_default_bg != C_MASK)
            return FALSE;
        if ((pair = GetPair(CHDEREF(ch))) != 0) {
            short fg, bg;
-           pair_content(pair, &fg, &bg);
+           NCURSES_SP_NAME(pair_content) (NCURSES_SP_ARGx pair, &fg, &bg);
            if (fg != C_MASK || bg != C_MASK)
                return FALSE;
        }
@@ -536,8 +548,8 @@ EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num)
             */
            if (erase_chars
                && runcount > SP_PARM->_ech_cost + SP_PARM->_cup_ch_cost
-               && can_clear_with(CHREF(ntext0))) {
-               UpdateAttrs(ntext0);
+               && can_clear_with(NCURSES_SP_ARGx CHREF(ntext0))) {
+               UpdateAttrs(SP_PARM, ntext0);
                putp(TPARM_1(erase_chars, runcount));
 
                /*
@@ -546,19 +558,21 @@ EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num)
                 * last update on the line.
                 */
                if (runcount < num) {
-                   GoTo(SP_PARM->_cursrow, SP_PARM->_curscol + runcount);
+                   GoTo(NCURSES_SP_ARGx
+                        SP_PARM->_cursrow,
+                        SP_PARM->_curscol + runcount);
                } else {
                    return 1;   /* cursor stays in the middle */
                }
            } else if (repeat_char && runcount > SP_PARM->_rep_cost) {
-               bool wrap_possible = (SP_PARM->_curscol + runcount
-                                     >= screen_columns(SP_PARM));
+               bool wrap_possible = (SP_PARM->_curscol + runcount >=
+                                     screen_columns(SP_PARM));
                int rep_count = runcount;
 
                if (wrap_possible)
                    rep_count--;
 
-               UpdateAttrs(ntext0);
+               UpdateAttrs(SP_PARM, ntext0);
                tputs(TPARM_2(repeat_char, CharOf(ntext0), rep_count),
                      rep_count, _nc_outch);
                SP_PARM->_curscol += rep_count;
@@ -597,8 +611,8 @@ PutRange(NCURSES_SP_DCLx
 {
     int i, j, same;
 
-    TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",
-                      otext, ntext, row, first, last));
+    TR(TRACE_CHARPUT, ("PutRange(%p, %p, %p, %d, %d, %d)",
+                      SP_PARM, otext, ntext, row, first, last));
 
     if (otext != ntext
        && (last - first + 1) > SP_PARM->_inline_cost) {
@@ -610,7 +624,7 @@ PutRange(NCURSES_SP_DCLx
            } else {
                if (same > SP_PARM->_inline_cost) {
                    EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
-                   GoTo(row, first = j);
+                   GoTo(NCURSES_SP_ARGx row, first = j);
                }
                same = 0;
            }
@@ -679,10 +693,10 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
     if (SP_PARM->_endwin) {
 
        T(("coming back from shell mode"));
-       reset_prog_mode();
+       NCURSES_SP_NAME(reset_prog_mode) (NCURSES_SP_ARG);
 
-       _nc_mvcur_resume();
-       _nc_screen_resume();
+       NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_ARG);
+       NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
        SP_PARM->_mouse_resume(SP_PARM);
 
        SP_PARM->_endwin = FALSE;
@@ -731,8 +745,8 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
                 * there's enough room to set the attribute before the first
                 * non-blank in the run.
                 */
-#define SAFE(a)        (!((a) & SP_PARM->_xmc_triggers))
-               if (ISBLANK(thisline[j]) && SAFE(turnon)) {
+#define SAFE(scr,a)    (!((a) & (scr)->_xmc_triggers))
+               if (ISBLANK(thisline[j]) && SAFE(SP_PARM, turnon)) {
                    RemAttr(thisline[j], turnon);
                    continue;
                }
@@ -741,14 +755,14 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
                for (k = 1; k <= magic_cookie_glitch; k++) {
                    if (j - k < 0
                        || !ISBLANK(thisline[j - k])
-                       || !SAFE(AttrOf(thisline[j - k]))) {
+                       || !SAFE(SP_PARM, AttrOf(thisline[j - k]))) {
                        failed = TRUE;
                        TR(TRACE_ATTRS, ("No room at start in %d,%d%s%s",
                                         i, j - k,
                                         (ISBLANK(thisline[j - k])
                                          ? ""
                                          : ":nonblank"),
-                                        (SAFE(AttrOf(thisline[j - k]))
+                                        (SAFE(SP_PARM, AttrOf(thisline[j - k]))
                                          ? ""
                                          : ":unsafe")));
                        break;
@@ -787,7 +801,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
                         */
                        while (n >= 0
                               && ISBLANK(lastline[n])
-                              && SAFE(AttrOf(lastline[n]))) {
+                              && SAFE(SP_PARM, AttrOf(lastline[n]))) {
                            RemAttr(lastline[n--], turnon);
                        }
 
@@ -795,7 +809,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
                        for (k = 1; k <= magic_cookie_glitch; k++) {
                            if (n + k >= screen_columns(SP_PARM)
                                || !ISBLANK(lastline[n + k])
-                               || !SAFE(AttrOf(lastline[n + k]))) {
+                               || !SAFE(SP_PARM, AttrOf(lastline[n + k]))) {
                                failed = TRUE;
                                TR(TRACE_ATTRS,
                                   ("No room at end in %d,%d%s%s",
@@ -803,7 +817,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
                                    (ISBLANK(lastline[n + k])
                                     ? ""
                                     : ":nonblank"),
-                                   (SAFE(AttrOf(lastline[n + k]))
+                                   (SAFE(SP_PARM, AttrOf(lastline[n + k]))
                                     ? ""
                                     : ":unsafe")));
                                break;
@@ -866,7 +880,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
     } else {
        int changedlines = CHECK_INTERVAL;
 
-       if (check_pending())
+       if (check_pending(NCURSES_SP_ARG))
            goto cleanup;
 
        nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
@@ -883,7 +897,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
             * Here is our line-breakout optimization.
             */
            if (changedlines == CHECK_INTERVAL) {
-               if (check_pending())
+               if (check_pending(NCURSES_SP_ARG))
                    goto cleanup;
                changedlines = 0;
            }
@@ -922,7 +936,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
        curscr->_curx = newscr->_curx;
        curscr->_cury = newscr->_cury;
 
-       GoTo(curscr->_cury, curscr->_curx);
+       GoTo(NCURSES_SP_ARGx curscr->_cury, curscr->_curx);
     }
 
   cleanup:
@@ -935,9 +949,9 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
 #if USE_XMC_SUPPORT
     if (magic_cookie_glitch != 0)
 #endif
-       UpdateAttrs(normal);
+       UpdateAttrs(SP_PARM, normal);
 
-    _nc_flush();
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
     WINDOW_ATTRS(curscr) = WINDOW_ATTRS(newscr);
 
 #if USE_TRACE_TIMES
@@ -994,21 +1008,21 @@ ClrBlank(WINDOW *win)
 static void
 ClrUpdate(NCURSES_SP_DCL0)
 {
-    int i;
-    NCURSES_CH_T blank = ClrBlank(stdscr);
-    int nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
-
     TR(TRACE_UPDATE, (T_CALLED("ClrUpdate")));
+    if (0 != SP_PARM) {
+       int i;
+       NCURSES_CH_T blank = ClrBlank(stdscr);
+       int nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
 
-    ClearScreen(NCURSES_SP_ARGx blank);
-
-    TR(TRACE_UPDATE, ("updating screen from scratch"));
+       ClearScreen(NCURSES_SP_ARGx blank);
 
-    nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
+       TR(TRACE_UPDATE, ("updating screen from scratch"));
 
-    for (i = 0; i < nonempty; i++)
-       TransformLine(NCURSES_SP_ARGx i);
+       nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
 
+       for (i = 0; i < nonempty; i++)
+           TransformLine(NCURSES_SP_ARGx i);
+    }
     TR(TRACE_UPDATE, (T_RETURN("")));
 }
 
@@ -1040,7 +1054,7 @@ ClrToEOL(NCURSES_SP_DCLx NCURSES_CH_T blank, bool needclear)
     }
 
     if (needclear) {
-       UpdateAttrs(blank);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("clr_eol");
        if (clr_eol && SP_PARM->_el_cost <= (screen_columns(SP_PARM) - SP_PARM->_curscol)) {
            putp(clr_eol);
@@ -1063,10 +1077,13 @@ ClrToEOS(NCURSES_SP_DCLx NCURSES_CH_T blank)
 {
     int row, col;
 
+    if (0 == SP_PARM)
+       return;
+
     row = SP_PARM->_cursrow;
     col = SP_PARM->_curscol;
 
-    UpdateAttrs(blank);
+    UpdateAttrs(SP_PARM, blank);
     TPUTS_TRACE("clr_eos");
     tputs(clr_eos, screen_lines(SP_PARM) - row, _nc_outch);
 
@@ -1096,7 +1113,7 @@ ClrBottom(NCURSES_SP_DCLx int total)
     NCURSES_CH_T blank = newscr->_line[total - 1].text[last - 1];
     bool ok;
 
-    if (clr_eos && can_clear_with(CHREF(blank))) {
+    if (clr_eos && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
 
        for (row = total - 1; row >= 0; row--) {
            for (col = 0, ok = TRUE; ok && col < last; col++) {
@@ -1114,7 +1131,7 @@ ClrBottom(NCURSES_SP_DCLx int total)
 
        /* don't use clr_eos for just one line if clr_eol available */
        if (top < total) {
-           GoTo(top, 0);
+           GoTo(NCURSES_SP_ARGx top, 0);
            ClrToEOS(NCURSES_SP_ARGx blank);
            if (SP_PARM->oldhash && SP_PARM->newhash) {
                for (row = top; row < screen_lines(SP_PARM); row++)
@@ -1127,15 +1144,15 @@ ClrBottom(NCURSES_SP_DCLx int total)
 
 #if USE_XMC_SUPPORT
 #if USE_WIDEC_SUPPORT
-#define check_xmc_transition(a, b) \
-    ((((a)->attr ^ (b)->attr) & ~((a)->attr) & SP->_xmc_triggers) != 0)
-#define xmc_turn_on(a,b) check_xmc_transition(&(a), &(b))
+#define check_xmc_transition(sp, a, b)                                 \
+    ((((a)->attr ^ (b)->attr) & ~((a)->attr) & (sp)->_xmc_triggers) != 0)
+#define xmc_turn_on(sp,a,b) check_xmc_transition(sp,&(a), &(b))
 #else
-#define xmc_turn_on(a,b) ((((a)^(b)) & ~(a) & SP->_xmc_triggers) != 0)
+#define xmc_turn_on(sp,a,b) ((((a)^(b)) & ~(a) & (sp)->_xmc_triggers) != 0)
 #endif
 
-#define xmc_new(r,c) newscr->_line[r].text[c]
-#define xmc_turn_off(a,b) xmc_turn_on(b,a)
+#define xmc_new(sp,r,c) newscr->_line[r].text[c]
+#define xmc_turn_off(sp,a,b) xmc_turn_on(sp,b,a)
 #endif /* USE_XMC_SUPPORT */
 
 /*
@@ -1165,7 +1182,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
     int n;
     bool attrchanged = FALSE;
 
-    TR(TRACE_UPDATE, (T_CALLED("TransformLine(%d)"), lineno));
+    TR(TRACE_UPDATE, (T_CALLED("TransformLine(%p, %d)"), SP_PARM, lineno));
 
     /* copy new hash value to old one */
     if (SP_PARM->oldhash && SP_PARM->newhash)
@@ -1212,10 +1229,11 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
     firstChar = 0;
 
     if (attrchanged) {         /* we may have to disregard the whole line */
-       GoTo(lineno, firstChar);
+       GoTo(NCURSES_SP_ARGx lineno, firstChar);
        ClrToEOL(NCURSES_SP_ARGx ClrBlank(curscr), FALSE);
-       PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                0, (screen_columns(SP_PARM) - 1));
+       PutRange(NCURSES_SP_ARGx
+                oldLine, newLine, lineno, 0,
+                screen_columns(SP_PARM) - 1);
 #if USE_XMC_SUPPORT
 
        /*
@@ -1230,7 +1248,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
         * following operation.
         */
     } else if (magic_cookie_glitch > 0) {
-       GoTo(lineno, firstChar);
+       GoTo(NCURSES_SP_ARGx lineno, firstChar);
        for (n = 0; n < screen_columns(SP_PARM); n++) {
            int m = n + magic_cookie_glitch;
 
@@ -1240,10 +1258,12 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
             */
            if (ISBLANK(newLine[n])
                && ((n > 0
-                    && xmc_turn_on(newLine[n - 1], newLine[n]))
+                    && xmc_turn_on(SP_PARM, newLine[n - 1], newLine[n]))
                    || (n == 0
                        && lineno > 0
-                       && xmc_turn_on(xmc_new(lineno - 1, screen_columns(SP_PARM) - 1),
+                       && xmc_turn_on(SP_PARM,
+                                      xmc_new(SP_PARM, lineno - 1,
+                                              screen_columns(SP_PARM) - 1),
                                       newLine[n])))) {
                n = m;
            }
@@ -1256,10 +1276,12 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
             */
            if (!ISBLANK(newLine[n])
                && ((n + 1 < screen_columns(SP_PARM)
-                    && xmc_turn_off(newLine[n], newLine[n + 1]))
+                    && xmc_turn_off(SP_PARM, newLine[n], newLine[n + 1]))
                    || (n + 1 >= screen_columns(SP_PARM)
                        && lineno + 1 < screen_lines(SP_PARM)
-                       && xmc_turn_off(newLine[n], xmc_new(lineno + 1, 0))))) {
+                       && xmc_turn_off(SP_PARM,
+                                       newLine[n],
+                                       xmc_new(SP_PARM, lineno + 1, 0))))) {
                n = m;
            }
 
@@ -1270,7 +1292,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
 
        /* it may be cheap to clear leading whitespace with clr_bol */
        blank = newLine[0];
-       if (clr_bol && can_clear_with(CHREF(blank))) {
+       if (clr_bol && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
            int oFirstChar, nFirstChar;
 
            for (oFirstChar = 0;
@@ -1297,13 +1319,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
                if (SP_PARM->_el1_cost < nFirstChar - oFirstChar) {
                    if (nFirstChar >= screen_columns(SP_PARM)
                        && SP_PARM->_el_cost <= SP_PARM->_el1_cost) {
-                       GoTo(lineno, 0);
-                       UpdateAttrs(blank);
+                       GoTo(NCURSES_SP_ARGx lineno, 0);
+                       UpdateAttrs(SP_PARM, blank);
                        TPUTS_TRACE("clr_eol");
                        putp(clr_eol);
                    } else {
-                       GoTo(lineno, nFirstChar - 1);
-                       UpdateAttrs(blank);
+                       GoTo(NCURSES_SP_ARGx lineno, nFirstChar - 1);
+                       UpdateAttrs(SP_PARM, blank);
                        TPUTS_TRACE("clr_bol");
                        putp(clr_bol);
                    }
@@ -1326,7 +1348,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
 
        blank = newLine[screen_columns(SP_PARM) - 1];
 
-       if (!can_clear_with(CHREF(blank))) {
+       if (!can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
            /* find the last differing character */
            nLastChar = screen_columns(SP_PARM) - 1;
 
@@ -1335,9 +1357,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
                nLastChar--;
 
            if (nLastChar >= firstChar) {
-               GoTo(lineno, firstChar);
-               PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                        firstChar, nLastChar);
+               GoTo(NCURSES_SP_ARGx lineno, firstChar);
+               PutRange(NCURSES_SP_ARGx
+                        oldLine,
+                        newLine,
+                        lineno,
+                        firstChar,
+                        nLastChar);
                memcpy(oldLine + firstChar,
                       newLine + firstChar,
                       (nLastChar - firstChar + 1) * sizeof(NCURSES_CH_T));
@@ -1358,24 +1384,32 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
 
        if ((nLastChar == firstChar)
            && (SP_PARM->_el_cost < (oLastChar - nLastChar))) {
-           GoTo(lineno, firstChar);
+           GoTo(NCURSES_SP_ARGx lineno, firstChar);
            if (!CharEq(newLine[firstChar], blank))
                PutChar(NCURSES_SP_ARGx CHREF(newLine[firstChar]));
            ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
        } else if ((nLastChar != oLastChar)
                   && (!CharEq(newLine[nLastChar], oldLine[oLastChar])
                       || !(_nc_idcok && has_ic()))) {
-           GoTo(lineno, firstChar);
+           GoTo(NCURSES_SP_ARGx lineno, firstChar);
            if ((oLastChar - nLastChar) > SP_PARM->_el_cost) {
-               if (PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                            firstChar, nLastChar)) {
-                   GoTo(lineno, nLastChar + 1);
+               if (PutRange(NCURSES_SP_ARGx
+                            oldLine,
+                            newLine,
+                            lineno,
+                            firstChar,
+                            nLastChar)) {
+                   GoTo(NCURSES_SP_ARGx lineno, nLastChar + 1);
                }
                ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
            } else {
                n = max(nLastChar, oLastChar);
-               PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                        firstChar, n);
+               PutRange(NCURSES_SP_ARGx
+                        oldLine,
+                        newLine,
+                        lineno,
+                        firstChar,
+                        n);
            }
        } else {
            int nLastNonblank = nLastChar;
@@ -1396,9 +1430,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
 
            n = min(oLastChar, nLastChar);
            if (n >= firstChar) {
-               GoTo(lineno, firstChar);
-               PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                        firstChar, n);
+               GoTo(NCURSES_SP_ARGx lineno, firstChar);
+               PutRange(NCURSES_SP_ARGx
+                        oldLine,
+                        newLine,
+                        lineno,
+                        firstChar,
+                        n);
            }
 
            if (oLastChar < nLastChar) {
@@ -1409,21 +1447,25 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
                    --oLastChar;
                }
 #endif
-               GoTo(lineno, n + 1);
+               GoTo(NCURSES_SP_ARGx lineno, n + 1);
                if ((nLastChar < nLastNonblank)
-                   || InsCharCost(nLastChar - oLastChar) > (m - n)) {
-                   PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
-                            n + 1, m);
+                   || InsCharCost(SP_PARM, nLastChar - oLastChar) > (m - n)) {
+                   PutRange(NCURSES_SP_ARGx
+                            oldLine,
+                            newLine,
+                            lineno,
+                            n + 1,
+                            m);
                } else {
-                   InsStr(&newLine[n + 1], nLastChar - oLastChar);
+                   InsStr(NCURSES_SP_ARGx &newLine[n + 1], nLastChar - oLastChar);
                }
            } else if (oLastChar > nLastChar) {
-               GoTo(lineno, n + 1);
-               if (DelCharCost(oLastChar - nLastChar)
+               GoTo(NCURSES_SP_ARGx lineno, n + 1);
+               if (DelCharCost(SP_PARM, oLastChar - nLastChar)
                    > SP_PARM->_el_cost + nLastNonblank - (n + 1)) {
                    if (PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
                                 n + 1, nLastNonblank))
-                         GoTo(lineno, nLastNonblank + 1);
+                         GoTo(NCURSES_SP_ARGx lineno, nLastNonblank + 1);
                    ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
                } else {
                    /*
@@ -1434,8 +1476,8 @@ TransformLine(NCURSES_SP_DCLx int const lineno)
                     * setting the video attributes from
                     * the last character on the row.
                     */
-                   UpdateAttrs(blank);
-                   DelChar(oLastChar - nLastChar);
+                   UpdateAttrs(SP_PARM, blank);
+                   DelChar(NCURSES_SP_ARGx oLastChar - nLastChar);
                }
            }
        }
@@ -1477,38 +1519,40 @@ ClearScreen(NCURSES_SP_DCLx NCURSES_CH_T blank)
 
     if (fast_clear) {
        if (clear_screen) {
-           UpdateAttrs(blank);
+           UpdateAttrs(SP_PARM, blank);
            TPUTS_TRACE("clear_screen");
            putp(clear_screen);
            SP_PARM->_cursrow = SP_PARM->_curscol = 0;
-           position_check(SP_PARM->_cursrow, SP_PARM->_curscol,
+           position_check(SP_PARM,
+                          SP_PARM->_cursrow,
+                          SP_PARM->_curscol,
                           "ClearScreen");
        } else if (clr_eos) {
            SP_PARM->_cursrow = SP_PARM->_curscol = -1;
-           GoTo(0, 0);
+           GoTo(NCURSES_SP_ARGx 0, 0);
 
-           UpdateAttrs(blank);
+           UpdateAttrs(SP_PARM, blank);
            TPUTS_TRACE("clr_eos");
            tputs(clr_eos, screen_lines(SP_PARM), _nc_outch);
        } else if (clr_eol) {
            SP_PARM->_cursrow = SP_PARM->_curscol = -1;
 
-           UpdateAttrs(blank);
+           UpdateAttrs(SP_PARM, blank);
            for (i = 0; i < screen_lines(SP_PARM); i++) {
-               GoTo(i, 0);
+               GoTo(NCURSES_SP_ARGx i, 0);
                TPUTS_TRACE("clr_eol");
                putp(clr_eol);
            }
-           GoTo(0, 0);
+           GoTo(NCURSES_SP_ARGx 0, 0);
        }
     } else {
-       UpdateAttrs(blank);
+       UpdateAttrs(SP_PARM, blank);
        for (i = 0; i < screen_lines(SP_PARM); i++) {
-           GoTo(i, 0);
+           GoTo(NCURSES_SP_ARGx i, 0);
            for (j = 0; j < screen_columns(SP_PARM); j++)
                PutChar(NCURSES_SP_ARGx CHREF(blank));
        }
-       GoTo(0, 0);
+       GoTo(NCURSES_SP_ARGx 0, 0);
     }
 
     for (i = 0; i < screen_lines(SP_PARM); i++) {
@@ -1527,9 +1571,9 @@ ClearScreen(NCURSES_SP_DCLx NCURSES_CH_T blank)
 */
 
 static void
-InsStr(NCURSES_CH_T * line, int count)
+InsStr(NCURSES_SP_DCLx NCURSES_CH_T * line, int count)
 {
-    TR(TRACE_UPDATE, ("InsStr(%p,%d) called", line, count));
+    TR(TRACE_UPDATE, ("InsStr(%p, %p,%d) called", SP_PARM, line, count));
 
     /* Prefer parm_ich as it has the smallest cost - no need to shift
      * the whole line on each character. */
@@ -1538,7 +1582,7 @@ InsStr(NCURSES_CH_T * line, int count)
        TPUTS_TRACE("parm_ich");
        tputs(TPARM_1(parm_ich, count), count, _nc_outch);
        while (count) {
-           PutAttrChar(CHREF(*line));
+           PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
            line++;
            count--;
        }
@@ -1546,7 +1590,7 @@ InsStr(NCURSES_CH_T * line, int count)
        TPUTS_TRACE("enter_insert_mode");
        putp(enter_insert_mode);
        while (count) {
-           PutAttrChar(CHREF(*line));
+           PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
            if (insert_padding) {
                TPUTS_TRACE("insert_padding");
                putp(insert_padding);
@@ -1560,7 +1604,7 @@ InsStr(NCURSES_CH_T * line, int count)
        while (count) {
            TPUTS_TRACE("insert_character");
            putp(insert_character);
-           PutAttrChar(CHREF(*line));
+           PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
            if (insert_padding) {
                TPUTS_TRACE("insert_padding");
                putp(insert_padding);
@@ -1569,7 +1613,7 @@ InsStr(NCURSES_CH_T * line, int count)
            count--;
        }
     }
-    position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
+    position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
 }
 
 /*
@@ -1580,12 +1624,12 @@ InsStr(NCURSES_CH_T * line, int count)
 */
 
 static void
-DelChar(int count)
+DelChar(NCURSES_SP_DCLx int count)
 {
     int n;
 
-    TR(TRACE_UPDATE, ("DelChar(%d) called, position = (%ld,%ld)",
-                     count,
+    TR(TRACE_UPDATE, ("DelChar(%p, %d) called, position = (%ld,%ld)",
+                     SP_PARM, count,
                      (long) newscr->_cury,
                      (long) newscr->_curx));
 
@@ -1645,35 +1689,35 @@ scroll_csr_forward(NCURSES_SP_DCLx
     int i;
 
     if (n == 1 && scroll_forward && top == miny && bot == maxy) {
-       GoTo(bot, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx bot, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("scroll_forward");
        putp(scroll_forward);
     } else if (n == 1 && delete_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("delete_line");
        putp(delete_line);
     } else if (parm_index && top == miny && bot == maxy) {
-       GoTo(bot, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx bot, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("parm_index");
        tputs(TPARM_2(parm_index, n, 0), n, _nc_outch);
     } else if (parm_delete_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("parm_delete_line");
        tputs(TPARM_2(parm_delete_line, n, 0), n, _nc_outch);
     } else if (scroll_forward && top == miny && bot == maxy) {
-       GoTo(bot, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx bot, 0);
+       UpdateAttrs(SP_PARM, blank);
        for (i = 0; i < n; i++) {
            TPUTS_TRACE("scroll_forward");
            putp(scroll_forward);
        }
     } else if (delete_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        for (i = 0; i < n; i++) {
            TPUTS_TRACE("delete_line");
            putp(delete_line);
@@ -1682,10 +1726,10 @@ scroll_csr_forward(NCURSES_SP_DCLx
        return ERR;
 
 #if NCURSES_EXT_FUNCS
-    if (FILL_BCE()) {
+    if (FILL_BCE(SP_PARM)) {
        int j;
        for (i = 0; i < n; i++) {
-           GoTo(bot - i, 0);
+           GoTo(NCURSES_SP_ARGx bot - i, 0);
            for (j = 0; j < screen_columns(SP_PARM); j++)
                PutChar(NCURSES_SP_ARGx CHREF(blank));
        }
@@ -1708,35 +1752,35 @@ scroll_csr_backward(NCURSES_SP_DCLx
     int i;
 
     if (n == 1 && scroll_reverse && top == miny && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("scroll_reverse");
        putp(scroll_reverse);
     } else if (n == 1 && insert_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("insert_line");
        putp(insert_line);
     } else if (parm_rindex && top == miny && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("parm_rindex");
        tputs(TPARM_2(parm_rindex, n, 0), n, _nc_outch);
     } else if (parm_insert_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        TPUTS_TRACE("parm_insert_line");
        tputs(TPARM_2(parm_insert_line, n, 0), n, _nc_outch);
     } else if (scroll_reverse && top == miny && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        for (i = 0; i < n; i++) {
            TPUTS_TRACE("scroll_reverse");
            putp(scroll_reverse);
        }
     } else if (insert_line && bot == maxy) {
-       GoTo(top, 0);
-       UpdateAttrs(blank);
+       GoTo(NCURSES_SP_ARGx top, 0);
+       UpdateAttrs(SP_PARM, blank);
        for (i = 0; i < n; i++) {
            TPUTS_TRACE("insert_line");
            putp(insert_line);
@@ -1745,10 +1789,10 @@ scroll_csr_backward(NCURSES_SP_DCLx
        return ERR;
 
 #if NCURSES_EXT_FUNCS
-    if (FILL_BCE()) {
+    if (FILL_BCE(SP_PARM)) {
        int j;
        for (i = 0; i < n; i++) {
-           GoTo(top + i, 0);
+           GoTo(NCURSES_SP_ARGx top + i, 0);
            for (j = 0; j < screen_columns(SP_PARM); j++)
                PutChar(NCURSES_SP_ARGx CHREF(blank));
        }
@@ -1760,15 +1804,15 @@ scroll_csr_backward(NCURSES_SP_DCLx
 /* scroll by using delete_line at del and insert_line at ins */
 /* n > 0 */
 static int
-scroll_idl(int n, int del, int ins, NCURSES_CH_T blank)
+scroll_idl(NCURSES_SP_DCLx int n, int del, int ins, NCURSES_CH_T blank)
 {
     int i;
 
     if (!((parm_delete_line || delete_line) && (parm_insert_line || insert_line)))
        return ERR;
 
-    GoTo(del, 0);
-    UpdateAttrs(blank);
+    GoTo(NCURSES_SP_ARGx del, 0);
+    UpdateAttrs(SP_PARM, blank);
     if (n == 1 && delete_line) {
        TPUTS_TRACE("delete_line");
        putp(delete_line);
@@ -1782,8 +1826,8 @@ scroll_idl(int n, int del, int ins, NCURSES_CH_T blank)
        }
     }
 
-    GoTo(ins, 0);
-    UpdateAttrs(blank);
+    GoTo(NCURSES_SP_ARGx ins, 0);
+    UpdateAttrs(SP_PARM, blank);
     if (n == 1 && insert_line) {
        TPUTS_TRACE("insert_line");
        putp(insert_line);
@@ -1864,7 +1908,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
        }
 
        if (res == ERR && _nc_idlok)
-           res = scroll_idl(n, top, bot - n + 1, blank);
+           res = scroll_idl(NCURSES_SP_ARGx n, top, bot - n + 1, blank);
 
        /*
         * Clear the newly shifted-in text.
@@ -1873,11 +1917,11 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
            && (non_dest_scroll_region || (memory_below && bot == maxy))) {
            static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
            if (bot == maxy && clr_eos) {
-               GoTo(bot - n + 1, 0);
+               GoTo(NCURSES_SP_ARGx bot - n + 1, 0);
                ClrToEOS(NCURSES_SP_ARGx blank2);
            } else {
                for (i = 0; i < n; i++) {
-                   GoTo(bot - i, 0);
+                   GoTo(NCURSES_SP_ARGx bot - i, 0);
                    ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
                }
            }
@@ -1888,7 +1932,8 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
 
        if (res == ERR && change_scroll_region) {
            if (top != 0
-               && (SP_PARM->_cursrow == top || SP_PARM->_cursrow == top - 1)
+               && (SP_PARM->_cursrow == top ||
+                   SP_PARM->_cursrow == top - 1)
                && save_cursor && restore_cursor) {
                cursor_saved = TRUE;
                TPUTS_TRACE("save_cursor");
@@ -1912,7 +1957,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
        }
 
        if (res == ERR && _nc_idlok)
-           res = scroll_idl(-n, bot + n + 1, top, blank);
+           res = scroll_idl(NCURSES_SP_ARGx -n, bot + n + 1, top, blank);
 
        /*
         * Clear the newly shifted-in text.
@@ -1921,7 +1966,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
            && (non_dest_scroll_region || (memory_above && top == 0))) {
            static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
            for (i = 0; i < -n; i++) {
-               GoTo(i + top, 0);
+               GoTo(NCURSES_SP_ARGx i + top, 0);
                ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
            }
        }
@@ -1933,7 +1978,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
     _nc_scroll_window(curscr, n, top, bot, blank);
 
     /* shift hash values too - they can be reused */
-    _nc_scroll_oldhash(n, top, bot);
+    NCURSES_SP_NAME(_nc_scroll_oldhash) (NCURSES_SP_ARGx n, top, bot);
 
     return (OK);
 }
@@ -1947,26 +1992,28 @@ _nc_scrolln(int n, int top, int bot, int maxy)
 #endif
 
 NCURSES_EXPORT(void)
-_nc_screen_resume(void)
+NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_DCL0)
 {
+    assert(SP_PARM);
+
     /* make sure terminal is in a sane known state */
-    SetAttr(SCREEN_ATTRS(SP), A_NORMAL);
+    SetAttr(SCREEN_ATTRS(SP_PARM), A_NORMAL);
     newscr->_clear = TRUE;
 
     /* reset color pairs and definitions */
-    if (SP->_coloron || SP->_color_defs)
-       _nc_reset_colors();
+    if (SP_PARM->_coloron || SP_PARM->_color_defs)
+       _nc_reset_colors ();
 
     /* restore user-defined colors, if any */
-    if (SP->_color_defs < 0) {
+    if (SP_PARM->_color_defs < 0) {
        int n;
-       SP->_color_defs = -(SP->_color_defs);
-       for (n = 0; n < SP->_color_defs; ++n) {
-           if (SP->_color_table[n].init) {
-               init_color(n,
-                          SP->_color_table[n].r,
-                          SP->_color_table[n].g,
-                          SP->_color_table[n].b);
+       SP_PARM->_color_defs = -(SP_PARM->_color_defs);
+       for (n = 0; n < SP_PARM->_color_defs; ++n) {
+           if (SP_PARM->_color_table[n].init) {
+               NCURSES_SP_NAME(init_color) (NCURSES_SP_ARGx n,
+                                            SP_PARM->_color_table[n].r,
+                                            SP_PARM->_color_table[n].g,
+                                            SP_PARM->_color_table[n].b);
            }
        }
     }
@@ -1988,17 +2035,36 @@ _nc_screen_resume(void)
        putp(auto_right_margin ? enter_am_mode : exit_am_mode);
 }
 
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_screen_resume(void)
+{
+    NCURSES_SP_NAME(_nc_screen_resume) (CURRENT_SCREEN);
+}
+#endif
+
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_screen_init) (NCURSES_SP_DCL0)
+{
+    NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
+}
+
+#if NCURSES_SP_FUNCS
 NCURSES_EXPORT(void)
 _nc_screen_init(void)
 {
-    _nc_screen_resume();
+    NCURSES_SP_NAME(_nc_screen_init) (CURRENT_SCREEN);
 }
+#endif
 
 /* wrap up screen handling */
 NCURSES_EXPORT(void)
 NCURSES_SP_NAME(_nc_screen_wrap) (NCURSES_SP_DCL0)
 {
-    UpdateAttrs(normal);
+    if (SP_PARM == 0)
+       return;
+
+    UpdateAttrs(SP_PARM, normal);
 #if NCURSES_EXT_FUNCS
     if (SP_PARM->_coloron
        && !SP_PARM->_default_color) {
@@ -2015,7 +2081,7 @@ NCURSES_SP_NAME(_nc_screen_wrap) (NCURSES_SP_DCL0)
     }
 #endif
     if (SP_PARM->_color_defs) {
-       _nc_reset_colors();
+       _nc_reset_colors ();
     }
 }
 
@@ -2029,18 +2095,30 @@ _nc_screen_wrap(void)
 
 #if USE_XMC_SUPPORT
 NCURSES_EXPORT(void)
-_nc_do_xmc_glitch(attr_t previous)
+NCURSES_SP_NAME(_nc_do_xmc_glitch) (NCURSES_SP_DCLx attr_t previous)
 {
-    attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP)));
-
-    while (chg != 0) {
-       if (chg & 1) {
-           SP->_curscol += magic_cookie_glitch;
-           if (SP->_curscol >= SP->_columns)
-               wrap_cursor();
-           TR(TRACE_UPDATE, ("bumped to %d,%d after cookie", SP->_cursrow, SP->_curscol));
+    if (SP_PARM != 0) {
+       attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP_PARM)));
+
+       while (chg != 0) {
+           if (chg & 1) {
+               SP_PARM->_curscol += magic_cookie_glitch;
+               if (SP_PARM->_curscol >= SP_PARM->_columns)
+                   wrap_cursor(NCURSES_SP_ARG);
+               TR(TRACE_UPDATE, ("bumped to %d,%d after cookie",
+                                 SP_PARM->_cursrow, SP_PARM->_curscol));
+           }
+           chg >>= 1;
        }
-       chg >>= 1;
     }
 }
+
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_do_xmc_glitch(attr_t previous)
+{
+    NCURSES_SP_NAME(_nc_do_xmc_glitch) (CURRENT_SCREEN, previous);
+}
+#endif
+
 #endif /* USE_XMC_SUPPORT */