ncurses 6.2 - patch 20201017
[ncurses.git] / ncurses / tty / lib_mvcur.c
index 5e29c62ff175ef0924c11fec0e00525398404603..c085ae140eac8ea4c9ac136b6e42ebaacdf1c80f 100644 (file)
@@ -1,5 +1,6 @@
 /****************************************************************************
- * Copyright (c) 1998-2009,2010 Free Software Foundation, Inc.              *
+ * Copyright 2018-2019,2020 Thomas E. Dickey                                *
+ * Copyright 1998-2016,2017 Free Software Foundation, Inc.                  *
  *                                                                          *
  * Permission is hereby granted, free of charge, to any person obtaining a  *
  * copy of this software and associated documentation files (the            *
 #define CUR SP_TERMTYPE
 #endif
 
-MODULE_ID("$Id: lib_mvcur.c,v 1.124 2010/12/19 01:22:58 tom Exp $")
+MODULE_ID("$Id: lib_mvcur.c,v 1.154 2020/10/03 20:25:48 tom Exp $")
 
 #define WANT_CHAR(sp, y, x) NewScreen(sp)->_line[y].text[x]    /* desired state */
 
@@ -176,6 +177,9 @@ static bool profiling = FALSE;
 static float diff;
 #endif /* MAIN */
 
+#undef NCURSES_OUTC_FUNC
+#define NCURSES_OUTC_FUNC myOutCh
+
 #define OPT_SIZE 512
 
 static int normalized_cost(NCURSES_SP_DCLx const char *const cap, int affcnt);
@@ -242,8 +246,9 @@ NCURSES_SP_NAME(_nc_msec_cost) (NCURSES_SP_DCLx const char *const cap, int affcn
                if (!GetNoPadding(SP_PARM))
 #endif
                    cum_cost += number * 10;
-           } else
+           } else if (SP_PARM) {
                cum_cost += (float) SP_PARM->_char_padding;
+           }
        }
 
        return ((int) cum_cost);
@@ -273,10 +278,9 @@ reset_scroll_region(NCURSES_SP_DCL0)
 /* Set the scroll-region to a known state (the default) */
 {
     if (change_scroll_region) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "change_scroll_region",
-                                  TPARM_2(change_scroll_region,
-                                          0, screen_lines(SP_PARM) - 1));
+       NCURSES_PUTP2("change_scroll_region",
+                     TIPARM_2(change_scroll_region,
+                              0, screen_lines(SP_PARM) - 1));
     }
 }
 
@@ -284,14 +288,12 @@ NCURSES_EXPORT(void)
 NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_DCL0)
 /* what to do at initialization time and after each shellout */
 {
-    if (SP_PARM && !IsTermInfo(SP_PARM))
+    if (!SP_PARM || !IsTermInfo(SP_PARM))
        return;
 
     /* initialize screen for cursor access */
     if (enter_ca_mode) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "enter_ca_mode",
-                                  enter_ca_mode);
+       NCURSES_PUTP2("enter_ca_mode", enter_ca_mode);
     }
 
     /*
@@ -326,13 +328,14 @@ NCURSES_EXPORT(void)
 NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
 /* initialize the cost structure */
 {
-    if (SP_PARM->_ofp && isatty(fileno(SP_PARM->_ofp)))
+    if (SP_PARM->_ofp && NC_ISATTY(fileno(SP_PARM->_ofp))) {
        SP_PARM->_char_padding = ((BAUDBYTE * 1000 * 10)
                                  / (BAUDRATE(SP_PARM) > 0
                                     ? BAUDRATE(SP_PARM)
                                     : 9600));
-    else
+    } else {
        SP_PARM->_char_padding = 1;     /* must be nonzero */
+    }
     if (SP_PARM->_char_padding <= 0)
        SP_PARM->_char_padding = 1;     /* must be nonzero */
     TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP_PARM->_char_padding));
