contrib/ncurses/tack/edit.c

   1 /*
   2 ** Copyright (C) 1997 Free Software Foundation, Inc.
   3 **
   4 ** This file is part of TACK.
   5 **
   6 ** TACK is free software; you can redistribute it and/or modify
   7 ** it under the terms of the GNU General Public License as published by
   8 ** the Free Software Foundation; either version 2, or (at your option)
   9 ** any later version.
  10 **
  11 ** TACK is distributed in the hope that it will be useful,
  12 ** but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 ** GNU General Public License for more details.
  15 **
  16 ** You should have received a copy of the GNU General Public License
  17 ** along with TACK; see the file COPYING.  If not, write to
  18 ** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  19 ** Boston, MA 02111-1307, USA.
  20 */
  21
  22 #include <tack.h>
  23 #include <time.h>
  24 #include <tic.h>
  25
  26 MODULE_ID("$Id: edit.c,v 1.8 2001/06/18 18:44:32 tom Exp $")
  27
  28 /*
  29  * Terminfo edit features
  30  */
  31 static void show_info(struct test_list *, int *, int *);
  32 static void show_value(struct test_list *, int *, int *);
  33 static void show_untested(struct test_list *, int *, int *);
  34 static void show_changed(struct test_list *, int *, int *);
  35
  36 #define SHOW_VALUE      1
  37 #define SHOW_EDIT       2
  38 #define SHOW_DELETE     3
  39
  40 struct test_list edit_test_list[] = {
  41         {MENU_CLEAR, 0, 0, 0, "i) display current terminfo", show_info, 0},
  42         {0, 0, 0, 0, "w) write the current terminfo to a file", save_info, 0},
  43         {SHOW_VALUE, 3, 0, 0, "v) show value of a selected cap", show_value, 0},
  44         {SHOW_EDIT, 4, 0, 0, "e) edit value of a selected cap", show_value, 0},
  45         {SHOW_DELETE, 3, 0, 0, "d) delete string", show_value, 0},
  46         {0, 3, 0, 0, "m) show caps that have been modified", show_changed, 0},
  47         {MENU_CLEAR + FLAG_CAN_TEST, 0, 0, 0, "c) show caps that can be tested", show_report, 0},
  48         {MENU_CLEAR + FLAG_TESTED, 0, 0, 0, "t) show caps that have been tested", show_report, 0},
  49         {MENU_CLEAR + FLAG_FUNCTION_KEY, 0, 0, 0, "f) show a list of function keys", show_report, 0},
  50         {MENU_CLEAR, 0, 0, 0, "u) show caps defined that can not be tested", show_untested, 0},
  51         {MENU_LAST, 0, 0, 0, 0, 0, 0}
  52 };
  53
  54 static char change_pad_text[MAX_CHANGES][80];
  55 struct test_list change_pad_list[MAX_CHANGES] = {
  56         {MENU_LAST, 0, 0, 0, 0, 0, 0}
  57 };
  58
  59 static void build_change_menu(struct test_menu *);
  60 static void change_one_entry(struct test_list *, int *, int *);
  61
  62 struct test_menu change_pad_menu = {
  63         0, 'q', 0,
  64         "Select cap name", "change", 0,
  65         build_change_menu, change_pad_list, 0, 0, 0
  66 };
  67
  68 extern struct test_results *pads[STRCOUNT];     /* save pad results here */
  69
  70 static TERMTYPE original_term;          /* terminal type description */
  71
  72 static char flag_boolean[BOOLCOUNT];    /* flags for booleans */
  73 static char flag_numerics[NUMCOUNT];    /* flags for numerics */
  74 static char flag_strings[STRCOUNT];     /* flags for strings */
  75 static int xon_index;                   /* Subscript for (xon) */
  76 int xon_shadow;
  77
  78 static int start_display;               /* the display has just started */
  79 static int display_lines;               /* number of lines displayed */
  80
  81 /*
  82 **      send_info_string(str)
  83 **
  84 **      Return the terminfo string prefixed by the correct separator
  85 */
  86 static void
  87 send_info_string(
  88         const char *str,
  89         int *ch)
  90 {
  91         int len;
  92
  93         if (display_lines == -1) {
  94                 return;
  95         }
  96         len = strlen(str);
  97         if (len + char_count + 3 >= columns) {
  98                 if (start_display == 0) {
  99                         put_str(",");
 100                 }
 101                 put_crlf();
 102                 if (++display_lines > lines) {
 103                         ptext("-- more -- ");
 104                         *ch = wait_here();
 105                         if (*ch == 'q') {
 106                                 display_lines = -1;
 107                                 return;
 108                         }
 109                         display_lines = 0;
 110                 }
 111                 if (len >= columns) {
 112                         /* if the terminal does not (am) then this loses */
 113                         if (columns) {
 114                                 display_lines += ((strlen(str) + 3) / columns) + 1;
 115                         }
 116                         put_str("   ");
 117                         put_str(str);
 118                         start_display = 0;
 119                         return;
 120                 }
 121                 ptext("   ");
 122         } else
 123         if (start_display == 0) {
 124                 ptext(", ");
 125         } else {
 126                 ptext("   ");
 127         }
 128         ptext(str);
 129         start_display = 0;
 130 }
 131
 132 /*
 133 **      show_info(test_list, status, ch)
 134 **
 135 **      Display the current terminfo
 136 */
 137 static void
 138 show_info(
 139         struct test_list *t GCC_UNUSED,
 140         int *state GCC_UNUSED,
 141         int *ch)
 142 {
 143         int i;
 144         char buf[1024];
 145
 146         display_lines = 1;
 147         start_display = 1;
 148         for (i = 0; i < BOOLCOUNT; i++) {
 149                 if ((i == xon_index) ? xon_shadow : CUR Booleans[i]) {
 150                         send_info_string(boolnames[i], ch);
 151                 }
 152         }
 153         for (i = 0; i < NUMCOUNT; i++) {
 154                 if (CUR Numbers[i] >= 0) {
 155                         sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]);
 156                         send_info_string(buf, ch);
 157                 }
 158         }
 159         for (i = 0; i < STRCOUNT; i++) {
 160                 if (CUR Strings[i]) {
 161                         sprintf(buf, "%s=%s", strnames[i],
 162                                 print_expand(CUR Strings[i]));
 163                         send_info_string(buf, ch);
 164                 }
 165         }
 166         put_newlines(2);
 167         *ch = REQUEST_PROMPT;
 168 }
 169
 170 /*
 171 **      save_info_string(str, fp)
 172 **
 173 **      Write the terminfo string prefixed by the correct separator
 174 */
 175 static void
 176 save_info_string(
 177         const char *str,
 178         FILE *fp)
 179 {
 180         int len;
 181
 182         len = strlen(str);
 183         if (len + display_lines >= 77) {
 184                 if (display_lines > 0) {
 185                         (void) fprintf(fp, "\n\t");
 186                 }
 187                 display_lines = 8;
 188         } else
 189         if (display_lines > 0) {
 190                 (void) fprintf(fp, " ");
 191                 display_lines++;
 192         } else {
 193                 (void) fprintf(fp, "\t");
 194                 display_lines = 8;
 195         }
 196         (void) fprintf(fp, "%s,", str);
 197         display_lines += len + 1;
 198 }
 199
 200 /*
 201 **      save_info(test_list, status, ch)
 202 **
 203 **      Write the current terminfo to a file
 204 */
 205 void
 206 save_info(
 207         struct test_list *t,
 208         int *state,
 209         int *ch)
 210 {
 211         int i;
 212         FILE *fp;
 213         time_t now;
 214         char buf[1024];
 215
 216         if ((fp = fopen(tty_basename, "w")) == (FILE *) NULL) {
 217                 (void) sprintf(temp, "can't open: %s", tty_basename);
 218                 ptextln(temp);
 219                 generic_done_message(t, state, ch);
 220                 return;
 221         }
 222         time(&now);
 223         /* Note: ctime() returns a newline at the end of the string */
 224         (void) fprintf(fp, "# Terminfo created by TACK for TERM=%s on %s",
 225                 tty_basename, ctime(&now));
 226         (void) fprintf(fp, "%s|%s,\n", tty_basename, longname());
 227
 228         display_lines = 0;
 229         for (i = 0; i < BOOLCOUNT; i++) {
 230                 if (i == xon_index ? xon_shadow : CUR Booleans[i]) {
 231                         save_info_string(boolnames[i], fp);
 232                 }
 233         }
 234         for (i = 0; i < NUMCOUNT; i++) {
 235                 if (CUR Numbers[i] >= 0) {
 236                         sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]);
 237                         save_info_string(buf, fp);
 238                 }
 239         }
 240         for (i = 0; i < STRCOUNT; i++) {
 241                 if (CUR Strings[i]) {
 242                         sprintf(buf, "%s=%s", strnames[i],
 243                                 _nc_tic_expand(CUR Strings[i], TRUE, TRUE));
 244                         save_info_string(buf, fp);
 245                 }
 246         }
 247         (void) fprintf(fp, "\n");
 248         (void) fclose(fp);
 249         sprintf(temp, "Terminfo saved as file: %s", tty_basename);
 250         ptextln(temp);
 251 }
 252
 253 /*
 254 **      show_value(test_list, status, ch)
 255 **
 256 **      Display the value of a selected cap
 257 */
 258 static void
 259 show_value(
 260         struct test_list *t,
 261         int *state GCC_UNUSED,
 262         int *ch)
 263 {
 264         struct name_table_entry const *nt;
 265         char *s;
 266         int n, op, b;
 267         char buf[1024];
 268         char tmp[1024];
 269
 270         ptext("enter name: ");
 271         read_string(buf, 80);
 272         if (buf[0] == '\0' || buf[1] == '\0') {
 273                 *ch = buf[0];
 274                 return;
 275         }
 276         if (line_count + 2 >= lines) {
 277                 put_clear();
 278         }
 279         op = t->flags & 255;
 280         if ((nt = _nc_find_entry(buf, _nc_info_hash_table))) {
 281                 switch (nt->nte_type) {
 282                 case BOOLEAN:
 283                         if (op == SHOW_DELETE) {
 284                                 if (nt->nte_index == xon_index) {
 285                                         xon_shadow = 0;
 286                                 } else {
 287                                         CUR Booleans[nt->nte_index] = 0;
 288                                 }
 289                                 return;
 290                         }
 291                         b = nt->nte_index == xon_index ? xon_shadow :
 292                                 CUR Booleans[nt->nte_index];
 293                         sprintf(temp, "boolean  %s %s", buf,
 294                                 b ? "True" : "False");
 295                         break;
 296                 case STRING:
 297                         if (op == SHOW_DELETE) {
 298                                 CUR Strings[nt->nte_index] = (char *) 0;
 299                                 return;
 300                         }
 301                         if (CUR Strings[nt->nte_index]) {
 302                                 sprintf(temp, "string  %s %s", buf,
 303                                         expand(CUR Strings[nt->nte_index]));
 304                         } else {
 305                                 sprintf(temp, "undefined string %s", buf);
 306                         }
 307                         break;
 308                 case NUMBER:
 309                         if (op == SHOW_DELETE) {
 310                                 CUR Numbers[nt->nte_index] = -1;
 311                                 return;
 312                         }
 313                         sprintf(temp, "numeric  %s %d", buf,
 314                                 CUR Numbers[nt->nte_index]);
 315                         break;
 316                 default:
 317                         sprintf(temp, "unknown");
 318                         break;
 319                 }
 320                 ptextln(temp);
 321         } else {
 322                 sprintf(temp, "Cap not found: %s", buf);
 323                 ptextln(temp);
 324                 return;
 325         }
 326         if (op != SHOW_EDIT) {
 327                 return;
 328         }
 329         if (nt->nte_type == BOOLEAN) {
 330                 ptextln("Value flipped");
 331                 if (nt->nte_index == xon_index) {
 332                         xon_shadow = !xon_shadow;
 333                 } else {
 334                         CUR Booleans[nt->nte_index] = !CUR Booleans[nt->nte_index];
 335                 }
 336                 return;
 337         }
 338         ptextln("Enter new value");
 339         read_string(buf, sizeof(buf));
 340
 341         switch (nt->nte_type) {
 342         case STRING:
 343                 _nc_reset_input((FILE *) 0, buf);
 344                 _nc_trans_string(tmp, tmp + sizeof(tmp));
 345                 s = (char *)malloc(strlen(tmp) + 1);
 346                 strcpy(s, tmp);
 347                 CUR Strings[nt->nte_index] = s;
 348                 sprintf(temp, "new string value  %s", nt->nte_name);
 349                 ptextln(temp);
 350                 ptextln(expand(CUR Strings[nt->nte_index]));
 351                 break;
 352         case NUMBER:
 353                 if (sscanf(buf, "%d", &n) == 1) {
 354                         CUR Numbers[nt->nte_index] = n;
 355                         sprintf(temp, "new numeric value  %s %d",
 356                                 nt->nte_name, n);
 357                         ptextln(temp);
 358                 } else {
 359                         sprintf(temp, "Illegal number: %s", buf);
 360                         ptextln(temp);
 361                 }
 362                 break;
 363         default:
 364                 break;
 365         }
 366 }
 367
 368 /*
 369 **      get_string_cap_byname(name, long_name)
 370 **
 371 **      Given a cap name, find the value
 372 **      Errors are quietly ignored.
 373 */
 374 char *
 375 get_string_cap_byname(
 376         const char *name,
 377         const char **long_name)
 378 {
 379         struct name_table_entry const *nt;
 380
 381         if ((nt = _nc_find_entry(name, _nc_info_hash_table))) {
 382                 if (nt->nte_type == STRING) {
 383                         *long_name = strfnames[nt->nte_index];
 384                         return (CUR Strings[nt->nte_index]);
 385                 }
 386         }
 387         *long_name = "??";
 388         return (char *) 0;
 389 }
 390
 391 /*
 392 **      get_string_cap_byvalue(value)
 393 **
 394 **      Given a capability string, find its position in the data base.
 395 **      Return the index or -1 if not found.
 396 */
 397 int
 398 get_string_cap_byvalue(
 399         const char *value)
 400 {
 401         int i;
 402
 403         if (value) {
 404                 for (i = 0; i < STRCOUNT; i++) {
 405                         if (CUR Strings[i] == value) {
 406                                 return i;
 407                         }
 408                 }
 409                 /* search for translated strings */
 410                 for (i = 0; i < TM_last; i++) {
 411                         if (TM_string[i].value == value) {
 412                                 return TM_string[i].index;
 413                         }
 414                 }
 415         }
 416         return -1;
 417 }
 418
 419 /*
 420 **      show_changed(test_list, status, ch)
 421 **
 422 **      Display a list of caps that have been changed.
 423 */
 424 static void
 425 show_changed(
 426         struct test_list *t GCC_UNUSED,
 427         int *state GCC_UNUSED,
 428         int *ch)
 429 {
 430         int i, header = 1, v;
 431         const char *a;
 432         const char *b;
 433         static char title[] = "                     old value   cap  new value";
 434         char abuf[1024];
 435
 436         for (i = 0; i < BOOLCOUNT; i++) {
 437                 v = (i == xon_index) ? xon_shadow : CUR Booleans[i];
 438                 if (original_term.Booleans[i] != v) {
 439                         if (header) {
 440                                 ptextln(title);
 441                                 header = 0;
 442                         }
 443                         sprintf(temp, "%30d %6s %d",
 444                                 original_term.Booleans[i], boolnames[i], v);
 445                         ptextln(temp);
 446                 }
 447         }
 448         for (i = 0; i < NUMCOUNT; i++) {
 449                 if (original_term.Numbers[i] != CUR Numbers[i]) {
 450                         if (header) {
 451                                 ptextln(title);
 452                                 header = 0;
 453                         }
 454                         sprintf(temp, "%30d %6s %d",
 455                                 original_term.Numbers[i], numnames[i],
 456                                 CUR Numbers[i]);
 457                         ptextln(temp);
 458                 }
 459         }
 460         for (i = 0; i < STRCOUNT; i++) {
 461                 a = original_term.Strings[i] ? original_term.Strings[i] : "";
 462                 b = CUR Strings[i] ?  CUR Strings[i] : "";
 463                 if (strcmp(a, b)) {
 464                         if (header) {
 465                                 ptextln(title);
 466                                 header = 0;
 467                         }
 468                         strcpy(abuf, _nc_tic_expand(a, TRUE, TRUE));
 469                         sprintf(temp, "%30s %6s %s", abuf, strnames[i],
 470                                 _nc_tic_expand(b, TRUE, TRUE));
 471                         putln(temp);
 472                 }
 473         }
 474         if (header) {
 475                 ptextln("No changes");
 476         }
 477         put_crlf();
 478         *ch = REQUEST_PROMPT;
 479 }
 480
 481 /*
 482 **      user_modified()
 483 **
 484 **      Return TRUE if the user has modified the terminfo
 485 */
 486 int
 487 user_modified(void)
 488 {
 489         const char *a, *b;
 490         int i, v;
 491
 492         for (i = 0; i < BOOLCOUNT; i++) {
 493                 v = (i == xon_index) ? xon_shadow : CUR Booleans[i];
 494                 if (original_term.Booleans[i] != v) {
 495                         return TRUE;
 496                 }
 497         }
 498         for (i = 0; i < NUMCOUNT; i++) {
 499                 if (original_term.Numbers[i] != CUR Numbers[i]) {
 500                         return TRUE;
 501                 }
 502         }
 503         for (i = 0; i < STRCOUNT; i++) {
 504                 a = original_term.Strings[i] ? original_term.Strings[i] : "";
 505                 b = CUR Strings[i] ?  CUR Strings[i] : "";
 506                 if (strcmp(a, b)) {
 507                         return TRUE;
 508                 }
 509         }
 510         return FALSE;
 511 }
 512
 513 /*****************************************************************************
 514  *
 515  * Maintain the list of capabilities that can be tested
 516  *
 517  *****************************************************************************/
 518
 519 /*
 520 **      mark_cap(name, flag)
 521 **
 522 **      Mark the cap data base with the flag provided.
 523 */
 524 static void
 525 mark_cap(
 526         char *name,
 527         int flag)
 528 {
 529         struct name_table_entry const *nt;
 530
 531         if ((nt = _nc_find_entry(name, _nc_info_hash_table))) {
 532                 switch (nt->nte_type) {
 533                 case BOOLEAN:
 534                         flag_boolean[nt->nte_index] |= flag;
 535                         break;
 536                 case STRING:
 537                         flag_strings[nt->nte_index] |= flag;
 538                         break;
 539                 case NUMBER:
 540                         flag_numerics[nt->nte_index] |= flag;
 541                         break;
 542                 default:
 543                         sprintf(temp, "unknown cap type (%s)", name);
 544                         ptextln(temp);
 545                         break;
 546                 }
 547         } else {
 548                 sprintf(temp, "Cap not found: %s", name);
 549                 ptextln(temp);
 550                 (void) wait_here();
 551         }
 552 }
 553
 554 /*
 555 **      can_test(name-list, flags)
 556 **
 557 **      Scan the name list and get the names.
 558 **      Enter each name into the can-test data base.
 559 **      <space> ( and ) may be used as separators.
 560 */
 561 void
 562 can_test(
 563         const char *s,
 564         int flags)
 565 {
 566         int ch, j;
 567         char name[32];
 568
 569         if (s) {
 570                 for (j = 0; (name[j] = ch = *s); s++) {
 571                         if (ch == ' ' || ch == ')' || ch == '(') {
 572                                 if (j) {
 573                                         name[j] = '\0';
 574                                         mark_cap(name, flags);
 575                                 }
 576                                 j = 0;
 577                         } else {
 578                                 j++;
 579                         }
 580                 }
 581                 if (j) {
 582                         mark_cap(name, flags);
 583                 }
 584         }
 585 }
 586
 587 /*
 588 **      cap_index(name-list, index-list)
 589 **
 590 **      Scan the name list and return a list of indexes.
 591 **      <space> ( and ) may be used as separators.
 592 **      This list is terminated with -1.
 593 */
 594 void
 595 cap_index(
 596         const char *s,
 597         int *inx)
 598 {
 599         struct name_table_entry const *nt;
 600         int ch, j;
 601         char name[32];
 602
 603         if (s) {
 604                 for (j = 0; ; s++) {
 605                         name[j] = ch = *s;
 606                         if (ch == ' ' || ch == ')' || ch == '(' || ch == 0) {
 607                                 if (j) {
 608                                         name[j] = '\0';
 609                                         if ((nt = _nc_find_entry(name,
 610                                                 _nc_info_hash_table)) &&
 611                                                 (nt->nte_type == STRING)) {
 612                                                 *inx++ = nt->nte_index;
 613                                         }
 614                                 }
 615                                 if (ch == 0) {
 616                                         break;
 617                                 }
 618                                 j = 0;
 619                         } else {
 620                                 j++;
 621                         }
 622                 }
 623         }
 624         *inx = -1;
 625 }
 626
 627 /*
 628 **      cap_match(name-list, cap)
 629 **
 630 **      Scan the name list and see if the cap is in the list.
 631 **      Return TRUE if we find an exact match.
 632 **      <space> ( and ) may be used as separators.
 633 */
 634 int
 635 cap_match(
 636         const char *names,
 637         const char *cap)
 638 {
 639         char *s;
 640         int c, l, t;
 641
 642         if (names) {
 643                 l = strlen(cap);
 644                 while ((s = strstr(names, cap))) {
 645                         c = (names == s) ? 0 : *(s - 1);
 646                         t = s[l];
 647                         if ((c == 0 || c == ' ' || c == '(') &&
 648                                 (t == 0 || t == ' ' || t == ')')) {
 649                                 return TRUE;
 650                         }
 651                         if (t == 0) {
 652                                 break;
 653                         }
 654                         names = s + l;
 655                 }
 656         }
 657         return FALSE;
 658 }
 659
 660 /*
 661 **      show_report(test_list, status, ch)
 662 **
 663 **      Display a list of caps that can be tested
 664 */
 665 void
 666 show_report(
 667         struct test_list *t,
 668         int *state GCC_UNUSED,
 669         int *ch)
 670 {
 671         int i, j, nc, flag;
 672         const char *s;
 673         const char *nx[BOOLCOUNT + NUMCOUNT + STRCOUNT];
 674
 675         flag = t->flags & 255;
 676         nc = 0;
 677         for (i = 0; i < BOOLCOUNT; i++) {
 678                 if (flag_boolean[i] & flag) {
 679                         nx[nc++] = boolnames[i];
 680                 }
 681         }
 682         for (i = 0; i < NUMCOUNT; i++) {
 683                 if (flag_numerics[i] & flag) {
 684                         nx[nc++] = numnames[i];
 685                 }
 686         }
 687         for (i = 0; i < STRCOUNT; i++) {
 688                 if (flag_strings[i] & flag) {
 689                         nx[nc++] = strnames[i];
 690                 }
 691         }
 692         /* sort */
 693         for (i = 0; i < nc - 1; i++) {
 694                 for (j = i + 1; j < nc; j++) {
 695                         if (strcmp(nx[i], nx[j]) > 0) {
 696                                 s = nx[i];
 697                                 nx[i] = nx[j];
 698                                 nx[j] = s;
 699                         }
 700                 }
 701         }
 702         if (flag & FLAG_FUNCTION_KEY) {
 703                 ptextln("The following function keys can be tested:");
 704         } else
 705         if (flag & FLAG_CAN_TEST) {
 706                 ptextln("The following capabilities can be tested:");
 707         } else
 708         if (flag & FLAG_TESTED) {
 709                 ptextln("The following capabilities have been tested:");
 710         }
 711         put_crlf();
 712         for (i = 0; i < nc; i++) {
 713                 sprintf(temp, "%s ", nx[i]);
 714                 ptext(temp);
 715         }
 716         put_newlines(1);
 717         *ch = REQUEST_PROMPT;
 718 }
 719
 720 /*
 721 **      show_untested(test_list, status, ch)
 722 **
 723 **      Display a list of caps that are defined but cannot be tested.
 724 **      Don't bother to sort this list.
 725 */
 726 static void
 727 show_untested(
 728         struct test_list *t GCC_UNUSED,
 729         int *state GCC_UNUSED,
 730         int *ch)
 731 {
 732         int i;
 733
 734         ptextln("Caps that are defined but cannot be tested:");
 735         for (i = 0; i < BOOLCOUNT; i++) {
 736                 if (flag_boolean[i] == 0 && CUR Booleans[i]) {
 737                         sprintf(temp, "%s ", boolnames[i]);
 738                         ptext(temp);
 739                 }
 740         }
 741         for (i = 0; i < NUMCOUNT; i++) {
 742                 if (flag_numerics[i] == 0 && CUR Numbers[i] >= 0) {
 743                         sprintf(temp, "%s ", numnames[i]);
 744                         ptext(temp);
 745                 }
 746         }
 747         for (i = 0; i < STRCOUNT; i++) {
 748                 if (flag_strings[i] == 0 && CUR Strings[i]) {
 749                         sprintf(temp, "%s ", strnames[i]);
 750                         ptext(temp);
 751                 }
 752         }
 753         put_newlines(1);
 754         *ch = REQUEST_PROMPT;
 755 }
 756
 757 /*
 758 **      edit_init()
 759 **
 760 **      Initialize the function key data base
 761 */
 762 void
 763 edit_init(void)
 764 {
 765         int i, j, lc;
 766         char *lab;
 767         struct name_table_entry const *nt;
 768         int label_strings[STRCOUNT];
 769
 770         _nc_copy_termtype(&original_term, &cur_term->type);
 771         for (i = 0; i < BOOLCOUNT; i++) {
 772                 original_term.Booleans[i] = CUR Booleans[i];
 773         }
 774         for (i = 0; i < NUMCOUNT; i++) {
 775                 original_term.Numbers[i] = CUR Numbers[i];
 776         }
 777         /* scan for labels */
 778         for (i = lc = 0; i < STRCOUNT; i++) {
 779                 original_term.Strings[i] = CUR Strings[i];
 780                 if (strncmp(strnames[i], "lf", 2) == 0) {
 781                         flag_strings[i] |= FLAG_LABEL;
 782                         if (CUR Strings[i]) {
 783                                 label_strings[lc++] = i;
 784                         }
 785                 }
 786         }
 787         /* scan for function keys */
 788         for (i = 0; i < STRCOUNT; i++) {
 789                 if ((strnames[i][0] == 'k') && strcmp(strnames[i], "kmous")) {
 790                         flag_strings[i] |= FLAG_FUNCTION_KEY;
 791                         lab = (char *) 0;
 792                         for (j = 0; j < lc; j++) {
 793                                 if (!strcmp(&strnames[i][1],
 794                                         &strnames[label_strings[j]][1])) {
 795                                         lab = CUR Strings[label_strings[j]];
 796                                         break;
 797                                 }
 798                         }
 799                         enter_key(strnames[i], CUR Strings[i], lab);
 800                 }
 801         }
 802         /* Lookup the translated strings */
 803         for (i = 0; i < TM_last; i++) {
 804                 if ((nt = _nc_find_entry(TM_string[i].name,
 805                         _nc_info_hash_table)) && (nt->nte_type == STRING)) {
 806                         TM_string[i].index = nt->nte_index;
 807                 } else {
 808                         sprintf(temp, "TM_string lookup failed for: %s",
 809                                 TM_string[i].name);
 810                         ptextln(temp);
 811                 }
 812         }
 813         if ((nt = _nc_find_entry("xon", _nc_info_hash_table)) != 0) {
 814                 xon_index = nt->nte_index;
 815         }
 816         xon_shadow = xon_xoff;
 817 }
 818
 819 /*
 820 **      change_one_entry(test_list, status, ch)
 821 **
 822 **      Change the padding on the selected cap
 823 */
 824 static void
 825 change_one_entry(
 826         struct test_list *test,
 827         int *state,
 828         int *chp)
 829 {
 830         struct name_table_entry const *nt;
 831         int i, j, x, star, slash,  v, dot, ch;
 832         const char *s;
 833         char *t, *p;
 834         const char *current_string;
 835         char buf[1024];
 836         char pad[1024];
 837
 838         i = test->flags & 255;
 839         if (i == 255) {
 840                 /* read the cap name from the user */
 841                 ptext("enter name: ");
 842                 read_string(pad, 32);
 843                 if (pad[0] == '\0' || pad[1] == '\0') {
 844                         *chp = pad[0];
 845                         return;
 846                 }
 847                 if ((nt = _nc_find_entry(pad, _nc_info_hash_table)) &&
 848                         (nt->nte_type == STRING)) {
 849                         x = nt->nte_index;
 850                         current_string = CUR Strings[x];
 851                 } else {
 852                         sprintf(temp, "%s is not a string capability", pad);
 853                         ptext(temp);
 854                         generic_done_message(test, state, chp);
 855                         return;
 856                 }
 857         } else {
 858                 x = tx_index[i];
 859                 current_string = tx_cap[i];
 860                 strcpy(pad, strnames[x]);
 861         }
 862         if (!current_string) {
 863                 ptextln("That string is not currently defined.  Please enter a new value, including the padding delay:");
 864                 read_string(buf, sizeof(buf));
 865                 _nc_reset_input((FILE *) 0, buf);
 866                 _nc_trans_string(pad, pad + sizeof(pad));
 867                 t = (char *)malloc(strlen(pad) + 1);
 868                 strcpy(t, pad);
 869                 CUR Strings[x] = t;
 870                 sprintf(temp, "new string value  %s", strnames[x]);
 871                 ptextln(temp);
 872                 ptextln(expand(t));
 873                 return;
 874         }
 875         sprintf(buf, "Current value: (%s) %s", pad, _nc_tic_expand(current_string, TRUE, TRUE));
 876         putln(buf);
 877         ptextln("Enter new pad.  0 for no pad.  CR for no change.");
 878         read_string(buf, 32);
 879         if (buf[0] == '\0' || (buf[1] == '\0' && isalpha(UChar(buf[0])))) {
 880                 *chp = buf[0];
 881                 return;
 882         }
 883         star = slash = FALSE;
 884         for (j = v = dot = 0; (ch = buf[j]); j++) {
 885                 if (ch >= '0' && ch <= '9') {
 886                         v = ch - '0' + v * 10;
 887                         if (dot) {
 888                                 dot++;
 889                         }
 890                 } else if (ch == '*') {
 891                         star = TRUE;
 892                 } else if (ch == '/') {
 893                         slash = TRUE;
 894                 } else if (ch == '.') {
 895                         dot = 1;
 896                 } else {
 897                         sprintf(temp, "Illegal character: %c", ch);
 898                         ptextln(temp);
 899                         ptext("General format:  99.9*/  ");
 900                         generic_done_message(test, state, chp);
 901                         return;
 902                 }
 903         }
 904         while (dot > 2) {
 905                 v /= 10;
 906                 dot--;
 907         }
 908         if (dot == 2) {
 909                 sprintf(pad, "%d.%d%s%s", v / 10, v % 10,
 910                                 star ? "*" : "", slash ? "/" : "");
 911         } else {
 912                 sprintf(pad, "%d%s%s",
 913                         v, star ? "*" : "", slash ? "/" : "");
 914         }
 915         s = current_string;
 916         t = buf;
 917         for (v = 0; (ch = *t = *s++); t++) {
 918                 if (v == '$' && ch == '<') {
 919                         while ((ch = *s++) && (ch != '>'));
 920                         for (p = pad; (*++t = *p++); );
 921                         *t++ = '>';
 922                         while ((*t++ = *s++));
 923                         pad[0] = '\0';
 924                         break;
 925                 }
 926                 v = ch;
 927         }
 928         if (pad[0]) {
 929                 sprintf(t, "$<%s>", pad);
 930         }
 931         if ((t = (char *)malloc(strlen(buf) + 1))) {
 932                 strcpy(t, buf);
 933                 CUR Strings[x] = t;
 934                 if (i != 255) {
 935                         tx_cap[i] = t;
 936                 }
 937         }
 938         generic_done_message(test, state, chp);
 939 }
 940
 941 /*
 942 **      build_change_menu(menu_list)
 943 **
 944 **      Build the change pad menu list
 945 */
 946 static void
 947 build_change_menu(
 948         struct test_menu *m)
 949 {
 950         int i, j, k;
 951         char *s;
 952
 953         for (i = j = 0; i < txp; i++) {
 954                 if ((k = tx_index[i]) >= 0) {
 955                         s = _nc_tic_expand(tx_cap[i], TRUE, TRUE);
 956                         s[40] = '\0';
 957                         sprintf(change_pad_text[j], "%c) (%s) %s",
 958                                 'a' + j, strnames[k], s);
 959                         change_pad_list[j].flags = i;
 960                         change_pad_list[j].lines_needed = 4;
 961                         change_pad_list[j].menu_entry = change_pad_text[j];
 962                         change_pad_list[j].test_procedure = change_one_entry;
 963                         j++;
 964                 }
 965         }
 966         strcpy(change_pad_text[j], "z) enter name");
 967         change_pad_list[j].flags = 255;
 968         change_pad_list[j].lines_needed = 4;
 969         change_pad_list[j].menu_entry = change_pad_text[j];
 970         change_pad_list[j].test_procedure = change_one_entry;
 971         j++;
 972         change_pad_list[j].flags = MENU_LAST;
 973         if (m->menu_title) {
 974                 put_crlf();
 975                 ptextln(m->menu_title);
 976         }
 977 }