/*

* This is a curses module for Python.

*

* Based on prior work by Lance Ellinghaus and Oliver Andrich

* Version 1.2 of this module: Copyright 1994 by Lance Ellinghouse,

* Cathedral City, California Republic, United States of America.

*

* Version 1.5b1, heavily extended for ncurses by Oliver Andrich:

* Copyright 1996,1997 by Oliver Andrich, Koblenz, Germany.

*

* Tidied for Python 1.6, and currently maintained by <amk@amk.ca>.

*

* Permission is hereby granted, free of charge, to any person obtaining

* a copy of this source file to use, copy, modify, merge, or publish it

* subject to the following conditions:

*

* The above copyright notice and this permission notice shall be included

* in all copies or in any new file that contains a substantial portion of

* this file.

*

* THE AUTHOR MAKES NO REPRESENTATIONS ABOUT THE SUITABILITY OF

* THE SOFTWARE FOR ANY PURPOSE. IT IS PROVIDED "AS IS" WITHOUT

* EXPRESS OR IMPLIED WARRANTY. THE AUTHOR DISCLAIMS ALL WARRANTIES

* WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES

* OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

* NON-INFRINGEMENT OF THIRD PARTY RIGHTS. IN NO EVENT SHALL THE

* AUTHOR BE LIABLE TO YOU OR ANY OTHER PARTY FOR ANY SPECIAL,

* INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER

* WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE, STRICT LIABILITY OR

* ANY OTHER ACTION ARISING OUT OF OR IN CONNECTION WITH THE USE OR

* PERFORMANCE OF THIS SOFTWARE.

*/

/*

A number of SysV or ncurses functions don't have wrappers yet; if you

need a given function, add it and send a patch. See

https://www.python.org/dev/patches/ for instructions on how to submit

patches to Python.

Here's a list of currently unsupported functions:

del_curterm mcprint mvcur restartterm

ripoffline set_curterm setterm

tgetent tgetflag tgetnum tgetstr tgoto tputs

vidattr vidputs

Menu extension (ncurses and probably SYSV):

current_item free_item free_menu item_count item_description

item_index item_init item_name item_opts item_opts_off

item_opts_on item_term item_userptr item_value item_visible

menu_back menu_driver menu_fore menu_format menu_grey

menu_init menu_items menu_mark menu_opts menu_opts_off

menu_opts_on menu_pad menu_pattern menu_request_by_name

menu_request_name menu_spacing menu_sub menu_term menu_userptr

menu_win new_item new_menu pos_menu_cursor post_menu

scale_menu set_current_item set_item_init set_item_opts

set_item_term set_item_userptr set_item_value set_menu_back

set_menu_fore set_menu_format set_menu_grey set_menu_init

set_menu_items set_menu_mark set_menu_opts set_menu_pad

set_menu_pattern set_menu_spacing set_menu_sub set_menu_term

set_menu_userptr set_menu_win set_top_row top_row unpost_menu

Form extension (ncurses and probably SYSV):

current_field data_ahead data_behind dup_field

dynamic_fieldinfo field_arg field_back field_buffer

field_count field_fore field_index field_info field_init

field_just field_opts field_opts_off field_opts_on field_pad

field_status field_term field_type field_userptr form_driver

form_fields form_init form_opts form_opts_off form_opts_on

form_page form_request_by_name form_request_name form_sub

form_term form_userptr form_win free_field free_form

link_field link_fieldtype move_field new_field new_form

new_page pos_form_cursor post_form scale_form

set_current_field set_field_back set_field_buffer

set_field_fore set_field_init set_field_just set_field_opts

set_field_pad set_field_status set_field_term set_field_type

set_field_userptr set_fieldtype_arg set_fieldtype_choice

set_form_fields set_form_init set_form_opts set_form_page

set_form_sub set_form_term set_form_userptr set_form_win

set_max_field set_new_page unpost_form

*/

/* Release Number */

static const char PyCursesVersion[] = "2.2";

/* Includes */

#ifndef Py_BUILD_CORE_BUILTIN

# define Py_BUILD_CORE_MODULE 1

#endif

#include "Python.h"