@@ -342,7 +345,9 @@ NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
     SP_PARM->_home_cost = CostOf(cursor_home, 0);
     SP_PARM->_ll_cost = CostOf(cursor_to_ll, 0);
 #if USE_HARD_TABS
-    if (getenv("NCURSES_NO_HARD_TABS") == 0) {
+    if (getenv("NCURSES_NO_HARD_TABS") == 0
+       && dest_tabs_magic_smso == 0
+       && HasHardTabs()) {
        SP_PARM->_ht_cost = CostOf(tab, 0);
        SP_PARM->_cbt_cost = CostOf(back_tab, 0);
     } else {
@@ -394,13 +399,13 @@ NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
      * All these averages depend on the assumption that all parameter values
      * are equally probable.
      */
-    SP_PARM->_cup_cost = CostOf(TPARM_2(SP_PARM->_address_cursor, 23, 23), 1);
-    SP_PARM->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1);
-    SP_PARM->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1);
-    SP_PARM->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1);
-    SP_PARM->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1);
-    SP_PARM->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1);
-    SP_PARM->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1);
+    SP_PARM->_cup_cost = CostOf(TIPARM_2(SP_PARM->_address_cursor, 23, 23), 1);
+    SP_PARM->_cub_cost = CostOf(TIPARM_1(parm_left_cursor, 23), 1);
+    SP_PARM->_cuf_cost = CostOf(TIPARM_1(parm_right_cursor, 23), 1);
+    SP_PARM->_cud_cost = CostOf(TIPARM_1(parm_down_cursor, 23), 1);
+    SP_PARM->_cuu_cost = CostOf(TIPARM_1(parm_up_cursor, 23), 1);
+    SP_PARM->_hpa_cost = CostOf(TIPARM_1(column_address, 23), 1);
+    SP_PARM->_vpa_cost = CostOf(TIPARM_1(row_address, 23), 1);
 
     /* non-parameterized screen-update strings */
     SP_PARM->_ed_cost = NormalizedCost(clr_eos, 1);
@@ -417,17 +422,16 @@ NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
        SP_PARM->_el_cost = 0;
 
     /* parameterized screen-update strings */
-    SP_PARM->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1);
-    SP_PARM->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1);
-    SP_PARM->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1);
-    SP_PARM->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1);
-
-    SP_PARM->_cup_ch_cost = NormalizedCost(
-                                             TPARM_2(SP_PARM->_address_cursor,
-                                                     23, 23),
-                                             1);
-    SP_PARM->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1);
-    SP_PARM->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1);
+    SP_PARM->_dch_cost = NormalizedCost(TIPARM_1(parm_dch, 23), 1);
+    SP_PARM->_ich_cost = NormalizedCost(TIPARM_1(parm_ich, 23), 1);
+    SP_PARM->_ech_cost = NormalizedCost(TIPARM_1(erase_chars, 23), 1);
+    SP_PARM->_rep_cost = NormalizedCost(TIPARM_2(repeat_char, ' ', 23), 1);
+
+    SP_PARM->_cup_ch_cost = NormalizedCost(TIPARM_2(SP_PARM->_address_cursor,
+                                                   23, 23),
+                                          1);
+    SP_PARM->_hpa_ch_cost = NormalizedCost(TIPARM_1(column_address, 23), 1);
+    SP_PARM->_cuf_ch_cost = NormalizedCost(TIPARM_1(parm_right_cursor, 23), 1);
     SP_PARM->_inline_cost = min(SP_PARM->_cup_ch_cost,
                                min(SP_PARM->_hpa_ch_cost,
                                    SP_PARM->_cuf_ch_cost));
@@ -448,8 +452,8 @@ NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0)
 
     /*
      * A different, possibly better way to arrange this would be to set the
-     * SCREEN's _endwin to TRUE at window initialization time and let this be
-     * called by doupdate's return-from-shellout code.
+     * SCREEN's _endwin at window initialization time and let this be called by
+     * doupdate's return-from-shellout code.
      */
     NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_ARG);
 }
