xref: /qemu/ui/curses.c (revision 8ac65578) 
1 /*
2  * QEMU curses/ncurses display driver
3  *
4  * Copyright (c) 2005 Andrzej Zaborowski  <balrog@zabor.org>
5  *
6  * Permission is hereby granted, free of charge, to any person obtaining a copy
7  * of this software and associated documentation files (the "Software"), to deal
8  * in the Software without restriction, including without limitation the rights
9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10  * copies of the Software, and to permit persons to whom the Software is
11  * furnished to do so, subject to the following conditions:
12  *
13  * The above copyright notice and this permission notice shall be included in
14  * all copies or substantial portions of the Software.
15  *
16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22  * THE SOFTWARE.
23  */
24 #include "qemu/osdep.h"
25 
26 #ifndef _WIN32
27 #include <sys/ioctl.h>
28 #include <termios.h>
29 #endif
30 #include <locale.h>
31 #include <wchar.h>
32 #include <langinfo.h>
33 #include <iconv.h>
34 
35 #include "qapi/error.h"
36 #include "qemu-common.h"
37 #include "ui/console.h"
38 #include "ui/input.h"
39 #include "sysemu/sysemu.h"
40 
41 /* KEY_EVENT is defined in wincon.h and in curses.h. Avoid redefinition. */
42 #undef KEY_EVENT
43 #include <curses.h>
44 #undef KEY_EVENT
45 
46 #define FONT_HEIGHT 16
47 #define FONT_WIDTH 8
48 
49 enum maybe_keycode {
50     CURSES_KEYCODE,
51     CURSES_CHAR,
52     CURSES_CHAR_OR_KEYCODE,
53 };
54 
55 static DisplayChangeListener *dcl;
56 static console_ch_t screen[160 * 100];
57 static WINDOW *screenpad = NULL;
58 static int width, height, gwidth, gheight, invalidate;
59 static int px, py, sminx, sminy, smaxx, smaxy;
60 
61 static const char *font_charset = "CP437";
62 static cchar_t vga_to_curses[256];
63 
64 static void curses_update(DisplayChangeListener *dcl,
65                           int x, int y, int w, int h)
66 {
67     console_ch_t *line;
68     cchar_t curses_line[width];
69 
70     line = screen + y * width;
71     for (h += y; y < h; y ++, line += width) {
72         for (x = 0; x < width; x++) {
73             chtype ch = line[x] & 0xff;
74             chtype at = line[x] & ~0xff;
75             if (vga_to_curses[ch].chars[0]) {
76                 curses_line[x] = vga_to_curses[ch];
77             } else {
78                 curses_line[x] = (cchar_t) {
79                     .chars[0] = ch,
80                 };
81             }
82             curses_line[x].attr |= at;
83         }
84         mvwadd_wchnstr(screenpad, y, 0, curses_line, width);
85     }
86 
87     pnoutrefresh(screenpad, py, px, sminy, sminx, smaxy - 1, smaxx - 1);
88     refresh();
89 }
90 
91 static void curses_calc_pad(void)
92 {
93     if (qemu_console_is_fixedsize(NULL)) {
94         width = gwidth;
95         height = gheight;
96     } else {
97         width = COLS;
98         height = LINES;
99     }
100 
101     if (screenpad)
102         delwin(screenpad);
103 
104     clear();
105     refresh();
106 
107     screenpad = newpad(height, width);
108 
109     if (width > COLS) {
110         px = (width - COLS) / 2;
111         sminx = 0;
112         smaxx = COLS;
113     } else {
114         px = 0;
115         sminx = (COLS - width) / 2;
116         smaxx = sminx + width;
117     }
118 
119     if (height > LINES) {
120         py = (height - LINES) / 2;
121         sminy = 0;
122         smaxy = LINES;
123     } else {
124         py = 0;
125         sminy = (LINES - height) / 2;
126         smaxy = sminy + height;
127     }
128 }
129 
130 static void curses_resize(DisplayChangeListener *dcl,
131                           int width, int height)
132 {
133     if (width == gwidth && height == gheight) {
134         return;
135     }
136 
137     gwidth = width;
138     gheight = height;
139 
140     curses_calc_pad();
141 }
142 
143 #if !defined(_WIN32) && defined(SIGWINCH) && defined(KEY_RESIZE)
144 static volatile sig_atomic_t got_sigwinch;
145 static void curses_winch_check(void)
146 {
147     struct winsize {
148         unsigned short ws_row;
149         unsigned short ws_col;
150         unsigned short ws_xpixel;   /* unused */
151         unsigned short ws_ypixel;   /* unused */
152     } ws;
153 
154     if (!got_sigwinch) {
155         return;
156     }
157     got_sigwinch = false;
158 
159     if (ioctl(1, TIOCGWINSZ, &ws) == -1) {
160         return;
161     }
162 
163     resize_term(ws.ws_row, ws.ws_col);
164     invalidate = 1;
165 }
166 
167 static void curses_winch_handler(int signum)
168 {
169     got_sigwinch = true;
170 }
171 
172 static void curses_winch_init(void)
173 {
174     struct sigaction old, winch = {
175         .sa_handler  = curses_winch_handler,
176     };
177     sigaction(SIGWINCH, &winch, &old);
178 }
179 #else
180 static void curses_winch_check(void) {}
181 static void curses_winch_init(void) {}
182 #endif
183 
184 static void curses_cursor_position(DisplayChangeListener *dcl,
185                                    int x, int y)
186 {
187     if (x >= 0) {
188         x = sminx + x - px;
189         y = sminy + y - py;
190 
191         if (x >= 0 && y >= 0 && x < COLS && y < LINES) {
192             move(y, x);
193             curs_set(1);
194             /* it seems that curs_set(1) must always be called before
195              * curs_set(2) for the latter to have effect */
196             if (!qemu_console_is_graphic(NULL)) {
197                 curs_set(2);
198             }
199             return;
200         }
201     }
202 
203     curs_set(0);
204 }
205 
206 /* generic keyboard conversion */
207 
208 #include "curses_keys.h"
209 
210 static kbd_layout_t *kbd_layout = NULL;
211 
212 static wint_t console_getch(enum maybe_keycode *maybe_keycode)
213 {
214     wint_t ret;
215     switch (get_wch(&ret)) {
216     case KEY_CODE_YES:
217         *maybe_keycode = CURSES_KEYCODE;
218         break;
219     case OK:
220         *maybe_keycode = CURSES_CHAR;
221         break;
222     case ERR:
223         ret = -1;
224         break;
225     }
226     return ret;
227 }
228 
229 static int curses2foo(const int _curses2foo[], const int _curseskey2foo[],
230                       int chr, enum maybe_keycode maybe_keycode)
231 {
232     int ret = -1;
233     if (maybe_keycode == CURSES_CHAR) {
234         if (chr < CURSES_CHARS) {
235             ret = _curses2foo[chr];
236         }
237     } else {
238         if (chr < CURSES_KEYS) {
239             ret = _curseskey2foo[chr];
240         }
241         if (ret == -1 && maybe_keycode == CURSES_CHAR_OR_KEYCODE &&
242             chr < CURSES_CHARS) {
243             ret = _curses2foo[chr];
244         }
245     }
246     return ret;
247 }
248 
249 #define curses2keycode(chr, maybe_keycode) \
250     curses2foo(_curses2keycode, _curseskey2keycode, chr, maybe_keycode)
251 #define curses2keysym(chr, maybe_keycode) \
252     curses2foo(_curses2keysym, _curseskey2keysym, chr, maybe_keycode)
253 #define curses2qemu(chr, maybe_keycode) \
254     curses2foo(_curses2qemu, _curseskey2qemu, chr, maybe_keycode)
255 
256 static void curses_refresh(DisplayChangeListener *dcl)
257 {
258     int chr, keysym, keycode, keycode_alt;
259     enum maybe_keycode maybe_keycode;
260 
261     curses_winch_check();
262 
263     if (invalidate) {
264         clear();
265         refresh();
266         curses_calc_pad();
267         graphic_hw_invalidate(NULL);
268         invalidate = 0;
269     }
270 
271     graphic_hw_text_update(NULL, screen);
272 
273     while (1) {
274         /* while there are any pending key strokes to process */
275         chr = console_getch(&maybe_keycode);
276 
277         if (chr == -1)
278             break;
279 
280 #ifdef KEY_RESIZE
281         /* this shouldn't occur when we use a custom SIGWINCH handler */
282         if (maybe_keycode != CURSES_CHAR && chr == KEY_RESIZE) {
283             clear();
284             refresh();
285             curses_calc_pad();
286             curses_update(dcl, 0, 0, width, height);
287             continue;
288         }
289 #endif
290 
291         keycode = curses2keycode(chr, maybe_keycode);
292         keycode_alt = 0;
293 
294         /* alt or esc key */
295         if (keycode == 1) {
296             enum maybe_keycode next_maybe_keycode;
297             int nextchr = console_getch(&next_maybe_keycode);
298 
299             if (nextchr != -1) {
300                 chr = nextchr;
301                 maybe_keycode = next_maybe_keycode;
302                 keycode_alt = ALT;
303                 keycode = curses2keycode(chr, maybe_keycode);
304 
305                 if (keycode != -1) {
306                     keycode |= ALT;
307 
308                     /* process keys reserved for qemu */
309                     if (keycode >= QEMU_KEY_CONSOLE0 &&
310                             keycode < QEMU_KEY_CONSOLE0 + 9) {
311                         erase();
312                         wnoutrefresh(stdscr);
313                         console_select(keycode - QEMU_KEY_CONSOLE0);
314 
315                         invalidate = 1;
316                         continue;
317                     }
318                 }
319             }
320         }
321 
322         if (kbd_layout) {
323             keysym = curses2keysym(chr, maybe_keycode);
324 
325             if (keysym == -1) {
326                 if (chr < ' ') {
327                     keysym = chr + '@';
328                     if (keysym >= 'A' && keysym <= 'Z')
329                         keysym += 'a' - 'A';
330                     keysym |= KEYSYM_CNTRL;
331                 } else
332                     keysym = chr;
333             }
334 
335             keycode = keysym2scancode(kbd_layout, keysym & KEYSYM_MASK,
336                                       NULL, false);
337             if (keycode == 0)
338                 continue;
339 
340             keycode |= (keysym & ~KEYSYM_MASK) >> 16;
341             keycode |= keycode_alt;
342         }
343 
344         if (keycode == -1)
345             continue;
346 
347         if (qemu_console_is_graphic(NULL)) {
348             /* since terminals don't know about key press and release
349              * events, we need to emit both for each key received */
350             if (keycode & SHIFT) {
351                 qemu_input_event_send_key_number(NULL, SHIFT_CODE, true);
352                 qemu_input_event_send_key_delay(0);
353             }
354             if (keycode & CNTRL) {
355                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, true);
356                 qemu_input_event_send_key_delay(0);
357             }
358             if (keycode & ALT) {
359                 qemu_input_event_send_key_number(NULL, ALT_CODE, true);
360                 qemu_input_event_send_key_delay(0);
361             }
362             if (keycode & ALTGR) {
363                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, true);
364                 qemu_input_event_send_key_delay(0);
365             }
366 
367             qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, true);
368             qemu_input_event_send_key_delay(0);
369             qemu_input_event_send_key_number(NULL, keycode & KEY_MASK, false);
370             qemu_input_event_send_key_delay(0);
371 
372             if (keycode & ALTGR) {
373                 qemu_input_event_send_key_number(NULL, GREY | ALT_CODE, false);
374                 qemu_input_event_send_key_delay(0);
375             }
376             if (keycode & ALT) {
377                 qemu_input_event_send_key_number(NULL, ALT_CODE, false);
378                 qemu_input_event_send_key_delay(0);
379             }
380             if (keycode & CNTRL) {
381                 qemu_input_event_send_key_number(NULL, CNTRL_CODE, false);
382                 qemu_input_event_send_key_delay(0);
383             }
384             if (keycode & SHIFT) {
385                 qemu_input_event_send_key_number(NULL, SHIFT_CODE, false);
386                 qemu_input_event_send_key_delay(0);
387             }
388         } else {
389             keysym = curses2qemu(chr, maybe_keycode);
390             if (keysym == -1)
391                 keysym = chr;
392 
393             kbd_put_keysym(keysym);
394         }
395     }
396 }
397 
398 static void curses_atexit(void)
399 {
400     endwin();
401 }
402 
403 /* Setup wchar glyph for one UCS-2 char */
404 static void convert_ucs(int glyph, uint16_t ch, iconv_t conv)
405 {
406     wchar_t wch;
407     char *pch, *pwch;
408     size_t sch, swch;
409 
410     pch = (char *) &ch;
411     pwch = (char *) &wch;
412     sch = sizeof(ch);
413     swch = sizeof(wch);
414 
415     if (iconv(conv, &pch, &sch, &pwch, &swch) == (size_t) -1) {
416         fprintf(stderr, "Could not convert 0x%04x from UCS-2 to WCHAR_T: %s\n",
417                         ch, strerror(errno));
418     } else {
419         vga_to_curses[glyph].chars[0] = wch;
420     }
421 }
422 
423 /* Setup wchar glyph for one font character */
424 static void convert_font(unsigned char ch, iconv_t conv)
425 {
426     wchar_t wch;
427     char *pch, *pwch;
428     size_t sch, swch;
429 
430     pch = (char *) &ch;
431     pwch = (char *) &wch;
432     sch = sizeof(ch);
433     swch = sizeof(wch);
434 
435     if (iconv(conv, &pch, &sch, &pwch, &swch) == (size_t) -1) {
436         fprintf(stderr, "Could not convert 0x%02x from %s to WCHAR_T: %s\n",
437                         ch, font_charset, strerror(errno));
438     } else {
439         vga_to_curses[ch].chars[0] = wch;
440     }
441 }
442 
443 /* Convert one wchar to UCS-2 */
444 static uint16_t get_ucs(wchar_t wch, iconv_t conv)
445 {
446     uint16_t ch;
447     char *pch, *pwch;
448     size_t sch, swch;
449 
450     pch = (char *) &ch;
451     pwch = (char *) &wch;
452     sch = sizeof(ch);
453     swch = sizeof(wch);
454 
455     if (iconv(conv, &pwch, &swch, &pch, &sch) == (size_t) -1) {
456         fprintf(stderr, "Could not convert 0x%02lx from WCHAR_T to UCS-2: %s\n",
457                 (unsigned long)wch, strerror(errno));
458         return 0xFFFD;
459     }
460 
461     return ch;
462 }
463 
464 /*
465  * Setup mapping for vga to curses line graphics.
466  */
467 static void font_setup(void)
468 {
469     /*
470      * Control characters are normally non-printable, but VGA does have
471      * well-known glyphs for them.
472      */
473     static uint16_t control_characters[0x20] = {
474       0x0020,
475       0x263a,
476       0x263b,
477       0x2665,
478       0x2666,
479       0x2663,
480       0x2660,
481       0x2022,
482       0x25d8,
483       0x25cb,
484       0x25d9,
485       0x2642,
486       0x2640,
487       0x266a,
488       0x266b,
489       0x263c,
490       0x25ba,
491       0x25c4,
492       0x2195,
493       0x203c,
494       0x00b6,
495       0x00a7,
496       0x25ac,
497       0x21a8,
498       0x2191,
499       0x2193,
500       0x2192,
501       0x2190,
502       0x221f,
503       0x2194,
504       0x25b2,
505       0x25bc
506     };
507 
508     iconv_t ucs_to_wchar_conv;
509     iconv_t wchar_to_ucs_conv;
510     iconv_t font_conv;
511     int i;
512 
513     ucs_to_wchar_conv = iconv_open("WCHAR_T", "UCS-2");
514     if (ucs_to_wchar_conv == (iconv_t) -1) {
515         fprintf(stderr, "Could not convert font glyphs from UCS-2: '%s'\n",
516                         strerror(errno));
517         exit(1);
518     }
519 
520     wchar_to_ucs_conv = iconv_open("UCS-2", "WCHAR_T");
521     if (wchar_to_ucs_conv == (iconv_t) -1) {
522         iconv_close(ucs_to_wchar_conv);
523         fprintf(stderr, "Could not convert font glyphs to UCS-2: '%s'\n",
524                         strerror(errno));
525         exit(1);
526     }
527 
528     font_conv = iconv_open("WCHAR_T", font_charset);
529     if (font_conv == (iconv_t) -1) {
530         iconv_close(ucs_to_wchar_conv);
531         iconv_close(wchar_to_ucs_conv);
532         fprintf(stderr, "Could not convert font glyphs from %s: '%s'\n",
533                         font_charset, strerror(errno));
534         exit(1);
535     }
536 
537     /* Control characters */
538     for (i = 0; i <= 0x1F; i++) {
539         convert_ucs(i, control_characters[i], ucs_to_wchar_conv);
540     }
541 
542     for (i = 0x20; i <= 0xFF; i++) {
543         convert_font(i, font_conv);
544     }
545 
546     /* DEL */
547     convert_ucs(0x7F, 0x2302, ucs_to_wchar_conv);
548 
549     if (strcmp(nl_langinfo(CODESET), "UTF-8")) {
550         /* Non-Unicode capable, use termcap equivalents for those available */
551         for (i = 0; i <= 0xFF; i++) {
552             switch (get_ucs(vga_to_curses[i].chars[0], wchar_to_ucs_conv)) {
553             case 0x00a3:
554                 vga_to_curses[i] = *WACS_STERLING;
555                 break;
556             case 0x2591:
557                 vga_to_curses[i] = *WACS_BOARD;
558                 break;
559             case 0x2592:
560                 vga_to_curses[i] = *WACS_CKBOARD;
561                 break;
562             case 0x2502:
563                 vga_to_curses[i] = *WACS_VLINE;
564                 break;
565             case 0x2524:
566                 vga_to_curses[i] = *WACS_RTEE;
567                 break;
568             case 0x2510:
569                 vga_to_curses[i] = *WACS_URCORNER;
570                 break;
571             case 0x2514:
572                 vga_to_curses[i] = *WACS_LLCORNER;
573                 break;
574             case 0x2534:
575                 vga_to_curses[i] = *WACS_BTEE;
576                 break;
577             case 0x252c:
578                 vga_to_curses[i] = *WACS_TTEE;
579                 break;
580             case 0x251c:
581                 vga_to_curses[i] = *WACS_LTEE;
582                 break;
583             case 0x2500:
584                 vga_to_curses[i] = *WACS_HLINE;
585                 break;
586             case 0x253c:
587                 vga_to_curses[i] = *WACS_PLUS;
588                 break;
589             case 0x256c:
590                 vga_to_curses[i] = *WACS_LANTERN;
591                 break;
592             case 0x256a:
593                 vga_to_curses[i] = *WACS_NEQUAL;
594                 break;
595             case 0x2518:
596                 vga_to_curses[i] = *WACS_LRCORNER;
597                 break;
598             case 0x250c:
599                 vga_to_curses[i] = *WACS_ULCORNER;
600                 break;
601             case 0x2588:
602                 vga_to_curses[i] = *WACS_BLOCK;
603                 break;
604             case 0x03c0:
605                 vga_to_curses[i] = *WACS_PI;
606                 break;
607             case 0x00b1:
608                 vga_to_curses[i] = *WACS_PLMINUS;
609                 break;
610             case 0x2265:
611                 vga_to_curses[i] = *WACS_GEQUAL;
612                 break;
613             case 0x2264:
614                 vga_to_curses[i] = *WACS_LEQUAL;
615                 break;
616             case 0x00b0:
617                 vga_to_curses[i] = *WACS_DEGREE;
618                 break;
619             case 0x25a0:
620                 vga_to_curses[i] = *WACS_BULLET;
621                 break;
622             case 0x2666:
623                 vga_to_curses[i] = *WACS_DIAMOND;
624                 break;
625             case 0x2192:
626                 vga_to_curses[i] = *WACS_RARROW;
627                 break;
628             case 0x2190:
629                 vga_to_curses[i] = *WACS_LARROW;
630                 break;
631             case 0x2191:
632                 vga_to_curses[i] = *WACS_UARROW;
633                 break;
634             case 0x2193:
635                 vga_to_curses[i] = *WACS_DARROW;
636                 break;
637             case 0x23ba:
638                 vga_to_curses[i] = *WACS_S1;
639                 break;
640             case 0x23bb:
641                 vga_to_curses[i] = *WACS_S3;
642                 break;
643             case 0x23bc:
644                 vga_to_curses[i] = *WACS_S7;
645                 break;
646             case 0x23bd:
647                 vga_to_curses[i] = *WACS_S9;
648                 break;
649             }
650         }
651     }
652     iconv_close(ucs_to_wchar_conv);
653     iconv_close(wchar_to_ucs_conv);
654     iconv_close(font_conv);
655 }
656 
657 static void curses_setup(void)
658 {
659     int i, colour_default[8] = {
660         [QEMU_COLOR_BLACK]   = COLOR_BLACK,
661         [QEMU_COLOR_BLUE]    = COLOR_BLUE,
662         [QEMU_COLOR_GREEN]   = COLOR_GREEN,
663         [QEMU_COLOR_CYAN]    = COLOR_CYAN,
664         [QEMU_COLOR_RED]     = COLOR_RED,
665         [QEMU_COLOR_MAGENTA] = COLOR_MAGENTA,
666         [QEMU_COLOR_YELLOW]  = COLOR_YELLOW,
667         [QEMU_COLOR_WHITE]   = COLOR_WHITE,
668     };
669 
670     /* input as raw as possible, let everything be interpreted
671      * by the guest system */
672     initscr(); noecho(); intrflush(stdscr, FALSE);
673     nodelay(stdscr, TRUE); nonl(); keypad(stdscr, TRUE);
674     start_color(); raw(); scrollok(stdscr, FALSE);
675     set_escdelay(25);
676 
677     /* Make color pair to match color format (3bits bg:3bits fg) */
678     for (i = 0; i < 64; i++) {
679         init_pair(i, colour_default[i & 7], colour_default[i >> 3]);
680     }
681     /* Set default color for more than 64 for safety. */
682     for (i = 64; i < COLOR_PAIRS; i++) {
683         init_pair(i, COLOR_WHITE, COLOR_BLACK);
684     }
685 
686     font_setup();
687 }
688 
689 static void curses_keyboard_setup(void)
690 {
691 #if defined(__APPLE__)
692     /* always use generic keymaps */
693     if (!keyboard_layout)
694         keyboard_layout = "en-us";
695 #endif
696     if(keyboard_layout) {
697         kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout,
698                                           &error_fatal);
699     }
700 }
701 
702 static const DisplayChangeListenerOps dcl_ops = {
703     .dpy_name        = "curses",
704     .dpy_text_update = curses_update,
705     .dpy_text_resize = curses_resize,
706     .dpy_refresh     = curses_refresh,
707     .dpy_text_cursor = curses_cursor_position,
708 };
709 
710 static void curses_display_init(DisplayState *ds, DisplayOptions *opts)
711 {
712 #ifndef _WIN32
713     if (!isatty(1)) {
714         fprintf(stderr, "We need a terminal output\n");
715         exit(1);
716     }
717 #endif
718 
719     setlocale(LC_CTYPE, "");
720     if (opts->u.curses.charset) {
721         font_charset = opts->u.curses.charset;
722     }
723     curses_setup();
724     curses_keyboard_setup();
725     atexit(curses_atexit);
726 
727     curses_winch_init();
728 
729     dcl = g_new0(DisplayChangeListener, 1);
730     dcl->ops = &dcl_ops;
731     register_displaychangelistener(dcl);
732 
733     invalidate = 1;
734 }
735 
736 static QemuDisplay qemu_display_curses = {
737     .type       = DISPLAY_TYPE_CURSES,
738     .init       = curses_display_init,
739 };
740 
741 static void register_curses(void)
742 {
743     qemu_display_register(&qemu_display_curses);
744 }
745 
746 type_init(register_curses);
747