#include "pycore_capsule.h" // _PyCapsule_SetTraverse()

#include "pycore_long.h" // _PyLong_GetZero()

#include "pycore_structseq.h" // _PyStructSequence_NewType()

#include "pycore_fileutils.h" // _Py_dup(), _Py_set_inheritable()

#include "pycore_tuple.h" // _PyTuple_HASH_XXPRIME_1

#ifdef __hpux

#define STRICT_SYSV_CURSES

#endif

#define CURSES_MODULE

#include "py_curses.h"

#if defined(HAVE_TERM_H) || defined(__sgi)

/* For termname, longname, putp, tigetflag, tigetnum, tigetstr, tparm

which are not declared in SysV curses and for setupterm. */

#include <term.h>

/* Including <term.h> #defines many common symbols. */

#undef lines

#undef columns

#endif

#ifdef HAVE_LANGINFO_H

#include <langinfo.h>

#endif

#if !defined(NCURSES_VERSION) && (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 */

#endif

#if defined(_AIX)

#define STRICT_SYSV_CURSES

#endif

#if defined(HAVE_NCURSESW) && NCURSES_EXT_FUNCS+0 >= 20170401 && NCURSES_EXT_COLORS+0 >= 20170401

#define _NCURSES_EXTENDED_COLOR_FUNCS 1

#else

#define _NCURSES_EXTENDED_COLOR_FUNCS 0

#endif

#if _NCURSES_EXTENDED_COLOR_FUNCS

#define _CURSES_COLOR_VAL_TYPE int

#define _CURSES_COLOR_NUM_TYPE int

#define _CURSES_INIT_COLOR_FUNC init_extended_color

#define _CURSES_INIT_PAIR_FUNC init_extended_pair

#define _COLOR_CONTENT_FUNC extended_color_content

#define _CURSES_PAIR_CONTENT_FUNC extended_pair_content

#else

#define _CURSES_COLOR_VAL_TYPE short

#define _CURSES_COLOR_NUM_TYPE short

#define _CURSES_INIT_COLOR_FUNC init_color

#define _CURSES_INIT_PAIR_FUNC init_pair

#define _COLOR_CONTENT_FUNC color_content

#define _CURSES_PAIR_CONTENT_FUNC pair_content

#endif /* _NCURSES_EXTENDED_COLOR_FUNCS */

typedef struct {

PyObject *error; // curses exception type

PyTypeObject *window_type; // exposed by PyCursesWindow_Type

PyTypeObject *screen_type; // _curses.screen

PyTypeObject *complexchar_type; // _curses.complexchar

PyTypeObject *complexstr_type; // _curses.complexstr

PyObject *topscreen; // owned ref to the current screen object,

// or NULL for the initscr() screen

} cursesmodule_state;

static inline cursesmodule_state *

get_cursesmodule_state(PyObject *module)

{

void *state = PyModule_GetState(module);

assert(state != NULL);

return (cursesmodule_state *)state;

}

static inline cursesmodule_state *

get_cursesmodule_state_by_cls(PyTypeObject *cls)

{

void *state = PyType_GetModuleState(cls);

assert(state != NULL);

return (cursesmodule_state *)state;

}

static inline cursesmodule_state *

get_cursesmodule_state_by_win(PyCursesWindowObject *win)

{

return get_cursesmodule_state_by_cls(Py_TYPE(win));

}

#define _PyCursesWindowObject_CAST(op) ((PyCursesWindowObject *)(op))

#define _PyCursesScreenObject_CAST(op) ((PyCursesScreenObject *)(op))

/*[clinic input]

module _curses

class _curses.window "PyCursesWindowObject *" "clinic_state()->window_type"

class _curses.screen "PyCursesScreenObject *" "clinic_state()->screen_type"

class _curses.complexchar "PyCursesComplexCharObject *" "clinic_state()->complexchar_type"

class _curses.complexstr "PyCursesComplexStrObject *" "get_cursesmodule_state_by_cls(type)->complexstr_type"

[clinic start generated code]*/

/*[clinic end generated code: output=da39a3ee5e6b4b0d input=e9439fe0a704a26e]*/

/* Indicate whether the module has already been loaded or not. */