@@ -469,7 +473,7 @@ NCURSES_SP_NAME(_nc_mvcur_wrap) (NCURSES_SP_DCL0)
     /* leave cursor at screen bottom */
     TINFO_MVCUR(NCURSES_SP_ARGx -1, -1, screen_lines(SP_PARM) - 1, 0);
 
-    if (SP_PARM && !IsTermInfo(SP_PARM))
+    if (!SP_PARM || !IsTermInfo(SP_PARM))
        return;
 
     /* set cursor to normal mode */
@@ -480,9 +484,7 @@ NCURSES_SP_NAME(_nc_mvcur_wrap) (NCURSES_SP_DCL0)
     }
 
     if (exit_ca_mode) {
-       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                  "exit_ca_mode",
-                                  exit_ca_mode);
+       NCURSES_PUTP2("exit_ca_mode", exit_ca_mode);
     }
     /*
      * Reset terminal's tab counter.  There's a long-time bug that
@@ -548,7 +550,7 @@ relative_move(NCURSES_SP_DCLx
              int from_x,
              int to_y,
              int to_x,
-             bool ovw)
+             int ovw)
 /* move via local motions (cuu/cuu1/cud/cud1/cub1/cub/cuf1/cuf/vpa/hpa) */
 {
     string_desc save;
@@ -560,7 +562,7 @@ relative_move(NCURSES_SP_DCLx
        vcost = INFINITY;
 
        if (row_address != 0
-           && _nc_safe_strcat(target, TPARM_1(row_address, to_y))) {
+           && _nc_safe_strcat(target, TIPARM_1(row_address, to_y))) {
            vcost = SP_PARM->_vpa_cost;
        }
 
@@ -570,12 +572,12 @@ relative_move(NCURSES_SP_DCLx
            if (parm_down_cursor
                && SP_PARM->_cud_cost < vcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
-                                  TPARM_1(parm_down_cursor, n))) {
+                                  TIPARM_1(parm_down_cursor, n))) {
                vcost = SP_PARM->_cud_cost;
            }
 
            if (cursor_down
-               && (*cursor_down != '\n' || SP_PARM->_nl)
+               && (*cursor_down != '\n')
                && (n * SP_PARM->_cud1_cost < vcost)) {
                vcost = repeated_append(_nc_str_copy(target, &save), 0,
                                        SP_PARM->_cud1_cost, n, cursor_down);
@@ -586,7 +588,7 @@ relative_move(NCURSES_SP_DCLx
            if (parm_up_cursor
                && SP_PARM->_cuu_cost < vcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
-                                  TPARM_1(parm_up_cursor, n))) {
+                                  TIPARM_1(parm_up_cursor, n))) {
                vcost = SP_PARM->_cuu_cost;
            }
 
@@ -610,7 +612,7 @@ relative_move(NCURSES_SP_DCLx
 
        if (column_address
            && _nc_safe_strcat(_nc_str_copy(target, &save),
-                              TPARM_1(column_address, to_x))) {
+                              TIPARM_1(column_address, to_x))) {
            hcost = SP_PARM->_hpa_cost;
        }
 
@@ -620,7 +622,7 @@ relative_move(NCURSES_SP_DCLx
            if (parm_right_cursor
                && SP_PARM->_cuf_cost < hcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
-                                  TPARM_1(parm_right_cursor, n))) {
+                                  TIPARM_1(parm_right_cursor, n))) {
                hcost = SP_PARM->_cuf_cost;
            }
 
@@ -713,7 +715,7 @@ relative_move(NCURSES_SP_DCLx
            if (parm_left_cursor
                && SP_PARM->_cub_cost < hcost
                && _nc_safe_strcat(_nc_str_copy(target, &save),
-                                  TPARM_1(parm_left_cursor, n))) {
+                                  TIPARM_1(parm_left_cursor, n))) {
                hcost = SP_PARM->_cub_cost;
            }
 
