modes.c

/*
** Copyright (C) 1991, 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., 51 Franklin Street, Fifth Floor,
** Boston, MA 02110-1301, USA
*/

#include <tack.h>

MODULE_ID("$Id: modes.c,v 1.6 2006/11/26 00:16:21 tom Exp $")

/*
 * Tests boolean flags and terminal modes.
 */
static void subtest_os(struct test_list *, int *, int *);
static void subtest_rmam(struct test_list *, int *, int *);
static void subtest_smam(struct test_list *, int *, int *);
static void subtest_am(struct test_list *, int *, int *);
static void subtest_ul(struct test_list *, int *, int *);
static void subtest_uc(struct test_list *, int *, int *);
static void subtest_bw(struct test_list *, int *, int *);
static void subtest_xenl(struct test_list *, int *, int *);
static void subtest_eo(struct test_list *, int *, int *);
static void subtest_xmc(struct test_list *, int *, int *);
static void subtest_xhp(struct test_list *, int *, int *);
static void subtest_mir(struct test_list *, int *, int *);
static void subtest_msgr(struct test_list *, int *, int *);
static void subtest_tbc(struct test_list *, int *, int *);
static void subtest_xt(struct test_list *, int *, int *);
static void subtest_hts(struct test_list *, int *, int *);
static void subtest_cbt(struct test_list *, int *, int *);
static void subtest_in(struct test_list *, int *, int *);
static void subtest_dadb(struct test_list *, int *, int *);

struct test_list mode_test_list[] = {
	{0, 0, 0, 0, "e) edit terminfo", 0, &edit_menu},
	{MENU_NEXT, 3, "os", 0, 0, subtest_os, 0},
	{MENU_NEXT, 1, "rmam", 0, 0, subtest_rmam, 0},
	{MENU_NEXT, 1, "smam", 0, 0, subtest_smam, 0},
	{MENU_NEXT, 1, "am", 0, 0, subtest_am, 0},
	{MENU_NEXT, 3, "ul", 0, 0, subtest_ul, 0},
	{MENU_NEXT, 3, "uc", 0, 0, subtest_uc, 0},
	{MENU_NEXT, 3, "bw", 0, 0, subtest_bw, 0},
	{MENU_NEXT, 4, "xenl", 0, 0, subtest_xenl, 0},
	{MENU_NEXT, 3, "eo", 0, 0, subtest_eo, 0},
	{MENU_NEXT, 3, "xmc", 0, 0, subtest_xmc, 0},
	{MENU_NEXT, 3, "xhp", 0, 0, subtest_xhp, 0},
	{MENU_NEXT, 6, "mir", 0, 0, subtest_mir, 0},
	{MENU_NEXT, 6, "msgr", 0, 0, subtest_msgr, 0},
	{MENU_NEXT | MENU_CLEAR, 0, "tbc", "it", 0, subtest_tbc, 0},
	{MENU_NEXT | MENU_CLEAR, 0, "hts", "it", 0, subtest_hts, 0},
	{MENU_NEXT, 4, "xt", "it", 0, subtest_xt, 0},
	{MENU_NEXT, 1, "cbt", "it", 0, subtest_cbt, 0},
	{MENU_NEXT, 6, "in", 0, 0, subtest_in, 0},
	{MENU_NEXT, 1, "da) (db", 0, 0, subtest_dadb, 0},
	{MENU_LAST, 0, 0, 0, 0, 0, 0}
};

/*
**	subtest_os(test_list, status, ch)
**
**	test over strike mode (os)
*/
static void
subtest_os(
	struct test_list *t,
	int *state,
	int *ch)
{
	ptext("(os) should be true, not false.");
	put_cr();
	ptextln("(os) should be           false.");
	sprintf(temp, "(os) over-strike is %s in the data base.  ",
		over_strike ? "true" : "false");
	ptext(temp);
	generic_done_message(t, state, ch);
}