static int curses_module_loaded = 0;

/* Tells whether setupterm() has been called to initialise terminfo. */

static int curses_setupterm_called = FALSE;

/* Tells whether initscr() has been called to initialise curses. */

static int curses_initscr_called = FALSE;

/* Tells whether start_color() has been called to initialise color usage. */

static int curses_start_color_called = FALSE;

/* Encoding of the initial screen, used by module-level functions that have

no window object to take it from (e.g. unctrl(), ungetch()). This is a

private copy: the window object that initscr() returns may be deallocated

while these functions are still in use. */

static char *curses_screen_encoding = NULL;

/* Utility Error Procedures */

static void

_curses_format_error(cursesmodule_state *state,

const char *curses_funcname,

const char *python_funcname,

const char *return_value,

const char *default_message)

{

assert(!PyErr_Occurred());

if (python_funcname == NULL && curses_funcname == NULL) {

PyErr_SetString(state->error, default_message);

}

else if (python_funcname == NULL) {

(void)PyErr_Format(state->error, CURSES_ERROR_FORMAT,

curses_funcname, return_value);

}

else {

assert(python_funcname != NULL);

(void)PyErr_Format(state->error, CURSES_ERROR_VERBOSE_FORMAT,

curses_funcname, python_funcname, return_value);

}

}

/*

* Format a curses error for a function that returned ERR.

*

* Specify a non-NULL 'python_funcname' when the latter differs from

* 'curses_funcname'. If both names are NULL, uses the 'catchall_ERR'

* message instead.

*/

static void

_curses_set_error(cursesmodule_state *state,

const char *curses_funcname,

const char *python_funcname)

{

_curses_format_error(state, curses_funcname, python_funcname,

"ERR", catchall_ERR);

}

/*

* Format a curses error for a function that returned NULL.

*

* Specify a non-NULL 'python_funcname' when the latter differs from

* 'curses_funcname'. If both names are NULL, uses the 'catchall_NULL'

* message instead.

*/

static inline void

_curses_set_null_error(cursesmodule_state *state,

const char *curses_funcname,

const char *python_funcname)

{

_curses_format_error(state, curses_funcname, python_funcname,

"NULL", catchall_NULL);

}

/* Same as _curses_set_error() for a module object. */

static void

curses_set_error(PyObject *module,

const char *curses_funcname,

const char *python_funcname)

{

cursesmodule_state *state = get_cursesmodule_state(module);

_curses_set_error(state, curses_funcname, python_funcname);

}

/* Same as _curses_set_null_error() for a module object. */

static void

curses_set_null_error(PyObject *module,

const char *curses_funcname,

const char *python_funcname)

{

cursesmodule_state *state = get_cursesmodule_state(module);

_curses_set_null_error(state, curses_funcname, python_funcname);

}

/* Same as _curses_set_error() for a Window object. */

static void

curses_window_set_error(PyCursesWindowObject *win,

const char *curses_funcname,

const char *python_funcname)

{

cursesmodule_state *state = get_cursesmodule_state_by_win(win);

_curses_set_error(state, curses_funcname, python_funcname);

}

/* Same as _curses_set_null_error() for a Window object. */

static void

curses_window_set_null_error(PyCursesWindowObject *win,

const char *curses_funcname,

const char *python_funcname)

{

cursesmodule_state *state = get_cursesmodule_state_by_win(win);

_curses_set_null_error(state, curses_funcname, python_funcname);

}

/* Utility Checking Procedures */

/*

* Function to check that 'funcname' has been called by testing

* the 'called' boolean. If an error occurs, an exception is

* set and this returns 0. Otherwise, this returns 1.

*

* Since this function can be called in functions that do not

* have a direct access to the module's state, '_curses.error'

* is imported on demand.

*

* Use _PyCursesStatefulCheckFunction() if the module is given.

*/

static int

_PyCursesCheckFunction(int called, const char *funcname)

{

if (called == TRUE) {

return 1;

}

PyObject *exc = PyImport_ImportModuleAttrString("_curses", "error");

if (exc != NULL) {

PyErr_Format(exc, CURSES_ERROR_MUST_CALL_FORMAT, funcname);

Py_DECREF(exc);

}

assert(PyErr_Occurred());

return 0;

}

