978 lines
21 KiB
C
978 lines
21 KiB
C
/*
|
|
** Copyright (C) 1997 Free Software Foundation, Inc.
|
|
**
|
|
** This file is part of TACK.
|
|
**
|
|
** TACK is free software; you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation; either version 2, or (at your option)
|
|
** any later version.
|
|
**
|
|
** TACK is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with TACK; see the file COPYING. If not, write to
|
|
** the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
** Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
#include <tack.h>
|
|
#include <time.h>
|
|
#include <tic.h>
|
|
|
|
MODULE_ID("$Id: edit.c,v 1.7 2001/02/24 22:10:40 tom Exp $")
|
|
|
|
/*
|
|
* Terminfo edit features
|
|
*/
|
|
static void show_info(struct test_list *, int *, int *);
|
|
static void show_value(struct test_list *, int *, int *);
|
|
static void show_untested(struct test_list *, int *, int *);
|
|
static void show_changed(struct test_list *, int *, int *);
|
|
|
|
#define SHOW_VALUE 1
|
|
#define SHOW_EDIT 2
|
|
#define SHOW_DELETE 3
|
|
|
|
struct test_list edit_test_list[] = {
|
|
{MENU_CLEAR, 0, 0, 0, "i) display current terminfo", show_info, 0},
|
|
{0, 0, 0, 0, "w) write the current terminfo to a file", save_info, 0},
|
|
{SHOW_VALUE, 3, 0, 0, "v) show value of a selected cap", show_value, 0},
|
|
{SHOW_EDIT, 4, 0, 0, "e) edit value of a selected cap", show_value, 0},
|
|
{SHOW_DELETE, 3, 0, 0, "d) delete string", show_value, 0},
|
|
{0, 3, 0, 0, "m) show caps that have been modified", show_changed, 0},
|
|
{MENU_CLEAR + FLAG_CAN_TEST, 0, 0, 0, "c) show caps that can be tested", show_report, 0},
|
|
{MENU_CLEAR + FLAG_TESTED, 0, 0, 0, "t) show caps that have been tested", show_report, 0},
|
|
{MENU_CLEAR + FLAG_FUNCTION_KEY, 0, 0, 0, "f) show a list of function keys", show_report, 0},
|
|
{MENU_CLEAR, 0, 0, 0, "u) show caps defined that can not be tested", show_untested, 0},
|
|
{MENU_LAST, 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
static char change_pad_text[MAX_CHANGES][80];
|
|
struct test_list change_pad_list[MAX_CHANGES] = {
|
|
{MENU_LAST, 0, 0, 0, 0, 0, 0}
|
|
};
|
|
|
|
static void build_change_menu(struct test_menu *);
|
|
static void change_one_entry(struct test_list *, int *, int *);
|
|
|
|
struct test_menu change_pad_menu = {
|
|
0, 'q', 0,
|
|
"Select cap name", "change", 0,
|
|
build_change_menu, change_pad_list, 0, 0, 0
|
|
};
|
|
|
|
extern struct test_results *pads[STRCOUNT]; /* save pad results here */
|
|
|
|
static TERMTYPE original_term; /* terminal type description */
|
|
|
|
static char flag_boolean[BOOLCOUNT]; /* flags for booleans */
|
|
static char flag_numerics[NUMCOUNT]; /* flags for numerics */
|
|
static char flag_strings[STRCOUNT]; /* flags for strings */
|
|
static int xon_index; /* Subscript for (xon) */
|
|
int xon_shadow;
|
|
|
|
static int start_display; /* the display has just started */
|
|
static int display_lines; /* number of lines displayed */
|
|
|
|
/*
|
|
** send_info_string(str)
|
|
**
|
|
** Return the terminfo string prefixed by the correct separator
|
|
*/
|
|
static void
|
|
send_info_string(
|
|
const char *str,
|
|
int *ch)
|
|
{
|
|
int len;
|
|
|
|
if (display_lines == -1) {
|
|
return;
|
|
}
|
|
len = strlen(str);
|
|
if (len + char_count + 3 >= columns) {
|
|
if (start_display == 0) {
|
|
put_str(",");
|
|
}
|
|
put_crlf();
|
|
if (++display_lines > lines) {
|
|
ptext("-- more -- ");
|
|
*ch = wait_here();
|
|
if (*ch == 'q') {
|
|
display_lines = -1;
|
|
return;
|
|
}
|
|
display_lines = 0;
|
|
}
|
|
if (len >= columns) {
|
|
/* if the terminal does not (am) then this loses */
|
|
if (columns) {
|
|
display_lines += ((strlen(str) + 3) / columns) + 1;
|
|
}
|
|
put_str(" ");
|
|
put_str(str);
|
|
start_display = 0;
|
|
return;
|
|
}
|
|
ptext(" ");
|
|
} else
|
|
if (start_display == 0) {
|
|
ptext(", ");
|
|
} else {
|
|
ptext(" ");
|
|
}
|
|
ptext(str);
|
|
start_display = 0;
|
|
}
|
|
|
|
/*
|
|
** show_info(test_list, status, ch)
|
|
**
|
|
** Display the current terminfo
|
|
*/
|
|
static void
|
|
show_info(
|
|
struct test_list *t GCC_UNUSED,
|
|
int *state GCC_UNUSED,
|
|
int *ch)
|
|
{
|
|
int i;
|
|
char buf[1024];
|
|
|
|
display_lines = 1;
|
|
start_display = 1;
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
if ((i == xon_index) ? xon_shadow : CUR Booleans[i]) {
|
|
send_info_string(boolnames[i], ch);
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (CUR Numbers[i] >= 0) {
|
|
sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]);
|
|
send_info_string(buf, ch);
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if (CUR Strings[i]) {
|
|
sprintf(buf, "%s=%s", strnames[i],
|
|
print_expand(CUR Strings[i]));
|
|
send_info_string(buf, ch);
|
|
}
|
|
}
|
|
put_newlines(2);
|
|
*ch = REQUEST_PROMPT;
|
|
}
|
|
|
|
/*
|
|
** save_info_string(str, fp)
|
|
**
|
|
** Write the terminfo string prefixed by the correct separator
|
|
*/
|
|
static void
|
|
save_info_string(
|
|
const char *str,
|
|
FILE *fp)
|
|
{
|
|
int len;
|
|
|
|
len = strlen(str);
|
|
if (len + display_lines >= 77) {
|
|
if (display_lines > 0) {
|
|
(void) fprintf(fp, "\n\t");
|
|
}
|
|
display_lines = 8;
|
|
} else
|
|
if (display_lines > 0) {
|
|
(void) fprintf(fp, " ");
|
|
display_lines++;
|
|
} else {
|
|
(void) fprintf(fp, "\t");
|
|
display_lines = 8;
|
|
}
|
|
(void) fprintf(fp, "%s,", str);
|
|
display_lines += len + 1;
|
|
}
|
|
|
|
/*
|
|
** save_info(test_list, status, ch)
|
|
**
|
|
** Write the current terminfo to a file
|
|
*/
|
|
void
|
|
save_info(
|
|
struct test_list *t,
|
|
int *state,
|
|
int *ch)
|
|
{
|
|
int i;
|
|
FILE *fp;
|
|
time_t now;
|
|
char buf[1024];
|
|
|
|
if ((fp = fopen(tty_basename, "w")) == (FILE *) NULL) {
|
|
(void) sprintf(temp, "can't open: %s", tty_basename);
|
|
ptextln(temp);
|
|
generic_done_message(t, state, ch);
|
|
return;
|
|
}
|
|
time(&now);
|
|
/* Note: ctime() returns a newline at the end of the string */
|
|
(void) fprintf(fp, "# Terminfo created by TACK for TERM=%s on %s",
|
|
tty_basename, ctime(&now));
|
|
(void) fprintf(fp, "%s|%s,\n", tty_basename, longname());
|
|
|
|
display_lines = 0;
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
if (i == xon_index ? xon_shadow : CUR Booleans[i]) {
|
|
save_info_string(boolnames[i], fp);
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (CUR Numbers[i] >= 0) {
|
|
sprintf(buf, "%s#%d", numnames[i], CUR Numbers[i]);
|
|
save_info_string(buf, fp);
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if (CUR Strings[i]) {
|
|
sprintf(buf, "%s=%s", strnames[i],
|
|
_nc_tic_expand(CUR Strings[i], TRUE, TRUE));
|
|
save_info_string(buf, fp);
|
|
}
|
|
}
|
|
(void) fprintf(fp, "\n");
|
|
(void) fclose(fp);
|
|
sprintf(temp, "Terminfo saved as file: %s", tty_basename);
|
|
ptextln(temp);
|
|
}
|
|
|
|
/*
|
|
** show_value(test_list, status, ch)
|
|
**
|
|
** Display the value of a selected cap
|
|
*/
|
|
static void
|
|
show_value(
|
|
struct test_list *t,
|
|
int *state GCC_UNUSED,
|
|
int *ch)
|
|
{
|
|
struct name_table_entry const *nt;
|
|
char *s;
|
|
int n, op, b;
|
|
char buf[1024];
|
|
char tmp[1024];
|
|
|
|
ptext("enter name: ");
|
|
read_string(buf, 80);
|
|
if (buf[0] == '\0' || buf[1] == '\0') {
|
|
*ch = buf[0];
|
|
return;
|
|
}
|
|
if (line_count + 2 >= lines) {
|
|
put_clear();
|
|
}
|
|
op = t->flags & 255;
|
|
if ((nt = _nc_find_entry(buf, _nc_info_hash_table))) {
|
|
switch (nt->nte_type) {
|
|
case BOOLEAN:
|
|
if (op == SHOW_DELETE) {
|
|
if (nt->nte_index == xon_index) {
|
|
xon_shadow = 0;
|
|
} else {
|
|
CUR Booleans[nt->nte_index] = 0;
|
|
}
|
|
return;
|
|
}
|
|
b = nt->nte_index == xon_index ? xon_shadow :
|
|
CUR Booleans[nt->nte_index];
|
|
sprintf(temp, "boolean %s %s", buf,
|
|
b ? "True" : "False");
|
|
break;
|
|
case STRING:
|
|
if (op == SHOW_DELETE) {
|
|
CUR Strings[nt->nte_index] = (char *) 0;
|
|
return;
|
|
}
|
|
if (CUR Strings[nt->nte_index]) {
|
|
sprintf(temp, "string %s %s", buf,
|
|
expand(CUR Strings[nt->nte_index]));
|
|
} else {
|
|
sprintf(temp, "undefined string %s", buf);
|
|
}
|
|
break;
|
|
case NUMBER:
|
|
if (op == SHOW_DELETE) {
|
|
CUR Numbers[nt->nte_index] = -1;
|
|
return;
|
|
}
|
|
sprintf(temp, "numeric %s %d", buf,
|
|
CUR Numbers[nt->nte_index]);
|
|
break;
|
|
default:
|
|
sprintf(temp, "unknown");
|
|
break;
|
|
}
|
|
ptextln(temp);
|
|
} else {
|
|
sprintf(temp, "Cap not found: %s", buf);
|
|
ptextln(temp);
|
|
return;
|
|
}
|
|
if (op != SHOW_EDIT) {
|
|
return;
|
|
}
|
|
if (nt->nte_type == BOOLEAN) {
|
|
ptextln("Value flipped");
|
|
if (nt->nte_index == xon_index) {
|
|
xon_shadow = !xon_shadow;
|
|
} else {
|
|
CUR Booleans[nt->nte_index] = !CUR Booleans[nt->nte_index];
|
|
}
|
|
return;
|
|
}
|
|
ptextln("Enter new value");
|
|
read_string(buf, sizeof(buf));
|
|
|
|
switch (nt->nte_type) {
|
|
case STRING:
|
|
_nc_reset_input((FILE *) 0, buf);
|
|
_nc_trans_string(tmp, tmp + sizeof(tmp));
|
|
s = (char *)malloc(strlen(tmp) + 1);
|
|
strcpy(s, tmp);
|
|
CUR Strings[nt->nte_index] = s;
|
|
sprintf(temp, "new string value %s", nt->nte_name);
|
|
ptextln(temp);
|
|
ptextln(expand(CUR Strings[nt->nte_index]));
|
|
break;
|
|
case NUMBER:
|
|
if (sscanf(buf, "%d", &n) == 1) {
|
|
CUR Numbers[nt->nte_index] = n;
|
|
sprintf(temp, "new numeric value %s %d",
|
|
nt->nte_name, n);
|
|
ptextln(temp);
|
|
} else {
|
|
sprintf(temp, "Illegal number: %s", buf);
|
|
ptextln(temp);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
** get_string_cap_byname(name, long_name)
|
|
**
|
|
** Given a cap name, find the value
|
|
** Errors are quietly ignored.
|
|
*/
|
|
char *
|
|
get_string_cap_byname(
|
|
const char *name,
|
|
const char **long_name)
|
|
{
|
|
struct name_table_entry const *nt;
|
|
|
|
if ((nt = _nc_find_entry(name, _nc_info_hash_table))) {
|
|
if (nt->nte_type == STRING) {
|
|
*long_name = strfnames[nt->nte_index];
|
|
return (CUR Strings[nt->nte_index]);
|
|
}
|
|
}
|
|
*long_name = "??";
|
|
return (char *) 0;
|
|
}
|
|
|
|
/*
|
|
** get_string_cap_byvalue(value)
|
|
**
|
|
** Given a capability string, find its position in the data base.
|
|
** Return the index or -1 if not found.
|
|
*/
|
|
int
|
|
get_string_cap_byvalue(
|
|
const char *value)
|
|
{
|
|
int i;
|
|
|
|
if (value) {
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if (CUR Strings[i] == value) {
|
|
return i;
|
|
}
|
|
}
|
|
/* search for translated strings */
|
|
for (i = 0; i < TM_last; i++) {
|
|
if (TM_string[i].value == value) {
|
|
return TM_string[i].index;
|
|
}
|
|
}
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
/*
|
|
** show_changed(test_list, status, ch)
|
|
**
|
|
** Display a list of caps that have been changed.
|
|
*/
|
|
static void
|
|
show_changed(
|
|
struct test_list *t GCC_UNUSED,
|
|
int *state GCC_UNUSED,
|
|
int *ch)
|
|
{
|
|
int i, header = 1, v;
|
|
const char *a;
|
|
const char *b;
|
|
static char title[] = " old value cap new value";
|
|
char abuf[1024];
|
|
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
v = (i == xon_index) ? xon_shadow : CUR Booleans[i];
|
|
if (original_term.Booleans[i] != v) {
|
|
if (header) {
|
|
ptextln(title);
|
|
header = 0;
|
|
}
|
|
sprintf(temp, "%30d %6s %d",
|
|
original_term.Booleans[i], boolnames[i], v);
|
|
ptextln(temp);
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (original_term.Numbers[i] != CUR Numbers[i]) {
|
|
if (header) {
|
|
ptextln(title);
|
|
header = 0;
|
|
}
|
|
sprintf(temp, "%30d %6s %d",
|
|
original_term.Numbers[i], numnames[i],
|
|
CUR Numbers[i]);
|
|
ptextln(temp);
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
a = original_term.Strings[i] ? original_term.Strings[i] : "";
|
|
b = CUR Strings[i] ? CUR Strings[i] : "";
|
|
if (strcmp(a, b)) {
|
|
if (header) {
|
|
ptextln(title);
|
|
header = 0;
|
|
}
|
|
strcpy(abuf, _nc_tic_expand(a, TRUE, TRUE));
|
|
sprintf(temp, "%30s %6s %s", abuf, strnames[i],
|
|
_nc_tic_expand(b, TRUE, TRUE));
|
|
putln(temp);
|
|
}
|
|
}
|
|
if (header) {
|
|
ptextln("No changes");
|
|
}
|
|
put_crlf();
|
|
*ch = REQUEST_PROMPT;
|
|
}
|
|
|
|
/*
|
|
** user_modified()
|
|
**
|
|
** Return TRUE if the user has modified the terminfo
|
|
*/
|
|
int
|
|
user_modified(void)
|
|
{
|
|
const char *a, *b;
|
|
int i, v;
|
|
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
v = (i == xon_index) ? xon_shadow : CUR Booleans[i];
|
|
if (original_term.Booleans[i] != v) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (original_term.Numbers[i] != CUR Numbers[i]) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
a = original_term.Strings[i] ? original_term.Strings[i] : "";
|
|
b = CUR Strings[i] ? CUR Strings[i] : "";
|
|
if (strcmp(a, b)) {
|
|
return TRUE;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
*
|
|
* Maintain the list of capabilities that can be tested
|
|
*
|
|
*****************************************************************************/
|
|
|
|
/*
|
|
** mark_cap(name, flag)
|
|
**
|
|
** Mark the cap data base with the flag provided.
|
|
*/
|
|
static void
|
|
mark_cap(
|
|
char *name,
|
|
int flag)
|
|
{
|
|
struct name_table_entry const *nt;
|
|
|
|
if ((nt = _nc_find_entry(name, _nc_info_hash_table))) {
|
|
switch (nt->nte_type) {
|
|
case BOOLEAN:
|
|
flag_boolean[nt->nte_index] |= flag;
|
|
break;
|
|
case STRING:
|
|
flag_strings[nt->nte_index] |= flag;
|
|
break;
|
|
case NUMBER:
|
|
flag_numerics[nt->nte_index] |= flag;
|
|
break;
|
|
default:
|
|
sprintf(temp, "unknown cap type (%s)", name);
|
|
ptextln(temp);
|
|
break;
|
|
}
|
|
} else {
|
|
sprintf(temp, "Cap not found: %s", name);
|
|
ptextln(temp);
|
|
(void) wait_here();
|
|
}
|
|
}
|
|
|
|
/*
|
|
** can_test(name-list, flags)
|
|
**
|
|
** Scan the name list and get the names.
|
|
** Enter each name into the can-test data base.
|
|
** <space> ( and ) may be used as separators.
|
|
*/
|
|
void
|
|
can_test(
|
|
const char *s,
|
|
int flags)
|
|
{
|
|
int ch, j;
|
|
char name[32];
|
|
|
|
if (s) {
|
|
for (j = 0; (name[j] = ch = *s); s++) {
|
|
if (ch == ' ' || ch == ')' || ch == '(') {
|
|
if (j) {
|
|
name[j] = '\0';
|
|
mark_cap(name, flags);
|
|
}
|
|
j = 0;
|
|
} else {
|
|
j++;
|
|
}
|
|
}
|
|
if (j) {
|
|
mark_cap(name, flags);
|
|
}
|
|
}
|
|
}
|
|
|
|
/*
|
|
** cap_index(name-list, index-list)
|
|
**
|
|
** Scan the name list and return a list of indexes.
|
|
** <space> ( and ) may be used as separators.
|
|
** This list is terminated with -1.
|
|
*/
|
|
void
|
|
cap_index(
|
|
const char *s,
|
|
int *inx)
|
|
{
|
|
struct name_table_entry const *nt;
|
|
int ch, j;
|
|
char name[32];
|
|
|
|
if (s) {
|
|
for (j = 0; ; s++) {
|
|
name[j] = ch = *s;
|
|
if (ch == ' ' || ch == ')' || ch == '(' || ch == 0) {
|
|
if (j) {
|
|
name[j] = '\0';
|
|
if ((nt = _nc_find_entry(name,
|
|
_nc_info_hash_table)) &&
|
|
(nt->nte_type == STRING)) {
|
|
*inx++ = nt->nte_index;
|
|
}
|
|
}
|
|
if (ch == 0) {
|
|
break;
|
|
}
|
|
j = 0;
|
|
} else {
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
*inx = -1;
|
|
}
|
|
|
|
/*
|
|
** cap_match(name-list, cap)
|
|
**
|
|
** Scan the name list and see if the cap is in the list.
|
|
** Return TRUE if we find an exact match.
|
|
** <space> ( and ) may be used as separators.
|
|
*/
|
|
int
|
|
cap_match(
|
|
const char *names,
|
|
const char *cap)
|
|
{
|
|
char *s;
|
|
int c, l, t;
|
|
|
|
if (names) {
|
|
l = strlen(cap);
|
|
while ((s = strstr(names, cap))) {
|
|
c = (names == s) ? 0 : *(s - 1);
|
|
t = s[l];
|
|
if ((c == 0 || c == ' ' || c == '(') &&
|
|
(t == 0 || t == ' ' || t == ')')) {
|
|
return TRUE;
|
|
}
|
|
if (t == 0) {
|
|
break;
|
|
}
|
|
names = s + l;
|
|
}
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
** show_report(test_list, status, ch)
|
|
**
|
|
** Display a list of caps that can be tested
|
|
*/
|
|
void
|
|
show_report(
|
|
struct test_list *t,
|
|
int *state GCC_UNUSED,
|
|
int *ch)
|
|
{
|
|
int i, j, nc, flag;
|
|
const char *s;
|
|
const char *nx[BOOLCOUNT + NUMCOUNT + STRCOUNT];
|
|
|
|
flag = t->flags & 255;
|
|
nc = 0;
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
if (flag_boolean[i] & flag) {
|
|
nx[nc++] = boolnames[i];
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (flag_numerics[i] & flag) {
|
|
nx[nc++] = numnames[i];
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if (flag_strings[i] & flag) {
|
|
nx[nc++] = strnames[i];
|
|
}
|
|
}
|
|
/* sort */
|
|
for (i = 0; i < nc - 1; i++) {
|
|
for (j = i + 1; j < nc; j++) {
|
|
if (strcmp(nx[i], nx[j]) > 0) {
|
|
s = nx[i];
|
|
nx[i] = nx[j];
|
|
nx[j] = s;
|
|
}
|
|
}
|
|
}
|
|
if (flag & FLAG_FUNCTION_KEY) {
|
|
ptextln("The following function keys can be tested:");
|
|
} else
|
|
if (flag & FLAG_CAN_TEST) {
|
|
ptextln("The following capabilities can be tested:");
|
|
} else
|
|
if (flag & FLAG_TESTED) {
|
|
ptextln("The following capabilities have been tested:");
|
|
}
|
|
put_crlf();
|
|
for (i = 0; i < nc; i++) {
|
|
sprintf(temp, "%s ", nx[i]);
|
|
ptext(temp);
|
|
}
|
|
put_newlines(1);
|
|
*ch = REQUEST_PROMPT;
|
|
}
|
|
|
|
/*
|
|
** show_untested(test_list, status, ch)
|
|
**
|
|
** Display a list of caps that are defined but cannot be tested.
|
|
** Don't bother to sort this list.
|
|
*/
|
|
static void
|
|
show_untested(
|
|
struct test_list *t GCC_UNUSED,
|
|
int *state GCC_UNUSED,
|
|
int *ch)
|
|
{
|
|
int i;
|
|
|
|
ptextln("Caps that are defined but cannot be tested:");
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
if (flag_boolean[i] == 0 && CUR Booleans[i]) {
|
|
sprintf(temp, "%s ", boolnames[i]);
|
|
ptext(temp);
|
|
}
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
if (flag_numerics[i] == 0 && CUR Numbers[i] >= 0) {
|
|
sprintf(temp, "%s ", numnames[i]);
|
|
ptext(temp);
|
|
}
|
|
}
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if (flag_strings[i] == 0 && CUR Strings[i]) {
|
|
sprintf(temp, "%s ", strnames[i]);
|
|
ptext(temp);
|
|
}
|
|
}
|
|
put_newlines(1);
|
|
*ch = REQUEST_PROMPT;
|
|
}
|
|
|
|
/*
|
|
** edit_init()
|
|
**
|
|
** Initialize the function key data base
|
|
*/
|
|
void
|
|
edit_init(void)
|
|
{
|
|
int i, j, lc;
|
|
char *lab;
|
|
struct name_table_entry const *nt;
|
|
int label_strings[STRCOUNT];
|
|
|
|
_nc_copy_termtype(&original_term, &cur_term->type);
|
|
for (i = 0; i < BOOLCOUNT; i++) {
|
|
original_term.Booleans[i] = CUR Booleans[i];
|
|
}
|
|
for (i = 0; i < NUMCOUNT; i++) {
|
|
original_term.Numbers[i] = CUR Numbers[i];
|
|
}
|
|
/* scan for labels */
|
|
for (i = lc = 0; i < STRCOUNT; i++) {
|
|
original_term.Strings[i] = CUR Strings[i];
|
|
if (strncmp(strnames[i], "lf", 2) == 0) {
|
|
flag_strings[i] |= FLAG_LABEL;
|
|
if (CUR Strings[i]) {
|
|
label_strings[lc++] = i;
|
|
}
|
|
}
|
|
}
|
|
/* scan for function keys */
|
|
for (i = 0; i < STRCOUNT; i++) {
|
|
if ((strnames[i][0] == 'k') && strcmp(strnames[i], "kmous")) {
|
|
flag_strings[i] |= FLAG_FUNCTION_KEY;
|
|
lab = (char *) 0;
|
|
for (j = 0; j < lc; j++) {
|
|
if (!strcmp(&strnames[i][1],
|
|
&strnames[label_strings[j]][1])) {
|
|
lab = CUR Strings[label_strings[j]];
|
|
break;
|
|
}
|
|
}
|
|
enter_key(strnames[i], CUR Strings[i], lab);
|
|
}
|
|
}
|
|
/* Lookup the translated strings */
|
|
for (i = 0; i < TM_last; i++) {
|
|
if ((nt = _nc_find_entry(TM_string[i].name,
|
|
_nc_info_hash_table)) && (nt->nte_type == STRING)) {
|
|
TM_string[i].index = nt->nte_index;
|
|
} else {
|
|
sprintf(temp, "TM_string lookup failed for: %s",
|
|
TM_string[i].name);
|
|
ptextln(temp);
|
|
}
|
|
}
|
|
if ((nt = _nc_find_entry("xon", _nc_info_hash_table)) != 0) {
|
|
xon_index = nt->nte_index;
|
|
}
|
|
xon_shadow = xon_xoff;
|
|
}
|
|
|
|
/*
|
|
** change_one_entry(test_list, status, ch)
|
|
**
|
|
** Change the padding on the selected cap
|
|
*/
|
|
static void
|
|
change_one_entry(
|
|
struct test_list *test,
|
|
int *state,
|
|
int *chp)
|
|
{
|
|
struct name_table_entry const *nt;
|
|
int i, j, x, star, slash, v, dot, ch;
|
|
const char *s;
|
|
char *t, *p;
|
|
const char *current_string;
|
|
char buf[1024];
|
|
char pad[1024];
|
|
|
|
i = test->flags & 255;
|
|
if (i == 255) {
|
|
/* read the cap name from the user */
|
|
ptext("enter name: ");
|
|
read_string(pad, 32);
|
|
if (pad[0] == '\0' || pad[1] == '\0') {
|
|
*chp = pad[0];
|
|
return;
|
|
}
|
|
if ((nt = _nc_find_entry(pad, _nc_info_hash_table)) &&
|
|
(nt->nte_type == STRING)) {
|
|
x = nt->nte_index;
|
|
current_string = CUR Strings[x];
|
|
} else {
|
|
sprintf(temp, "%s is not a string capability", pad);
|
|
ptext(temp);
|
|
generic_done_message(test, state, chp);
|
|
return;
|
|
}
|
|
} else {
|
|
x = tx_index[i];
|
|
current_string = tx_cap[i];
|
|
strcpy(pad, strnames[x]);
|
|
}
|
|
if (!current_string) {
|
|
ptextln("That string is not currently defined. Please enter a new value, including the padding delay:");
|
|
read_string(buf, sizeof(buf));
|
|
_nc_reset_input((FILE *) 0, buf);
|
|
_nc_trans_string(pad, pad + sizeof(pad));
|
|
t = (char *)malloc(strlen(pad) + 1);
|
|
strcpy(t, pad);
|
|
CUR Strings[x] = t;
|
|
sprintf(temp, "new string value %s", strnames[x]);
|
|
ptextln(temp);
|
|
ptextln(expand(t));
|
|
return;
|
|
}
|
|
sprintf(buf, "Current value: (%s) %s", pad, _nc_tic_expand(current_string, TRUE, TRUE));
|
|
putln(buf);
|
|
ptextln("Enter new pad. 0 for no pad. CR for no change.");
|
|
read_string(buf, 32);
|
|
if (buf[0] == '\0' || (buf[1] == '\0' && isalpha(CharOf(buf[0])))) {
|
|
*chp = buf[0];
|
|
return;
|
|
}
|
|
star = slash = FALSE;
|
|
for (j = v = dot = 0; (ch = buf[j]); j++) {
|
|
if (ch >= '0' && ch <= '9') {
|
|
v = ch - '0' + v * 10;
|
|
if (dot) {
|
|
dot++;
|
|
}
|
|
} else if (ch == '*') {
|
|
star = TRUE;
|
|
} else if (ch == '/') {
|
|
slash = TRUE;
|
|
} else if (ch == '.') {
|
|
dot = 1;
|
|
} else {
|
|
sprintf(temp, "Illegal character: %c", ch);
|
|
ptextln(temp);
|
|
ptext("General format: 99.9*/ ");
|
|
generic_done_message(test, state, chp);
|
|
return;
|
|
}
|
|
}
|
|
while (dot > 2) {
|
|
v /= 10;
|
|
dot--;
|
|
}
|
|
if (dot == 2) {
|
|
sprintf(pad, "%d.%d%s%s", v / 10, v % 10,
|
|
star ? "*" : "", slash ? "/" : "");
|
|
} else {
|
|
sprintf(pad, "%d%s%s",
|
|
v, star ? "*" : "", slash ? "/" : "");
|
|
}
|
|
s = current_string;
|
|
t = buf;
|
|
for (v = 0; (ch = *t = *s++); t++) {
|
|
if (v == '$' && ch == '<') {
|
|
while ((ch = *s++) && (ch != '>'));
|
|
for (p = pad; (*++t = *p++); );
|
|
*t++ = '>';
|
|
while ((*t++ = *s++));
|
|
pad[0] = '\0';
|
|
break;
|
|
}
|
|
v = ch;
|
|
}
|
|
if (pad[0]) {
|
|
sprintf(t, "$<%s>", pad);
|
|
}
|
|
if ((t = (char *)malloc(strlen(buf) + 1))) {
|
|
strcpy(t, buf);
|
|
CUR Strings[x] = t;
|
|
if (i != 255) {
|
|
tx_cap[i] = t;
|
|
}
|
|
}
|
|
generic_done_message(test, state, chp);
|
|
}
|
|
|
|
/*
|
|
** build_change_menu(menu_list)
|
|
**
|
|
** Build the change pad menu list
|
|
*/
|
|
static void
|
|
build_change_menu(
|
|
struct test_menu *m)
|
|
{
|
|
int i, j, k;
|
|
char *s;
|
|
|
|
for (i = j = 0; i < txp; i++) {
|
|
if ((k = tx_index[i]) >= 0) {
|
|
s = _nc_tic_expand(tx_cap[i], TRUE, TRUE);
|
|
s[40] = '\0';
|
|
sprintf(change_pad_text[j], "%c) (%s) %s",
|
|
'a' + j, strnames[k], s);
|
|
change_pad_list[j].flags = i;
|
|
change_pad_list[j].lines_needed = 4;
|
|
change_pad_list[j].menu_entry = change_pad_text[j];
|
|
change_pad_list[j].test_procedure = change_one_entry;
|
|
j++;
|
|
}
|
|
}
|
|
strcpy(change_pad_text[j], "z) enter name");
|
|
change_pad_list[j].flags = 255;
|
|
change_pad_list[j].lines_needed = 4;
|
|
change_pad_list[j].menu_entry = change_pad_text[j];
|
|
change_pad_list[j].test_procedure = change_one_entry;
|
|
j++;
|
|
change_pad_list[j].flags = MENU_LAST;
|
|
if (m->menu_title) {
|
|
put_crlf();
|
|
ptextln(m->menu_title);
|
|
}
|
|
}
|