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