/*

* Function to check that 'funcname' has been called by testing

* the 'called'' boolean. If an error occurs, a PyCursesError is

* set and this returns 0. Otherwise this returns 1.

*

* The exception type is obtained from the 'module' state.

*/

static int

_PyCursesStatefulCheckFunction(PyObject *module,

int called, const char *funcname)

{

if (called == TRUE) {

return 1;

}

cursesmodule_state *state = get_cursesmodule_state(module);

PyErr_Format(state->error, CURSES_ERROR_MUST_CALL_FORMAT, funcname);

return 0;

}

/*

* Function to check that the current screen has a terminal, by testing

* stdscr, which a screen made by new_prescr() does not have. If an error

* occurs, a PyCursesError is set and this returns 0. Otherwise this

* returns 1.

*/

static int

_PyCursesStatefulCheckTerminal(PyObject *module)

{

if (stdscr != NULL) {

return 1;

}

cursesmodule_state *state = get_cursesmodule_state(module);

PyErr_SetString(state->error, "the current screen has no terminal");

return 0;

}

/* Same as _PyCursesStatefulCheckTerminal() for a Window object. */

static int

curses_window_check_terminal(PyCursesWindowObject *win)

{

if (stdscr != NULL) {

return 1;

}

cursesmodule_state *state = get_cursesmodule_state_by_win(win);

PyErr_SetString(state->error, "the current screen has no terminal");

return 0;

}

#define PyCursesStatefulSetupTermCalled(MODULE) \

do { \

if (!_PyCursesStatefulCheckFunction(MODULE, \

curses_setupterm_called, \

"setupterm")) \

{ \

return 0; \

} \

} while (0)

#define PyCursesStatefulInitialised(MODULE) \

do { \

if (!_PyCursesStatefulCheckFunction(MODULE, \

curses_initscr_called, \

"initscr") \

|| !_PyCursesStatefulCheckTerminal(MODULE)) \

{ \

return 0; \

} \

} while (0)

#define PyCursesStatefulInitialisedColor(MODULE) \

do { \

if (!_PyCursesStatefulCheckFunction(MODULE, \

curses_start_color_called, \

"start_color")) \

{ \

return 0; \

} \

} while (0)

/* Utility Functions */

/*

* Check the return code from a curses function, returning None

* on success and setting an exception on error.

*/

/*

* Return None if 'code' is different from ERR (implementation-defined).

* Otherwise, set an exception using curses_set_error() and the remaining

* arguments, and return NULL.

*/

static PyObject *

curses_check_err(PyObject *module, int code,

const char *curses_funcname,

const char *python_funcname)

{

if (code != ERR) {

Py_RETURN_NONE;

}

curses_set_error(module, curses_funcname, python_funcname);

return NULL;

}

/* Same as curses_check_err() for a Window object. */

static PyObject *

curses_window_check_err(PyCursesWindowObject *win, int code,

const char *curses_funcname,

const char *python_funcname)

{

if (code != ERR) {

Py_RETURN_NONE;

}

curses_window_set_error(win, curses_funcname, python_funcname);

return NULL;

}