@@ -769,7 +771,10 @@ relative_move(NCURSES_SP_DCLx
  */
 
 static NCURSES_INLINE int
-onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw)
+onscreen_mvcur(NCURSES_SP_DCLx
+              int yold, int xold,
+              int ynew, int xnew, int ovw,
+              NCURSES_SP_OUTC myOutCh)
 /* onscreen move from (yold, xold) to (ynew, xnew) */
 {
     string_desc result;
@@ -787,7 +792,8 @@ onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw)
 #define InitResult _nc_str_init(&result, buffer, sizeof(buffer))
 
     /* tactic #0: use direct cursor addressing */
-    if (_nc_safe_strcpy(InitResult, TPARM_2(SP_PARM->_address_cursor, ynew, xnew))) {
+    if (_nc_safe_strcpy(InitResult, TIPARM_2(SP_PARM->_address_cursor,
+                                            ynew, xnew))) {
        tactic = 0;
        usecost = SP_PARM->_cup_cost;
 
@@ -932,9 +938,10 @@ onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw)
 #endif /* MAIN */
 
     if (usecost != INFINITY) {
+       TR(TRACE_MOVE, ("mvcur tactic %d", tactic));
        TPUTS_TRACE("mvcur");
        NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
-                               buffer, 1, NCURSES_SP_NAME(_nc_outch));
+                               buffer, 1, myOutCh);
        SP_PARM->_cursrow = ynew;
        SP_PARM->_curscol = xnew;
        return (OK);
@@ -942,9 +949,15 @@ onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw)
        return (ERR);
 }
 
