X-Git-Url: https://ncurses.scripts.mit.edu/?p=ncurses.git;a=blobdiff_plain;f=ncurses%2Ftty%2Flib_mvcur.c;h=795922710978ab7e9362359178ec983ef1119043;hp=c4847c720589edb685e200a4749bf48367de79ac;hb=461e72d1826483cb2c2cb243412f2dc5b00b2b1a;hpb=9a0b985989d0aeb66b66b5711d432322aa994969 diff --git a/ncurses/tty/lib_mvcur.c b/ncurses/tty/lib_mvcur.c index c4847c72..79592271 100644 --- a/ncurses/tty/lib_mvcur.c +++ b/ncurses/tty/lib_mvcur.c @@ -1,5 +1,6 @@ /**************************************************************************** - * Copyright (c) 1998-2018,2019 Free Software Foundation, Inc. * + * Copyright 2018-2020,2021 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 * @@ -82,8 +83,8 @@ /* * The average overhead of a full optimization computation in character - * transmission times. If it's too high, the algorithm will be a bit - * over-biased toward using cup rather than local motions; if it's too + * transmission times. If it is too high, the algorithm will be a bit + * over-biased toward using cup rather than local motions; if it is too * low, the algorithm may spend more time than is strictly optimal * looking for non-cup motions. Profile the optimizer using the `t' * command of the exerciser (see below), and round to the nearest integer. @@ -97,7 +98,7 @@ /* * LONG_DIST is the distance we consider to be just as costly to move over as a - * cup sequence is to emit. In other words, it's the length of a cup sequence + * cup sequence is to emit. In other words, it is the length of a cup sequence * adjusted for average computation overhead. The magic number is the length * of "\033[yy;xxH", the typical cup sequence these days. */ @@ -147,7 +148,7 @@ * int _rep_cost; // cost of (repeat_char) * * The USE_HARD_TABS switch controls whether it is reliable to use tab/backtabs - * for local motions. On many systems, it's not, due to uncertainties about + * for local motions. On many systems, it is not, due to uncertainties about * tab delays and whether or not tabs will be expanded in raw mode. If you * have parm_right_cursor, tab motions don't win you a lot anyhow. */ @@ -159,7 +160,7 @@ #define CUR SP_TERMTYPE #endif -MODULE_ID("$Id: lib_mvcur.c,v 1.150 2019/06/01 23:42:09 tom Exp $") +MODULE_ID("$Id: lib_mvcur.c,v 1.156 2021/09/04 10:29:15 tom Exp $") #define WANT_CHAR(sp, y, x) NewScreen(sp)->_line[y].text[x] /* desired state */ @@ -278,8 +279,8 @@ reset_scroll_region(NCURSES_SP_DCL0) { if (change_scroll_region) { NCURSES_PUTP2("change_scroll_region", - TPARM_2(change_scroll_region, - 0, screen_lines(SP_PARM) - 1)); + TIPARM_2(change_scroll_region, + 0, screen_lines(SP_PARM) - 1)); } } @@ -398,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); @@ -421,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)); @@ -562,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; } @@ -572,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); @@ -588,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; } @@ -612,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; } @@ -622,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; } @@ -715,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; } @@ -760,7 +760,7 @@ relative_move(NCURSES_SP_DCLx #endif /* !NO_OPTIMIZE */ /* - * With the machinery set up above, it's conceivable that + * With the machinery set up above, it is conceivable that * onscreen_mvcur could be modified into a recursive function that does * an alpha-beta search of motion space, as though it were a chess * move tree, with the weight function being boolean and the search @@ -792,7 +792,8 @@ onscreen_mvcur(NCURSES_SP_DCLx #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; @@ -961,7 +962,7 @@ _nc_real_mvcur(NCURSES_SP_DCLx NCURSES_CH_T oldattr; int code; - TR(TRACE_CALLS | TRACE_MOVE, (T_CALLED("_nc_tinfo_mvcur(%p,%d,%d,%d,%d)"), + TR(TRACE_CALLS | TRACE_MOVE, (T_CALLED("_nc_real_mvcur(%p,%d,%d,%d,%d)"), (void *) SP_PARM, yold, xold, ynew, xnew)); if (SP_PARM == 0) { @@ -996,37 +997,28 @@ _nc_real_mvcur(NCURSES_SP_DCLx if (xold >= screen_columns(SP_PARM)) { - if (SP_PARM->_nl) { - int l = (xold + 1) / screen_columns(SP_PARM); + int l = (xold + 1) / screen_columns(SP_PARM); - yold += l; - if (yold >= screen_lines(SP_PARM)) - l -= (yold - screen_lines(SP_PARM) - 1); + 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; + 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--; + 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; } }