/* 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(PyCursesWindowObject *win, PyObject *obj, chtype *ch)

{

unsigned long long value;

if (PyBytes_Check(obj)) {

if (PyBytes_GET_SIZE(obj) != 1) {

PyErr_Format(PyExc_TypeError,

"expect int or bytes or str of length 1, "

"got a bytes of length %zd",

PyBytes_GET_SIZE(obj));

return 0;

}

value = (unsigned char)PyBytes_AsString(obj)[0];

}

else if (PyUnicode_Check(obj)) {

if (PyUnicode_GET_LENGTH(obj) != 1) {

PyErr_Format(PyExc_TypeError,

"expect int or bytes or str of length 1, "

"got a str of length %zi",

PyUnicode_GET_LENGTH(obj));

return 0;

}

value = PyUnicode_READ_CHAR(obj, 0);

if (128 < value) {

PyObject *bytes;

const char *encoding;

if (win)

encoding = win->encoding;

else

encoding = curses_screen_encoding;

bytes = PyUnicode_AsEncodedString(obj, encoding, NULL);

if (bytes == NULL)

return 0;

if (PyBytes_GET_SIZE(bytes) != 1) {

Py_DECREF(bytes);

goto overflow;

}

value = (unsigned char)PyBytes_AS_STRING(bytes)[0];

Py_DECREF(bytes);

}

}

else if (PyLong_CheckExact(obj)) {

value = PyLong_AsUnsignedLongLong(obj);

if (value == (unsigned long long)-1 && PyErr_Occurred())

return 0;

}

else {

PyErr_Format(PyExc_TypeError,

"expect int or bytes or str of length 1, got %s",

Py_TYPE(obj)->tp_name);

return 0;

}

*ch = (chtype)value;

if ((unsigned long long)*ch != value)

goto overflow;

return 1;

overflow:

PyErr_SetString(PyExc_OverflowError,

"byte doesn't fit in chtype");

return 0;

}

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

- int

- bytes of length 1

- str of length 1, or a spacing character followed by up to

CCHARW_MAX - 1 combining characters

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 */

#ifdef HAVE_NCURSESW

/* Convert a str -- a spacing character optionally followed by up to

CCHARW_MAX - 1 combining characters -- into a wide-character cell.

wch must point to a buffer of at least CCHARW_MAX + 1 wide characters.

Return 0 on success, -1 with an exception set on error. */

static int

PyCurses_ConvertToWideCell(PyObject *obj, wchar_t *wch)

{

assert(PyUnicode_Check(obj));

Py_ssize_t nch = PyUnicode_AsWideChar(obj, wch, CCHARW_MAX + 1);

if (nch < 0) {

return -1;

}

if (nch == 0 || nch > CCHARW_MAX) {

PyErr_Format(PyExc_TypeError,

"expect a string of 1 to %d characters, "

"got a str of length %zi",

(int)CCHARW_MAX, PyUnicode_GET_LENGTH(obj));

return -1;

}

/* A lone control character is allowed (like addch(ord('\n'))), but in a

multi-character cell the base must be a printable spacing character and

the rest zero-width combining characters. Check explicitly: otherwise

setcchar() would silently drop a trailing spacing character, or fail

with a generic error for a control-character base. */

if (nch > 1) {

int bad = wcwidth(wch[0]) < 0;

for (Py_ssize_t i = 1; !bad && i < nch; i++) {

bad = wcwidth(wch[i]) != 0;

}

if (bad) {

PyErr_Format(PyExc_ValueError,

"a character cell must be a single spacing character "

"optionally followed by up to %d combining characters",

(int)(CCHARW_MAX - 1));

return -1;

}

}

return 0;

}

#endif

static int

PyCurses_ConvertToCchar_t(PyCursesWindowObject *win, PyObject *obj,

chtype *ch

#ifdef HAVE_NCURSESW

, wchar_t *wch

#endif

)

{

unsigned long long value;

if (PyUnicode_Check(obj)) {

#ifdef HAVE_NCURSESW

if (PyCurses_ConvertToWideCell(obj, wch) < 0) {

return 0;

}

return 2;

#else

return PyCurses_ConvertToChtype(win, obj, ch);

#endif

}

else if (PyBytes_Check(obj)) {

if (PyBytes_GET_SIZE(obj) != 1) {

PyErr_Format(PyExc_TypeError,

"expect int or bytes or str of length 1, "

"got a bytes of length %zd",

PyBytes_GET_SIZE(obj));

return 0;

}

value = (unsigned char)PyBytes_AsString(obj)[0];

}

else if (PyLong_CheckExact(obj)) {

value = PyLong_AsUnsignedLongLong(obj);

if (value == (unsigned long long)-1 && PyErr_Occurred()) {

return 0;

}

}

else {

PyErr_Format(PyExc_TypeError,

"expect int or bytes or str of length 1, got %s",

Py_TYPE(obj)->tp_name);

return 0;

}

*ch = (chtype)value;

if ((unsigned long long)*ch != value) {

PyErr_Format(PyExc_OverflowError,

"byte doesn't fit in chtype");

return 0;

}

return 1;

}

