cpython: c3581ca21a57 (original) (raw)

--- a/Doc/library/curses.rst +++ b/Doc/library/curses.rst @@ -653,7 +653,7 @@ Window Objects -------------- Window objects, as returned by :func:initscr and :func:newwin above, have -the following methods: +the following methods and attributes: .. method:: window.addch([y, x,] ch[, attr]) @@ -834,6 +834,16 @@ the following methods: event. +.. attribute:: window.encoding +

• Encoding used to encode method arguments (Unicode strings and characters).
• The encoding attribute is inherited from by parent window when a subwindow
• is created, for example with :meth:window.subwin. By default, the locale
• encoding is used (see :func:locale.getpreferredencoding). +
• .. versionadded:: 3.3 +

+ .. method:: window.erase() Clear the window.

--- a/Doc/whatsnew/3.3.rst +++ b/Doc/whatsnew/3.3.rst @@ -333,6 +333,11 @@ function to the :mod:crypt module. curses ------

• • If the :mod:curses module is linked to the ncursesw library, use Unicode
• functions when Unicode strings or characters are passed (e.g.
• :c:func:waddwstr), and bytes functions otherwise (e.g. :c:func:waddstr).
• • Use the locale encoding instead of utf-8 to encode Unicode strings.
• • :class:curses.window has a new :attr:curses.window.encoding attribute.
  • The :class:curses.window class has a new :meth:~curses.window.get_wch method to get a wide character
  • The :mod:curses module has a new :meth:~curses.unget_wch function to

