Logo Search packages:      
Sourcecode: tack version File versions  Download package

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);
}

Generated by  Doxygen 1.6.0   Back to index