![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mvcur.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / ncurses / screen|
Return to mvcur.c CVS log | Up to [Research Unix] / researchv10no / ncurses / screen |
1.1 ! root 1: #include "curses.ext" ! 2: /* @(#) mvcur.c: 1.1 10/15/83 (1.14 3/16/83) */ ! 3: ! 4: ! 5: /* ! 6: * Cursor motion optimization routine. This routine takes as parameters ! 7: * the screen positions that the cursor is currently at, and the position ! 8: * you want it to be at, and it will move the cursor there very ! 9: * efficiently. It isn't really optimal, since several approximations ! 10: * are taken in the interests of efficiency and simplicity. The code ! 11: * here considers directly addressing the cursor, and also considers ! 12: * local motions using left, right, up, down, tabs, backtabs, vertical ! 13: * and horizontal addressing, and parameterized motions. It does not ! 14: * consider using home down, or taking advantage of automatic margins on ! 15: * any of the four directions. (Two of these directions, left and right, ! 16: * are well defined by the am and bw capabilities, but up and down are ! 17: * not defined, nor are tab or backtab off the ends.) ! 18: * ! 19: * General strategies considered: ! 20: * CA Direct Cursor Addressing ! 21: * LM Local Motions from the old position ! 22: * HDR Home + Local Motions from upper left corner ! 23: * CR CR + Local Motions from left margin ! 24: * ! 25: * Local Motions can include ! 26: * Up cuu, cuu1, vpa ! 27: * Down cud, cud1, vpa ! 28: * Left cul, cul1, hpa, bs, cbt ! 29: * Right cuf, cuf1, hpa, tab, char moved over ! 30: */ ! 31: ! 32: #ifdef DEBUG ! 33: /* We don't want this debugging output now. */ ! 34: # undef DEBUG ! 35: #endif ! 36: ! 37: /* #define mvcurdebug */ ! 38: ! 39: #ifdef mvcurdebug ! 40: # define DEBUG ! 41: # define _outch oc ! 42: FILE *outf; ! 43: main() ! 44: { ! 45: int oldrow, oldcol, newrow, newcol, n; ! 46: ! 47: newterm(getenv("TERM"), stdout, stdin); ! 48: echo(); ! 49: nocrmode(); ! 50: nl(); ! 51: outf = stdout; ! 52: setbuf(stdout, NULL); ! 53: for (;;) { ! 54: printf("oldrow, oldcol, newrow, newcol: "); ! 55: n = scanf("%d %d %d %d", &oldrow, &oldcol, &newrow, &newcol); ! 56: if (n < 0) { ! 57: endwin(); ! 58: exit(1); ! 59: } ! 60: mvcur(oldrow, oldcol, newrow, newcol); ! 61: } ! 62: } ! 63: ! 64: _outch(ch) ! 65: { ! 66: printf("_outch '%s'\n", unctrl(ch)); ! 67: } ! 68: #else ! 69: int _outch(); ! 70: #endif ! 71: ! 72: static int bare_lf_ok; /* bare_lf_ok is true if linefeed will work right */ ! 73: char *tparm(); ! 74: ! 75: mvcur(oldrow, oldcol, newrow, newcol) ! 76: int oldrow, oldcol, newrow, newcol; ! 77: { ! 78: /* temporary costs of various submotions */ ! 79: int home_right; /* cost to move from col 0 right to newcol */ ! 80: int cur_right; /* motion from current postition to right */ ! 81: int cur_left; /* motion from current postition to left */ ! 82: int home_down; /* motion from line 0 downward */ ! 83: int cur_down; /* motion from current position downward */ ! 84: int cur_up; /* motion from current position upward */ ! 85: /* costs of various full motions we consider */ ! 86: int cost_ca; /* cost of directly addressing the cursor */ ! 87: int cost_hdr; /* going home, local motions down & right */ ! 88: int cost_cr; /* return, local motions up/down & right */ ! 89: int cost_lm; /* local motions up/down & left/right */ ! 90: int sgf; ! 91: ! 92: #ifdef DEBUG ! 93: if(outf) fprintf(outf, "mvcur(oldrow=%d, oldcol=%d, newrow=%d, newcol=%d)\n", ! 94: oldrow, oldcol, newrow, newcol); ! 95: #endif ! 96: /* Quick check for nothing to do - very common case. */ ! 97: if (oldrow == newrow && oldcol == newcol) ! 98: return; ! 99: #ifndef NONSTANDARD ! 100: # ifdef USG ! 101: bare_lf_ok = ((cur_term->Nttyb.c_oflag&ONLCR)==0); ! 102: # else ! 103: sgf = cur_term->Nttyb.sg_flags; ! 104: bare_lf_ok = (sgf&RAW) ? 1 : (sgf&CRMOD)==0; ! 105: # endif ! 106: #else NONSTANDARD ! 107: bare_lf_ok = 1; ! 108: #endif NONSTANDARD ! 109: /* Another common case: crlf */ ! 110: if (newcol==0 && newrow==oldrow+1 && carriage_return && cursor_down) { ! 111: /* ! 112: * Just because bare_lf_ok is on doesn't mean cursor_down is ! 113: * crlf. E.g. in the tty 40/2 it's escape B. The test below ! 114: * will be wrong on a newline style terminal (!bare_lf_ok) ! 115: * with no carriage_return where cursor_down is not crlf. ! 116: * I have never seen such a terminal. ! 117: */ ! 118: if (oldcol > 0 && carriage_return) ! 119: tputs(carriage_return, 1, _outch); ! 120: tputs(cursor_down, 1, _outch); ! 121: return; ! 122: } ! 123: ! 124: /* Figure out costs of various component motions */ ! 125: home_right = _loc_right(0 , newcol, 0, newcol); ! 126: cur_right = _loc_right(oldcol, newcol, 0, newcol); ! 127: cur_left = _loc_left (oldcol, newcol, 0); ! 128: home_down = _loc_down (0 , newrow, 0, newcol); ! 129: cur_down = _loc_down (oldrow, newrow, 0, newcol); ! 130: cur_up = _loc_up (oldrow, newrow, 0); ! 131: #ifdef DEBUG ! 132: if(outf) fprintf(outf, "home_right %d, cur_right %d, cur_left %d, home_down %d, cur_down %d, cur_up %d\n", ! 133: home_right, cur_right, cur_left, home_down, cur_down, cur_up); ! 134: #endif ! 135: ! 136: /* 4 possible strategies: get costs for each */ ! 137: cost_ca = _cost(Cursor_address); ! 138: cost_hdr = _cost(Cursor_home) + home_down + home_right; ! 139: /* 3rd and 4th strategies: local motions and with carriage return. */ ! 140: if (newrow < oldrow) { ! 141: if (newcol < oldcol) ! 142: cost_lm = cur_left + cur_up; ! 143: else ! 144: cost_lm = cur_right + cur_up; ! 145: cost_cr = _cost(Carriage_return) + cur_up + home_right; ! 146: } else { ! 147: if (newcol < oldcol) ! 148: cost_lm = cur_left + cur_down; ! 149: else ! 150: cost_lm = cur_right + cur_down; ! 151: if (cur_down >= INFINITY) ! 152: cur_down = _loc_down(oldrow, newrow, 0, 0); ! 153: cost_cr = _cost(Carriage_return) + cur_down + home_right; ! 154: } ! 155: ! 156: #ifdef DEBUG ! 157: if(outf) fprintf(outf, "cost_ca %d, cost_hdr %d, cost_cr %d, cost_lm %d\n", ! 158: cost_ca, cost_hdr, cost_cr, cost_lm); ! 159: #endif ! 160: /* ! 161: * Now we pick which one is cheapest and actually do it. ! 162: * Note the ordering if they come out equal - this was ! 163: * conciously chosen based on how visually distracting ! 164: * it is to see the cursor bounce all over the screen, ! 165: * I did not take into account approximation errors. ! 166: */ ! 167: if (cost_ca <= cost_hdr && cost_ca <= cost_cr && cost_ca <= cost_lm) { ! 168: /* direct cursor addressing is cheapest */ ! 169: #ifdef DEBUG ! 170: if(outf) fprintf(outf, "chose absolute cursor addressing\n"); ! 171: #endif ! 172: tputs(tparm(cursor_address, newrow, newcol), 1, _outch); ! 173: } else if (cost_lm <= cost_cr && cost_lm <= cost_hdr) { ! 174: /* local motions are cheapest */ ! 175: #ifdef DEBUG ! 176: if(outf) fprintf(outf, "chose local motions\n"); ! 177: #endif ! 178: if (newcol > oldcol) { ! 179: if (newrow > oldrow) ! 180: (void) _loc_down(oldrow, newrow, 1, newcol); ! 181: else ! 182: (void) _loc_up(oldrow, newrow, 1); ! 183: (void) _loc_right(oldcol, newcol, 1, newrow); ! 184: } else { ! 185: if (newrow > oldrow) ! 186: (void) _loc_down(oldrow, newrow, 1, newcol); ! 187: else ! 188: (void) _loc_up(oldrow, newrow, 1); ! 189: (void) _loc_left(oldcol, newcol, 1); ! 190: } ! 191: } else if (cost_cr <= cost_hdr) { ! 192: /* carriage return + local motions are cheapest */ ! 193: #ifdef DEBUG ! 194: if(outf) fprintf(outf, "chose carriage return + local motions\n"); ! 195: #endif ! 196: tputs(carriage_return, 1, _outch); ! 197: if (newrow > oldrow) ! 198: (void) _loc_down(oldrow, newrow, 1, 0); ! 199: else ! 200: (void) _loc_up(oldrow, newrow, 1); ! 201: (void) _loc_right(0, newcol, 1, newrow); ! 202: } else { ! 203: /* home + local motions are cheapest */ ! 204: #ifdef DEBUG ! 205: if(outf) fprintf(outf, "chose home + local motions\n"); ! 206: #endif ! 207: tputs(cursor_home, 1, _outch); ! 208: (void) _loc_down(0, newrow, 1, newcol); ! 209: (void) _loc_right(0, newcol, 1, newrow); ! 210: } ! 211: #ifdef DEBUG ! 212: if(outf) fprintf(outf, "end of mvcur\n"); ! 213: #endif ! 214: } ! 215: ! 216: /* ! 217: * These four routines figure out what the cost of the most efficient ! 218: * kind of local motion from the given row or column to the other given ! 219: * row or column is. They return the cost, in characters. If the third ! 220: * argument is 1, they actually do the motion. The row number is useful ! 221: * if we're going to actually do the motion - that way we can look in ! 222: * the screen image (if we have it) and just output the characters that ! 223: * are already on the screen - this usually saves 50% over cursor_right. ! 224: */ ! 225: static ! 226: _loc_right(oldcol, newcol, domotion, row) ! 227: { ! 228: int c0, c1, c2, c3; ! 229: int i, tabcol, ntabs, nright, nleft; ! 230: /* notinsmode: we know for sure we aren't in insert char mode */ ! 231: int notinsmode = SP && SP->phys_irm!=1; ! 232: register struct line *rp; ! 233: ! 234: if (newcol < oldcol) /* can't go left with right motions */ ! 235: return INFINITY; ! 236: if (newcol == oldcol) ! 237: return 0; /* already there - nothing to do */ ! 238: #ifdef DEBUG ! 239: fprintf(outf, "SP %x, phys_irm %d, notinsmode %d\n", ! 240: SP, SP->phys_irm, notinsmode); ! 241: #endif ! 242: ! 243: /* ! 244: * Code here and further down attempts to output the character that ! 245: * is already on the screen to move right. ! 246: */ ! 247: if (notinsmode) ! 248: _cost(Cursor_right) = 1; ! 249: else ! 250: _cost(Cursor_right) = _cost(Right_base); ! 251: /* figure out various costs */ ! 252: ! 253: tabcol = (newcol+4)/8 * 8; /* round to nearest 8 */ ! 254: /* tab past right margin is undefined */ ! 255: if (tabcol >= columns) ! 256: tabcol = (columns-1)/8 * 8; ! 257: ntabs = (tabcol-oldcol+7)/8; ! 258: if (ntabs <= 0) ! 259: tabcol = oldcol; ! 260: if (tabcol < newcol) { ! 261: /* some tabs plus some rights */ ! 262: nright = newcol - tabcol; ! 263: c1 = ntabs*_cost(Tab) + nright*_cost(Cursor_right); ! 264: } else { ! 265: /* some tabs plus some lefts */ ! 266: nleft = tabcol - newcol; ! 267: c1 = ntabs*_cost(Tab) + nleft*_cost(Cursor_left); ! 268: } ! 269: ! 270: c0 = (newcol - oldcol) * _cost(Cursor_right); ! 271: ! 272: if (parm_right_cursor) ! 273: c2 = _cost(Parm_right_cursor); ! 274: else ! 275: c2 = INFINITY; ! 276: ! 277: if (column_address) ! 278: c3 = _cost(Column_address); ! 279: else ! 280: c3 = INFINITY; ! 281: ! 282: #ifdef DEBUG ! 283: if(outf) fprintf(outf, "_loc_right(%d, %d, %d), chars %d, ri %d, RI %d, ch %d\n", ! 284: oldcol, newcol, domotion, c0, c1, c2, c3); ! 285: #endif ! 286: ! 287: /* Decide and maybe do them */ ! 288: if (c3 <= c1 && c3 <= c2 && c3 <= c0) { ! 289: /* cheapest to use column absolute cursor addressing */ ! 290: #ifdef DEBUG ! 291: if(outf) fprintf(outf, "chose column absolute cursor addressing\n"); ! 292: #endif ! 293: if (domotion) ! 294: tputs(tparm(column_address, newcol), 1, _outch); ! 295: return c3; ! 296: } else if (c2 <= c1 && c2 <= c0) { ! 297: /* cheapest to use column relative motion */ ! 298: #ifdef DEBUG ! 299: if(outf) fprintf(outf, "chose column relative motion\n"); ! 300: #endif ! 301: if (domotion) ! 302: tputs(tparm(parm_right_cursor, newcol-oldcol), 1, _outch); ! 303: return c2; ! 304: } else { ! 305: /* cheapest to use several right commands */ ! 306: #ifdef DEBUG ! 307: if(outf) fprintf(outf, "chose rights: ntabs %d, tabcol %d, nleft %d, nright %d\n", ntabs, tabcol, nleft, nright); ! 308: #endif ! 309: if (domotion) ! 310: if (c1 < c0) { ! 311: for (i=0; i<ntabs; i++) ! 312: tputs(tab, 1, _outch); ! 313: if (tabcol < newcol) { ! 314: /* some tabs plus some rights */ ! 315: for (i=0; i<nright; i++) { ! 316: #ifdef DEBUG ! 317: if (outf && SP->cur_body[row+1]) fprintf(outf, "nd1, row %d col %d+%d=%d, char '%c'\n", ! 318: row, tabcol, i, tabcol+i, SP->cur_body[row+1]->body[tabcol+i]); ! 319: #endif ! 320: rp = SP->cur_body[row+1]; ! 321: if (cursor_right && (!notinsmode || rp && SP->phys_gr != (rp->body[tabcol+i] & A_ATTRIBUTES))) /* dont know */ ! 322: tputs(cursor_right,1,_outch); ! 323: else if (rp && rp->length > tabcol+i) ! 324: /* Note we assume dumb terminals without cursor_right don't have ! 325: * standout either, otherwise we should go into right standout ! 326: * mode here and in the essentially similar code below. ! 327: */ ! 328: _outch(rp->body[tabcol+i]&A_CHARTEXT); ! 329: else /* off edge */ ! 330: _outch(' '); ! 331: } ! 332: } else { ! 333: /* some tabs plus some lefts */ ! 334: for (i=0; i<nleft; i++) ! 335: tputs(cursor_left,1,_outch); ! 336: } ! 337: } else { ! 338: for (i=oldcol; i<newcol; i++) { ! 339: #ifdef DEBUG ! 340: if (outf && SP->cur_body[row+1]) fprintf(outf, "nd2, row %d col %d, char '%c'\n", ! 341: row, i, SP->cur_body[row+1]->body[i]); ! 342: #endif ! 343: rp = SP->cur_body[row+1]; ! 344: if (cursor_right && (!notinsmode || rp && SP->phys_gr != (rp->body[i] & A_ATTRIBUTES))) /* dont know */ ! 345: tputs(cursor_right,1,_outch); ! 346: else if (rp && rp->length > i) ! 347: _outch(rp->body[i]&A_CHARTEXT); ! 348: else /* off edge */ ! 349: _outch(' '); ! 350: } ! 351: } ! 352: return (c1 < c0) ? c1 : c0; ! 353: } ! 354: } ! 355: ! 356: static ! 357: _loc_left(oldcol, newcol, domotion) ! 358: { ! 359: int c1, c2, c3; ! 360: int i, tabcol, ntabs, nright, nleft; ! 361: ! 362: if (newcol > oldcol) /* can't go right with left motions */ ! 363: return INFINITY; ! 364: if (newcol == oldcol) ! 365: return 0; /* already there - nothing to do */ ! 366: ! 367: /* figure out various costs */ ! 368: if (cursor_left) { ! 369: if (back_tab) { ! 370: tabcol = (newcol+4)/8 * 8; /* round to nearest 8 */ ! 371: /* tab past left margin is undefined */ ! 372: if (tabcol < 8) ! 373: tabcol = 8; ! 374: ntabs = (oldcol-tabcol+7)/8; ! 375: if (ntabs <= 0) ! 376: tabcol = oldcol; ! 377: if (tabcol < newcol) { ! 378: /* some backtabs plus some rights */ ! 379: nright = newcol - tabcol; ! 380: c1 = ntabs*_cost(Back_tab) + nright*_cost(Cursor_right); ! 381: } else { ! 382: /* some tabs plus some lefts */ ! 383: nleft = tabcol - newcol; ! 384: c1 = ntabs*_cost(Back_tab) + nleft*_cost(Cursor_left); ! 385: } ! 386: } else { ! 387: c1 = (oldcol - newcol) * _cost(Cursor_left); ! 388: } ! 389: } else ! 390: c1 = INFINITY; ! 391: if (parm_left_cursor) ! 392: c2 = _cost(Parm_left_cursor); ! 393: else ! 394: c2 = INFINITY; ! 395: if (column_address) ! 396: c3 = _cost(Column_address); ! 397: else ! 398: c3 = INFINITY; ! 399: ! 400: #ifdef DEBUG ! 401: if(outf) fprintf(outf, "_loc_left(%d, %d, %d), le %d, LE %d, ch %d\n", ! 402: oldcol, newcol, domotion, c1, c2, c3); ! 403: #endif ! 404: ! 405: /* Decide and maybe do them */ ! 406: if (c3 <= c1 && c3 <= c2) { ! 407: /* cheapest to use column absolute cursor addressing */ ! 408: #ifdef DEBUG ! 409: if(outf) fprintf(outf, "chose column absolute cursor addressing\n"); ! 410: #endif ! 411: if (domotion) ! 412: tputs(tparm(column_address, newcol), 1, _outch); ! 413: return c3; ! 414: } else if (c2 <= c1) { ! 415: /* cheapest to use column relative motion */ ! 416: #ifdef DEBUG ! 417: if(outf) fprintf(outf, "chose column relative motion\n"); ! 418: #endif ! 419: if (domotion) ! 420: tputs(tparm(parm_left_cursor, oldcol-newcol), 1, _outch); ! 421: return c2; ! 422: } else { ! 423: /* cheapest to use several left commands */ ! 424: #ifdef DEBUG ! 425: if(outf) fprintf(outf, "chose several left commands\n"); ! 426: #endif ! 427: if (domotion) ! 428: if (back_tab) { ! 429: for (i=0; i<ntabs; i++) ! 430: tputs(back_tab, 1, _outch); ! 431: if (tabcol < newcol) { ! 432: /* some tabs plus some rights */ ! 433: for (i=0; i<nright; i++) ! 434: tputs(cursor_right,1, _outch); ! 435: } else { ! 436: /* some tabs plus some lefts */ ! 437: for (i=0; i<nleft; i++) ! 438: tputs(cursor_left,1,_outch); ! 439: } ! 440: } else { ! 441: for (i=oldcol; i>newcol; i--) ! 442: tputs(cursor_left, 1, _outch); ! 443: } ! 444: return c1; ! 445: } ! 446: } ! 447: ! 448: static ! 449: _loc_up(oldrow, newrow, domotion) ! 450: { ! 451: int c1, c2, c3, i; ! 452: ! 453: if (newrow > oldrow) /* can't go down with up motions */ ! 454: return INFINITY; ! 455: if (newrow == oldrow) ! 456: return 0; /* already there - nothing to do */ ! 457: ! 458: /* figure out various costs */ ! 459: if (cursor_up) ! 460: c1 = (oldrow - newrow) * _cost(Cursor_up); ! 461: else ! 462: c1 = INFINITY; ! 463: if (parm_up_cursor) ! 464: c2 = _cost(Parm_up_cursor); ! 465: else ! 466: c2 = INFINITY; ! 467: if (row_address) ! 468: c3 = _cost(Row_address); ! 469: else ! 470: c3 = INFINITY; ! 471: ! 472: #ifdef DEBUG ! 473: if(outf) fprintf(outf, "_loc_up(%d, %d, %d), up %d, UP %d, cv %d\n", ! 474: oldrow, newrow, domotion, c1, c2, c3); ! 475: #endif ! 476: ! 477: /* Decide and maybe do them */ ! 478: if (c3 <= c1 && c3 <= c2) { ! 479: /* cheapest to use row absolute cursor addressing */ ! 480: #ifdef DEBUG ! 481: if(outf) fprintf(outf, "chose row absolute cursor addressing\n"); ! 482: #endif ! 483: if (domotion) ! 484: tputs(tparm(row_address, newrow), 1, _outch); ! 485: return c3; ! 486: } else if (c2 <= c1) { ! 487: /* cheapest to use row relative motion */ ! 488: #ifdef DEBUG ! 489: if(outf) fprintf(outf, "chose row relative motion\n"); ! 490: #endif ! 491: if (domotion) ! 492: tputs(tparm(parm_up_cursor, oldrow-newrow), 1, _outch); ! 493: return c2; ! 494: } else { ! 495: /* cheapest to use several up commands */ ! 496: #ifdef DEBUG ! 497: if(outf) fprintf(outf, "chose several up commands\n"); ! 498: #endif ! 499: if (domotion) ! 500: for (i=oldrow; i>newrow; i--) ! 501: tputs(cursor_up, 1, _outch); ! 502: return c1; ! 503: } ! 504: } ! 505: ! 506: static ! 507: _loc_down(oldrow, newrow, domotion, col) ! 508: { ! 509: int c1, c2, c3, i; ! 510: ! 511: if (newrow < oldrow) /* can't go up with down motions */ ! 512: return INFINITY; ! 513: if (newrow == oldrow) ! 514: return 0; /* already there - nothing to do */ ! 515: ! 516: /* figure out various costs */ ! 517: if (cursor_down && (col==0 || bare_lf_ok || *cursor_down!='\n')) ! 518: c1 = (newrow - oldrow) * _cost(Cursor_down); ! 519: else ! 520: c1 = INFINITY; ! 521: if (parm_down_cursor) ! 522: c2 = _cost(Parm_down_cursor); ! 523: else ! 524: c2 = INFINITY; ! 525: if (row_address) ! 526: c3 = _cost(Row_address); ! 527: else ! 528: c3 = INFINITY; ! 529: ! 530: #ifdef DEBUG ! 531: if(outf) fprintf(outf, "_loc_down(%d, %d, %d, %d), do %d, DO %d, cv %d\n", ! 532: oldrow, newrow, domotion, col,c1, c2, c3); ! 533: #endif ! 534: ! 535: /* Decide and maybe do them */ ! 536: if (c3 <= c1 && c3 <= c2) { ! 537: /* cheapest to use row absolute cursor addressing */ ! 538: #ifdef DEBUG ! 539: if(outf) fprintf(outf, "chose row absolute cursor addressing\n"); ! 540: #endif ! 541: if (domotion) ! 542: tputs(tparm(row_address, newrow), 1, _outch); ! 543: return c3; ! 544: } else if (c2 <= c1) { ! 545: /* cheapest to use row relative motion */ ! 546: #ifdef DEBUG ! 547: if(outf) fprintf(outf, "chose row relative motion\n"); ! 548: #endif ! 549: if (domotion) ! 550: tputs(tparm(parm_down_cursor, newrow-oldrow), 1, _outch); ! 551: return c2; ! 552: } else { ! 553: /* cheapest to use several down commands */ ! 554: #ifdef DEBUG ! 555: if(outf) fprintf(outf, "chose several down commands\n"); ! 556: #endif ! 557: if (domotion) ! 558: for (i=oldrow; i<newrow; i++) ! 559: tputs(cursor_down, 1, _outch); ! 560: return c1; ! 561: } ! 562: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.