--- a/Include/py_curses.h +++ b/Include/py_curses.h @@ -76,6 +76,7 @@ extern "C" { typedef struct { PyObject_HEAD WINDOW *win; + char *encoding; } PyCursesWindowObject; #define PyCursesWindow_Check(v) (Py_TYPE(v) == &PyCursesWindow_Type)

--- a/Lib/test/test_curses.py +++ b/Lib/test/test_curses.py @@ -267,24 +267,42 @@ def test_issue6243(stdscr): def test_unget_wch(stdscr): if not hasattr(curses, 'unget_wch'): return

• ch = 'a'
• curses.unget_wch(ch)
• read = stdscr.get_wch()
• read = chr(read)
• if read != ch:

•    raise AssertionError("%r != %r" % (read, ch))[](#l4.12)

• for ch in ('a', '\xe9', '\u20ac', '\U0010FFFF'):

•    curses.unget_wch(ch)[](#l4.14)

•    read = stdscr.get_wch()[](#l4.15)

•    read = chr(read)[](#l4.16)

•    if read != ch:[](#l4.17)

•        raise AssertionError("%r != %r" % (read, ch))[](#l4.18)

• ch = ord('a')
• curses.unget_wch(ch)
• read = stdscr.get_wch()
• if read != ch:

•    raise AssertionError("%r != %r" % (read, ch))[](#l4.24)

•    code = ord(ch)[](#l4.25)

•    curses.unget_wch(code)[](#l4.26)

•    read = stdscr.get_wch()[](#l4.27)

•    if read != code:[](#l4.28)

•        raise AssertionError("%r != %r" % (read, code))[](#l4.29)

def test_issue10570(): b = curses.tparm(curses.tigetstr("cup"), 5, 3) assert type(b) is bytes curses.putp(b) +def test_encoding(stdscr):

• import codecs
• encoding = stdscr.encoding
• codecs.lookup(encoding)
• try:

•    stdscr.encoding = 10[](#l4.41)

• except TypeError:

•    pass[](#l4.43)

• else:

•    raise AssertionError("TypeError not raised")[](#l4.45)

• stdscr.encoding = encoding
• try:

•    del stdscr.encoding[](#l4.48)

• except TypeError:

•    pass[](#l4.50)

• else:

•    raise AssertionError("TypeError not raised")[](#l4.52)

+ def main(stdscr): curses.savetty() try: @@ -295,6 +313,7 @@ def main(stdscr): test_issue6243(stdscr) test_unget_wch(stdscr) test_issue10570()

•    test_encoding(stdscr)[](#l4.61)

  finally: curses.resetty()

--- a/Misc/NEWS +++ b/Misc/NEWS @@ -395,6 +395,10 @@ Core and Builtins Library ------- +- Issue #12567: The curses module uses Unicode functions for Unicode arguments

• when it is linked to the ncurses library. It encodes also Unicode strings to
• the locale encoding instead of UTF-8. +

• Issue #12856: Ensure child processes do not inherit the parent's random seed for filename generation in the tempfile module. Patch by Brian Harring.

--- a/Modules/_cursesmodule.c +++ b/Modules/_cursesmodule.c @@ -121,6 +121,10 @@ extern int setupterm(char *,int,int ); #include <term.h> #endif +#ifdef HAVE_LANGINFO_H +#include <langinfo.h> +#endif + #if !defined(HAVE_NCURSES_H) && (defined(sgi) || defined(__sun) || defined(SCO5)) #define STRICT_SYSV_CURSES / Don't use ncurses extensions / typedef chtype attr_t; / No attr_t type is available / @@ -143,6 +147,8 @@ static int initialised = FALSE; / Tells whether start_color() has been called to initialise color usage. */ static int initialisedcolors = FALSE; +static char screen_encoding = NULL; + / Utility Macros */ #define PyCursesSetupTermCalled [](#l6.21) if (initialised_setupterm != TRUE) { [](#l6.22) @@ -175,7 +181,7 @@ static int initialisedcolors = FALSE; */ static PyObject * -PyCursesCheckERR(int code, char *fname) +PyCursesCheckERR(int code, const char *fname) { if (code != ERR) { Py_INCREF(Py_None); @@ -190,28 +196,193 @@ PyCursesCheckERR(int code, char fname) } } +/ Convert an object to a byte (an integer of type chtype): +

• • int
• • bytes of length 1
• • str of length 1 +
• Return 1 on success, 0 on error (invalid type or integer overflow). */ static int -PyCurses_ConvertToChtype(PyObject *obj, chtype *ch) +PyCurses_ConvertToChtype(PyCursesWindowObject *win, PyObject *obj, chtype *ch) {

• if (PyLong_CheckExact(obj)) {

•    int overflow;[](#l6.48)

•    /* XXX should the truncation by the cast also be reported[](#l6.49)

•       as an error? */[](#l6.50)

•    *ch = (chtype) PyLong_AsLongAndOverflow(obj, &overflow);[](#l6.51)

•    if (overflow)[](#l6.52)

• long value;
• if(PyBytes_Check(obj) && PyBytes_Size(obj) == 1) {

•    value = (unsigned char)PyBytes_AsString(obj)[0];[](#l6.55)

• }
• else if (PyUnicode_Check(obj)) {

•    if (PyUnicode_GetLength(obj) != 1) {[](#l6.58)

•        PyErr_Format(PyExc_TypeError,[](#l6.59)

•                     "expect bytes or str of length 1, or int, "[](#l6.60)

•                     "got a str of length %zi",[](#l6.61)

•                     PyUnicode_GET_LENGTH(obj));[](#l6.62)
         return 0;[](#l6.63)

• } else if(PyBytes_Check(obj)

•          && (PyBytes_Size(obj) == 1)) {[](#l6.65)

•    *ch = (chtype) *PyBytes_AsString(obj);[](#l6.66)

• } else if (PyUnicode_Check(obj) && PyUnicode_GET_LENGTH(obj) == 1) {

•    Py_UCS4 ucs = PyUnicode_READ(PyUnicode_KIND(obj),[](#l6.68)

•                                 PyUnicode_DATA(obj),[](#l6.69)

•                                 0);[](#l6.70)

•    *ch = (chtype)ucs;[](#l6.71)

• } else {

•    }[](#l6.73)

•    value = PyUnicode_READ_CHAR(obj, 0);[](#l6.74)

•    if (128 < value) {[](#l6.75)

•        PyObject *bytes;[](#l6.76)

•        const char *encoding;[](#l6.77)

•        if (win)[](#l6.78)

•            encoding = win->encoding;[](#l6.79)

•        else[](#l6.80)

•            encoding = screen_encoding;[](#l6.81)

•        bytes = PyUnicode_AsEncodedObject(obj, encoding, NULL);[](#l6.82)

•        if (bytes == NULL)[](#l6.83)

•            return 0;[](#l6.84)

•        if (PyBytes_GET_SIZE(bytes) == 1)[](#l6.85)

•            value = (unsigned char)PyBytes_AS_STRING(bytes)[0];[](#l6.86)

•        else[](#l6.87)

•            value = -1;[](#l6.88)

•        Py_DECREF(bytes);[](#l6.89)

•        if (value < 0)[](#l6.90)

•            goto overflow;[](#l6.91)

•    }[](#l6.92)

• }
• else if (PyLong_CheckExact(obj)) {

•    int long_overflow;[](#l6.95)

•    value = PyLong_AsLongAndOverflow(obj, &long_overflow);[](#l6.96)

•    if (long_overflow)[](#l6.97)

•        goto overflow;[](#l6.98)

• }
• else {

•    PyErr_Format(PyExc_TypeError,[](#l6.101)

•                 "expect bytes or str of length 1, or int, got %s",[](#l6.102)

•                 Py_TYPE(obj)->tp_name);[](#l6.103)
     return 0;[](#l6.104)

  }
• *ch = (chtype)value;
• if ((long)*ch != value)

•    goto overflow;[](#l6.108)

  return 1; + +overflow:
• PyErr_SetString(PyExc_OverflowError,

•                "byte doesn't fit in chtype");[](#l6.113)

• return 0;

+} + +/* Convert an object to a byte (chtype) or a character (cchar_t): +

• • int
• • bytes of length 1
• • str of length 1

+

• Return: +
• • 2 if obj is a character (written into *wch)
• • 1 if obj is a byte (written into *ch)
• • 0 on error: raise an exception */

+static int +PyCurses_ConvertToCchar_t(PyCursesWindowObject *win, PyObject *obj,

•                      chtype *ch[](#l6.130)

+#ifdef HAVE_NCURSESW

•                      , cchar_t *wch[](#l6.132)

+#endif

•                      )[](#l6.134)

+{

• int ret = 0;
• long value;

+#ifdef HAVE_NCURSESW

• wchar_t buffer[2];

+#endif +

• if (PyUnicode_Check(obj)) {

+#ifdef HAVE_NCURSESW

•    if (PyUnicode_AsWideChar(obj, buffer, 2) != 1) {[](#l6.144)

•        PyErr_Format(PyExc_TypeError,[](#l6.145)

•                     "expect bytes or str of length 1, or int, "[](#l6.146)

•                     "got a str of length %zi",[](#l6.147)

•                     PyUnicode_GET_LENGTH(obj));[](#l6.148)

•        return 0;[](#l6.149)

•    }[](#l6.150)

•    memset(wch->chars, 0, sizeof(wch->chars));[](#l6.151)

•    wch->chars[0] = buffer[0];[](#l6.152)

•    return 2;[](#l6.153)

+#else

•    return PyCurses_ConvertToChtype(win, obj, ch);[](#l6.155)

+#endif

• }
• else if(PyBytes_Check(obj) && PyBytes_Size(obj) == 1) {

•    value = (unsigned char)PyBytes_AsString(obj)[0];[](#l6.159)

•    ret = 1;[](#l6.160)

• }
• else if (PyLong_CheckExact(obj)) {

•    int overflow;[](#l6.163)

•    value = PyLong_AsLongAndOverflow(obj, &overflow);[](#l6.164)

•    if (overflow) {[](#l6.165)

•        PyErr_SetString(PyExc_OverflowError,[](#l6.166)

•                        "int doesn't fit in long");[](#l6.167)

•        return 0;[](#l6.168)

•    }[](#l6.169)

+#ifdef HAVE_NCURSESW

•    ret = 2;[](#l6.171)

+#else

•    ret = 1;[](#l6.173)

+#endif

• }
• else {

•    PyErr_Format(PyExc_TypeError,[](#l6.177)

•                 "expect bytes or str of length 1, or int, got %s",[](#l6.178)

•                 Py_TYPE(obj)->tp_name);[](#l6.179)

•    return 0;[](#l6.180)

• }

+#ifdef HAVE_NCURSESW

• if (ret == 2) {

•    memset(wch->chars, 0, sizeof(wch->chars));[](#l6.184)

•    wch->chars[0] = (wchar_t)value;[](#l6.185)

•    if ((long)wch->chars[0] != value) {[](#l6.186)

•        PyErr_Format(PyExc_OverflowError,[](#l6.187)

•                     "character doesn't fit in wchar_t");[](#l6.188)

•        return 0;[](#l6.189)

•    }[](#l6.190)

• }
• else

+#endif

• {

•    *ch = (chtype)value;[](#l6.195)

•    if ((long)*ch != value || value < 0 || value > 255) {[](#l6.196)

•        PyErr_Format(PyExc_OverflowError,[](#l6.197)

•                     "byte doesn't fit in chtype");[](#l6.198)

•        return 0;[](#l6.199)

•    }[](#l6.200)

• }
• return ret;

+} + +/* Convert an object to a byte string (char*) or a wide character string

• (wchar_t*). Return: +
• • 2 if obj is a character string (written into *wch)
• • 1 if obj is a byte string (written into *bytes)
• • 0 on error: raise an exception */

+static int +PyCurses_ConvertToString(PyCursesWindowObject *win, PyObject *obj,

•                     PyObject **bytes, wchar_t **wstr)[](#l6.213)

+{

• if (PyUnicode_Check(obj)) {

+#ifdef HAVE_NCURSESW

•    assert (wstr != NULL);[](#l6.217)

•    *wstr = PyUnicode_AsWideCharString(obj, NULL);[](#l6.218)

•    if (*wstr == NULL)[](#l6.219)

•        return 0;[](#l6.220)

•    return 2;[](#l6.221)

+#else

•    assert (wstr == NULL);[](#l6.223)

•    *bytes = PyUnicode_AsEncodedObject(obj, win->encoding, NULL);[](#l6.224)

•    if (*bytes == NULL)[](#l6.225)

•        return 0;[](#l6.226)

•    return 1;[](#l6.227)

+#endif

• }
• else if (PyBytes_Check(obj)) {

•    Py_INCREF(obj);[](#l6.231)

•    *bytes = obj;[](#l6.232)

•    return 1;[](#l6.233)

• }

+

• PyErr_Format(PyExc_TypeError, "expect bytes or str, got %s",

•             Py_TYPE(obj)->tp_name);[](#l6.237)

• return 0;

} /* Function versions of the 3 functions for testing whether curses has been @@ -357,13 +528,37 @@ Window_TwoArgNoReturnFunction(wresize, i /* Allocation and deallocation of Window Objects */ static PyObject * -PyCursesWindow_New(WINDOW *win) +PyCursesWindow_New(WINDOW *win, const char *encoding) { PyCursesWindowObject *wo;

• if (encoding == NULL) {

+#if defined(MS_WINDOWS)

•    char *buffer[100];[](#l6.253)

•    UINT cp;[](#l6.254)

•    cp = GetConsoleOutputCP();[](#l6.255)

•    if (cp != 0) {[](#l6.256)

•        PyOS_snprintf(buffer, sizeof(buffer), "cp%u", cp);[](#l6.257)

•        encoding = buffer;[](#l6.258)

•    }[](#l6.259)

+#elif defined(CODESET)

•    const char *codeset = nl_langinfo(CODESET);[](#l6.261)

•    if (codeset != NULL && codeset[0] != 0)[](#l6.262)

•        encoding = codeset;[](#l6.263)

+#endif

•    if (encoding == NULL)[](#l6.265)

•        encoding = "utf-8";[](#l6.266)

• }

+ wo = PyObject_NEW(PyCursesWindowObject, &PyCursesWindow_Type); if (wo == NULL) return NULL; wo->win = win;

• wo->encoding = strdup(encoding);
• if (wo->encoding == NULL) {

•    Py_DECREF(wo);[](#l6.274)

•    PyErr_NoMemory();[](#l6.275)

•    return NULL;[](#l6.276)

• } return (PyObject *)wo; }

@@ -371,6 +566,8 @@ static void PyCursesWindow_Dealloc(PyCursesWindowObject *wo) { if (wo->win != stdscr) delwin(wo->win);

• if (wo->encoding != NULL)

•    free(wo->encoding);[](#l6.286)

  PyObject_DEL(wo); } @@ -380,29 +577,34 @@ static PyObject * PyCursesWindow_AddCh(PyCursesWindowObject *self, PyObject *args) { int rtn, x, y, use_xy = FALSE;

• PyObject *temp;
• chtype ch = 0;

• PyObject *chobj;
• int type;
• chtype ch;

+#ifdef HAVE_NCURSESW

• cchar_t wch;

+#endif attr_t attr = A_NORMAL; long lattr;

• const char *funcname;

switch (PyTuple_Size(args)) { case 1:

•    if (!PyArg_ParseTuple(args, "O;ch or int", &temp))[](#l6.308)

•    if (!PyArg_ParseTuple(args, "O;ch or int", &chobj))[](#l6.309)
         return NULL;[](#l6.310)
     break;[](#l6.311)

  case 2:

•    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &temp, &lattr))[](#l6.313)

•    if (!PyArg_ParseTuple(args, "Ol;ch or int,attr", &chobj, &lattr))[](#l6.314)
         return NULL;[](#l6.315)
     attr = lattr;[](#l6.316)
     break;[](#l6.317)

  case 3:

•    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &temp))[](#l6.319)

•    if (!PyArg_ParseTuple(args,"iiO;y,x,ch or int", &y, &x, &chobj))[](#l6.320)
         return NULL;[](#l6.321)
     use_xy = TRUE;[](#l6.322)
     break;[](#l6.323)

  case 4: if (!PyArg_ParseTuple(args,"iiOl;y,x,ch or int, attr",

•                          &y, &x, &temp, &lattr))[](#l6.326)

•                          &y, &x, &chobj, &lattr))[](#l6.327)
         return NULL;[](#l6.328)
     attr = lattr;[](#l6.329)
     use_xy = TRUE;[](#l6.330)

@@ -412,17 +614,33 @@ PyCursesWindow_AddCh(PyCursesWindowObjec return NULL; }

• if (!PyCurses_ConvertToChtype(temp, &ch)) {

•    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");[](#l6.336)

+#ifdef HAVE_NCURSESW

• type = PyCurses_ConvertToCchar_t(self, chobj, &ch, &wch);
• if (type == 2) {

•    funcname = "add_wch";[](#l6.340)

•    wch.attr = attr;[](#l6.341)

•    if (use_xy == TRUE)[](#l6.342)

•        rtn = mvwadd_wch(self->win,y,x, &wch);[](#l6.343)

•    else {[](#l6.344)

•        rtn = wadd_wch(self->win, &wch);[](#l6.345)

•    }[](#l6.346)

• }
• else

+#else

• type = PyCurses_ConvertToCchar_t(self, chobj, &ch);

+#endif

• if (type == 1) {

•    funcname = "addch";[](#l6.353)

•    if (use_xy == TRUE)[](#l6.354)

•        rtn = mvwaddch(self->win,y,x, ch | attr);[](#l6.355)

•    else {[](#l6.356)

•        rtn = waddch(self->win, ch | attr);[](#l6.357)

•    }[](#l6.358)

• }
• else { return NULL; } -

• if (use_xy == TRUE)

•    rtn = mvwaddch(self->win,y,x, ch | attr);[](#l6.365)

• else {

•    rtn = waddch(self->win, ch | attr);[](#l6.367)

• }
• return PyCursesCheckERR(rtn, "addch");

• return PyCursesCheckERR(rtn, funcname);

} static PyObject * @@ -430,29 +648,34 @@ PyCursesWindow_AddStr(PyCursesWindowObje { int rtn; int x, y;

• char *str;

• int strtype;
• PyObject *strobj, *bytesobj;

+#ifdef HAVE_NCURSESW

• wchar_t *wstr = NULL;

+#endif attr_t attr = A_NORMAL , attr_old = A_NORMAL; long lattr; int use_xy = FALSE, use_attr = FALSE;

• const char *funcname;

switch (PyTuple_Size(args)) { case 1:

•    if (!PyArg_ParseTuple(args,"s;str", &str))[](#l6.391)

•    if (!PyArg_ParseTuple(args,"O;str", &strobj))[](#l6.392)
         return NULL;[](#l6.393)
     break;[](#l6.394)

  case 2:

•    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))[](#l6.396)

•    if (!PyArg_ParseTuple(args,"Ol;str,attr", &strobj, &lattr))[](#l6.397)
         return NULL;[](#l6.398)
     attr = lattr;[](#l6.399)
     use_attr = TRUE;[](#l6.400)
     break;[](#l6.401)

  case 3:

•    if (!PyArg_ParseTuple(args,"iis;int,int,str", &y, &x, &str))[](#l6.403)

•    if (!PyArg_ParseTuple(args,"iiO;int,int,str", &y, &x, &strobj))[](#l6.404)
         return NULL;[](#l6.405)
     use_xy = TRUE;[](#l6.406)
     break;[](#l6.407)

  case 4:

•    if (!PyArg_ParseTuple(args,"iisl;int,int,str,attr", &y, &x, &str, &lattr))[](#l6.409)

•    if (!PyArg_ParseTuple(args,"iiOl;int,int,str,attr", &y, &x, &strobj, &lattr))[](#l6.410)
         return NULL;[](#l6.411)
     attr = lattr;[](#l6.412)
     use_xy = use_attr = TRUE;[](#l6.413)

@@ -461,47 +684,74 @@ PyCursesWindow_AddStr(PyCursesWindowObje PyErr_SetString(PyExc_TypeError, "addstr requires 1 to 4 arguments"); return NULL; } - +#ifdef HAVE_NCURSESW

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, &wstr);

+#else

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, NULL);

+#endif

• if (strtype == 0)

•    return NULL;[](#l6.425)

  if (use_attr == TRUE) { attr_old = getattrs(self->win); (void)wattrset(self->win,attr); }

• if (use_xy == TRUE)

•    rtn = mvwaddstr(self->win,y,x,str);[](#l6.431)

+#ifdef HAVE_NCURSESW

• if (strtype == 2) {

•    funcname = "addwstr";[](#l6.434)

•    if (use_xy == TRUE)[](#l6.435)

•        rtn = mvwaddwstr(self->win,y,x,wstr);[](#l6.436)

•    else[](#l6.437)

•        rtn = waddwstr(self->win,wstr);[](#l6.438)

•    PyMem_Free(wstr);[](#l6.439)

• } else

•    rtn = waddstr(self->win,str);[](#l6.442)

+#endif

• {

•    char *str = PyBytes_AS_STRING(bytesobj);[](#l6.445)

•    funcname = "addstr";[](#l6.446)

•    if (use_xy == TRUE)[](#l6.447)

•        rtn = mvwaddstr(self->win,y,x,str);[](#l6.448)

•    else[](#l6.449)

•        rtn = waddstr(self->win,str);[](#l6.450)

•    Py_DECREF(bytesobj);[](#l6.451)

• } if (use_attr == TRUE) (void)wattrset(self->win,attr_old);

• return PyCursesCheckERR(rtn, "addstr");

• return PyCursesCheckERR(rtn, funcname);

} static PyObject * PyCursesWindow_AddNStr(PyCursesWindowObject *self, PyObject *args) { int rtn, x, y, n;

• char *str;

• int strtype;
• PyObject *strobj, *bytesobj;

+#ifdef HAVE_NCURSESW

• wchar_t *wstr = NULL;

+#endif attr_t attr = A_NORMAL , attr_old = A_NORMAL; long lattr; int use_xy = FALSE, use_attr = FALSE;

• const char *funcname;

switch (PyTuple_Size(args)) { case 2:

•    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))[](#l6.476)

•    if (!PyArg_ParseTuple(args,"Oi;str,n", &strobj, &n))[](#l6.477)
         return NULL;[](#l6.478)
     break;[](#l6.479)

  case 3:

•    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))[](#l6.481)

•    if (!PyArg_ParseTuple(args,"Oil;str,n,attr", &strobj, &n, &lattr))[](#l6.482)
         return NULL;[](#l6.483)
     attr = lattr;[](#l6.484)
     use_attr = TRUE;[](#l6.485)
     break;[](#l6.486)

  case 4:

•    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))[](#l6.488)

•    if (!PyArg_ParseTuple(args,"iiOi;y,x,str,n", &y, &x, &strobj, &n))[](#l6.489)
         return NULL;[](#l6.490)
     use_xy = TRUE;[](#l6.491)
     break;[](#l6.492)

  case 5:

•    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))[](#l6.494)

•    if (!PyArg_ParseTuple(args,"iiOil;y,x,str,n,attr", &y, &x, &strobj, &n, &lattr))[](#l6.495)
         return NULL;[](#l6.496)
     attr = lattr;[](#l6.497)
     use_xy = use_attr = TRUE;[](#l6.498)

@@ -510,18 +760,41 @@ PyCursesWindow_AddNStr(PyCursesWindowObj PyErr_SetString(PyExc_TypeError, "addnstr requires 2 to 5 arguments"); return NULL; } +#ifdef HAVE_NCURSESW

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, &wstr);

+#else

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, NULL);

+#endif

• if (strtype == 0)

•    return NULL;[](#l6.509)

if (use_attr == TRUE) { attr_old = getattrs(self->win); (void)wattrset(self->win,attr); }

• if (use_xy == TRUE)

•    rtn = mvwaddnstr(self->win,y,x,str,n);[](#l6.516)

+#ifdef HAVE_NCURSESW

• if (strtype == 2) {

•    funcname = "addnwstr";[](#l6.519)

•    if (use_xy == TRUE)[](#l6.520)

•        rtn = mvwaddnwstr(self->win,y,x,wstr,n);[](#l6.521)

•    else[](#l6.522)

•        rtn = waddnwstr(self->win,wstr,n);[](#l6.523)

•    PyMem_Free(wstr);[](#l6.524)

• } else

•    rtn = waddnstr(self->win,str,n);[](#l6.527)

+#endif

• {

•    char *str = PyBytes_AS_STRING(bytesobj);[](#l6.530)

•    funcname = "addnstr";[](#l6.531)

•    if (use_xy == TRUE)[](#l6.532)

•        rtn = mvwaddnstr(self->win,y,x,str,n);[](#l6.533)

•    else[](#l6.534)

•        rtn = waddnstr(self->win,str,n);[](#l6.535)

•    Py_DECREF(bytesobj);[](#l6.536)

• } if (use_attr == TRUE) (void)wattrset(self->win,attr_old);

• return PyCursesCheckERR(rtn, "addnstr");

• return PyCursesCheckERR(rtn, funcname);

} static PyObject * @@ -547,10 +820,8 @@ PyCursesWindow_Bkgd(PyCursesWindowObject return NULL; }

• if (!PyCurses_ConvertToChtype(temp, &bkgd)) {

•    PyErr_SetString(PyExc_TypeError, "argument 1 or 3 must be a ch or an int");[](#l6.550)

• if (!PyCurses_ConvertToChtype(self, temp, &bkgd)) return NULL;

• }

return PyCursesCheckERR(wbkgd(self->win, bkgd | attr), "bkgd"); } @@ -605,10 +876,8 @@ PyCursesWindow_BkgdSet(PyCursesWindowObj return NULL; }

• if (!PyCurses_ConvertToChtype(temp, &bkgd)) {

•    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");[](#l6.562)

• if (!PyCurses_ConvertToChtype(self, temp, &bkgd)) return NULL;

• }

wbkgdset(self->win, bkgd | attr); return PyCursesCheckERR(0, "bkgdset"); @@ -633,11 +902,8 @@ PyCursesWindow_Border(PyCursesWindowObje return NULL; for(i=0; i<8; i++) {

•    if (temp[i] != NULL && !PyCurses_ConvertToChtype(temp[i], &ch[i])) {[](#l6.573)

•        PyErr_Format(PyExc_TypeError,[](#l6.574)

•                     "argument %i must be a ch or an int", i+1);[](#l6.575)

•    if (temp[i] != NULL && !PyCurses_ConvertToChtype(self, temp[i], &ch[i]))[](#l6.576)
         return NULL;[](#l6.577)

•    }[](#l6.578)

  } wborder(self->win, @@ -782,7 +1048,7 @@ PyCursesWindow_DerWin(PyCursesWindowObje return NULL; }
• return (PyObject *)PyCursesWindow_New(win);

• return (PyObject *)PyCursesWindow_New(win, NULL);

} static PyObject * @@ -810,10 +1076,8 @@ PyCursesWindow_EchoChar(PyCursesWindowOb return NULL; }

• if (!PyCurses_ConvertToChtype(temp, &ch)) {

•    PyErr_SetString(PyExc_TypeError, "argument 1 must be a ch or an int");[](#l6.596)

• if (!PyCurses_ConvertToChtype(self, temp, &ch)) return NULL;

• }

#ifdef WINDOW_HAS_FLAGS if (self->win->_flags & _ISPAD) @@ -1034,11 +1298,8 @@ PyCursesWindow_Hline(PyCursesWindowObjec } if (code != ERR) {

•    if (!PyCurses_ConvertToChtype(temp, &ch)) {[](#l6.607)

•        PyErr_SetString(PyExc_TypeError,[](#l6.608)

•                        "argument 1 or 3 must be a ch or an int");[](#l6.609)

•    if (!PyCurses_ConvertToChtype(self, temp, &ch))[](#l6.610)
         return NULL;[](#l6.611)

•    }[](#l6.612)
     return PyCursesCheckERR(whline(self->win, ch | attr, n), "hline");[](#l6.613)

  } else return PyCursesCheckERR(code, "wmove");

@@ -1079,11 +1340,8 @@ PyCursesWindow_InsCh(PyCursesWindowObjec return NULL; }

• if (!PyCurses_ConvertToChtype(temp, &ch)) {

•    PyErr_SetString(PyExc_TypeError,[](#l6.621)

•                    "argument 1 or 3 must be a ch or an int");[](#l6.622)

• if (!PyCurses_ConvertToChtype(self, temp, &ch)) return NULL;

• }

if (use_xy == TRUE) rtn = mvwinsch(self->win,y,x, ch | attr); @@ -1154,29 +1412,34 @@ PyCursesWindow_InsStr(PyCursesWindowObje { int rtn; int x, y;

• char *str;

• int strtype;
• PyObject *strobj, *bytesobj;

+#ifdef HAVE_NCURSESW

• wchar_t *wstr = NULL;

+#endif attr_t attr = A_NORMAL , attr_old = A_NORMAL; long lattr; int use_xy = FALSE, use_attr = FALSE;

• const char *funcname;

switch (PyTuple_Size(args)) { case 1:

•    if (!PyArg_ParseTuple(args,"s;str", &str))[](#l6.646)

•    if (!PyArg_ParseTuple(args,"O;str", &strobj))[](#l6.647)
         return NULL;[](#l6.648)
     break;[](#l6.649)

  case 2:

•    if (!PyArg_ParseTuple(args,"sl;str,attr", &str, &lattr))[](#l6.651)

•    if (!PyArg_ParseTuple(args,"Ol;str,attr", &strobj, &lattr))[](#l6.652)
         return NULL;[](#l6.653)
     attr = lattr;[](#l6.654)
     use_attr = TRUE;[](#l6.655)
     break;[](#l6.656)

  case 3:

•    if (!PyArg_ParseTuple(args,"iis;y,x,str", &y, &x, &str))[](#l6.658)

•    if (!PyArg_ParseTuple(args,"iiO;y,x,str", &y, &x, &strobj))[](#l6.659)
         return NULL;[](#l6.660)
     use_xy = TRUE;[](#l6.661)
     break;[](#l6.662)

  case 4:

•    if (!PyArg_ParseTuple(args,"iisl;y,x,str,attr", &y, &x, &str, &lattr))[](#l6.664)

•    if (!PyArg_ParseTuple(args,"iiOl;y,x,str,attr", &y, &x, &strobj, &lattr))[](#l6.665)
         return NULL;[](#l6.666)
     attr = lattr;[](#l6.667)
     use_xy = use_attr = TRUE;[](#l6.668)

@@ -1186,46 +1449,75 @@ PyCursesWindow_InsStr(PyCursesWindowObje return NULL; } +#ifdef HAVE_NCURSESW

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, &wstr);

+#else

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, NULL);

+#endif

• if (strtype == 0)

•    return NULL;[](#l6.679)

+ if (use_attr == TRUE) { attr_old = getattrs(self->win); (void)wattrset(self->win,attr); }

• if (use_xy == TRUE)

•    rtn = mvwinsstr(self->win,y,x,str);[](#l6.686)

+#ifdef HAVE_NCURSESW

• if (strtype == 2) {

•    funcname = "inswstr";[](#l6.689)

•    if (use_xy == TRUE)[](#l6.690)

•        rtn = mvwins_wstr(self->win,y,x,wstr);[](#l6.691)

•    else[](#l6.692)

•        rtn = wins_wstr(self->win,wstr);[](#l6.693)

•    PyMem_Free(wstr);[](#l6.694)

• } else

•    rtn = winsstr(self->win,str);[](#l6.697)

+#endif

• {

•    char *str = PyBytes_AS_STRING(bytesobj);[](#l6.700)

•    funcname = "insstr";[](#l6.701)

•    if (use_xy == TRUE)[](#l6.702)

•        rtn = mvwinsstr(self->win,y,x,str);[](#l6.703)

•    else[](#l6.704)

•        rtn = winsstr(self->win,str);[](#l6.705)

•    Py_DECREF(bytesobj);[](#l6.706)

• } if (use_attr == TRUE) (void)wattrset(self->win,attr_old);

• return PyCursesCheckERR(rtn, "insstr");

• return PyCursesCheckERR(rtn, funcname);

} static PyObject * PyCursesWindow_InsNStr(PyCursesWindowObject *self, PyObject *args) { int rtn, x, y, n;

• char *str;

• int strtype;
• PyObject *strobj, *bytesobj;

+#ifdef HAVE_NCURSESW

• wchar_t *wstr = NULL;

+#endif attr_t attr = A_NORMAL , attr_old = A_NORMAL; long lattr; int use_xy = FALSE, use_attr = FALSE;

• const char *funcname;

switch (PyTuple_Size(args)) { case 2:

•    if (!PyArg_ParseTuple(args,"si;str,n", &str, &n))[](#l6.731)

•    if (!PyArg_ParseTuple(args,"Oi;str,n", &strobj, &n))[](#l6.732)
         return NULL;[](#l6.733)
     break;[](#l6.734)

  case 3:

•    if (!PyArg_ParseTuple(args,"sil;str,n,attr", &str, &n, &lattr))[](#l6.736)

•    if (!PyArg_ParseTuple(args,"Oil;str,n,attr", &strobj, &n, &lattr))[](#l6.737)
         return NULL;[](#l6.738)
     attr = lattr;[](#l6.739)
     use_attr = TRUE;[](#l6.740)
     break;[](#l6.741)

  case 4:

•    if (!PyArg_ParseTuple(args,"iisi;y,x,str,n", &y, &x, &str, &n))[](#l6.743)

•    if (!PyArg_ParseTuple(args,"iiOi;y,x,str,n", &y, &x, &strobj, &n))[](#l6.744)
         return NULL;[](#l6.745)
     use_xy = TRUE;[](#l6.746)
     break;[](#l6.747)

  case 5:

•    if (!PyArg_ParseTuple(args,"iisil;y,x,str,n,attr", &y, &x, &str, &n, &lattr))[](#l6.749)

•    if (!PyArg_ParseTuple(args,"iiOil;y,x,str,n,attr", &y, &x, &strobj, &n, &lattr))[](#l6.750)
         return NULL;[](#l6.751)
     attr = lattr;[](#l6.752)
     use_xy = use_attr = TRUE;[](#l6.753)

@@ -1235,17 +1527,41 @@ PyCursesWindow_InsNStr(PyCursesWindowObj return NULL; } +#ifdef HAVE_NCURSESW

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, &wstr);

+#else

• strtype = PyCurses_ConvertToString(self, strobj, &bytesobj, NULL);

+#endif

• if (strtype == 0)

•    return NULL;[](#l6.764)

+ if (use_attr == TRUE) { attr_old = getattrs(self->win); (void)wattrset(self->win,attr); }

• if (use_xy == TRUE)

•    rtn = mvwinsnstr(self->win,y,x,str,n);[](#l6.771)

+#ifdef HAVE_NCURSESW

• if (strtype == 2) {

•    funcname = "insn_wstr";[](#l6.774)

•    if (use_xy == TRUE)[](#l6.775)

•        rtn = mvwins_nwstr(self->win,y,x,wstr,n);[](#l6.776)

•    else[](#l6.777)

•        rtn = wins_nwstr(self->win,wstr,n);[](#l6.778)

•    PyMem_Free(wstr);[](#l6.779)

• } else

•    rtn = winsnstr(self->win,str,n);[](#l6.782)

+#endif

• {

•    char *str = PyBytes_AS_STRING(bytesobj);[](#l6.785)

•    funcname = "insnstr";[](#l6.786)

•    if (use_xy == TRUE)[](#l6.787)

•        rtn = mvwinsnstr(self->win,y,x,str,n);[](#l6.788)

•    else[](#l6.789)

•        rtn = winsnstr(self->win,str,n);[](#l6.790)

•    Py_DECREF(bytesobj);[](#l6.791)

• } if (use_attr == TRUE) (void)wattrset(self->win,attr_old);

• return PyCursesCheckERR(rtn, "insnstr");

• return PyCursesCheckERR(rtn, funcname);

} static PyObject * @@ -1528,7 +1844,7 @@ PyCursesWindow_SubWin(PyCursesWindowObje return NULL; }

• return (PyObject *)PyCursesWindow_New(win);

• return (PyObject *)PyCursesWindow_New(win, self->encoding);

} static PyObject * @@ -1604,16 +1920,51 @@ PyCursesWindow_Vline(PyCursesWindowObjec } if (code != ERR) {

•    if (!PyCurses_ConvertToChtype(temp, &ch)) {[](#l6.813)

•        PyErr_SetString(PyExc_TypeError,[](#l6.814)

•                        "argument 1 or 3 must be a ch or an int");[](#l6.815)

•    if (!PyCurses_ConvertToChtype(self, temp, &ch))[](#l6.816)
         return NULL;[](#l6.817)

•    }[](#l6.818)
     return PyCursesCheckERR(wvline(self->win, ch | attr, n), "vline");[](#l6.819)

  } else return PyCursesCheckERR(code, "wmove");

} +static PyObject * +PyCursesWindow_get_encoding(PyCursesWindowObject *self, void *closure) +{

• return PyUnicode_FromString(self->encoding);

+} + +static int +PyCursesWindow_set_encoding(PyCursesWindowObject *self, PyObject *value) +{

• PyObject *ascii;
• char *encoding;

+

• /* It is illegal to del win.encoding */
• if (value == NULL) {

•    PyErr_SetString(PyExc_TypeError,[](#l6.838)

•                    "encoding may not be deleted");[](#l6.839)

•    return -1;[](#l6.840)

• }

+

• if (!PyUnicode_Check(value)) {

•    PyErr_SetString(PyExc_TypeError,[](#l6.844)

•                    "setting encoding to a non-string");[](#l6.845)

•    return -1;[](#l6.846)

• }
• ascii = PyUnicode_AsASCIIString(value);
• if (ascii == NULL)

•    return -1;[](#l6.850)

• encoding = strdup(PyBytes_AS_STRING(ascii));
• if (encoding == NULL) {

•    PyErr_NoMemory();[](#l6.853)

•    return -1;[](#l6.854)

• }
• free(self->encoding);
• self->encoding = encoding;
• return 0;

+} + + static PyMethodDef PyCursesWindow_Methods[] = { {"addch", (PyCFunction)PyCursesWindow_AddCh, METH_VARARGS}, {"addnstr", (PyCFunction)PyCursesWindow_AddNStr, METH_VARARGS}, @@ -1701,6 +2052,13 @@ static PyMethodDef PyCursesWindow_Method {NULL, NULL} /* sentinel */ }; +static PyGetSetDef PyCursesWindow_getsets[] = {

• {"encoding",

• (getter)PyCursesWindow_get_encoding,[](#l6.871)

• (setter)PyCursesWindow_set_encoding,[](#l6.872)

• "the typecode character used to create the array"}[](#l6.873)

+}; + /* -------------------------------------------------------*/ PyTypeObject PyCursesWindow_Type = { @@ -1733,6 +2091,8 @@ PyTypeObject PyCursesWindow_Type = { 0, /tp_iter/ 0, /tp_iternext/ PyCursesWindow_Methods, /tp_methods/

• 0, /* tp_members */
• PyCursesWindow_getsets, /* tp_getset */

}; /********************************************************************* @@ -1956,7 +2316,7 @@ PyCurses_GetWin(PyCursesWindowObject *se PyErr_SetString(PyCursesError, catchall_NULL); return NULL; }

• return PyCursesWindow_New(win);

• return PyCursesWindow_New(win, NULL);

} static PyObject * @@ -2034,10 +2394,11 @@ static PyObject * PyCurses_InitScr(PyObject *self) { WINDOW *win;

• PyCursesWindowObject *winobj;

if (initialised == TRUE) { wrefresh(stdscr);

•    return (PyObject *)PyCursesWindow_New(stdscr);[](#l6.905)

•    return (PyObject *)PyCursesWindow_New(stdscr, NULL);[](#l6.906)

  } win = initscr(); @@ -2129,7 +2490,9 @@ PyCurses_InitScr(PyObject *self) SetDictInt("LINES", LINES); SetDictInt("COLS", COLS);

• return (PyObject *)PyCursesWindow_New(win);

• winobj = (PyCursesWindowObject *)PyCursesWindow_New(win, NULL);
• screen_encoding = winobj->encoding;
• return (PyObject *)winobj;

} static PyObject * @@ -2331,7 +2694,7 @@ PyCurses_NewPad(PyObject *self, PyObject return NULL; }

• return (PyObject *)PyCursesWindow_New(win);

• return (PyObject *)PyCursesWindow_New(win, NULL);

} static PyObject * @@ -2363,7 +2726,7 @@ PyCurses_NewWindow(PyObject *self, PyObj return NULL; }

• return (PyObject *)PyCursesWindow_New(win);

• return (PyObject *)PyCursesWindow_New(win, NULL);

} static PyObject * @@ -2680,10 +3043,8 @@ PyCurses_UnCtrl(PyObject *self, PyObject if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;

• if (!PyCurses_ConvertToChtype(temp, &ch)) {

•    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");[](#l6.944)

• if (!PyCurses_ConvertToChtype(NULL, temp, &ch)) return NULL;

• }

return PyBytes_FromString(unctrl(ch)); } @@ -2696,12 +3057,11 @@ PyCurses_UngetCh(PyObject *self, PyObjec PyCursesInitialised;

• if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;

-

• if (!PyCurses_ConvertToChtype(temp, &ch)) {

•    PyErr_SetString(PyExc_TypeError, "argument must be a ch or an int");[](#l6.958)

• if (!PyArg_ParseTuple(args,"O;ch or int",&temp)) return NULL;

• }

+

• if (!PyCurses_ConvertToChtype(NULL, temp, &ch))

•    return NULL;[](#l6.964)

return PyCursesCheckERR(ungetch(ch), "ungetch"); }