/* 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)

{

char *str;

if (PyUnicode_Check(obj)) {

#ifdef HAVE_NCURSESW

assert (wstr != NULL);

*wstr = PyUnicode_AsWideCharString(obj, NULL);

if (*wstr == NULL)

return 0;

return 2;

#else

assert (wstr == NULL);

*bytes = PyUnicode_AsEncodedString(obj, win->encoding, NULL);

if (*bytes == NULL)

return 0;

/* check for embedded null bytes */

if (PyBytes_AsStringAndSize(*bytes, &str, NULL) < 0) {

Py_CLEAR(*bytes);

return 0;

}

return 1;

#endif

}

else if (PyBytes_Check(obj)) {

*bytes = Py_NewRef(obj);

/* check for embedded null bytes */

if (PyBytes_AsStringAndSize(*bytes, &str, NULL) < 0) {

Py_DECREF(obj);

return 0;

}

return 1;

}

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

Py_TYPE(obj)->tp_name);

return 0;

}

/* A styled character cell: a cchar_t on a wide build, a chtype on a narrow one

(a single locale character ORed with its attributes and color pair).

complexchar wraps one cell, complexstr an array. */

#ifdef HAVE_NCURSESW

typedef cchar_t curses_cell_t;

#else

typedef chtype curses_cell_t;

#endif

typedef struct {

PyObject_HEAD

curses_cell_t cval;

} PyCursesComplexCharObject;

#define _PyCursesComplexCharObject_CAST(op) ((PyCursesComplexCharObject *)(op))

/* An immutable inline array of cells -- the string counterpart of complexchar.

The read functions fill the buffer directly, so read-then-rewrite is a

zero-copy round-trip. */

typedef struct {

PyObject_VAR_HEAD

curses_cell_t cells[1]; // ob_size cells, stored inline (variable-size object)

} PyCursesComplexStrObject;

#define _PyCursesComplexStrObject_CAST(op) ((PyCursesComplexStrObject *)(op))

/* Build a single character cell from obj.

On a wide build, return 1 and store a chtype in *pch for an int or bytes, or

2 and store a cchar_t (with *attr* applied) in *pwc for a str (a spacing

character optionally followed by combining characters). On a narrow build

there is no cchar_t, so always return 1 with a chtype in *pch. Return 0

with an exception set on error.

obj may also be a complexchar, whose cell is used directly; it carries its

own rendition, so supplying *attr* too (attr_given) is rejected. */

static int

PyCurses_ConvertToCell(PyCursesWindowObject *win, PyObject *obj, attr_t attr,

int attr_given, const char *funcname,

chtype *pch

#ifdef HAVE_NCURSESW

, cchar_t *pwc

#endif

)

{

cursesmodule_state *state = get_cursesmodule_state_by_win(win);

if (Py_IS_TYPE(obj, state->complexchar_type)) {

if (attr_given) {

PyErr_Format(PyExc_TypeError,

"%s(): attr cannot be specified together with "

"a complexchar", funcname);

return 0;

}

#ifdef HAVE_NCURSESW

*pwc = _PyCursesComplexCharObject_CAST(obj)->cval;

return 2;

#else

*pch = _PyCursesComplexCharObject_CAST(obj)->cval;

return 1;

#endif

}

#ifdef HAVE_NCURSESW

wchar_t wstr[CCHARW_MAX + 1];

int type = PyCurses_ConvertToCchar_t(win, obj, pch, wstr);

if (type == 2) {

if (setcchar(pwc, wstr, (attr_t)attr, PAIR_NUMBER(attr), NULL) == ERR) {

curses_window_set_error(win, "setcchar", funcname);

return 0;

}

}

return type;

#else

return PyCurses_ConvertToCchar_t(win, obj, pch);

#endif

}

#ifdef HAVE_NCURSESW

/* Pack a wide-character cell, routing the color pair through the

extended-color opts slot so it is not limited to a short (unlike the

chtype COLOR_PAIR field). Without that slot the pair must fit in the

short that setcchar() takes; raise OverflowError instead of silently

truncating a larger one. */

static int

curses_setcchar(cchar_t *wcval, const wchar_t *wstr, attr_t attrs, int pair)