/*
**	subtest_rmam(test_list, status, ch)
**
**	test exit automatic margins mode (rmam)
*/
static void
subtest_rmam(
	struct test_list *t,
	int *state,
	int *ch)
{
	int j;

	if (!exit_am_mode) {
		ptext("(rmam) not present.  ");
	} else
	if (!can_go_home) {
		ptext("(rmam) not tested, no way to home cursor.  ");
	} else
	if (over_strike) {
		put_clear();
		go_home();
		tc_putp(exit_am_mode);
		ptext("\n(rmam) will     reset (am)");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		ptext("(rmam) will not reset (am)");
		go_home();
		put_newlines(2);
	} else {
		put_clear();
		go_home();
		tc_putp(exit_am_mode);
		ptext("\n(rmam) will reset (am)");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		ptext("(rmam) will not reset (am) ");
		go_home();
		put_str("                          ");
		go_home();
		put_newlines(2);
	}
	ptext("Exit-automatic-margins ");
	generic_done_message(t, state, ch);
}

/*
**	subtest_smam(test_list, status, ch)
**
**	test enter automatic margins mode (smam)
*/
static void
subtest_smam(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j;

	if (!enter_am_mode) {
		ptext("(smam) not present.  ");
	} else
	if (!can_go_home) {
		ptext("(smam) not tested, no way to home cursor.  ");
	} else
	if (over_strike) {
		put_clear();
		go_home();
		tc_putp(enter_am_mode);
		ptext("\n(smam) will ");
		i = char_count;
		ptext("not set (am)");
		go_home();
		for (j = -i; j < columns; j++)
			put_this(' ');
		put_str("@@@");
		put_newlines(2);
	} else {
		put_clear();
		go_home();
		tc_putp(enter_am_mode);
		ptext("\n(smam) will not set (am)");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		ptext("(smam) will set (am)    ");
		go_home();
		put_str("                          ");
		put_newlines(2);
	}
	ptext("Enter-automatic-margins ");
	generic_done_message(t, state, ch);
}

/*
**	subtest_am(test_list, status, ch)
**
**	test automatic margins (am)
*/
static void
subtest_am(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j;

	if (!can_go_home) {
		ptextln("(am) not tested, no way to home cursor.  ");
	} else
	if (over_strike) {
		put_clear();
		go_home();
		ptext("\n(am) should ");
		i = char_count;
		ptext("not be set");
		go_home();
		for (j = -i; j < columns; j++)
			put_this(' ');
		put_str("@@@");
		go_home();
		put_newlines(2);
		sprintf(temp, "(am) is %s in the data base",
			auto_right_margin ? "true" : "false");
		ptextln(temp);
	} else {
		put_clear();
		go_home();
		ptext("\n(am) should not be set");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		ptext("(am) should be set    ");
		go_home();
		put_str("                       \n\n");
		sprintf(temp, "(am) is %s in the data base",
			auto_right_margin ? "true" : "false");
		ptextln(temp);
	}
	ptext("Automatic-right-margin ");
	generic_done_message(t, state, ch);
}

/* Note: uprint() sends underscore back-space character, and
        ucprint() sends character back-space underscore.  */

/*
**	uprint(string)
**
**	underline string for (ul) test
*/
static void
uprint(const char *s)
{
	if (s) {
		while (*s) {
			put_str("_\b");
			putchp(*s++);
		}
	}
}

/*
**	ucprint(string)
**
**	underline string for (uc) test
*/
static void
ucprint(const char *s)
{
	if (s) {
		while (*s) {
			putchp(*s++);
			putchp('\b');
			tc_putp(underline_char);
		}
	}
}

