ncurses 5.5
[ncurses.git] / tack / fun.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., 51 Franklin Street, Fifth Floor,
19 ** Boston, MA 02110-1301, USA
20 */
21
22 #include <tack.h>
23
24 MODULE_ID("$Id: fun.c,v 1.6 2005/09/17 19:49:16 tom Exp $")
25
26 /*
27  * Test the function keys on the terminal.  The code for echo tests
28  * lives here too.
29  */
30
31 static void funkey_keys(struct test_list *, int *, int *);
32 static void funkey_meta(struct test_list *, int *, int *);
33 static void funkey_label(struct test_list *, int *, int *);
34 static void funkey_prog(struct test_list *, int *, int *);
35 static void funkey_local(struct test_list *, int *, int *);
36
37 struct test_list funkey_test_list[] = {
38         {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
39         {MENU_CLEAR + FLAG_FUNCTION_KEY, 0, 0, 0, "f) show a list of function keys", show_report, 0},
40         {MENU_NEXT | MENU_CLEAR, 0, "smkx) (rmkx", 0,
41                 "k) test function keys", funkey_keys, 0},
42         {MENU_NEXT, 10, "km", "smm rmm", 0, funkey_meta, 0},
43         {MENU_NEXT, 8, "nlab) (smln) (pln) (rmln", "lw lh", 0, funkey_label, 0},
44         {MENU_NEXT, 2, "pfx", 0, 0, funkey_prog, 0},
45         {MENU_NEXT, 2, "pfloc", 0, 0, funkey_local, 0},
46         {MENU_LAST, 0, 0, 0, 0, 0, 0}
47 };
48
49 static void printer_on(struct test_list *, int *, int *);
50 static void printer_mc0(struct test_list *, int *, int *);
51
52 struct test_list printer_test_list[] = {
53         {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
54         {MENU_NEXT | MENU_CLEAR, 0, "mc4) (mc5) (mc5i", 0, 0, printer_on, 0},
55         {MENU_NEXT | MENU_CLEAR, 0, "mc0", 0, 0, printer_mc0, 0},
56         {MENU_LAST, 0, 0, 0, 0, 0, 0}
57 };
58
59 #define MAX_STRINGS STRCOUNT
60
61
62 /* local definitions */
63 static const char *fk_name[MAX_STRINGS];
64 static char *fkval[MAX_STRINGS];
65 static char *fk_label[MAX_STRINGS];     /* function key labels (if any) */
66 static int fk_tested[MAX_STRINGS];
67 static int fkmax = 1;           /* length of longest key */
68 static int got_labels = 0;      /* true if we have some labels */
69 static int key_count = 0;
70 static int end_state;
71
72 /* unknown function keys */
73 #define MAX_FK_UNK 50
74 static char *fk_unknown[MAX_FK_UNK];
75 static int fk_length[MAX_FK_UNK];
76 static int funk;
77
78 /*
79 **      keys_tested(first-time, show-help, hex-output)
80 **
81 **      Display a list of the keys not tested.
82 */
83 static void
84 keys_tested(
85         int first_time,
86         int show_help,
87         int hex_output)
88 {
89         int i, l;
90         char outbuf[256];
91
92         put_clear();
93         tty_set();
94         flush_input();
95         if (got_labels) {
96                 putln("Function key labels:");
97                 for (i = 0; i < key_count; ++i) {
98                         if (fk_label[i]) {
99                                 sprintf(outbuf, "%s %s",
100                                         fk_name[i] ? fk_name[i] : "??", fk_label[i]);
101                                 put_columns(outbuf, (int) strlen(outbuf), 16);
102                         }
103                 }
104                 put_newlines(2);
105         }
106         if (funk) {
107                 putln("The following keys are not defined:");
108                 for (i = 0; i < funk; ++i) {
109                         put_columns(fk_unknown[i], fk_length[i], 16);
110                 }
111                 put_mode(exit_attribute_mode);
112                 put_newlines(2);
113         }
114         if (first_time) {
115                 putln("The following keys are defined:");
116         } else {
117                 putln("The following keys have not been tested:");
118         }
119         if (scan_mode) {
120                 for (i = 0; scan_down[i]; i++) {
121                         if (!scan_tested[i]) {
122                                 if (hex_output) {
123                                         strcpy(outbuf, hex_expand_to(scan_down[i], 3));
124                                 } else {
125                                         strcpy(outbuf, expand(scan_down[i]));
126                                 }
127                                 l = expand_chars;
128                                 if (hex_output) {
129                                         strcat(outbuf, hex_expand_to(scan_up[i], 3));
130                                 } else {
131                                         strcat(outbuf, expand(scan_up[i]));
132                                 }
133                                 expand_chars += l;
134                                 l = strlen(scan_name[i]);
135                                 if (((char_count + 16) & ~15) +
136                                         ((expand_chars + 7) & ~7) + l >= columns) {
137                                         put_crlf();
138                                 } else
139                                 if (char_count + 24 > columns) {
140                                         put_crlf();
141                                 } else if (char_count) {
142                                         putchp(' ');
143                                 }
144                                 put_columns(outbuf, expand_chars, 16);
145                                 put_columns(scan_name[i], l, 8);
146                         }
147                 }
148         } else {
149                 for (i = 0; i < key_count; i++) {
150                         if (!fk_tested[i]) {
151                                 if (hex_output) {
152                                         strcpy(outbuf, hex_expand_to(fkval[i], 3));
153                                 } else {
154                                         strcpy(outbuf, expand(fkval[i]));
155                                 }
156                                 l = strlen(fk_name[i]);
157                                 if (((char_count + 16) & ~15) +
158                                         ((expand_chars + 7) & ~7) + l >= columns) {
159                                         put_crlf();
160                                 } else
161                                 if (char_count + 24 > columns) {
162                                         put_crlf();
163                                 } else
164                                 if (char_count) {
165                                         putchp(' ');
166                                 }
167                                 put_columns(outbuf, expand_chars, 16);
168                                 put_columns(fk_name[i], l, 8);
169                         }
170                 }
171         }
172         put_newlines(2);
173         if (show_help) {
174                 ptextln("Hit any function key.  Type 'end' to quit.  Type ? to update the display.");
175                 put_crlf();
176         }
177 }
178
179 /*
180 **      enter_key(name, value, label)
181 **
182 **      Enter a function key into the data base
183 */
184 void
185 enter_key(
186         const char *name,
187         char *value,
188         char *lab)
189 {
190         int j;
191
192         if (value) {
193                 j = strlen(value);
194                 fkmax = fkmax > j ? fkmax : j;
195                 /* do not permit duplicates */
196                 for (j = 0; j < key_count; j++) {
197                         if (!strcmp(fk_name[j], name)) {
198                                 return;
199                         }
200                 }
201                 fkval[key_count] = value;
202                 fk_tested[key_count] = 0;
203                 fk_label[key_count] = lab;
204                 fk_name[key_count++] = name;
205                 if (lab) {
206                         got_labels = TRUE;
207                 }
208         }
209 }
210
211
212 static void
213 fresh_line(void)
214 {                               /* clear the line for a new function key line */
215         if (over_strike) {
216                 put_crlf();
217         } else {
218                 put_cr();
219                 if (clr_eol) {
220                         tc_putp(clr_eol);
221                 } else {
222                         put_str("                    \r");
223                 }
224         }
225 }
226
227
228 static int
229 end_funky(int ch)
230 {                               /* return true if this is the end */
231         switch (ch) {
232         case 'e':
233         case 'E':
234                 end_state = 'e';
235                 break;
236         case 'n':
237         case 'N':
238                 if (end_state == 'e') {
239                         end_state = 'n';
240                 } else {
241                         end_state = 0;
242                 }
243                 break;
244         case 'd':
245         case 'D':
246                 if (end_state == 'n') {
247                         end_state = 'd';
248                 } else {
249                         end_state = 0;
250                 }
251                 break;
252         case 'l':
253         case 'L':
254                 if (end_state == 'l') {
255                         end_state = '?';
256                 } else {
257                         end_state = 'l';
258                 }
259                 break;
260         default:
261                 end_state = 0;
262                 break;
263         }
264         return end_state == 'd';
265 }
266
267
268 static int
269 found_match(char *s, int hx, int cc)
270 {                               /* return true if this string is a match */
271         int j, f;
272         char outbuf[256];
273
274         if (!*s) {
275                 return 0;
276         }
277         if (scan_mode) {
278                 for (j = f = 0; scan_down[j]; j++) {
279                         if (scan_length[j] == 0) {
280                                 continue;
281                         }
282                         if (!strncmp(s, scan_down[j], scan_length[j])) {
283                                 if (!f) {       /* first match */
284                                         put_cr();
285                                         if (hx) {
286                                                 put_str(hex_expand_to(s, 10));
287                                         } else {
288                                                 put_str(expand_to(s, 10));
289                                         }
290                                         f = 1;
291                                 }
292                                 (void) end_funky(scan_name[j][0]);
293                                 put_str(" ");
294                                 put_str(scan_name[j]);
295                                 scan_tested[j] = 1;
296                                 s += scan_length[j];
297                                 if (strncmp(s, scan_up[j], scan_length[j])) {
298                                         put_str(" scan down");
299                                 } else {
300                                         s += scan_length[j];
301                                 }
302                                 if (!*s) {
303                                         break;
304                                 }
305                                 j = -1;
306                         }
307                         if (!strncmp(s, scan_up[j], scan_length[j])) {
308                                 if (!f) {       /* first match */
309                                         put_cr();
310                                         if (hx) {
311                                                 put_str(hex_expand_to(s, 10));
312                                         } else {
313                                                 put_str(expand_to(s, 10));
314                                         }
315                                         f = 1;
316                                 }
317                                 put_str(" ");
318                                 put_str(scan_name[j]);
319                                 put_str(" scan up");
320                                 s += scan_length[j];
321                                 if (!*s) {
322                                         break;
323                                 }
324                                 j = -1;
325                         }
326                 }
327         } else {
328                 for (j = f = 0; j < key_count; j++) {
329                         if (!strcmp(s, fkval[j])) {
330                                 if (!f) {       /* first match */
331                                         put_cr();
332                                         if (hx) {
333                                                 put_str(hex_expand_to(s, 10));
334                                         } else {
335                                                 put_str(expand_to(s, 10));
336                                         }
337                                         f = 1;
338                                 }
339                                 sprintf(outbuf, " (%s)", fk_name[j]);
340                                 put_str(outbuf);
341                                 if (fk_label[j]) {
342                                         sprintf(outbuf, " <%s>", fk_label[j]);
343                                         put_str(outbuf);
344                                 }
345                                 fk_tested[j] = 1;
346                         }
347                 }
348         }
349         if (end_state == '?') {
350                 keys_tested(0, 1, hx);
351                 tty_raw(cc, char_mask);
352                 end_state = 0;
353         }
354         return f;
355 }
356
357
358 static int
359 found_exit(char *keybuf, int hx, int cc)
360 {                               /* return true if the user wants to exit */
361         int j, k;
362         char *s;
363
364
365         if (scan_mode) {
366                 if (*keybuf == '\0') {
367                         return TRUE;
368                 }
369         } else {
370                 /* break is a special case */
371                 if (*keybuf == '\0') {
372                         fresh_line();
373                         tty_set();
374                         ptext("Hit X to exit: ");
375                         if (wait_here() == 'X') {
376                                 return TRUE;
377                         }
378                         keys_tested(0, 1, hx);
379                         tty_raw(cc, char_mask);
380                         return FALSE;
381                 }
382                 /* is this the end? */
383                 for (k = 0; (j = (keybuf[k] & STRIP_PARITY)); k++) {
384                         if (end_funky(j)) {
385                                 return TRUE;
386                         }
387                 }
388
389                 j = TRUE;       /* does he need an updated list? */
390                 for (k = 0; keybuf[k]; k++) {
391                         j &= (keybuf[k] & STRIP_PARITY) == '?';
392                 }
393                 if (j || end_state == '?') {
394                         keys_tested(0, 1, hx);
395                         tty_raw(cc, char_mask);
396                         end_state = 0;
397                         return FALSE;
398                 }
399         }
400
401         put_cr();
402         if (hx) {
403                 s = hex_expand_to(keybuf, 10);
404         } else {
405                 s = expand_to(keybuf, 10);
406         }
407         sprintf(temp, "%s Unknown", s);
408         put_str(temp);
409         for (j = 0; j < MAX_FK_UNK; j++) {
410                 if (j == funk) {
411                         fk_length[funk] = expand_chars;
412                         if ((fk_unknown[funk] = (char *)malloc(strlen(s) + 1))) {
413                                 strcpy(fk_unknown[funk++], s);
414                         }
415                         break;
416                 }
417                 if (fk_length[j] == expand_chars) {
418                         if (!strcmp(fk_unknown[j], s)) {
419                                 break;
420                         }
421                 }
422         }
423         return FALSE;
424 }
425
426 /*
427 **      funkey_keys(test_list, status, ch)
428 **
429 **      Test function keys
430 */
431 static void
432 funkey_keys(
433         struct test_list *t,
434         int *state,
435         int *ch)
436 {
437         char keybuf[256];
438
439         if (keypad_xmit) {
440                 tc_putp(keypad_xmit);
441         }
442         keys_tested(1, 1, hex_out);     /* also clears screen */
443         keybuf[0] = '\0';
444         end_state = 0;
445         if (scan_mode) {
446                 fkmax = scan_max;
447         }
448         tty_raw(0, char_mask);
449         while (end_state != 'd') {
450                 read_key(keybuf, sizeof(keybuf));
451                 fresh_line();
452                 if (found_match(keybuf, hex_out, 0)) {
453                         continue;
454                 }
455                 if (found_exit(keybuf, hex_out, 0)) {
456                         break;
457                 }
458         }
459         if (keypad_local) {
460                 tc_putp(keypad_local);
461         }
462         keys_tested(0, 0, hex_out);
463         ptext("Function key test ");
464         generic_done_message(t, state, ch);
465 }
466
467 int
468 tty_meta_prep(void)
469 {                               /* print a warning before the meta key test */
470         if (not_a_tty) {
471                 return 0;
472         }
473         if (initial_stty_query(TTY_8_BIT)) {
474                 return 0;
475         }
476         ptext("The meta key test must be run with the");
477         ptext(" terminal set for 8 data bits.  Two stop bits");
478         ptext(" may also be needed for correct display.  I will");
479         ptext(" transmit 8 bit data but if the terminal is set for");
480         ptextln(" 7 bit data, garbage may appear on the screen.");
481         return 1;
482 }
483
484 /*
485 **      funkey_meta(test_list, status, ch)
486 **
487 **      Test meta key (km) (smm) (rmm)
488 */
489 static void
490 funkey_meta(
491         struct test_list *t,
492         int *state,
493         int *ch)
494 {
495         int i, j, k, len;
496         char outbuf[256];
497
498         if (has_meta_key) {
499                 put_crlf();
500                 if (char_mask != ALLOW_PARITY) {
501                         if (tty_meta_prep()) {
502                                 ptext("\nHit any key to continue > ");
503                                 (void) wait_here();
504                                 put_crlf();
505                         }
506                 }
507                 ptext("Begin meta key test. (km) (smm) (rmm)  Hit any key");
508                 ptext(" with the meta key.  The character will be");
509                 ptext(" displayed in hex.  If the meta key is working");
510                 ptext(" then the most significant bit will be set.  Type");
511                 ptextln(" 'end' to exit.");
512                 tty_raw(1, ALLOW_PARITY);
513                 tc_putp(meta_on);
514
515                 for (i = j = k = len = 0; i != 'e' || j != 'n' || k != 'd';) {
516                         i = j;
517                         j = k;
518                         k = getchp(ALLOW_PARITY);
519                         if (k == EOF) {
520                                 break;
521                         }
522                         if ((len += 3) >= columns) {
523                                 put_crlf();
524                                 len = 3;
525                         }
526                         sprintf(outbuf, "%02X ", k);
527                         put_str(outbuf);
528                         k &= STRIP_PARITY;
529                 }
530                 tc_putp(meta_off);
531                 put_crlf();
532                 tty_set();
533                 put_crlf();
534         } else {
535                 ptext("(km) Has-meta-key is not set.  ");
536         }
537         generic_done_message(t, state, ch);
538 }
539
540 /*
541 **      funkey_label(test_list, status, ch)
542 **
543 **      Test labels (nlab) (smln) (pln) (rmln) (lw) (lh)
544 */
545 static void
546 funkey_label(
547         struct test_list *t,
548         int *state,
549         int *ch)
550 {
551         int i;
552         char outbuf[256];
553
554         if (num_labels == -1) {
555                 ptextln("Your terminal has no labels. (nlab)");
556         } else {
557                 sprintf(temp, "Your terminal has %d labels (nlab) that are %d characters wide (lw) and %d lines high (lh)",
558                         num_labels, label_width, label_height);
559                 ptext(temp);
560                 ptextln(" Testing (smln) (pln) (rmln)");
561                 if (label_on) {
562                         tc_putp(label_on);
563                 }
564                 if (label_width <= 0) {
565                         label_width = sizeof(outbuf) - 1;
566                 }
567                 for (i = 1; i <= num_labels; i++) {
568                         sprintf(outbuf, "L%d..............................", i);
569                         outbuf[label_width] = '\0';
570                         tc_putp(tparm(plab_norm, i, outbuf));
571                 }
572                 if (label_off) {
573                         ptext("Hit any key to remove the labels: ");
574                         (void) wait_here();
575                         tc_putp(label_off);
576                 }
577         }
578         generic_done_message(t, state, ch);
579 }
580
581 /*
582 **      funkey_prog(test_list, status, ch)
583 **
584 **      Test program function keys (pfx)
585 */
586 static void
587 funkey_prog(
588         struct test_list *t,
589         int *state,
590         int *ch)
591 {
592         int i, fk;
593         char mm[256];
594
595         fk = 1; /* use function key 1 for now */
596         if (pkey_xmit) {
597                 /* test program function key */
598                 sprintf(temp,
599                         "(pfx) Set function key %d to transmit abc\\n", fk);
600                 ptextln(temp);
601                 tc_putp(tparm(pkey_xmit, fk, "abc\n"));
602                 sprintf(temp, "Hit function key %d\n", fk);
603                 ptextln(temp);
604                 for (i = 0; i < 4; ++i)
605                         mm[i] = getchp(STRIP_PARITY);
606                 mm[i] = '\0';
607                 put_crlf();
608                 if (mm[0] != 'a' || mm[1] != 'b' || mm[2] != 'c') {
609                         sprintf(temp, "Error string received was: %s", expand(mm));
610                         ptextln(temp);
611                 } else {
612                         putln("Thank you\n");
613                 }
614                 flush_input();
615                 if (key_f1) {
616                         tc_putp(tparm(pkey_xmit, fk, key_f1));
617                 }
618         } else {
619                 ptextln("Function key transmit (pfx), not present.");
620         }
621         generic_done_message(t, state, ch);
622 }
623
624 /*
625 **      funkey_local(test_list, status, ch)
626 **
627 **      Test program local function keys (pfloc)
628 */
629 static void
630 funkey_local(
631         struct test_list *t,
632         int *state,
633         int *ch)
634 {
635         int fk;
636
637         fk = 1;
638         if (pkey_local) {
639                 /* test local function key */
640                 sprintf(temp,
641                         "(pfloc) Set function key %d to execute a clear and print \"Done!\"", fk);
642                 ptextln(temp);
643                 sprintf(temp, "%sDone!", liberated(clear_screen));
644                 tc_putp(tparm(pkey_local, fk, temp));
645                 sprintf(temp, "Hit function key %d.  Then hit return.", fk);
646                 ptextln(temp);
647                 (void) wait_here();
648                 flush_input();
649                 if (key_f1 && pkey_xmit) {
650                         tc_putp(tparm(pkey_xmit, fk, key_f1));
651                 }
652         } else {
653                 ptextln("Function key execute local (pfloc), not present.");
654         }
655
656         generic_done_message(t, state, ch);
657 }
658
659 /*
660 **      printer_on(test_list, status, ch)
661 **
662 **      Test printer on/off (mc4) (mc5) (mc5i)
663 */
664 static void
665 printer_on(
666         struct test_list *t,
667         int *state,
668         int *ch)
669 {
670         if (!prtr_on || !prtr_off) {
671                 ptextln("Printer on/off missing. (mc5) (mc4)");
672         } else if (prtr_silent) {
673                 ptextln("Your printer is silent. (mc5i) is set.");
674                 tc_putp(prtr_on);
675                 ptextln("This line should be on the printer but not your screen. (mc5)");
676                 tc_putp(prtr_off);
677                 ptextln("This line should be only on the screen. (mc4)");
678         } else {
679                 ptextln("Your printer is not silent. (mc5i) is reset.");
680                 tc_putp(prtr_on);
681                 ptextln("This line should be on the printer and the screen. (mc5)");
682                 tc_putp(prtr_off);
683                 ptextln("This line should only be on the screen. (mc4)");
684         }
685         generic_done_message(t, state, ch);
686 }
687
688 /*
689 **      printer_mc0(test_list, status, ch)
690 **
691 **      Test screen print (mc0)
692 */
693 static void
694 printer_mc0(
695         struct test_list *t,
696         int *state,
697         int *ch)
698 {
699         if (print_screen) {
700                 ptext("I am going to send the contents of the screen to");
701                 ptext(" the printer, then wait for a keystroke from you.");
702                 ptext("  All of the text that appears on the screen");
703                 ptextln(" should be printed. (mc0)");
704                 tc_putp(print_screen);
705         } else {
706                 ptext("(mc0) Print-screen is not present.  ");
707         }
708         generic_done_message(t, state, ch);
709 }
710
711
712 static void
713 line_pattern(void)
714 {                               /* put up a pattern that will help count the
715                                    number of lines */
716         int i, j;
717
718         put_clear();
719         if (over_strike) {
720                 for (i = 0; i < 100; i++) {
721                         if (i) {
722                                 put_crlf();
723                         }
724                         for (j = i / 10; j; j--) {
725                                 put_this(' ');
726                         }
727                         put_this('0' + ((i + 1) % 10));
728                 }
729         } else  /* I assume it will scroll */ {
730                 for (i = 100; i; i--) {
731                         sprintf(temp, "\r\n%d", i);
732                         put_str(temp);
733                 }
734         }
735 }
736
737
738 static void
739 column_pattern(void)
740 {                               /* put up a pattern that will help count the
741                                    number of columns */
742         int i, j;
743
744         put_clear();
745         for (i = 0; i < 20; i++) {
746                 for (j = 1; j < 10; j++) {
747                         put_this('0' + j);
748                 }
749                 put_this('.');
750         }
751 }
752
753 /*
754 **      report_help()
755 **
756 **      Print the help text for the echo tests
757 */
758 static void
759 report_help(int crx)
760 {
761         ptextln("The following commands may also be entered:");
762         ptextln(" clear   clear screen.");
763         ptextln(" columns print a test pattern to help count screen width.");
764         ptextln(" lines   print a test pattern to help count screen length.");
765         ptextln(" end     exit.");
766         ptextln(" echo    redisplay last report.");
767         if (crx) {
768                 ptextln(" hex     redisplay last report in hex.");
769         } else {
770                 ptextln(" hex     toggle hex display mode.");
771         }
772         ptextln(" help    display this list.");
773         ptextln(" high    toggle forced high bit (0x80).");
774         ptextln(" scan    toggle scan mode.");
775         ptextln(" one     echo one character after <cr> or <lf> as is. (report mode)");
776         ptextln(" two     echo two characters after <cr> or <lf> as is.");
777         ptextln(" all     echo all characters after <cr> or <lf> as is. (echo mode)");
778 }
779
780 /*
781 **      tools_report(testlist, state, ch)
782 **
783 **      Run the echo tool and report tool
784 */
785 void
786 tools_report(
787         struct test_list *t,
788         int *state GCC_UNUSED,
789         int *pch GCC_UNUSED)
790 {
791         int i, j, ch, crp, crx, high_bit, save_scan_mode, hex_display;
792         char buf[1024];
793         char txt[8];
794
795         hex_display = hex_out;
796         put_clear();
797         if ((crx = (t->flags & 255)) == 1) {
798                 ptext("Characters after a CR or LF will be echoed as");
799                 ptextln(" is.  All other characters will be expanded.");
800                 report_help(crx);
801         } else {        /* echo test */
802                 ptextln("Begin echo test.");
803                 report_help(crx);
804         }
805         txt[sizeof(txt) - 1] = '\0';
806         save_scan_mode = scan_mode;
807         tty_raw(1, char_mask);
808         for (i = crp = high_bit = 0;;) {
809                 ch = getchp(char_mask);
810                 if (ch == EOF) {
811                         break;
812                 }
813                 if (i >= (int) sizeof(buf) - 1) {
814                         i = 0;
815                 }
816                 buf[i++] = ch;
817                 buf[i] = '\0';
818                 for (j = 0; j < (int) sizeof(txt) - 1; j++) {
819                         txt[j] = txt[j + 1];
820                 }
821                 txt[sizeof(txt) - 1] = ch & STRIP_PARITY;
822                 if (crx == 0) { /* echo test */
823                         if (hex_display) {
824                                 ptext(hex_expand_to(&buf[i - 1], 3));
825                         } else {
826                                 tc_putch(ch | high_bit);
827                         }
828                 } else /* status report test */
829                 if (ch == '\n' || ch == '\r') {
830                         put_crlf();
831                         crp = 0;
832                 } else if (crp++ < crx) {
833                         tc_putch(ch | high_bit);
834                 } else {
835                         put_str(expand(&buf[i - 1]));
836                 }
837                 if (!strncmp(&txt[sizeof(txt) - 7], "columns", 7)) {
838                         column_pattern();
839                         buf[i = 0] = '\0';
840                         crp = 0;
841                 }
842                 if (!strncmp(&txt[sizeof(txt) - 5], "lines", 5)) {
843                         line_pattern();
844                         buf[i = 0] = '\0';
845                         crp = 0;
846                 }
847                 if (!strncmp(&txt[sizeof(txt) - 5], "clear", 5)) {
848                         put_clear();
849                         buf[i = 0] = '\0';
850                         crp = 0;
851                 }
852                 if (!strncmp(&txt[sizeof(txt) - 4], "high", 4)) {
853                         high_bit ^= 0x80;
854                         if (high_bit) {
855                                 ptextln("\nParity bit set");
856                         } else {
857                                 ptextln("\nParity bit reset");
858                         }
859                 }
860                 if (!strncmp(&txt[sizeof(txt) - 4], "help", 4)) {
861                         put_crlf();
862                         report_help(crx);
863                 }
864                 if (!strncmp(&txt[sizeof(txt) - 4], "echo", 4)) {
865                         /* display the last status report */
866                         /* clear bypass condition on Tek terminals */
867                         put_crlf();
868                         if (i >= 4) {
869                                 buf[i -= 4] = '\0';
870                         }
871                         put_str(expand(buf));
872                 }
873                 if (save_scan_mode &&
874                         !strncmp(&txt[sizeof(txt) - 4], "scan", 4)) {
875                         /* toggle scan mode */
876                         scan_mode = !scan_mode;
877                 }
878                 if (!strncmp(&txt[sizeof(txt) - 3], "end", 3))
879                         break;
880                 if (!strncmp(&txt[sizeof(txt) - 3], "hex", 3)) {
881                         if (crx) {
882                                 /* display the last status report in hex */
883                                 /* clear bypass condition on Tek terminals */
884                                 put_crlf();
885                                 if (i >= 3) {
886                                         buf[i -= 3] = '\0';
887                                 }
888                                 put_str(hex_expand_to(buf, 3));
889                         } else {
890                                 hex_display = !hex_display;
891                         }
892                 }
893                 if (!strncmp(&txt[sizeof(txt) - 3], "two", 3))
894                         crx = 2;
895                 if (!strncmp(&txt[sizeof(txt) - 3], "one", 3))
896                         crx = 1;
897                 if (!strncmp(&txt[sizeof(txt) - 3], "all", 3))
898                         crx = 0;
899         }
900         scan_mode = save_scan_mode;
901         put_crlf();
902         tty_set();
903         if (crx) {
904                 ptextln("End of status report test.");
905         } else {
906                 ptextln("End of echo test.");
907         }
908 }