{

#if _NCURSES_EXTENDED_COLOR_FUNCS

/* The pair passed through the opts slot is authoritative and may exceed

a short; ncurses then ignores the short argument, but clamp it into

range so the int-to-short narrowing stays well-defined. */

short spair = pair <= SHRT_MAX ? (short)pair : SHRT_MAX;

return setcchar(wcval, wstr, attrs, spair, &pair);

#else

if (pair > SHRT_MAX) {

PyErr_Format(PyExc_OverflowError,

"color pair %d does not fit in a short", pair);

return ERR;

}

return setcchar(wcval, wstr, attrs, (short)pair, NULL);

#endif

}

/* Unpack a wide-character cell into its text, attributes and color pair.

The pair is read through the extended-color opts slot when available, so

values above SHRT_MAX are preserved. */

static int

curses_getcchar(const cchar_t *wcval, wchar_t *wstr, attr_t *attrs, int *pair)

{

short spair = 0;

/* getcchar() is not guaranteed to write the text of an empty cell, so make

the output an empty string by default. */

wstr[0] = L'\0';

/* getcchar()'s opts slot returns the extended color pair, but ncurses

returned ERR for a non-NULL opts until 6.3 (patch 20210116). */

#if _NCURSES_EXTENDED_COLOR_FUNCS && NCURSES_VERSION_PATCH+0 >= 20210116

int rtn = getcchar(wcval, wstr, attrs, &spair, pair);

#else

int rtn = getcchar(wcval, wstr, attrs, &spair, NULL);

if (rtn != ERR) {

*pair = spair;

}

#endif

if (rtn != ERR) {

*attrs &= ~(attr_t)A_COLOR;

}

return rtn;

}

/* Hash one cell by value (text, attributes, pair) -- consistent with the

equality comparison, not the raw cchar_t whose padding and unused text tail

it ignores. Zero the key first so those bytes are deterministic, then

unpack into it. Returns -1 with an exception set on the (practically

impossible) getcchar() failure. */

static Py_hash_t

curses_cchar_hash(cursesmodule_state *state, const cchar_t *cell)

{

struct {

attr_t attrs;

int pair;

wchar_t wstr[CCHARW_MAX + 1];

} key;

memset(&key, 0, sizeof(key));

if (curses_getcchar(cell, key.wstr, &key.attrs, &key.pair) == ERR) {

PyErr_SetString(state->error, "getcchar() returned ERR");

return -1;

}

return Py_HashBuffer(&key, sizeof(key));

}

#endif

/* ---- Build-agnostic cell helpers over curses_cell_t -------------------- */

/* Pack a cell's text (a str), attributes and color pair into *cell. On a

narrow build the text must be one character that encodes to a single byte.

Return 0, or -1 with an exception set. */

static int

curses_cell_pack(cursesmodule_state *state, curses_cell_t *cell,

PyObject *text, attr_t attr, int pair, const char *funcname)

{

#ifdef HAVE_NCURSESW

wchar_t wstr[CCHARW_MAX + 1];

if (PyCurses_ConvertToWideCell(text, wstr) < 0) {

return -1;

}

if (curses_setcchar(cell, wstr, attr, pair) == ERR) {

if (!PyErr_Occurred()) {

PyErr_SetString(state->error, "setcchar() returned ERR");

}

return -1;

}

return 0;

#else

/* A narrow cell holds one character; reject a longer string with the same

ValueError as the wide build, so the exception type is build-independent. */

if (PyUnicode_GET_LENGTH(text) != 1) {

PyErr_SetString(PyExc_ValueError,

"a character cell must be a single character");

return -1;

}

chtype ch;

if (!PyCurses_ConvertToChtype(NULL, text, &ch)) {

return -1;

}

/* Reject a pair that COLOR_PAIR()/PAIR_NUMBER() cannot round-trip (assumes

only that they are inverses). A wide build, or color_set(), can use

larger pairs. */

chtype color = COLOR_PAIR(pair);

if (pair < 0 || PAIR_NUMBER(color) != pair) {

PyErr_Format(PyExc_OverflowError,

"%s(): color pair %d does not fit in a chtype "

"(color_pair() can encode only pairs 0 to %d)",

funcname, pair, (int)PAIR_NUMBER(A_COLOR));

return -1;

}

*cell = (ch & A_CHARTEXT) | (attr & ~(attr_t)A_COLOR) | color;

return 0;

#endif

}