-NCURSES_EXPORT(int)
-TINFO_MVCUR(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew)
-/* optimized cursor move from (yold, xold) to (ynew, xnew) */
+/*
+ * optimized cursor move from (yold, xold) to (ynew, xnew)
+ */
+static int
+_nc_real_mvcur(NCURSES_SP_DCLx
+              int yold, int xold,
+              int ynew, int xnew,
+              NCURSES_SP_OUTC myOutCh,
+              int ovw)
 {
     NCURSES_CH_T oldattr;
     int code;
@@ -979,44 +992,33 @@ TINFO_MVCUR(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew)
            TR(TRACE_CHARPUT, ("turning off (%#lx) %s before move",
                               (unsigned long) AttrOf(oldattr),
                               _traceattr(AttrOf(oldattr))));
-           (void) VIDATTR(SP_PARM, A_NORMAL, 0);
+           VIDPUTS(SP_PARM, A_NORMAL, 0);
        }
 
        if (xold >= screen_columns(SP_PARM)) {
-           int l;
-
-           if (SP_PARM->_nl) {
-               l = (xold + 1) / screen_columns(SP_PARM);
-               yold += l;
-               if (yold >= screen_lines(SP_PARM))
-                   l -= (yold - screen_lines(SP_PARM) - 1);
-
-               if (l > 0) {
-                   if (carriage_return) {
-                       NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                                  "carriage_return",
-                                                  carriage_return);
-                   } else
-                       NCURSES_SP_NAME(_nc_outch) (NCURSES_SP_ARGx '\r');
-                   xold = 0;
-
-                   while (l > 0) {
-                       if (newline) {
-                           NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
-                                                      "newline",
-                                                      newline);
-                       } else
-                           NCURSES_SP_NAME(_nc_outch) (NCURSES_SP_ARGx '\n');
-                       l--;
+
+           int l = (xold + 1) / screen_columns(SP_PARM);
+
+           yold += l;
+           if (yold >= screen_lines(SP_PARM))
+               l -= (yold - screen_lines(SP_PARM) - 1);
+
+           if (l > 0) {
+               if (carriage_return) {
+                   NCURSES_PUTP2("carriage_return", carriage_return);
+               } else {
+                   myOutCh(NCURSES_SP_ARGx '\r');
+               }
+               xold = 0;
+
+               while (l > 0) {
+                   if (newline) {
+                       NCURSES_PUTP2("newline", newline);
+                   } else {
+                       myOutCh(NCURSES_SP_ARGx '\n');
                    }
+                   l--;
                }
-           } else {
-               /*
-                * If caller set nonl(), we cannot really use newlines to
-                * position to the next row.
-                */
-               xold = -1;
-               yold = -1;
            }
        }
 
@@ -1026,7 +1028,7 @@ TINFO_MVCUR(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew)
            ynew = screen_lines(SP_PARM) - 1;
 
        /* destination location is on screen now */
-       code = onscreen_mvcur(NCURSES_SP_ARGx yold, xold, ynew, xnew, TRUE);
+       code = onscreen_mvcur(NCURSES_SP_ARGx yold, xold, ynew, xnew, ovw, myOutCh);
 
        /*
         * Restore attributes if we disabled them before moving.
@@ -1035,19 +1037,86 @@ TINFO_MVCUR(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew)
            TR(TRACE_CHARPUT, ("turning on (%#lx) %s after move",
                               (unsigned long) AttrOf(oldattr),
                               _traceattr(AttrOf(oldattr))));
-           (void) VIDATTR(SP_PARM, AttrOf(oldattr), GetPair(oldattr));
+           VIDPUTS(SP_PARM, AttrOf(oldattr), GetPair(oldattr));
        }
     }
     returnCode(code);
 }
 
-#if NCURSES_SP_FUNCS && !defined(USE_TERM_DRIVER)
+/*
+ * These entrypoints are used within the library.
+ */
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(_nc_mvcur) (NCURSES_SP_DCLx
+                           int yold, int xold,
+                           int ynew, int xnew)
+{
+    int rc;
+    rc = _nc_real_mvcur(NCURSES_SP_ARGx yold, xold, ynew, xnew,
+                       NCURSES_SP_NAME(_nc_outch),
+                       TRUE);
+    /*
+     * With the terminal-driver, we cannot distinguish between internal and
+     * external calls.  Flush the output if the screen has not been
+     * initialized, e.g., when used from low-level terminfo programs.
+     */
+    if ((SP_PARM != 0) && (SP_PARM->_endwin == ewInitial))
+       NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
+    return rc;
+}
+
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+_nc_mvcur(int yold, int xold,
+         int ynew, int xnew)
+{
+    return NCURSES_SP_NAME(_nc_mvcur) (CURRENT_SCREEN, yold, xold, ynew, xnew);
+}
+#endif
+
+#if defined(USE_TERM_DRIVER)
+/*
+ * The terminal driver does not support the external "mvcur()".
+ */
+NCURSES_EXPORT(int)
+TINFO_MVCUR(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew)
+{
+    int rc;
+    rc = _nc_real_mvcur(NCURSES_SP_ARGx
+                       yold, xold,
+                       ynew, xnew,
+                       NCURSES_SP_NAME(_nc_outch),
+                       TRUE);
+    if ((SP_PARM != 0) && (SP_PARM->_endwin == ewInitial))
+       NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
+    NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
+    return rc;
+}
+
+#else /* !USE_TERM_DRIVER */
+
+/*
+ * These entrypoints support users of the library.
+ */
+NCURSES_EXPORT(int)
+NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx int yold, int xold, int ynew,
+                       int xnew)
+{
+    return _nc_real_mvcur(NCURSES_SP_ARGx
+                         yold, xold,
+                         ynew, xnew,
+                         NCURSES_SP_NAME(_nc_putchar),
+                         FALSE);
+}
+
+#if NCURSES_SP_FUNCS
 NCURSES_EXPORT(int)
 mvcur(int yold, int xold, int ynew, int xnew)
 {
     return NCURSES_SP_NAME(mvcur) (CURRENT_SCREEN, yold, xold, ynew, xnew);
 }
 #endif
+#endif /* USE_TERM_DRIVER */
 
 #if defined(TRACE) || defined(NCURSES_TEST)
 NCURSES_EXPORT_VAR(int) _nc_optimize_enable = OPTIMIZE_ALL;
