Add `set print array-indexes' tests for C/C++ arrays
[binutils-gdb.git] / gdb / python / py-tui.c
1 /* TUI windows implemented in Python
2
3 Copyright (C) 2020-2022 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20
21 #include "defs.h"
22 #include "arch-utils.h"
23 #include "python-internal.h"
24
25 #ifdef TUI
26
27 /* Note that Python's public headers may define HAVE_NCURSES_H, so if
28 we unconditionally include this (outside the #ifdef above), then we
29 can get a compile error when ncurses is not in fact installed. See
30 PR tui/25597; or the upstream Python bug
31 https://bugs.python.org/issue20768. */
32 #include "gdb_curses.h"
33
34 #include "tui/tui-data.h"
35 #include "tui/tui-io.h"
36 #include "tui/tui-layout.h"
37 #include "tui/tui-wingeneral.h"
38 #include "tui/tui-winsource.h"
39
40 class tui_py_window;
41
42 /* A PyObject representing a TUI window. */
43
44 struct gdbpy_tui_window
45 {
46 PyObject_HEAD
47
48 /* The TUI window, or nullptr if the window has been deleted. */
49 tui_py_window *window;
50
51 /* Return true if this object is valid. */
52 bool is_valid () const;
53 };
54
55 extern PyTypeObject gdbpy_tui_window_object_type
56 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("gdbpy_tui_window");
57
58 /* A TUI window written in Python. */
59
60 class tui_py_window : public tui_win_info
61 {
62 public:
63
64 tui_py_window (const char *name, gdbpy_ref<gdbpy_tui_window> wrapper)
65 : m_name (name),
66 m_wrapper (std::move (wrapper))
67 {
68 m_wrapper->window = this;
69 }
70
71 ~tui_py_window ();
72
73 DISABLE_COPY_AND_ASSIGN (tui_py_window);
74
75 /* Set the "user window" to the indicated reference. The user
76 window is the object returned the by user-defined window
77 constructor. */
78 void set_user_window (gdbpy_ref<> &&user_window)
79 {
80 m_window = std::move (user_window);
81 }
82
83 const char *name () const override
84 {
85 return m_name.c_str ();
86 }
87
88 void rerender () override;
89 void do_scroll_vertical (int num_to_scroll) override;
90 void do_scroll_horizontal (int num_to_scroll) override;
91
92 void refresh_window () override
93 {
94 if (m_inner_window != nullptr)
95 {
96 wnoutrefresh (handle.get ());
97 touchwin (m_inner_window.get ());
98 tui_wrefresh (m_inner_window.get ());
99 }
100 else
101 tui_win_info::refresh_window ();
102 }
103
104 void click (int mouse_x, int mouse_y, int mouse_button) override;
105
106 /* Erase and re-box the window. */
107 void erase ()
108 {
109 if (is_visible () && m_inner_window != nullptr)
110 {
111 werase (m_inner_window.get ());
112 check_and_display_highlight_if_needed ();
113 }
114 }
115
116 /* Write STR to the window. FULL_WINDOW is true to erase the window
117 contents beforehand. */
118 void output (const char *str, bool full_window);
119
120 /* A helper function to compute the viewport width. */
121 int viewport_width () const
122 {
123 return std::max (0, width - 2);
124 }
125
126 /* A helper function to compute the viewport height. */
127 int viewport_height () const
128 {
129 return std::max (0, height - 2);
130 }
131
132 private:
133
134 /* The name of this window. */
135 std::string m_name;
136
137 /* We make our own inner window, so that it is easy to print without
138 overwriting the border. */
139 std::unique_ptr<WINDOW, curses_deleter> m_inner_window;
140
141 /* The underlying Python window object. */
142 gdbpy_ref<> m_window;
143
144 /* The Python wrapper for this object. */
145 gdbpy_ref<gdbpy_tui_window> m_wrapper;
146 };
147
148 /* See gdbpy_tui_window declaration above. */
149
150 bool
151 gdbpy_tui_window::is_valid () const
152 {
153 return window != nullptr && tui_active;
154 }
155
156 tui_py_window::~tui_py_window ()
157 {
158 gdbpy_enter enter_py (get_current_arch (), current_language);
159
160 /* This can be null if the user-provided Python construction
161 function failed. */
162 if (m_window != nullptr
163 && PyObject_HasAttrString (m_window.get (), "close"))
164 {
165 gdbpy_ref<> result (PyObject_CallMethod (m_window.get (), "close",
166 nullptr));
167 if (result == nullptr)
168 gdbpy_print_stack ();
169 }
170
171 /* Unlink. */
172 m_wrapper->window = nullptr;
173 /* Explicitly free the Python references. We have to do this
174 manually because we need to hold the GIL while doing so. */
175 m_wrapper.reset (nullptr);
176 m_window.reset (nullptr);
177 }
178
179 void
180 tui_py_window::rerender ()
181 {
182 tui_win_info::rerender ();
183
184 gdbpy_enter enter_py (get_current_arch (), current_language);
185
186 int h = viewport_height ();
187 int w = viewport_width ();
188 if (h == 0 || w == 0)
189 {
190 /* The window would be too small, so just remove the
191 contents. */
192 m_inner_window.reset (nullptr);
193 return;
194 }
195 m_inner_window.reset (newwin (h, w, y + 1, x + 1));
196
197 if (PyObject_HasAttrString (m_window.get (), "render"))
198 {
199 gdbpy_ref<> result (PyObject_CallMethod (m_window.get (), "render",
200 nullptr));
201 if (result == nullptr)
202 gdbpy_print_stack ();
203 }
204 }
205
206 void
207 tui_py_window::do_scroll_horizontal (int num_to_scroll)
208 {
209 gdbpy_enter enter_py (get_current_arch (), current_language);
210
211 if (PyObject_HasAttrString (m_window.get (), "hscroll"))
212 {
213 gdbpy_ref<> result (PyObject_CallMethod (m_window.get(), "hscroll",
214 "i", num_to_scroll, nullptr));
215 if (result == nullptr)
216 gdbpy_print_stack ();
217 }
218 }
219
220 void
221 tui_py_window::do_scroll_vertical (int num_to_scroll)
222 {
223 gdbpy_enter enter_py (get_current_arch (), current_language);
224
225 if (PyObject_HasAttrString (m_window.get (), "vscroll"))
226 {
227 gdbpy_ref<> result (PyObject_CallMethod (m_window.get (), "vscroll",
228 "i", num_to_scroll, nullptr));
229 if (result == nullptr)
230 gdbpy_print_stack ();
231 }
232 }
233
234 void
235 tui_py_window::click (int mouse_x, int mouse_y, int mouse_button)
236 {
237 gdbpy_enter enter_py (get_current_arch (), current_language);
238
239 if (PyObject_HasAttrString (m_window.get (), "click"))
240 {
241 gdbpy_ref<> result (PyObject_CallMethod (m_window.get (), "click",
242 "iii", mouse_x, mouse_y,
243 mouse_button));
244 if (result == nullptr)
245 gdbpy_print_stack ();
246 }
247 }
248
249 void
250 tui_py_window::output (const char *text, bool full_window)
251 {
252 if (m_inner_window != nullptr)
253 {
254 if (full_window)
255 werase (m_inner_window.get ());
256
257 tui_puts (text, m_inner_window.get ());
258 if (full_window)
259 check_and_display_highlight_if_needed ();
260 else
261 tui_wrefresh (m_inner_window.get ());
262 }
263 }
264
265 \f
266
267 /* A callable that is used to create a TUI window. It wraps the
268 user-supplied window constructor. */
269
270 class gdbpy_tui_window_maker
271 {
272 public:
273
274 explicit gdbpy_tui_window_maker (gdbpy_ref<> &&constr)
275 : m_constr (std::move (constr))
276 {
277 }
278
279 ~gdbpy_tui_window_maker ();
280
281 gdbpy_tui_window_maker (gdbpy_tui_window_maker &&other) noexcept
282 : m_constr (std::move (other.m_constr))
283 {
284 }
285
286 gdbpy_tui_window_maker (const gdbpy_tui_window_maker &other)
287 {
288 gdbpy_enter enter_py (get_current_arch (), current_language);
289 m_constr = other.m_constr;
290 }
291
292 gdbpy_tui_window_maker &operator= (gdbpy_tui_window_maker &&other)
293 {
294 m_constr = std::move (other.m_constr);
295 return *this;
296 }
297
298 gdbpy_tui_window_maker &operator= (const gdbpy_tui_window_maker &other)
299 {
300 gdbpy_enter enter_py (get_current_arch (), current_language);
301 m_constr = other.m_constr;
302 return *this;
303 }
304
305 tui_win_info *operator() (const char *name);
306
307 private:
308
309 /* A constructor that is called to make a TUI window. */
310 gdbpy_ref<> m_constr;
311 };
312
313 gdbpy_tui_window_maker::~gdbpy_tui_window_maker ()
314 {
315 gdbpy_enter enter_py (get_current_arch (), current_language);
316 m_constr.reset (nullptr);
317 }
318
319 tui_win_info *
320 gdbpy_tui_window_maker::operator() (const char *win_name)
321 {
322 gdbpy_enter enter_py (get_current_arch (), current_language);
323
324 gdbpy_ref<gdbpy_tui_window> wrapper
325 (PyObject_New (gdbpy_tui_window, &gdbpy_tui_window_object_type));
326 if (wrapper == nullptr)
327 {
328 gdbpy_print_stack ();
329 return nullptr;
330 }
331
332 std::unique_ptr<tui_py_window> window
333 (new tui_py_window (win_name, wrapper));
334
335 gdbpy_ref<> user_window
336 (PyObject_CallFunctionObjArgs (m_constr.get (),
337 (PyObject *) wrapper.get (),
338 nullptr));
339 if (user_window == nullptr)
340 {
341 gdbpy_print_stack ();
342 return nullptr;
343 }
344
345 window->set_user_window (std::move (user_window));
346 /* Window is now owned by the TUI. */
347 return window.release ();
348 }
349
350 /* Implement "gdb.register_window_type". */
351
352 PyObject *
353 gdbpy_register_tui_window (PyObject *self, PyObject *args, PyObject *kw)
354 {
355 static const char *keywords[] = { "name", "constructor", nullptr };
356
357 const char *name;
358 PyObject *cons_obj;
359
360 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "sO", keywords,
361 &name, &cons_obj))
362 return nullptr;
363
364 try
365 {
366 gdbpy_tui_window_maker constr (gdbpy_ref<>::new_reference (cons_obj));
367 tui_register_window (name, constr);
368 }
369 catch (const gdb_exception &except)
370 {
371 gdbpy_convert_exception (except);
372 return nullptr;
373 }
374
375 Py_RETURN_NONE;
376 }
377
378 \f
379
380 /* Require that "Window" be a valid window. */
381
382 #define REQUIRE_WINDOW(Window) \
383 do { \
384 if (!(Window)->is_valid ()) \
385 return PyErr_Format (PyExc_RuntimeError, \
386 _("TUI window is invalid.")); \
387 } while (0)
388
389 /* Require that "Window" be a valid window. */
390
391 #define REQUIRE_WINDOW_FOR_SETTER(Window) \
392 do { \
393 if (!(Window)->is_valid ()) \
394 { \
395 PyErr_Format (PyExc_RuntimeError, \
396 _("TUI window is invalid.")); \
397 return -1; \
398 } \
399 } while (0)
400
401 /* Python function which checks the validity of a TUI window
402 object. */
403 static PyObject *
404 gdbpy_tui_is_valid (PyObject *self, PyObject *args)
405 {
406 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
407
408 if (win->is_valid ())
409 Py_RETURN_TRUE;
410 Py_RETURN_FALSE;
411 }
412
413 /* Python function that erases the TUI window. */
414 static PyObject *
415 gdbpy_tui_erase (PyObject *self, PyObject *args)
416 {
417 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
418
419 REQUIRE_WINDOW (win);
420
421 win->window->erase ();
422
423 Py_RETURN_NONE;
424 }
425
426 /* Python function that writes some text to a TUI window. */
427 static PyObject *
428 gdbpy_tui_write (PyObject *self, PyObject *args)
429 {
430 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
431 const char *text;
432 int full_window = 0;
433
434 if (!PyArg_ParseTuple (args, "s|i", &text, &full_window))
435 return nullptr;
436
437 REQUIRE_WINDOW (win);
438
439 win->window->output (text, full_window);
440
441 Py_RETURN_NONE;
442 }
443
444 /* Return the width of the TUI window. */
445 static PyObject *
446 gdbpy_tui_width (PyObject *self, void *closure)
447 {
448 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
449 REQUIRE_WINDOW (win);
450 gdbpy_ref<> result
451 = gdb_py_object_from_longest (win->window->viewport_width ());
452 return result.release ();
453 }
454
455 /* Return the height of the TUI window. */
456 static PyObject *
457 gdbpy_tui_height (PyObject *self, void *closure)
458 {
459 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
460 REQUIRE_WINDOW (win);
461 gdbpy_ref<> result
462 = gdb_py_object_from_longest (win->window->viewport_height ());
463 return result.release ();
464 }
465
466 /* Return the title of the TUI window. */
467 static PyObject *
468 gdbpy_tui_title (PyObject *self, void *closure)
469 {
470 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
471 REQUIRE_WINDOW (win);
472 return host_string_to_python_string (win->window->title.c_str ()).release ();
473 }
474
475 /* Set the title of the TUI window. */
476 static int
477 gdbpy_tui_set_title (PyObject *self, PyObject *newvalue, void *closure)
478 {
479 gdbpy_tui_window *win = (gdbpy_tui_window *) self;
480
481 REQUIRE_WINDOW_FOR_SETTER (win);
482
483 if (newvalue == nullptr)
484 {
485 PyErr_Format (PyExc_TypeError, _("Cannot delete \"title\" attribute."));
486 return -1;
487 }
488
489 gdb::unique_xmalloc_ptr<char> value
490 = python_string_to_host_string (newvalue);
491 if (value == nullptr)
492 return -1;
493
494 win->window->title = value.get ();
495 return 0;
496 }
497
498 static gdb_PyGetSetDef tui_object_getset[] =
499 {
500 { "width", gdbpy_tui_width, NULL, "Width of the window.", NULL },
501 { "height", gdbpy_tui_height, NULL, "Height of the window.", NULL },
502 { "title", gdbpy_tui_title, gdbpy_tui_set_title, "Title of the window.",
503 NULL },
504 { NULL } /* Sentinel */
505 };
506
507 static PyMethodDef tui_object_methods[] =
508 {
509 { "is_valid", gdbpy_tui_is_valid, METH_NOARGS,
510 "is_valid () -> Boolean\n\
511 Return true if this TUI window is valid, false if not." },
512 { "erase", gdbpy_tui_erase, METH_NOARGS,
513 "Erase the TUI window." },
514 { "write", (PyCFunction) gdbpy_tui_write, METH_VARARGS,
515 "Append a string to the TUI window." },
516 { NULL } /* Sentinel. */
517 };
518
519 PyTypeObject gdbpy_tui_window_object_type =
520 {
521 PyVarObject_HEAD_INIT (NULL, 0)
522 "gdb.TuiWindow", /*tp_name*/
523 sizeof (gdbpy_tui_window), /*tp_basicsize*/
524 0, /*tp_itemsize*/
525 0, /*tp_dealloc*/
526 0, /*tp_print*/
527 0, /*tp_getattr*/
528 0, /*tp_setattr*/
529 0, /*tp_compare*/
530 0, /*tp_repr*/
531 0, /*tp_as_number*/
532 0, /*tp_as_sequence*/
533 0, /*tp_as_mapping*/
534 0, /*tp_hash */
535 0, /*tp_call*/
536 0, /*tp_str*/
537 0, /*tp_getattro*/
538 0, /*tp_setattro */
539 0, /*tp_as_buffer*/
540 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
541 "GDB TUI window object", /* tp_doc */
542 0, /* tp_traverse */
543 0, /* tp_clear */
544 0, /* tp_richcompare */
545 0, /* tp_weaklistoffset */
546 0, /* tp_iter */
547 0, /* tp_iternext */
548 tui_object_methods, /* tp_methods */
549 0, /* tp_members */
550 tui_object_getset, /* tp_getset */
551 0, /* tp_base */
552 0, /* tp_dict */
553 0, /* tp_descr_get */
554 0, /* tp_descr_set */
555 0, /* tp_dictoffset */
556 0, /* tp_init */
557 0, /* tp_alloc */
558 };
559
560 #endif /* TUI */
561
562 /* Initialize this module. */
563
564 int
565 gdbpy_initialize_tui ()
566 {
567 #ifdef TUI
568 gdbpy_tui_window_object_type.tp_new = PyType_GenericNew;
569 if (PyType_Ready (&gdbpy_tui_window_object_type) < 0)
570 return -1;
571 #endif /* TUI */
572
573 return 0;
574 }