-
-
Notifications
You must be signed in to change notification settings - Fork 34.8k
Expand file tree
/
Copy path_cursesmodule.c
More file actions
9163 lines (7944 loc) · 270 KB
/
Copy path_cursesmodule.c
File metadata and controls
9163 lines (7944 loc) · 270 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/*
* 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;
}
#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")) \
{ \
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)
{
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)
value = (unsigned char)PyBytes_AS_STRING(bytes)[0];
else
value = -1;
Py_DECREF(bytes);
if (value < 0)
goto overflow;
}
}
else if (PyLong_CheckExact(obj)) {
int long_overflow;
value = PyLong_AsLongAndOverflow(obj, &long_overflow);
if (long_overflow)
goto overflow;
}
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 ((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
)
{
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)) {
int overflow;
value = PyLong_AsLongAndOverflow(obj, &overflow);
if (overflow) {
PyErr_SetString(PyExc_OverflowError,
"int doesn't fit in long");
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 ((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';
#if _NCURSES_EXTENDED_COLOR_FUNCS
int rtn = getcchar(wcval, wstr, attrs, &spair, pair);
#else
int rtn = getcchar(wcval, wstr, attrs, &spair, NULL);
if (rtn != ERR) {
*pair = spair;
}
#endif
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'
[python start generated code]*/
/*[python end generated code: output=da39a3ee5e6b4b0d input=975602bc058a872d]*/
static int
pair_converter(PyObject *arg, void *ptr)
{
long pair_number;
int overflow;
pair_number = PyLong_AsLongAndOverflow(arg, &overflow);
if (pair_number == -1 && PyErr_Occurred())
return 0;
#if _NCURSES_EXTENDED_COLOR_FUNCS
if (overflow > 0 || pair_number > INT_MAX) {
PyErr_Format(PyExc_ValueError,
"Color pair is greater than maximum (%d).",
INT_MAX);
return 0;
}
#else
if (overflow > 0 || pair_number >= COLOR_PAIRS) {
PyErr_Format(PyExc_ValueError,
"Color pair is greater than COLOR_PAIRS-1 (%d).",
COLOR_PAIRS - 1);
return 0;
}
#endif
else if (overflow < 0 || pair_number < 0) {
PyErr_SetString(PyExc_ValueError,