source: trunk/essentials/sys-libs/ncurses/tack/tack.c

Last change on this file was 2621, checked in by bird, 19 years ago

GNU ncurses 5.5
File size: 14.7 KB
Line 
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
24MODULE_ID("$Id: tack.c,v 1.4 2005/09/17 19:49:16 tom Exp $")
25
26/*
27 This program is designed to test terminfo, not curses. Therefore
28 I have used as little of curses as possible.
29
30 Pads associated with the following capabilities are used to set
31 delay times in the handler: (cr), (ind), (cub1), (ff), (tab).
32
33 I use the (nxon) capability to set the tty handler with/without
34 xon/xoff. If (smxon)/(rmxon) is defined I will change the terminal
35 too.
36
37 (xon) inhibits the sending of delay characters in putp().
38 If the terminal is defined with no padding then the (xon) boolean
39 is a don't care. In this case I recommend that it be reset.
40 */
41
42/*****************************************************************************
43 *
44 * Option processing
45 *
46 *****************************************************************************/
47
48/* options and modes */
49int debug_level; /* debugging level */
50int translate_mode; /* translate tab, bs, cr, lf, ff */
51int scan_mode; /* use scan codes */
52int char_mask; /* either 0xFF else 0x7F, eight bit data mask */
53int select_delay_type; /* set handler delays for <cr><lf> */
54int select_xon_xoff; /* TTY driver XON/XOFF mode select */
55int hex_out; /* Display output in hex */
56int send_reset_init; /* Send the reset and initialization strings */
57FILE *log_fp; /* Terminal logfile */
58
59/*****************************************************************************
60 *
61 * Menu definitions
62 *
63 *****************************************************************************/
64
65static void tools_hex_echo(struct test_list *, int *, int *);
66static void tools_debug(struct test_list *, int *, int *);
67
68static char hex_echo_menu_entry[80];
69
70static struct test_list tools_test_list[] = {
71 {0, 0, 0, 0, "s) ANSI status reports", tools_status, 0},
72 {0, 0, 0, 0, "g) ANSI SGR modes (bold, underline, reverse)", tools_sgr, 0},
73 {0, 0, 0, 0, "c) ANSI character sets", tools_charset, 0},
74 {0, 0, 0, 0, hex_echo_menu_entry, tools_hex_echo, 0},
75 {0, 0, 0, 0, "e) echo tool", tools_report, 0},
76 {1, 0, 0, 0, "r) reply tool", tools_report, 0},
77 {0, 0, 0, 0, "p) performance testing", 0, &sync_menu},
78 {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0},
79 {0, 0, "u8) (u9", 0, "u) test ENQ/ACK handshake", sync_handshake, 0},
80 {0, 0, 0, 0, "d) change debug level", tools_debug, 0},
81 {MENU_LAST, 0, 0, 0, 0, 0, 0}
82};
83
84static struct test_menu tools_menu = {
85 0, 'q', 0, "Tools Menu", "tools",
86 0, 0, tools_test_list, 0, 0, 0
87};
88
89static void tty_width(struct test_list *, int *, int *);
90static void tty_delay(struct test_list *, int *, int *);
91static void tty_xon(struct test_list *, int *, int *);
92static void tty_trans(struct test_list *, int *, int *);
93static void tty_show_state(struct test_menu *);
94
95static char tty_width_menu[80];
96static char tty_delay_menu[80];
97static char tty_xon_menu[80];
98static char tty_trans_menu[80];
99static char enable_xon_xoff[] = {"x) enable xon/xoff"};
100static char disable_xon_xoff[] = {"x) disable xon/xoff"};
101
102static struct test_list tty_test_list[] = {
103 {0, 0, 0, 0, tty_width_menu, tty_width, 0},
104 {0, 0, 0, 0, tty_delay_menu, tty_delay, 0},
105 {0, 0, 0, 0, tty_xon_menu, tty_xon, 0},
106 {0, 0, 0, 0, tty_trans_menu, tty_trans, 0},
107 {MENU_LAST, 0, 0, 0, 0, 0, 0}
108};
109
110static struct test_menu tty_menu = {
111 0, 'q', 0, "Terminal and driver configuration",
112 "tty", 0,
113 tty_show_state, tty_test_list, 0, 0, 0
114};
115
116struct test_menu edit_menu = {
117 0, 'q', 0, "Edit terminfo menu",
118 "edit", 0,
119 0, edit_test_list, 0, 0, 0
120};
121
122static struct test_menu mode_menu = {
123 0, 'n', 0, "Test modes and glitches:",
124 "mode", "n) run standard tests",
125 0, mode_test_list, 0, 0, 0
126};
127
128static struct test_menu acs_menu = {
129 0, 'n', 0,
130 "Test alternate character set and graphics rendition:",
131 "acs", "n) run standard tests",
132 0, acs_test_list, 0, 0, 0
133};
134
135static struct test_menu color_menu = {
136 0, 'n', 0,
137 "Test color:",
138 "color", "n) run standard tests",
139 0, color_test_list, 0, 0, 0
140};
141
142static struct test_menu crum_menu = {
143 0, 'n', 0,
144 "Test cursor movement:",
145 "move", "n) run standard tests",
146 0, crum_test_list, 0, 0, 0
147};
148
149static struct test_menu funkey_menu = {
150 0, 'n', 0,
151 "Test function keys:",
152 "fkey", "n) run standard tests",
153 sync_test, funkey_test_list, 0, 0, 0
154};
155
156static struct test_menu printer_menu = {
157 0, 'n', 0,
158 "Test printer:",
159 "printer", "n) run standard tests",
160 0, printer_test_list, 0, 0, 0
161};
162
163static void pad_gen(struct test_list *, int *, int *);
164
165static struct test_menu pad_menu = {
166 0, 'n', 0,
167 "Test padding and string capabilities:",
168 "pad", "n) run standard tests",
169 sync_test, pad_test_list, 0, 0, 0
170};
171
172static struct test_list normal_test_list[] = {
173 {0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
174 {0, 0, 0, 0, "i) send reset and init", menu_reset_init, 0},
175 {MENU_NEXT, 0, 0, 0, "x) test modes and glitches", 0, &mode_menu},
176 {MENU_NEXT, 0, 0, 0, "a) test alternate character set and graphic rendition", 0, &acs_menu},
177 {MENU_NEXT, 0, 0, 0, "c) test color", 0, &color_menu},
178 {MENU_NEXT, 0, 0, 0, "m) test cursor movement", 0, &crum_menu},
179 {MENU_NEXT, 0, 0, 0, "f) test function keys", 0, &funkey_menu},
180 {MENU_NEXT, 0, 0, 0, "p) test padding and string capabilities", 0, &pad_menu},
181 {0, 0, 0, 0, "P) test printer", 0, &printer_menu},
182 {MENU_MENU, 0, 0, 0, "/) test a specific capability", 0, 0},
183 {0, 0, 0, 0, "t) auto generate pad delays", pad_gen, &pad_menu},
184 {0, 0, "u8) (u9", 0, 0, sync_handshake, 0},
185 {MENU_LAST, 0, 0, 0, 0, 0, 0}
186};
187
188
189static struct test_menu normal_menu = {
190 0, 'n', 0, "Main test menu",
191 "test", "n) run standard tests",
192 0, normal_test_list, 0, 0, 0
193};
194
195static void start_tools(struct test_list *, int *, int *);
196static void start_modes(struct test_list *, int *, int *);
197static void start_basic(struct test_list *, int *, int *);
198static void start_log(struct test_list *, int *, int *);
199
200static char logging_menu_entry[80] = "l) start logging";
201
202static struct test_list start_test_list[] = {
203 {0, 0, 0, 0, "b) display basic information", start_basic, 0},
204 {0, 0, 0, 0, "m) change modes", start_modes, 0},
205 {0, 0, 0, 0, "t) tools", start_tools, 0},
206 {MENU_COMPLETE, 0, 0, 0, "n) begin testing", 0, &normal_menu},
207 {0, 0, 0, 0, logging_menu_entry, start_log, 0},
208 {MENU_LAST, 0, 0, 0, 0, 0, 0}
209};
210
211
212static struct test_menu start_menu = {
213 0, 'n', 0, "Main Menu", "tack", 0,
214 0, start_test_list, 0, 0, 0
215};
216
217static struct test_list write_terminfo_list[] = {
218 {0, 0, 0, 0, "w) write the current terminfo to a file", save_info, 0},
219 {MENU_LAST, 0, 0, 0, 0, 0, 0}
220};
221
222/*****************************************************************************
223 *
224 * Menu command interpretation.
225 *
226 *****************************************************************************/
227
228/*
229** tools_hex_echo(testlist, state, ch)
230**
231** Flip the hex echo flag.
232*/
233static void
234tools_hex_echo(
235 struct test_list *t GCC_UNUSED,
236 int *state GCC_UNUSED,
237 int *ch GCC_UNUSED)
238{
239 if (hex_out) {
240 hex_out = FALSE;
241 strcpy(hex_echo_menu_entry,
242 "h) enable hex output on echo tool");
243 } else {
244 hex_out = TRUE;
245 strcpy(hex_echo_menu_entry,
246 "h) disable hex output on echo tool");
247 }
248}
249
250/*
251** tools_debug(testlist, state, ch)
252**
253** Change the debug level.
254*/
255static void
256tools_debug(
257 struct test_list *t GCC_UNUSED,
258 int *state GCC_UNUSED,
259 int *ch)
260{
261 char buf[32];
262
263 ptext("Enter a new value: ");
264 read_string(buf, sizeof(buf));
265 if (buf[0]) {
266 sscanf(buf, "%d", &debug_level);
267 }
268 sprintf(temp, "Debug level is now %d", debug_level);
269 ptext(temp);
270 *ch = REQUEST_PROMPT;
271}
272
273/*
274** start_tools(testlist, state, ch)
275**
276** Run the generic test tools
277*/
278static void
279start_tools(
280 struct test_list *t GCC_UNUSED,
281 int *state GCC_UNUSED,
282 int *ch GCC_UNUSED)
283{
284 if (hex_out) {
285 strcpy(hex_echo_menu_entry,
286 "h) disable hex output on echo tool");
287 } else {
288 strcpy(hex_echo_menu_entry,
289 "h) enable hex output on echo tool");
290 }
291 menu_display(&tools_menu, 0);
292}
293
294/*
295** tty_show_state()
296**
297** Display the current state on the tty driver settings
298*/
299static void
300tty_show_state(
301 struct test_menu *menu GCC_UNUSED)
302{
303 put_crlf();
304 (void) sprintf(temp,
305 "Accepting %d bits, UNIX delays %d, XON/XOFF %sabled, speed %u, translate %s, scan-code mode %s.",
306 (char_mask == ALLOW_PARITY) ? 8 : 7,
307 select_delay_type,
308 select_xon_xoff ? "en" : "dis",
309 tty_baud_rate,
310 translate_mode ? "on" : "off",
311 scan_mode ? "on" : "off");
312 ptextln(temp);
313 put_crlf();
314}
315
316/*
317** tty_width(testlist, state, ch)
318**
319** Change the character width
320*/
321static void
322tty_width(
323 struct test_list *t GCC_UNUSED,
324 int *state GCC_UNUSED,
325 int *ch GCC_UNUSED)
326{
327 if (char_mask == STRIP_PARITY) {
328 char_mask = ALLOW_PARITY;
329 strcpy(tty_width_menu, "7) treat terminal as 7-bit");
330 } else {
331 char_mask = STRIP_PARITY;
332 strcpy(tty_width_menu, "8) treat terminal as 8-bit");
333 }
334}
335
336/*
337** tty_delay(testlist, state, ch)
338**
339** Change the delay for <cr><lf> in the TTY driver
340*/
341static void
342tty_delay(
343 struct test_list *t GCC_UNUSED,
344 int *state GCC_UNUSED,
345 int *ch GCC_UNUSED)
346{
347 if (select_delay_type) {
348 select_delay_type = FALSE;
349 strcpy(tty_delay_menu,
350 "d) enable UNIX tty driver delays for <cr><lf>");
351 } else {
352 select_delay_type = TRUE;
353 strcpy(tty_delay_menu,
354 "d) disable UNIX tty driver delays for <cr><lf>");
355 }
356}
357
358/*
359** tty_xon(testlist, state, ch)
360**
361** Change the XON/XOFF flags in the TTY driver
362*/
363static void
364tty_xon(
365 struct test_list *t GCC_UNUSED,
366 int *state GCC_UNUSED,
367 int *ch GCC_UNUSED)
368{
369 if (select_xon_xoff) {
370 if (needs_xon_xoff) {
371 ptextln("This terminal is marked as needing XON/XOFF protocol with (nxon)");
372 }
373 if (exit_xon_mode) {
374 tc_putp(exit_xon_mode);
375 }
376 xon_xoff = select_xon_xoff = FALSE;
377 strcpy(tty_xon_menu, enable_xon_xoff);
378 } else {
379 if (enter_xon_mode) {
380 tc_putp(enter_xon_mode);
381 }
382 xon_xoff = select_xon_xoff = TRUE;
383 strcpy(tty_xon_menu, disable_xon_xoff);
384 }
385 tty_set();
386}
387
388/*
389** tty_trans(testlist, state, ch)
390**
391** Change the translation mode for special characters
392*/
393static void
394tty_trans(
395 struct test_list *t GCC_UNUSED,
396 int *state GCC_UNUSED,
397 int *ch GCC_UNUSED)
398{
399 if (translate_mode) {
400 translate_mode = FALSE;
401 strcpy(tty_trans_menu,
402 "t) use terminfo values for \\b\\f\\n\\r\\t");
403 } else {
404 translate_mode = TRUE;
405 strcpy(tty_trans_menu,
406 "t) override terminfo values for \\b\\f\\n\\r\\t");
407 }
408}
409
410/*
411** pad_gen(testlist, state, ch)
412**
413** Menu function for automatic pad generation
414*/
415static void
416pad_gen(
417 struct test_list *t,
418 int *state GCC_UNUSED,
419 int *ch)
420{
421 control_init();
422 if (tty_can_sync == SYNC_NOT_TESTED) {
423 verify_time();
424 }
425 auto_pad_mode = TRUE;
426 menu_display(t->sub_menu, ch);
427 auto_pad_mode = FALSE;
428}
429
430/*
431** start_modes(testlist, state, ch)
432**
433** Change the TTY modes
434*/
435static void
436start_modes(
437 struct test_list *t GCC_UNUSED,
438 int *state GCC_UNUSED,
439 int *ch GCC_UNUSED)
440{
441
442 if (select_delay_type) {
443 strcpy(tty_delay_menu,
444 "d) disable UNIX tty driver delays for <cr><lf>");
445 } else {
446 strcpy(tty_delay_menu,
447 "d) enable UNIX tty driver delays for <cr><lf>");
448 }
449 if (char_mask == ALLOW_PARITY) {
450 strcpy(tty_width_menu,
451 "7) treat terminal as 7-bit");
452 } else {
453 strcpy(tty_width_menu,
454 "8) treat terminal as 8-bit");
455 }
456 if (select_xon_xoff) {
457 strcpy(tty_xon_menu, disable_xon_xoff);
458 } else {
459 strcpy(tty_xon_menu, enable_xon_xoff);
460 }
461 if (translate_mode) {
462 strcpy(tty_trans_menu,
463 "t) override terminfo values for \\b\\f\\n\\r\\t");
464 } else {
465 strcpy(tty_trans_menu,
466 "t) use terminfo values for \\b\\f\\n\\r\\t");
467 }
468 menu_display(&tty_menu, 0);
469 tty_set();
470}
471
472/*
473** start_basic(testlist, state, ch)
474**
475** Display basic terminal information
476*/
477static void
478start_basic(
479 struct test_list *t GCC_UNUSED,
480 int *state GCC_UNUSED,
481 int *ch)
482{
483 display_basic();
484 *ch = REQUEST_PROMPT;
485}
486
487/*
488** start_log(testlist, state, ch)
489**
490** Start/stop in logging function
491*/
492static void
493start_log(
494 struct test_list *t GCC_UNUSED,
495 int *state GCC_UNUSED,
496 int *ch GCC_UNUSED)
497{
498 if (logging_menu_entry[5] == 'a') {
499 ptextln("The log file will capture all characters sent to the terminal.");
500 if ((log_fp = fopen("tack.log", "w"))) {
501 ptextln("Start logging to file: tack.log");
502 strcpy(logging_menu_entry, "l) stop logging");
503 } else {
504 ptextln("File open error: tack.log");
505 }
506 } else {
507 if (log_fp) {
508 fclose(log_fp);
509 log_fp = 0;
510 }
511 ptextln("Terminal output logging stopped.");
512 strcpy(logging_menu_entry, "l) start logging");
513 }
514}
515
516/*
517** show_usage()
518**
519** Tell the user how its done.
520*/
521void
522show_usage(
523 char *name)
524{
525 (void) fprintf(stderr, "usage: %s [-itV] [term]\n", name);
526}
527
528/*
529** print_version()
530**
531** Print version and other useful information.
532*/
533void
534print_version(void)
535{
536 printf("tack version %d.%02d\n", MAJOR_VERSION, MINOR_VERSION);
537 printf("Copyright (C) 1997 Free Software Foundation, Inc.\n");
538 printf("Tack comes with NO WARRANTY, to the extent permitted by law.\n");
539 printf("You may redistribute copies of Tack under the terms of the\n");
540 printf("GNU General Public License. For more information about\n");
541 printf("these matters, see the file named COPYING.\n");
542}
543
544
545/*****************************************************************************
546 *
547 * Main sequence
548 *
549 *****************************************************************************/
550
551int
552main(int argc, char *argv[])
553{
554 int i, j;
555 char *term_variable;
556
557 /* scan the option flags */
558 send_reset_init = TRUE;
559 translate_mode = FALSE;
560 term_variable = getenv("TERM");
561 tty_can_sync = SYNC_NOT_TESTED;
562 for (i = 1; i < argc; i++) {
563 if (argv[i][0] == '-') {
564 for (j = 1; argv[i][j]; j++) {
565 switch (argv[i][j]) {
566 case 'V':
567 print_version();
568 return (1);
569 case 'i':
570 send_reset_init = FALSE;
571 break;
572 case 't':
573 translate_mode = FALSE;
574 break;
575 default:
576 show_usage(argv[0]);
577 return (0);
578 }
579 }
580 } else {
581 term_variable = argv[i];
582 }
583 }
584 (void) strcpy(tty_basename, term_variable);
585
586 curses_setup(argv[0]);
587
588 menu_can_scan(&normal_menu); /* extract which caps can be tested */
589 menu_display(&start_menu, 0);
590
591 if (user_modified()) {
592 sprintf(temp, "Hit y to save changes to file: %s ? ",
593 tty_basename);
594 ptext(temp);
595 if (wait_here() == 'y') {
596 save_info(write_terminfo_list, &i, &j);
597 }
598 }
599
600 put_str("\nTerminal test complete\n");
601 bye_kids(0);
602 return (0);
603}
Note: See TracBrowser for help on using the repository browser.