/* Read a cell's attributes and color pair. Return 0, or -1 if wide getcchar()

fails (practically impossible). */

static int

curses_cell_attr_pair(cursesmodule_state *state, const curses_cell_t *cell,

attr_t *attr, int *pair)

{

#ifdef HAVE_NCURSESW

wchar_t wstr[CCHARW_MAX + 1];

if (curses_getcchar(cell, wstr, attr, pair) == ERR) {

PyErr_SetString(state->error, "getcchar() returned ERR");

return -1;

}

return 0;

#else

*attr = *cell & A_ATTRIBUTES & ~(attr_t)A_COLOR;

*pair = PAIR_NUMBER(*cell & A_COLOR);

return 0;

#endif

}

/* Build a str from a cell's text (decoding the stored byte on a narrow build).

Return a new reference, or NULL with an exception set. */

static PyObject *

curses_cell_text(cursesmodule_state *state, const curses_cell_t *cell)

{

#ifdef HAVE_NCURSESW

wchar_t wstr[CCHARW_MAX + 1];

attr_t attr;

int pair;

if (curses_getcchar(cell, wstr, &attr, &pair) == ERR) {

PyErr_SetString(state->error, "getcchar() returned ERR");

return NULL;

}

return PyUnicode_FromWideChar(wstr, -1);

#else

char ch = (char)(*cell & A_CHARTEXT);

return PyUnicode_Decode(&ch, 1, curses_screen_encoding, NULL);

#endif

}

/* Compare two cells by value (text, attributes, pair). Return 1, 0, or -1 if

wide getcchar() fails (practically impossible). */

static int

curses_cell_equal(cursesmodule_state *state, const curses_cell_t *a,

const curses_cell_t *b)

{

#ifdef HAVE_NCURSESW

wchar_t wa[CCHARW_MAX + 1], wb[CCHARW_MAX + 1];

attr_t aa, ab;

int pa, pb;

if (curses_getcchar(a, wa, &aa, &pa) == ERR ||

curses_getcchar(b, wb, &ab, &pb) == ERR)

{

PyErr_SetString(state->error, "getcchar() returned ERR");

return -1;

}

return (aa == ab && pa == pb && wcscmp(wa, wb) == 0);

#else

return *a == *b;

#endif

}

/* Hash a cell by value, consistent with curses_cell_equal. */

static Py_hash_t

curses_cell_hash(cursesmodule_state *state, const curses_cell_t *cell)

{

#ifdef HAVE_NCURSESW

return curses_cchar_hash(state, cell);

#else

Py_hash_t h = Py_HashBuffer(cell, sizeof(*cell));

return h == -1 ? -2 : h;

#endif

}

static int

color_allow_default_converter(PyObject *arg, void *ptr)

{

long color_number;

int overflow;

color_number = PyLong_AsLongAndOverflow(arg, &overflow);

if (color_number == -1 && PyErr_Occurred())

return 0;

if (overflow > 0 || color_number >= COLORS) {

PyErr_Format(PyExc_ValueError,

"Color number is greater than COLORS-1 (%d).",

COLORS - 1);

return 0;

}

else if (overflow < 0 || color_number < 0) {

color_number = -1;

}

*(int *)ptr = (int)color_number;

return 1;

}

static int

color_converter(PyObject *arg, void *ptr)

{

if (!color_allow_default_converter(arg, ptr)) {

return 0;

}

if (*(int *)ptr < 0) {

PyErr_SetString(PyExc_ValueError,

"Color number is less than 0.");

return 0;

}

return 1;

}

/*[python input]

class color_converter(CConverter):

type = 'int'

converter = 'color_converter'

[python start generated code]*/

/*[python end generated code: output=da39a3ee5e6b4b0d input=4260d2b6e66b3709]*/

/*[python input]

class color_allow_default_converter(CConverter):

type = 'int'

converter = 'color_allow_default_converter'