/*
**	subtest_ul(test_list, status, ch)
**
**	test transparent underline (ul)
*/
static void
subtest_ul(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (!over_strike) {
		/* (ul) is used only if (os) is reset */
		put_crlf();
		sprintf(temp, "This text should %sbe underlined.",
			transparent_underline ? "" : "not ");
		uprint(temp);
		put_crlf();
		ptextln("If the above line is not underlined the (ul) should be false.");
		sprintf(temp, "(ul) Transparent-underline is %s in the data base",
			transparent_underline ? "true" : "false");
		ptextln(temp);
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_uc(test_list, status, ch)
**
**	test underline character (uc)
*/
static void
subtest_uc(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (!over_strike) {
		if (underline_char) {
			ucprint("This text should be underlined.");
			put_crlf();
			ptextln("If the above text is not underlined the (uc) has failed.");
			ptext("Underline-character ");
		} else {
			ptext("(uc) underline-character is not defined.  ");
		}
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_bw(test_list, status, ch)
**
**	test auto left margin (bw)
*/
static void
subtest_bw(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j;

	if (over_strike) {
		/* test (bw) */
		ptext("\n(bw) should ");
		i = char_count;
		ptextln("not be set.");
		for (j = i; j < columns; j++)
			put_str("\b");
		put_str("@@@");
		put_crlf();
		sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
			auto_left_margin ? "true" : "false");
		ptextln(temp);
	} else {
		/* test (bw) */
		ptextln("(bw) should not be set.");
		for (i = 12; i < columns; i++)
			put_str("\b");
		if (delete_character) {
			for (i = 0; i < 4; i++)
				tc_putp(delete_character);
		} else {
			put_str("   ");
		}
		put_crlf();
		sprintf(temp, "(bw) Auto-left-margin is %s in the data base",
			auto_left_margin ? "true" : "false");
		ptextln(temp);
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_tbc(test_list, status, ch)
**
**	test clear tabs (tbc)
*/
static void
subtest_tbc(
	struct test_list *t,
	int *state,
	int *ch)
{
	int tabat;		/* the tab spacing we end up with */
	int i;

	if (clear_all_tabs && !set_tab) {
		ptext("(tbc) Clear-all-tabs is defined but (hts) set-tab is not.  ");
		ptext("Once the tabs are cleared there is no way to set them.  ");
	} else
	if (clear_all_tabs) {
		tabat = set_tab ? 8 : init_tabs;
		tc_putp(clear_all_tabs);
		ptext("Clear tabs (tbc)");
		go_home();
		put_crlf();
		putchp('\t');
		putchp('T');
		go_home();
		put_newlines(2);
		for (i = 0; i < columns; i++) {
			if (i == tabat) {
				putchp('T');
			} else {
				putchp('.');
			}
		}
		go_home();
		ptext("\n\n\nIf the above two lines have T's in the same column then (tbc) has failed.  ");
	} else {
		ptext("(tbc) Clear-all-tabs is not defined.  ");
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_hts(test_list, status, ch)
**
**	(ht) and set tabs with (hts)
*/
static void
subtest_hts(
	struct test_list *t,
	int *state,
	int *ch)
{
	int tabat;		/* the tab spacing we end up with */
	int i;

	tabat = init_tabs;
	if (set_tab) {
		ptext("Tabs set with (hts)");
		put_crlf();
		for (i = 1; i < columns; i++) {
			if (i % 8 == 1) {
				tc_putp(set_tab);
			}
			putchp(' ');
		}
		tabat = 8;
	} else {
		sprintf(temp, "(hts) Set-tabs not defined.  (it) Initial-tabs at %d", init_tabs);
		ptext(temp);
	}
	go_home();
	put_newlines(2);
	if (tabat <= 0) {
		tabat = 8;
	}
	for (i = tabat; i < columns; i += tabat) {
		putchp('\t');
		putchp('T');
	}
	go_home();
	put_newlines(3);
	for (i = 1; i < columns; i++) {
		putchp('.');
	}
	go_home();
	put_newlines(3);
	for (i = tabat; i < columns; i += tabat) {
		putchp('\t');
		putchp('T');
	}
	go_home();
	put_newlines(4);
	putchp('.');
	for (i = 2; i < columns; i++) {
		if (i % tabat == 1) {
			putchp('T');
		} else {
			putchp('.');
		}
	}
	go_home();
	put_newlines(5);
	if (set_tab) {
		ptextln("If the last two lines are not the same then (hts) has failed.");
	} else
	if (init_tabs > 0) {
		ptextln("If the last two lines are not the same then (it) is wrong.");
	} else {
		ptextln("If the last two lines are the same then maybe you do have tabs and (it) should be changed.");
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_xt(test_list, status, ch)
**
**	(xt) glitch
*/
static void
subtest_xt(
	struct test_list *t,
	int *state,
	int *ch)
{
	int tabat;		/* the tab spacing we end up with */
	int cc;

	tabat = set_tab ? 8 : init_tabs;
	if (!over_strike && (tabat > 0)) {
		ptext("(xt) should not ");
		put_cr();
		ptext("(xt) should");
		cc = char_count;
		while (cc < 16) {
			putchp('\t');
			cc = ((cc / tabat) + 1) * tabat;
		}
		putln("be set.");
		sprintf(temp, "(xt) Destructive-tab is %s in the data base.",
			dest_tabs_magic_smso ? "true" : "false");
		ptextln(temp);
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_cbt(test_list, status, ch)
**
**	(cbt) back tab
*/
static void
subtest_cbt(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i;

	if (back_tab) {
		put_clear();
		ptext("Back-tab (cbt)");
		go_home();
		put_crlf();
		for (i = 1; i < columns; i++) {
			putchp(' ');
		}
		for (i = 0; i < columns; i += 8) {
			tc_putp(back_tab);
			putchp('T');
			tc_putp(back_tab);
		}
		go_home();
		put_newlines(2);
		for (i = 1; i < columns; i++) {
			if (i % 8 == 1) {
				putchp('T');
			} else {
				putchp(' ');
			}
		}
		go_home();
		put_newlines(3);
		ptextln("The preceding two lines should be the same.");
	} else {
		ptextln("(cbt) Back-tab not present");
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_xenl(test_list, status, ch)
**
**	(xenl) eat newline glitch
*/
static void
subtest_xenl(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j, k;

	if (over_strike) {
		/* test (xenl) on overstrike terminals */
		if (!can_go_home || !can_clear_screen) {
			ptextln("(xenl) Newline-glitch not tested, can't home cursor and clear.");
			generic_done_message(t, state, ch);
			return;
		}
		put_clear();
		/*
		   this test must be done in raw mode.  Otherwise UNIX will
		   translate CR to CRLF.
		*/
		if (stty_query(TTY_OUT_TRANS))
			tty_raw(1, char_mask);
		ptext("\nreset (xenl). Does ");
		i = char_count;
		put_str("not ignore CR, does ");
		k = char_count;
		put_str("not ignore LF");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_cr();
		for (j = 0; j < i; j++)
			putchp(' ');
		put_str("@@@\n@@");
		go_home();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_lf();
		for (j = 0; j < k; j++)
			putchp(' ');
		put_str("@@@\r@@");
		tty_set();
		go_home();
		put_newlines(4);
		sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
			eat_newline_glitch ? "true" : "false");
		ptextln(temp);
	} else {
		/* test (xenl) when (os) is reset */
		if (!can_go_home) {
			ptextln("(xenl) Newline-glitch not tested, can't home cursor");
			generic_done_message(t, state, ch);
			return;
		}
		/* (xenl) test */
		put_clear();
		/*
		   this test must be done in raw mode.  Otherwise
		   UNIX will translate CR to CRLF.
		*/
		if (stty_query(TTY_OUT_TRANS))
			tty_raw(1, char_mask);
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_cr();
		ptext("(xenl) should be set. Does not ignore CR");
		go_home();
		put_crlf();
		for (j = 0; j < columns; j++)
			put_this(' ');
		put_lf();	/* test (cud1) */
		ptext("(xenl) should be set. Ignores (cud1)");
		go_home();
		put_newlines(3);
		if (scroll_forward && cursor_down &&
			strcmp(scroll_forward, cursor_down)) {
			for (j = 0; j < columns; j++)
				put_this(' ');
			put_ind();	/* test (ind) */
			ptext("(xenl) should be set. Ignores (ind)");
			go_home();
			put_newlines(5);
		}
		tty_set();
		ptextln("If you don't see text above telling you to set it, (xenl) should be false");
		sprintf(temp, "(xenl) Newline-glitch is %s in the data base",
			eat_newline_glitch ? "true" : "false");
		ptextln(temp);
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_eo(test_list, status, ch)
**
**	(eo) erase overstrike
*/
static void
subtest_eo(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (transparent_underline || over_strike || underline_char) {
		ptext("(eo) should ");
		if (underline_char) {
			ucprint("not");
		} else {
			uprint("not");
		}
		put_cr();
		ptextln("(eo) should     be set");
		sprintf(temp, "\n(eo) Erase-overstrike is %s in the data base",
			erase_overstrike ? "true" : "false");
		ptextln(temp);
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_xmc(test_list, status, ch)
**
**	(xmc) magic cookie glitch
*/
static void
subtest_xmc(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i, j;

	if (enter_standout_mode) {
		sprintf(temp, "\n(xmc) Magic-cookie-glitch is %d in the data base", magic_cookie_glitch);
		ptextln(temp);
		j = magic_cookie_glitch * 8;
		for (i = 0; i < j; i++) {
			put_str(" ");
		}
		ptextln("        These two lines should line up.");
		if (j > 0) {
			char_count += j;
		}
		for (i = 0; i < 4; i++) {
			put_mode(enter_standout_mode);
			putchp(' ');
			put_mode(exit_standout_mode);
			putchp(' ');
		}
		ptextln("These two lines should line up.");
		ptext("If they don't line up then (xmc) magic-cookie-glitch should be greater than zero.  ");
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_xhp(test_list, status, ch)
**
**	(xhp) erase does not clear standout mode
*/
static void
subtest_xhp(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (enter_standout_mode) {
		put_crlf();
		put_mode(enter_standout_mode);
		put_str("Stand out");
		put_mode(exit_standout_mode);
		put_cr();
		ptextln("If any part of this line is standout then (xhp) should be set.");
		sprintf(temp, "(xhp) Erase-standout-glitch is %s in the data base",
			ceol_standout_glitch ? "true" : "false");
		ptextln(temp);
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_mir(test_list, status, ch)
**
**	(mir) move in insert mode
*/
static void
subtest_mir(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i;
	char *s;

	if (enter_insert_mode && exit_insert_mode && cursor_address) {
		put_clear();
		i = line_count;
		put_str("\nXXX\nXXX\nXXX\nXXX");
		tc_putp(enter_insert_mode);
		s = TPARM_2(cursor_address, i + 1, 0);
		tputs(s, lines, tc_putch);
		putchp('X');
		s = TPARM_2(cursor_address, i + 2, 1);
		tputs(s, lines, tc_putch);
		putchp('X');
		s = TPARM_2(cursor_address, i + 3, 2);
		tputs(s, lines, tc_putch);
		putchp('X');
		s = TPARM_2(cursor_address, i + 4, 3);
		tputs(s, lines, tc_putch);
		putchp('X');
		tc_putp(exit_insert_mode);
		put_newlines(2);
		ptextln("If you see a 4 by 4 block of X's then (mir) should be true.");
		sprintf(temp, "(mir) Move-in-insert-mode is %s in the data base",
			move_insert_mode ? "true" : "false");
		ptextln(temp);
	} else {
		ptext("(mir) Move-in-insert-mode not tested, ");
		if (!enter_insert_mode) {
			ptext("(smir) ");
		}
		if (!exit_insert_mode) {
			ptext("(rmir) ");
		}
		if (!cursor_address) {
			ptext("(cup) ");
		}
		ptext("not present.  ");
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_msgr(test_list, status, ch)
**
**	(msgr) move in sgr mode
*/
static void
subtest_msgr(
	struct test_list *t,
	int *state,
	int *ch)
{
	int i;

	if (cursor_address &&
		((enter_standout_mode && exit_standout_mode) ||
		(enter_alt_charset_mode && exit_alt_charset_mode))) {
		put_crlf();
		i = line_count + 1;
		tputs(TPARM_2(cursor_address, i, 0), lines, tc_putch);
		put_mode(enter_alt_charset_mode);
		put_crlf();
		/*
		   some versions of the wy-120 can not clear lines or
		   screen when in alt charset mode.  If (el) and (ed)
		   are defined then I can test them.  If they are not
		   defined then they can not break (msgr)
		*/
		tc_putp(clr_eos);
		tc_putp(clr_eol);
		put_mode(exit_alt_charset_mode);
		put_mode(enter_standout_mode);
		putchp('X');
		tputs(TPARM_2(cursor_address, i + 2, 1), lines, tc_putch);
		putchp('X');
		tputs(TPARM_2(cursor_address, i + 3, 2), lines, tc_putch);
		putchp('X');
		tputs(TPARM_2(cursor_address, i + 4, 3), lines, tc_putch);
		putchp('X');
		put_mode(exit_standout_mode);
		put_crlf();
		tc_putp(clr_eos);	/* OK if missing */
		put_crlf();
		ptextln("If you see a diagonal line of standout X's then (msgr) should be true.  If any of the blanks are standout then (msgr) should be false.");
		sprintf(temp, "(msgr) Move-in-SGR-mode is %s in the data base",
			move_standout_mode ? "true" : "false");
		ptextln(temp);
	} else {
		ptextln("(smso) (rmso) (smacs) (rmacs) missing; (msgr) Move-in-SGR-mode not tested.");
	}
	generic_done_message(t, state, ch);
}

/*
**	subtest_in(test_list, status, ch)
**
**	(in) insert null glitch
*/
static void
subtest_in(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (enter_insert_mode && exit_insert_mode) {
		ptextln("\nTesting (in) with (smir) and (rmir)");
		putln("\tIf these two lines line up ...");
		put_str("\tIf these two lines line up ...");
		put_cr();
		tc_putp(enter_insert_mode);
		putchp(' ');
		tc_putp(exit_insert_mode);
		ptext("\nthen (in) should be set.  ");
		sprintf(temp,
			"(in) Insert-null-glitch is %s in the data base.",
			insert_null_glitch ? "true" : "false");
		ptextln(temp);
		generic_done_message(t, state, ch);
	}
}

/*
**	subtest_dadb(test_list, status, ch)
**
**	(da) (db) data above, (db) data below
*/
static void
subtest_dadb(
	struct test_list *t,
	int *state,
	int *ch)
{
	if (can_clear_screen && scroll_reverse && scroll_forward) {
		put_clear();
		if (scroll_reverse)
			ptext("(da) Data-above should be set\r");
		home_down();
		if (scroll_forward)
			ptext("(db) Data-below should be set\r");
		tc_putp(scroll_forward);
		go_home();
		tc_putp(scroll_reverse);
		tc_putp(scroll_reverse);
		home_down();
		tc_putp(scroll_forward);
		go_home();
		ptextln("\n\n\n\n\nIf the top line is blank then (da) should be false.");
		ptextln("If the bottom line is blank then (db) should be false.");
		sprintf(temp, "\n(da) Data-above is %s, and (db) Data-below is %s, in the data base.",
			memory_above ? "true" : "false",
			memory_below ? "true" : "false");
		ptextln(temp);
		line_count = lines;
	} else {
		ptextln("(da) Data-above, (db) Data-below not tested, scrolls or (clear) is missing.");
	}
	generic_done_message(t, state, ch);
}