ncurses 5.1
[ncurses.git] / tack / ansi.c
1 /*
2 ** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
3 ** 
4 ** This file is part of TACK.
5 ** 
6 ** TACK is free software; you can redistribute it and/or modify
7 ** it under the terms of the GNU General Public License as published by
8 ** the Free Software Foundation; either version 2, or (at your option)
9 ** any later version.
10 ** 
11 ** TACK is distributed in the hope that it will be useful,
12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 ** GNU General Public License for more details.
15 ** 
16 ** You should have received a copy of the GNU General Public License
17 ** along with TACK; see the file COPYING.  If not, write to
18 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 ** Boston, MA 02111-1307, USA.
20 */
21
22 #include <tack.h>
23
24 MODULE_ID("$Id: ansi.c,v 1.5 2000/04/22 21:06:57 tom Exp $")
25
26 /*
27  * Standalone tests for ANSI terminals.  Three entry points:
28  * test_ansi_graphics(), test_ansi_reports() and test_ansi_sgr().
29  */
30
31 /*****************************************************************************
32  *
33  * Test ANSI status reports
34  *
35  *****************************************************************************/
36
37 /* ASCII control characters */
38 #define A_DC1 0x11              /* Control Q */
39 #define A_DC3 0x13              /* Control S */
40 #define A_ESC 0x1b
41 #define A_DCS 0x90
42 #define A_CSI 0x9b
43 #define A_ST  0x9c
44
45 #define MAX_MODES 256
46
47 static char default_bank[] = "\033(B\017";
48 static int private_use, ape, terminal_class;
49 static short ansi_value[256];
50 static unsigned char ansi_buf[512], pack_buf[512];
51
52 struct ansi_reports {
53         int lvl, final;
54         const char *text;
55         const char *request;
56 };
57
58 static struct ansi_reports report_list[] = {
59         {0, 'c', "(DA) Primary device attributes", "\033[0c"},
60         {1, 0, "(DSR) Terminal status", "\033[5n"},
61         {1, 'R', "(DSR) Cursor position", "\033[6n"},
62         {62, 0, "(DA) Secondary device attributes", "\033[>0c"},
63         {62, 0, "(DSR) Printer status", "\033[?15n"},
64         {62, 0, "(DSR) Function key definition", "\033[?25n"},
65         {62, 0, "(DSR) Keyboard language", "\033[?26n"},
66         {63, 0, "(DECRQSS) Data destination", "\033P$q$}\033\\"},
67         {63, 0, "(DECRQSS) Status line type", "\033P$q$~\033\\"},
68         {63, 0, "(DECRQSS) Erase attribute", "\033P$q\"q\033\\"},
69         {63, 0, "(DECRQSS) Personality", "\033P$q\"p\033\\"},
70         {63, 0, "(DECRQSS) Top and bottom margins", "\033P$qr\033\\"},
71         {63, 0, "(DECRQSS) Character attributes", "\033P$qm\033\\"},
72         {63, 0, "(DECRQSS) Illegal request", "\033P$q@\033\\"},
73         {63, 0, "(DECRQUPSS) User pref supplemental set", "\033[&u"},
74         {63, 0, "(DECRQPSR) Cursor information", "\033[1$w"},
75         {63, 0, "(DECRQPSR) Tab stop information", "\033[2$w"},
76         {64, 0, "(DA) Tertiary device attributes", "\033[=0c"},
77         {64, 0, "(DSR) Extended cursor position", "\033[?6n"},
78         {64, 0, "(DSR) Macro space", "\033[?62n"},
79         {64, 0, "(DSR) Memory checksum", "\033[?63n"},
80         {64, 0, "(DSR) Data integrity", "\033[?75n"},
81         {64, 0, "(DSR) Multiple session status", "\033[?85n"},
82         {64, 0, "(DECRQSS) Attribute change extent", "\033P$q*x\033\\"},
83         {64, 0, "(DECRQSS) Columns per page", "\033P$q$|\033\\"},
84         {64, 0, "(DECRQSS) Lines per page", "\033P$qt\033\\"},
85         {64, 0, "(DECRQSS) Lines per screen", "\033P$q*|\033\\"},
86         {64, 0, "(DECRQSS) Left and right margins", "\033P$qs\033\\"},
87         {64, 0, "(DECRQSS) Local functions", "\033P$q+q\033\\"},
88         {64, 0, "(DECRQSS) Local function key control", "\033P$q=}\033\\"},
89         {64, 0, "(DECRQSS) Select modifier key reporting", "\033P$q+r\033\\"},
90         {64, 0, "(DECRQDE) Window report", "\033[\"v"},
91         {0, 0, 0, 0}
92 };
93
94 struct request_control {
95         const char *text;
96         const char *expect;
97         const char *request;
98         const char *set_mode;
99         const char *reset_mode;
100 };
101
102 /* Request control function selection or setting */
103 static const struct request_control rqss[] = {
104         {"Data sent to screen", "0", "$}", "\033[0$}", 0},
105         {"Data sent to disabled status line", "0", "$}", 0, 0},
106         {"\033[0$~\033[1$}", "\033[0$}", 0, 0, 0},
107         {"Data sent to enabled status line", "1", "$}", 0, 0},
108         {"\033[2$~\033[1$}", "\033[0$}", 0, 0, 0},
109         {"Disable status line", "0", "$~", "\033[0$~", 0},
110         {"Top status line", "1", "$~", "\033[1$~", 0},
111         {"Bottom status line", "2", "$~", "\033[2$~", 0},
112         {"Erasable character", "0", "\"q", "\033[0\"q", 0},
113         {"Nonerasable character", "1", "\"q", "\033[1\"q", "\033[0\"q"},
114         {"Top and bottom margins", "3;10", "r", "\0337\033[3;10r", 0},
115         {"\033[r\0338", 0, 0, 0, 0},
116         {"Top and bottom margins", "default", "r", "\0337\033[r", "\0338"},
117         {"Character attributes, dim, bold", "1", "m", "\033[2;1m", "\033[m"},
118         {"Character attributes, bold, dim", "2", "m", "\033[1;2m", "\033[m"},
119         {"Character attributes, under, rev", "4;7", "m", "\033[4;7m", "\033[m"},
120         {"Character attributes, color", "35;42", "m", "\033[35;42m", "\033[m"},
121         {"All character attributes", "", "m", "\033[1;2;3;4;5;6;7;8;9m", 0},
122         {"\033[m", 0, 0, 0, 0},
123         {0, 0, 0, 0, 0}
124 };
125
126
127 /*
128 **      read_ansi()
129 **
130 **      read an ANSI status report from terminal
131 */
132 static void
133 read_ansi(void)
134 {
135         int ch, i, j, last_escape;
136
137         fflush(stdout);
138         read_key(ansi_buf, sizeof(ansi_buf));
139         /* Throw away control characters inside CSI sequences.
140            Convert two character 7-bit sequences into 8-bit sequences. */
141         for (i = j = last_escape = 0; (ch = ansi_buf[i]) != 0; i++) {
142                 if (ch == A_ESC) {
143                         if (last_escape == A_ESC) {
144                                 pack_buf[j++] = A_ESC;
145                         }
146                         last_escape = A_ESC;
147                 } else
148                 if (last_escape == A_ESC && ch >= '@' && ch <= '_') {
149                         pack_buf[j++] = last_escape = ch + 0x40;
150                 } else
151                 if (last_escape != A_CSI || (ch > 0x20 && ch != 0x80)) {
152                         if (last_escape == A_ESC) {
153                                 pack_buf[j++] = A_ESC;
154                         }
155                         if (ch > 0x80 && ch < 0xa0) {
156                                 last_escape = ch;
157                         }
158                         pack_buf[j++] = ch;
159                 }
160         }
161         if (last_escape == A_ESC) {
162                 pack_buf[j++] = A_ESC;
163         }
164         pack_buf[j] = '\0';
165         return;
166 }
167
168 /*
169 **      valid_mode(expected)
170 **
171 **      read a terminal mode status report and parse the result
172 **      Return TRUE if we got the expected terminating character.
173 */
174 static int
175 valid_mode(int expected)
176 {
177         char *s;
178         int ch, terminator;
179
180         read_ansi();
181
182         ape = 0;
183         ch = pack_buf[0] & 0xff;
184         ansi_value[0] = 0;
185         if (ch != A_CSI && ch != A_DCS)
186                 return FALSE;
187
188         s = pack_buf + 1;
189         private_use = 0;
190         if ((*s >= '<') & (*s <= '?')) {
191                 private_use = *s++;
192         }
193         terminator = 0;
194         for (; (ch = *s); s++) {
195                 if (ch >= '0' && ch <= '9')
196                         ansi_value[ape] = ansi_value[ape] * 10 + ch - '0';
197                 else if (ch == ';' || ch == ':')
198                         ansi_value[++ape] = 0;
199                 else if (ch >= '<' && ch <= '?')
200                         private_use = ch;
201                 else if (ch >= ' ')
202                         terminator = (terminator << 8) | ch;
203                 else
204                         break;
205         }
206         return terminator == expected;
207 }
208
209 /*
210 **      read_reports()
211 **
212 **      read all the reports in the ANSI report structure
213 */
214 static int
215 read_reports(void)
216 {
217         int i, j, k, tc, vcr, lc;
218         char *s;
219
220         lc = 5;
221         terminal_class = tc = 0;
222         for (i = 0; report_list[i].text; i++, lc++) {
223                 if (terminal_class < report_list[i].lvl &&
224                         tc < report_list[i].lvl) {
225                         put_crlf();
226                         menu_prompt();
227                         ptext("/status [q] > ");
228                         j = wait_here();
229                         if (j != 'n' && j != 'N')
230                                 return 0;
231                         tc = report_list[i].lvl;
232                         lc = 1;
233                 } else if (lc + 2 >= lines) {
234                         put_crlf();
235                         ptext("Hit any key to continue ");
236                         (void) wait_here();
237                         lc = 1;
238                 }
239                 sprintf(temp, "%s (%s) ", report_list[i].text,
240                         expand_command(report_list[i].request));
241                 ptext(temp);
242                 for (j = strlen(temp); j < 49; j++)
243                         putchp(' ');
244                 tc_putp(report_list[i].request);
245                 vcr = 0;
246                 if (report_list[i].final == 0) {
247                         read_ansi();
248                 } else if (valid_mode(report_list[i].final))
249                         switch (report_list[i].final) {
250                         case 'c':
251                                 terminal_class = ansi_value[0];
252                                 break;
253                         case 'R':
254                                 vcr = TRUE;
255                                 break;
256                         }
257                 j = pack_buf[0] & 0xff;
258                 if (j != A_CSI && j != A_DCS) {
259                         put_crlf();
260                         s = "*** The above request gives illegal response ***";
261                         ptext(s);
262                         for (j = strlen(s); j < 49; j++)
263                                 putchp(' ');
264                 }
265                 s = expand(ansi_buf);
266                 if (char_count + expand_chars >= columns) {
267                         put_str("\r\n        ");
268                         lc++;
269                 }
270                 putln(s);
271                 if (vcr) {      /* find out how big the screen is */
272                         tc_putp(report_list[i].request);
273                         if (!valid_mode('R'))
274                                 continue;
275                         j = ansi_value[0];
276                         k = ansi_value[1];
277                         tc_putp("\033[255B\033[255C\033[6n");
278                         if (!valid_mode('R'))
279                                 continue;
280                         sprintf(temp, "\033[%d;%dH", j, k);
281                         tc_putp(temp);
282                         ptext("(DSR) Screen size (CSI 6 n)");
283                         for (j = char_count; j < 50; j++)
284                                 putchp(' ');
285                         sprintf(temp, "%d x %d", ansi_value[1], ansi_value[0]);
286                         ptextln(temp);
287
288                 }
289         }
290         menu_prompt();
291         ptext("/status r->repeat test, <return> to continue > ");
292         return wait_here();
293 }
294
295 /*
296 **      request_cfss()
297 **
298 **      Request Control function selection or settings
299 */
300 static int
301 request_cfss(void)
302 {
303         int i, j, k, l, ch;
304         char *s;
305
306         put_clear();
307         ptextln("Request                         Expected  Received");
308         put_crlf();
309         for (i = 0; rqss[i].text; i++) {
310                 ptext(rqss[i].text);
311                 j = strlen(rqss[i].text) + strlen(rqss[i].expect);
312                 putchp(' ');
313                 for (j++; j < 40; j++)
314                         putchp(' ');
315                 ptext(rqss[i].expect);
316                 putchp(' ');
317                 tc_putp(rqss[i].set_mode);
318                 sprintf(temp, "\033P$q%s\033\\", rqss[i].request);
319                 tc_putp(temp);
320                 read_ansi();
321                 tc_putp(rqss[i].reset_mode);
322                 putchp(' ');
323                 for (j = 0; ansi_buf[j]; j++) {
324                         if (ansi_buf[j] == 'r') {
325                                 for (k = j++; (ch = (ansi_buf[k] & 0xff)); k++)
326                                         if (ch == A_ESC) {
327                                                 break;
328                                         } else if (ch == A_ST) {
329                                                 break;
330                                         }
331                                 ansi_buf[k] = '\0';
332                                 s = expand(&ansi_buf[j]);
333                                 if (char_count + expand_chars >= columns)
334                                         put_str("\r\n        ");
335                                 put_str(s);
336                         }
337                 }
338                 put_crlf();
339         }
340         /* calculate the valid attributes */
341         ptext("Valid attributes:         0");
342         j = 0;
343         for (i = 1; i < 20; i++) {
344                 sprintf(temp, "\033[0;%dm\033P$qm\033\\", i);
345                 tc_putp(temp);
346                 (void) valid_mode('m');
347                 if (ape > 0) {
348                         j = i;
349                         sprintf(temp, "\033[0m; %d", i);
350                         tc_putp(temp);
351                 }
352         }
353         put_crlf();
354         /* calculate how many parameters can be sent */
355         ptext("Max number of parameters: ");
356         sprintf(temp, "%dm\033P$qm\033\\", j);
357         l = -1;
358         if (j > 0)
359                 for (l = 1; l < 33; l++) {
360                         tc_putp("\033[0");
361                         for (ch = 1; ch <= l; ch++)
362                                 put_this(';');
363                         tc_putp(temp);
364                         (void) valid_mode('m');
365                         if (ape == 0)
366                                 break;
367                 }
368         tc_putp("\033[m");
369         if (l >= 0) {
370                 sprintf(temp, "%d", l);
371                 ptext(temp);
372         } else
373                 ptext("unknown");
374         put_crlf();
375         return wait_here();
376 }
377
378 /*
379 **      mode_display(puc, mode, initial, set, reset)
380 **
381 **      print the mode display entry
382 */
383 static void
384 mode_display(const char *p, int n, int c, char s, char r)
385 {
386         int k;
387
388         sprintf(temp, "%s%d (%c, %c, %c)", p, n, c, s, r);
389         k = strlen(temp);
390         if (char_count + k >= columns)
391                 put_crlf();
392         for (; k < 14; k++)
393                 putchp(' ');
394         put_str(temp);
395 }
396
397 /*
398 **      terminal_state()
399 **
400 **      test DECRQM status reports
401 */
402 static void
403 terminal_state(void)
404 {
405         static const char *puc[] = {"", "<", "=", ">", "?", 0};
406
407         int i, j, k, l, modes_found;
408         char *s;
409         char buf[256], tms[256];
410         int mode_puc[MAX_MODES], mode_number[MAX_MODES];
411         char set_value[MAX_MODES], reset_value[MAX_MODES];
412         char current_value[MAX_MODES];
413
414         ptext("Testing terminal mode status. (CSI 0 $ p)");
415         tc_putp("\033[0$p");
416         modes_found = 0;
417         tms[0] = '\0';
418         if (valid_mode(('$' << 8) | 'y')) {
419                 for (i = 0; puc[i]; i++) {
420                         put_crlf();
421                         if (i) {
422                                 sprintf(temp, "Private use: %c", puc[i][0]);
423                         } else {
424                                 strcpy(temp, "Standard modes:");
425                         }
426                         k = strlen(temp);
427                         ptext(temp);
428                         for (j = 0; j < (int) sizeof(buf); buf[j++] = ' ')
429                                 ;
430                         for (j = l = 0; j < 255 && j - l < 50; j++) {
431                                 sprintf(temp, "\033[%s%d$p", puc[i], j);
432                                 tc_putp(temp);
433                                 if (!valid_mode(('$' << 8) | 'y')) {
434                                         /* not valid, save terminating value */
435                                         s = expand(ansi_buf);
436                                         sprintf(tms, "%s%s%d %s  ", tms,
437                                                 puc[i], j, s);
438                                         break;
439                                 }
440                                 if (private_use != puc[i][0])
441                                         break;
442                                 if (ansi_value[0] != j)
443                                         break;
444                                 if (ansi_value[1]) {
445                                         l = j;
446                                         if (k > 70) {
447                                                 buf[k] = '\0';
448                                                 put_crlf();
449                                                 ptextln(buf);
450                                                 for (k = 0; k < (int) sizeof(buf);) {
451                                                         buf[k++] = ' ';
452                                                 }
453                                                 k = 0;
454                                         }
455                                         sprintf(temp, " %d", j);
456                                         ptext(temp);
457                                         k += strlen(temp);
458                                         buf[k - 1] = ansi_value[1] + '0';
459                                         if (modes_found >= MAX_MODES)
460                                                 continue;
461                                         current_value[modes_found] =
462                                                 ansi_value[1] + '0';
463                                         /* some modes never return */
464                                         if ((i == 0 && j == 13) /* control execution */
465                                                 || (puc[i][0] == '?' && j == 2))        /* VT52 */
466                                                 set_value[modes_found] =
467                                                         reset_value[modes_found] = '-';
468                                         else
469                                                 set_value[modes_found] =
470                                                         reset_value[modes_found] = ' ';
471                                         mode_puc[modes_found] = i;
472                                         mode_number[modes_found++] = j;
473                                 }
474                         }
475                         buf[k] = '\0';
476                         if (buf[k - 1] != ' ') {
477                                 put_crlf();
478                                 ptext(buf);
479                         }
480                 }
481
482         if ((i = modes_found) != 0) {
483                 put_crlf();
484                 put_crlf();
485                 if (tms[0]) {
486                         ptextln(tms);
487                 }
488                 ptext("Hit 'Y' to test mode set/reset states: ");
489                 i = wait_here();
490         }
491         if (i == 'y' || i == 'Y')
492                 while (1) {
493 #ifdef STATUSFIX
494                         FILE *fp;
495
496 #ifdef TEDANSI
497                         fp = fopen("ted.ansi", "w");
498 #else
499                         fp = fopen("/dev/console", "w");
500 #endif
501 #endif
502                         for (i = j = 0; j < modes_found; j = ++i >> 1) {
503                                 if (set_value[j] == '-')
504                                         continue;
505                                 k = (current_value[j] ^ i) & 1;
506                                 sprintf(temp, "\033[%s%d%c\033[%s%d$p",
507                                         puc[mode_puc[j]], mode_number[j],
508                                         k ? 'l' : 'h',
509                                         puc[mode_puc[j]], mode_number[j]);
510 #ifdef STATUSFIX
511                                 if (fp) {
512                                         fprintf(fp, "%s\n", expand(temp));
513                                         fflush(fp);
514                                 }
515 #endif
516                                 tc_putp(temp);
517                                 if (!valid_mode(('$' << 8) | 'y'))
518                                         continue;
519                                 if (k) {
520                                         reset_value[j] = ansi_value[1] + '0';
521                                 } else {
522                                         set_value[j] = ansi_value[1] + '0';
523                                 }
524                         }
525                         put_str("\033[30l");    /* added for GORT bug
526                                                    (WY-185) */
527 #ifdef STATUSFIX
528                         if (fp)
529                                 fclose(fp);
530 #endif
531                         tty_set();
532                         /* print the results */
533                         put_clear();
534                         putln("mode (initial, set, reset)");
535                         for (j = 0; j < modes_found; j++) {
536                                 mode_display(puc[mode_puc[j]], mode_number[j],
537                                         current_value[j], set_value[j], reset_value[j]);
538                         }
539                         ptext("\n\nHit 'R' to repeat test.  'S' to sort results: ");
540                         i = wait_here();
541                         if (i == 's' || i == 'S') {     /* print the same stuff,
542                                                            sorted by
543                                                            current_value */
544                                 put_crlf();
545                                 for (i = '1'; i <= '4'; i++) {
546                                         for (j = 0; j < modes_found; j++) {
547                                                 if (current_value[j] == i)
548                                                         mode_display(puc[mode_puc[j]],
549                                                                 mode_number[j], current_value[j],
550                                                                 set_value[j], reset_value[j]);
551                                         }
552                                 }
553                                 ptext("\n\nHit 'R' to repeat test: ");
554                                 i = wait_here();
555                         }
556                         if (i != 'r' && i != 'R')
557                                 break;
558                         tty_raw(1, char_mask);
559                 }
560         } else {
561                 tty_set();
562         }
563 }
564
565
566 /*
567 **      ansi_report_help()
568 **
569 **      Display the informational data for the ANSI report test.
570 */
571 static void
572 ansi_report_help(void)
573 {
574         ptext("Begin ANSI status report testing. ");
575         ptext(" Parity bit set will be displayed in reverse video. ");
576         ptext(" If the terminal hangs, hit any alphabetic key. ");
577         ptextln(" Use n to continue testing.  Use q to quit.");
578         put_crlf();
579 }
580
581 /*
582 **      test_ansi_reports()
583 **
584 **      Test the ANSI status report functions
585 */
586 void
587 tools_status(
588         struct test_list *t GCC_UNUSED,
589         int *state GCC_UNUSED,
590         int *ch)
591 {
592         int i;
593
594         put_clear();
595         ansi_report_help();
596         tty_raw(1, char_mask);
597
598         do {
599                 i = read_reports();
600                 if (i != 'r' && i != 'R') {
601                         *ch = i;
602                         return;
603                 }
604         } while (i);
605
606         if (terminal_class >= 63) {
607                 do {
608                         i = request_cfss();
609                 } while (i == 'r' || i == 'R');
610                 *ch = i;
611                 terminal_state();
612         } else {
613                 tty_set();
614         }
615 }
616
617
618 /*
619 **      display_sgr()
620 **
621 **      Test a range of ANSI sgr attributes
622 **      puc -> Private Use Character
623 */
624 static void 
625 display_sgr(int puc)
626 {
627         int k;
628
629         temp[0] = puc;
630         temp[1] = '\0';
631         for (k = 0; k < 80; k++) {
632                 if (char_count + 8 > 80)
633                         put_crlf();
634                 else if (char_count + 8 > columns)
635                         put_crlf();
636                 else if (k > 0)
637                         printf(" ");
638                 printf("\033[%s%dmMode %2d\033[0m", temp, k, k);
639                 char_count += 8;
640                 if (puc == '\0') {
641                         if (k == 19)
642                                 printf("\033[10m");
643                         if (k == 39)
644                                 printf("\033[37m");
645                         if (k == 49)
646                                 printf("\033[40m");
647                 }
648         }
649         put_crlf();
650         if (puc == '<')
651                 printf("\033[<1m");
652         else if (puc)
653                 printf("\033[%s0m", temp);
654         set_attr(0);
655 }
656
657 /*
658 **      print_sgr20(on, off)
659 **
660 **      print the sgr line for sgr20()
661 */
662 static void 
663 print_sgr20(int on, int off)
664 {
665         if (char_count > columns - 13) {
666                 put_crlf();
667         } else if (char_count) {
668                 put_str("  ");
669         }
670         char_count += 11;
671         printf("%d/%d \033[%dmon\033[%dm off\033[0m", on, off, on, off);
672 }
673
674 /*
675 **      sgr20(void)
676 **
677 **      display the enter/exit attributes 1-9 and 20-29
678 */
679 static void 
680 sgr20(void)
681 {
682         int k;
683
684         put_crlf();
685         ptextln("Test enter/exit attributes 1-9 and 21-29.");
686         for (k = 1; k < 10; k++) {
687                 print_sgr20(k, k + 20);
688         }
689         print_sgr20(1, 22);     /* bold */
690         print_sgr20(2, 22);     /* dim */
691         print_sgr20(8, 22);     /* blank */
692         printf("\033[0m");
693         set_attr(0);
694 }
695
696 /*
697 **      tools_sgr(testlist, state, ch)
698 **
699 **      Run the ANSI graphics rendition mode tool
700 **      Return the last character typed.
701 */
702 void
703 tools_sgr(
704         struct test_list *t GCC_UNUSED,
705         int *state GCC_UNUSED,
706         int *ch)
707 {
708         int k;
709
710         put_clear();
711         for (k = 0;;) {
712                 display_sgr(k);
713                 put_crlf();
714                 menu_prompt();
715                 ptext("/sgr Enter =><?r [<cr>] > ");
716                 k = wait_here();
717                 if ((k == 'r') || (k == 'R')) {
718                         k = 0;
719                 } else if ((k < '<') || (k > '?')) {
720                         break;
721                 }
722         }
723         sgr20();
724
725         put_newlines(2);
726         *ch = REQUEST_PROMPT;
727 }
728
729 /*****************************************************************************
730  *
731  * Test ANSI graphics
732  *
733  *****************************************************************************/
734 /*
735 **      select_bank(bank)
736 **
737 **      select a graphics character set for ANSI terminals
738 */
739 static void
740 select_bank(char *bank)
741 {
742         tc_putp(bank);
743         switch (bank[1] & 3) {
744         case 0:
745                 putchp('O' & 0x1f);     /* control O */
746                 break;
747         case 1:
748                 putchp('N' & 0x1f);     /* control N */
749                 tc_putp("\033~");
750                 break;
751         case 2:
752                 tc_putp("\033n\033}");
753                 break;
754         case 3:
755                 tc_putp("\033o\033|");
756                 break;
757         }
758 }
759
760 /*
761 **      show_characters(bank, bias)
762 **
763 **      print the ANSI graphics characters
764 */
765 static void
766 show_characters(char *bank, int bias)
767 {
768         int i;
769
770         sprintf(temp, "G%d GL   ", bank[1] & 3);
771         ptext(temp);
772         select_bank(bank);
773         for (i = ' '; i < 0x80; i++) {
774                 if (char_count >= columns ||
775                         (i != ' ' && (i & 31) == 0))
776                         put_str("\n        ");
777                 putchp(i + bias);
778         }
779         select_bank(default_bank);
780         put_str("   DEL <");
781         select_bank(bank);
782         putchp(0x7f + bias);
783         select_bank(default_bank);
784         putchp('>');
785         put_crlf();
786         put_crlf();
787 }
788
789
790 /* ANSI graphics test
791         94     96   character sets
792    G0   (      ,
793    G1   )      -
794    G2   *      .
795    G3   +      /
796
797 Standard Definitions
798    A    UK
799    B    US ASCII
800
801 Dec extended definitions
802    0    Special graphics
803
804  */
805
806 /*
807 **      tools_charset(testlist, state, ch)
808 **
809 **      Run the ANSI alt-charset mode tool
810 */
811 void
812 tools_charset(
813         struct test_list *t GCC_UNUSED,
814         int *state GCC_UNUSED,
815         int *chp GCC_UNUSED)
816 {
817         int j, ch;
818         char bank[32];
819
820         put_clear();
821         ptext("Enter the bank ()*+,-./ followed by the character set");
822         ptext(" 0123456789:;<=>? for private use, and");
823         ptextln(" @A...Z[\\]^_`a...z{|}~ for standard sets.");
824         strcpy(bank, "\033)0");
825         for (; bank[0];) {
826                 put_crlf();
827                 show_characters(bank, 0);
828
829                 /* G0 will not print in GR */
830                 if (bank[1] & 3) {
831                         show_characters(bank, 0x80);
832                 }
833                 ptext("bank+set> ");
834                 for (j = 1; (ch = getchp(char_mask)); j++) {
835                         if (ch == EOF)
836                                 break;
837                         putchp(ch);
838                         if (j == 1 && ch > '/')
839                                 j++;
840                         bank[j] = ch;
841                         if (ch < ' ' || ch > '/')
842                                 break;
843                         if (j + 1 >= (int) sizeof(bank))
844                                 break;
845                 }
846                 if (j == 1)
847                         break;
848                 if (bank[j] < '0' || bank[j] > '~')
849                         break;
850                 bank[j + 1] = '\0';
851         }
852         put_crlf();
853 }