2 ** Copyright (C) 1991, 1997 Free Software Foundation, Inc.
4 ** This file is part of TACK.
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)
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.
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
24 MODULE_ID("$Id: fun.c,v 1.9 2006/11/26 00:15:53 tom Exp $")
27 * Test the function keys on the terminal. The code for echo tests
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 *);
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}
49 static void printer_on(struct test_list *, int *, int *);
50 static void printer_mc0(struct test_list *, int *, int *);
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}
59 /* local definitions */
60 static const char **fk_name;
62 static char **fk_label; /* function key labels (if any) */
63 static int *fk_tested;
64 static int num_strings = 0;
66 static int fkmax = 1; /* length of longest key */
67 static int got_labels = 0; /* true if we have some labels */
68 static int key_count = 0;
71 /* unknown function keys */
73 static char *fk_unknown[MAX_FK_UNK];
74 static int fk_length[MAX_FK_UNK];
78 * Initialize arrays that depend on the actual number of strings.
83 if (num_strings != MAX_STRINGS) {
84 num_strings = MAX_STRINGS;
85 fk_name = (const char **)calloc(num_strings, sizeof(const char *));
86 fkval = (char **)calloc(num_strings, sizeof(char *));
87 fk_label = (char **)calloc(num_strings, sizeof(char *));
88 fk_tested = (int *)calloc(num_strings, sizeof(int));
93 ** keys_tested(first-time, show-help, hex-output)
95 ** Display a list of the keys not tested.
111 putln("Function key labels:");
112 for (i = 0; i < key_count; ++i) {
114 sprintf(outbuf, "%s %s",
115 fk_name[i] ? fk_name[i] : "??", fk_label[i]);
116 put_columns(outbuf, (int) strlen(outbuf), 16);
122 putln("The following keys are not defined:");
123 for (i = 0; i < funk; ++i) {
124 put_columns(fk_unknown[i], fk_length[i], 16);
126 put_mode(exit_attribute_mode);
130 putln("The following keys are defined:");
132 putln("The following keys have not been tested:");
135 for (i = 0; scan_down[i]; i++) {
136 if (!scan_tested[i]) {
138 strcpy(outbuf, hex_expand_to(scan_down[i], 3));
140 strcpy(outbuf, expand(scan_down[i]));
144 strcat(outbuf, hex_expand_to(scan_up[i], 3));
146 strcat(outbuf, expand(scan_up[i]));
149 l = strlen(scan_name[i]);
150 if (((char_count + 16) & ~15) +
151 ((expand_chars + 7) & ~7) + l >= columns) {
154 if (char_count + 24 > columns) {
156 } else if (char_count) {
159 put_columns(outbuf, expand_chars, 16);
160 put_columns(scan_name[i], l, 8);
164 for (i = 0; i < key_count; i++) {
167 strcpy(outbuf, hex_expand_to(fkval[i], 3));
169 strcpy(outbuf, expand(fkval[i]));
171 l = strlen(fk_name[i]);
172 if (((char_count + 16) & ~15) +
173 ((expand_chars + 7) & ~7) + l >= columns) {
176 if (char_count + 24 > columns) {
182 put_columns(outbuf, expand_chars, 16);
183 put_columns(fk_name[i], l, 8);
189 ptextln("Hit any function key. Type 'end' to quit. Type ? to update the display.");
195 ** enter_key(name, value, label)
197 ** Enter a function key into the data base
210 fkmax = fkmax > j ? fkmax : j;
211 /* do not permit duplicates */
212 for (j = 0; j < key_count; j++) {
213 if (!strcmp(fk_name[j], name)) {
217 fkval[key_count] = value;
218 fk_tested[key_count] = 0;
219 fk_label[key_count] = lab;
220 fk_name[key_count++] = name;
230 { /* clear the line for a new function key line */
246 { /* return true if this is the end */
254 if (end_state == 'e') {
262 if (end_state == 'n') {
270 if (end_state == 'l') {
280 return end_state == 'd';
285 found_match(char *s, int hx, int cc)
286 { /* return true if this string is a match */
295 for (j = f = 0; scan_down[j]; j++) {
296 if (scan_length[j] == 0) {
299 if (!strncmp(s, scan_down[j], scan_length[j])) {
300 if (!f) { /* first match */
303 put_str(hex_expand_to(s, 10));
305 put_str(expand_to(s, 10));
309 (void) end_funky(scan_name[j][0]);
311 put_str(scan_name[j]);
314 if (strncmp(s, scan_up[j], scan_length[j])) {
315 put_str(" scan down");
324 if (!strncmp(s, scan_up[j], scan_length[j])) {
325 if (!f) { /* first match */
328 put_str(hex_expand_to(s, 10));
330 put_str(expand_to(s, 10));
335 put_str(scan_name[j]);
345 for (j = f = 0; j < key_count; j++) {
346 if (!strcmp(s, fkval[j])) {
347 if (!f) { /* first match */
350 put_str(hex_expand_to(s, 10));
352 put_str(expand_to(s, 10));
356 sprintf(outbuf, " (%s)", fk_name[j]);
359 sprintf(outbuf, " <%s>", fk_label[j]);
366 if (end_state == '?') {
367 keys_tested(0, 1, hx);
368 tty_raw(cc, char_mask);
376 found_exit(char *keybuf, int hx, int cc)
377 { /* return true if the user wants to exit */
383 if (*keybuf == '\0') {
387 /* break is a special case */
388 if (*keybuf == '\0') {
391 ptext("Hit X to exit: ");
392 if (wait_here() == 'X') {
395 keys_tested(0, 1, hx);
396 tty_raw(cc, char_mask);
399 /* is this the end? */
400 for (k = 0; (j = (keybuf[k] & STRIP_PARITY)); k++) {
406 j = TRUE; /* does he need an updated list? */
407 for (k = 0; keybuf[k]; k++) {
408 j &= (keybuf[k] & STRIP_PARITY) == '?';
410 if (j || end_state == '?') {
411 keys_tested(0, 1, hx);
412 tty_raw(cc, char_mask);
420 s = hex_expand_to(keybuf, 10);
422 s = expand_to(keybuf, 10);
424 sprintf(temp, "%s Unknown", s);
426 for (j = 0; j < MAX_FK_UNK; j++) {
428 fk_length[funk] = expand_chars;
429 if ((fk_unknown[funk] = (char *)malloc(strlen(s) + 1))) {
430 strcpy(fk_unknown[funk++], s);
434 if (fk_length[j] == expand_chars) {
435 if (!strcmp(fk_unknown[j], s)) {
444 ** funkey_keys(test_list, status, ch)
446 ** Test function keys
457 tc_putp(keypad_xmit);
459 keys_tested(1, 1, hex_out); /* also clears screen */
465 tty_raw(0, char_mask);
466 while (end_state != 'd') {
467 read_key(keybuf, sizeof(keybuf));
469 if (found_match(keybuf, hex_out, 0)) {
472 if (found_exit(keybuf, hex_out, 0)) {
477 tc_putp(keypad_local);
479 keys_tested(0, 0, hex_out);
480 ptext("Function key test ");
481 generic_done_message(t, state, ch);
486 { /* print a warning before the meta key test */
490 if (initial_stty_query(TTY_8_BIT)) {
493 ptext("The meta key test must be run with the");
494 ptext(" terminal set for 8 data bits. Two stop bits");
495 ptext(" may also be needed for correct display. I will");
496 ptext(" transmit 8 bit data but if the terminal is set for");
497 ptextln(" 7 bit data, garbage may appear on the screen.");
502 ** funkey_meta(test_list, status, ch)
504 ** Test meta key (km) (smm) (rmm)
517 if (char_mask != ALLOW_PARITY) {
518 if (tty_meta_prep()) {
519 ptext("\nHit any key to continue > ");
524 ptext("Begin meta key test. (km) (smm) (rmm) Hit any key");
525 ptext(" with the meta key. The character will be");
526 ptext(" displayed in hex. If the meta key is working");
527 ptext(" then the most significant bit will be set. Type");
528 ptextln(" 'end' to exit.");
529 tty_raw(1, ALLOW_PARITY);
532 for (i = j = k = len = 0; i != 'e' || j != 'n' || k != 'd';) {
535 k = getchp(ALLOW_PARITY);
539 if ((len += 3) >= columns) {
543 sprintf(outbuf, "%02X ", k);
552 ptext("(km) Has-meta-key is not set. ");
554 generic_done_message(t, state, ch);
558 ** funkey_label(test_list, status, ch)
560 ** Test labels (nlab) (smln) (pln) (rmln) (lw) (lh)
571 if (num_labels == -1) {
572 ptextln("Your terminal has no labels. (nlab)");
574 sprintf(temp, "Your terminal has %d labels (nlab) that are %d characters wide (lw) and %d lines high (lh)",
575 num_labels, label_width, label_height);
577 ptextln(" Testing (smln) (pln) (rmln)");
581 if (label_width <= 0) {
582 label_width = sizeof(outbuf) - 1;
584 for (i = 1; i <= num_labels; i++) {
585 sprintf(outbuf, "L%d..............................", i);
586 outbuf[label_width] = '\0';
587 tc_putp(TPARM_2(plab_norm, i, outbuf));
590 ptext("Hit any key to remove the labels: ");
595 generic_done_message(t, state, ch);
599 ** funkey_prog(test_list, status, ch)
601 ** Test program function keys (pfx)
612 fk = 1; /* use function key 1 for now */
614 /* test program function key */
616 "(pfx) Set function key %d to transmit abc\\n", fk);
618 tc_putp(TPARM_2(pkey_xmit, fk, "abc\n"));
619 sprintf(temp, "Hit function key %d\n", fk);
621 for (i = 0; i < 4; ++i)
622 mm[i] = getchp(STRIP_PARITY);
625 if (mm[0] != 'a' || mm[1] != 'b' || mm[2] != 'c') {
626 sprintf(temp, "Error string received was: %s", expand(mm));
629 putln("Thank you\n");
633 tc_putp(TPARM_2(pkey_xmit, fk, key_f1));
636 ptextln("Function key transmit (pfx), not present.");
638 generic_done_message(t, state, ch);
642 ** funkey_local(test_list, status, ch)
644 ** Test program local function keys (pfloc)
656 /* test local function key */
658 "(pfloc) Set function key %d to execute a clear and print \"Done!\"", fk);
660 sprintf(temp, "%sDone!", liberated(clear_screen));
661 tc_putp(TPARM_2(pkey_local, fk, temp));
662 sprintf(temp, "Hit function key %d. Then hit return.", fk);
666 if (key_f1 && pkey_xmit) {
667 tc_putp(TPARM_2(pkey_xmit, fk, key_f1));
670 ptextln("Function key execute local (pfloc), not present.");
673 generic_done_message(t, state, ch);
677 ** printer_on(test_list, status, ch)
679 ** Test printer on/off (mc4) (mc5) (mc5i)
687 if (!prtr_on || !prtr_off) {
688 ptextln("Printer on/off missing. (mc5) (mc4)");
689 } else if (prtr_silent) {
690 ptextln("Your printer is silent. (mc5i) is set.");
692 ptextln("This line should be on the printer but not your screen. (mc5)");
694 ptextln("This line should be only on the screen. (mc4)");
696 ptextln("Your printer is not silent. (mc5i) is reset.");
698 ptextln("This line should be on the printer and the screen. (mc5)");
700 ptextln("This line should only be on the screen. (mc4)");
702 generic_done_message(t, state, ch);
706 ** printer_mc0(test_list, status, ch)
708 ** Test screen print (mc0)
717 ptext("I am going to send the contents of the screen to");
718 ptext(" the printer, then wait for a keystroke from you.");
719 ptext(" All of the text that appears on the screen");
720 ptextln(" should be printed. (mc0)");
721 tc_putp(print_screen);
723 ptext("(mc0) Print-screen is not present. ");
725 generic_done_message(t, state, ch);
731 { /* put up a pattern that will help count the
737 for (i = 0; i < 100; i++) {
741 for (j = i / 10; j; j--) {
744 put_this('0' + ((i + 1) % 10));
746 } else /* I assume it will scroll */ {
747 for (i = 100; i; i--) {
748 sprintf(temp, "\r\n%d", i);
757 { /* put up a pattern that will help count the
762 for (i = 0; i < 20; i++) {
763 for (j = 1; j < 10; j++) {
773 ** Print the help text for the echo tests
778 ptextln("The following commands may also be entered:");
779 ptextln(" clear clear screen.");
780 ptextln(" columns print a test pattern to help count screen width.");
781 ptextln(" lines print a test pattern to help count screen length.");
782 ptextln(" end exit.");
783 ptextln(" echo redisplay last report.");
785 ptextln(" hex redisplay last report in hex.");
787 ptextln(" hex toggle hex display mode.");
789 ptextln(" help display this list.");
790 ptextln(" high toggle forced high bit (0x80).");
791 ptextln(" scan toggle scan mode.");
792 ptextln(" one echo one character after <cr> or <lf> as is. (report mode)");
793 ptextln(" two echo two characters after <cr> or <lf> as is.");
794 ptextln(" all echo all characters after <cr> or <lf> as is. (echo mode)");
798 ** tools_report(testlist, state, ch)
800 ** Run the echo tool and report tool
805 int *state GCC_UNUSED,
808 int i, j, ch, crp, crx, high_bit, save_scan_mode, hex_display;
812 hex_display = hex_out;
814 if ((crx = (t->flags & 255)) == 1) {
815 ptext("Characters after a CR or LF will be echoed as");
816 ptextln(" is. All other characters will be expanded.");
818 } else { /* echo test */
819 ptextln("Begin echo test.");
822 memset(txt, 0, sizeof(txt));
823 save_scan_mode = scan_mode;
824 tty_raw(1, char_mask);
825 for (i = crp = high_bit = 0;;) {
826 ch = getchp(char_mask);
830 if (i >= (int) sizeof(buf) - 1) {
835 for (j = 0; j < (int) sizeof(txt) - 1; j++) {
838 txt[sizeof(txt) - 1] = ch & STRIP_PARITY;
839 if (crx == 0) { /* echo test */
841 ptext(hex_expand_to(&buf[i - 1], 3));
843 tc_putch(ch | high_bit);
845 } else /* status report test */
846 if (ch == '\n' || ch == '\r') {
849 } else if (crp++ < crx) {
850 tc_putch(ch | high_bit);
852 put_str(expand(&buf[i - 1]));
854 if (!strncmp(&txt[sizeof(txt) - 7], "columns", 7)) {
859 if (!strncmp(&txt[sizeof(txt) - 5], "lines", 5)) {
864 if (!strncmp(&txt[sizeof(txt) - 5], "clear", 5)) {
869 if (!strncmp(&txt[sizeof(txt) - 4], "high", 4)) {
872 ptextln("\nParity bit set");
874 ptextln("\nParity bit reset");
877 if (!strncmp(&txt[sizeof(txt) - 4], "help", 4)) {
881 if (!strncmp(&txt[sizeof(txt) - 4], "echo", 4)) {
882 /* display the last status report */
883 /* clear bypass condition on Tek terminals */
888 put_str(expand(buf));
890 if (save_scan_mode &&
891 !strncmp(&txt[sizeof(txt) - 4], "scan", 4)) {
892 /* toggle scan mode */
893 scan_mode = !scan_mode;
895 if (!strncmp(&txt[sizeof(txt) - 3], "end", 3))
897 if (!strncmp(&txt[sizeof(txt) - 3], "hex", 3)) {
899 /* display the last status report in hex */
900 /* clear bypass condition on Tek terminals */
905 put_str(hex_expand_to(buf, 3));
907 hex_display = !hex_display;
910 if (!strncmp(&txt[sizeof(txt) - 3], "two", 3))
912 if (!strncmp(&txt[sizeof(txt) - 3], "one", 3))
914 if (!strncmp(&txt[sizeof(txt) - 3], "all", 3))
917 scan_mode = save_scan_mode;
921 ptextln("End of status report test.");
923 ptextln("End of echo test.");