@@ -1121,13 +1190,12 @@ roll(int n)
 int
 main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
 {
-    strcpy(tname, getenv("TERM"));
+    _nc_STRCPY(tname, getenv("TERM"), sizeof(tname));
     load_term();
     _nc_setupscreen(lines, columns, stdout, FALSE, 0);
     baudrate();
 
     _nc_mvcur_init();
-    NC_BUFFERED(FALSE);
 
     (void) puts("The mvcur tester.  Type ? for help");
 
@@ -1138,27 +1206,26 @@ main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
        int fy, fx, ty, tx, n, i;
        char buf[BUFSIZ], capname[BUFSIZ];
 
-       (void) fputs("> ", stdout);
-       (void) fgets(buf, sizeof(buf), stdin);
+       if (fputs("> ", stdout) == EOF)
+           break;
+       if (fgets(buf, sizeof(buf), stdin) == 0)
+           break;
 
+#define PUTS(s)   (void) puts(s)
+#define PUTF(s,t) (void) printf(s,t)
        if (buf[0] == '?') {
-           (void) puts("?                -- display this help message");
-           (void)
-               puts("fy fx ty tx      -- (4 numbers) display (fy,fx)->(ty,tx) move");
-           (void) puts("s[croll] n t b m -- display scrolling sequence");
-           (void)
-               printf("r[eload]         -- reload terminal info for %s\n",
-                      termname());
-           (void)
-               puts("l[oad] <term>    -- load terminal info for type <term>");
-           (void) puts("d[elete] <cap>   -- delete named capability");
-           (void) puts("i[nspect]        -- display terminal capabilities");
-           (void)
-               puts("c[ost]           -- dump cursor-optimization cost table");
-           (void) puts("o[optimize]      -- toggle movement optimization");
-           (void)
-               puts("t[orture] <num>  -- torture-test with <num> random moves");
-           (void) puts("q[uit]           -- quit the program");
+           PUTS("?                -- display this help message");
+           PUTS("fy fx ty tx      -- (4 numbers) display (fy,fx)->(ty,tx) move");
+           PUTS("s[croll] n t b m -- display scrolling sequence");
+           PUTF("r[eload]         -- reload terminal info for %s\n",
+                termname());
+           PUTS("l[oad] <term>    -- load terminal info for type <term>");
+           PUTS("d[elete] <cap>   -- delete named capability");
+           PUTS("i[nspect]        -- display terminal capabilities");
+           PUTS("c[ost]           -- dump cursor-optimization cost table");
+           PUTS("o[optimize]      -- toggle movement optimization");
+           PUTS("t[orture] <num>  -- torture-test with <num> random moves");
+           PUTS("q[uit]           -- quit the program");
        } else if (sscanf(buf, "%d %d %d %d", &fy, &fx, &ty, &tx) == 4) {
            struct timeval before, after;
 
@@ -1186,7 +1253,7 @@ main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
                                                             before.tv_sec)
                           * 1000000));
        } else if (buf[0] == 'r') {
-           (void) strcpy(tname, termname());
+           _nc_STRCPY(tname, termname(), sizeof(tname));
            load_term();
        } else if (sscanf(buf, "l %s", tname) == 1) {
            load_term();
@@ -1219,8 +1286,9 @@ main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED)
                }
            }
        } else if (buf[0] == 'i') {
-           dump_init((char *) NULL, F_TERMINFO, S_TERMINFO, 70, 0, FALSE);
-           dump_entry(&cur_term->type, FALSE, TRUE, 0, 0);
+           dump_init(NULL, F_TERMINFO, S_TERMINFO,
+                     FALSE, 70, 0, 0, FALSE, FALSE, 0);
+           dump_entry(&TerminalType(cur_term), FALSE, TRUE, 0, 0);
            putchar('\n');
        } else if (buf[0] == 'o') {
            if (_nc_optimize_enable & OPTIMIZE_MVCUR) {