![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lib_mvcur.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses|
Return to lib_mvcur.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / lib / ncurses |
1.1 ! root 1: /********************************************************************* ! 2: * COPYRIGHT NOTICE * ! 3: ********************************************************************** ! 4: * This software is copyright (C) 1982 by Pavel Curtis * ! 5: * * ! 6: * Permission is granted to reproduce and distribute * ! 7: * this file by any means so long as no fee is charged * ! 8: * above a nominal handling fee and so long as this * ! 9: * notice is always included in the copies. * ! 10: * * ! 11: * Other rights are reserved except as explicitly granted * ! 12: * by written permission of the author. * ! 13: * Pavel Curtis * ! 14: * Computer Science Dept. * ! 15: * 405 Upson Hall * ! 16: * Cornell University * ! 17: * Ithaca, NY 14853 * ! 18: * * ! 19: * Ph- (607) 256-4934 * ! 20: * * ! 21: * Pavel.Cornell@Udel-Relay (ARPAnet) * ! 22: * decvax!cornell!pavel (UUCPnet) * ! 23: *********************************************************************/ ! 24: ! 25: /* ! 26: ** ! 27: ** lib_mvcur.c ! 28: ** ! 29: ** mvcur() and its subroutines ! 30: ** ! 31: ** $Log: lib_mvcur.c,v $ ! 32: * Revision 1.8 93/04/12 14:13:47 bin ! 33: * Udo: third color update ! 34: * ! 35: * Revision 1.2 92/04/13 14:37:43 bin ! 36: * update by vlad ! 37: * ! 38: * Revision 2.2 91/04/20 19:25:30 munk ! 39: * Usage of register variables ! 40: * ! 41: * Revision 2.1 82/10/25 14:47:54 pavel ! 42: * Added Copyright Notice ! 43: * ! 44: * Revision 2.0 82/10/25 13:46:40 pavel ! 45: * Beta-one Test Release ! 46: * ! 47: ** ! 48: ** Revisions needed: ! 49: ** implement c_save instead of multiple tputs() calls ! 50: ** routine revisions ! 51: */ ! 52: ! 53: #ifdef RCSHDR ! 54: static char RCSid[] = ! 55: "$Header: /src386/usr/lib/ncurses/RCS/lib_mvcur.c,v 1.8 93/04/12 14:13:47 bin Exp Locker: bin $"; ! 56: #endif ! 57: ! 58: #include "term.h" ! 59: #include "curses.h" ! 60: #include "curses.priv.h" ! 61: ! 62: ! 63: #define BUFSIZE 128 /* size of strategy buffer */ ! 64: ! 65: struct Sequence ! 66: { ! 67: int vec[BUFSIZE], /* vector of operations */ ! 68: *end, /* end of vector */ ! 69: cost; /* cost of vector */ ! 70: }; ! 71: ! 72: /* ! 73: ** #define ! 74: ** Make_seq_best(s1, s2) ! 75: ** ! 76: ** Make_seq_best() swaps the values ! 77: ** of the pointers if s1->cost > s2->cost. ! 78: */ ! 79: ! 80: #define Make_seq_best(s1, s2) \ ! 81: if (s1->cost > s2->cost) \ ! 82: { \ ! 83: struct Sequence *temp; \ ! 84: \ ! 85: temp = s1; \ ! 86: s1 = s2; \ ! 87: s2 = temp; \ ! 88: } ! 89: ! 90: ! 91: FILE *out_file; /* pointer to output file */ ! 92: ! 93: static int c_count; /* used for counting tputs output */ ! 94: ! 95: /*rev c_save not yet used*/ ! 96: /*static char *c_save;*/ /* used for saving tputs output */ ! 97: ! 98: #define INFINITY 1000 /* biggest, impossible sequence cost */ ! 99: ! 100: #define NUM_OPS 16 /* num. term. control sequences */ ! 101: #define NUM_NPARM 9 /* num. ops wo/ parameters */ ! 102: ! 103: /* operator indexes into op_info */ ! 104: ! 105: #define CARRIAGE_RETURN 0 /* watch out for nl mapping */ ! 106: #define CURS_DOWN 1 ! 107: #define CURS_HOME 2 ! 108: #define CURS_LEFT 3 ! 109: #define CURS_RIGHT 4 ! 110: #define CURS_TO_LL 5 ! 111: #define CURS_UP 6 ! 112: #define TAB 7 ! 113: #define BACK_TAB 8 ! 114: #define ROW_ADDR 9 ! 115: #define COL_ADDR 10 ! 116: #define P_DOWN_CURS 11 ! 117: #define P_LEFT_CURS 12 ! 118: #define P_RIGHT_CURS 13 ! 119: #define P_UP_CURS 14 ! 120: #define CURS_ADDR 15 ! 121: ! 122: static bool loc_init = FALSE; /* set if op_info is init'ed */ ! 123: ! 124: static bool rel_ok; /* set if we really know where we are */ ! 125: ! 126: /* ! 127: * op_info[NUM_OPS] ! 128: * ! 129: * op_info[] contains for operations with no parameters ! 130: * the cost of the operation. These ops should be first in the array. ! 131: * For operations with parameters, op_info[] contains ! 132: * the negative of the number of parameters. ! 133: */ ! 134: ! 135: static int op_info[NUM_OPS] = ! 136: { ! 137: 0, /* carriage_return */ ! 138: 0, /* cursor_down */ ! 139: 0, /* cursor_home */ ! 140: 0, /* cursor_left */ ! 141: 0, /* cursor_right */ ! 142: 0, /* cursor_to_ll */ ! 143: 0, /* cursor_up */ ! 144: 0, /* tab */ ! 145: 0, /* back_tab */ ! 146: -1, /* row_address */ ! 147: -1, /* column_address */ ! 148: -1, /* parm_down_cursor */ ! 149: -1, /* parm_left_cursor */ ! 150: -1, /* parm_right_cursor */ ! 151: -1, /* parm_up_cursor */ ! 152: -2 /* cursor_address */ ! 153: }; ! 154: ! 155: ! 156: /* ! 157: ** ! 158: ** mvcur(oldrow, oldcol, newrow, newcol) ! 159: ** ! 160: ** mvcur() optimally moves the cursor from the position ! 161: ** specified by (oldrow, oldcol) to (newrow, newcol). If ! 162: ** (oldrow, oldcol) == (-1, -1), mvcur() does not use relative ! 163: ** cursor motions. If the coordinates are otherwise ! 164: ** out of bounds, it mods them into range. ! 165: ** ! 166: ** Revisions needed: ! 167: ** eat_newline_glitch, auto_right_margin ! 168: */ ! 169: ! 170: mvcur(oldrow, oldcol, newrow, newcol) ! 171: int oldrow, oldcol, ! 172: newrow, newcol; ! 173: { ! 174: struct Sequence seqA, seqB, /* allocate work structures */ ! 175: col0seq, /* sequence to get from col0 to nc */ ! 176: *best, /* best sequence so far */ ! 177: *try; /* next try */ ! 178: ! 179: #ifdef TRACE ! 180: if (_tracing) ! 181: _tracef("mvcur(%d,%d,%d,%d) called", ! 182: oldrow, oldcol, newrow, newcol); ! 183: #endif ! 184: ! 185: update_ops(); /* make sure op_info[] is current */ ! 186: ! 187: if (oldrow < 0 || oldcol < 0) ! 188: rel_ok = FALSE; /* relative ops ok? */ ! 189: else ! 190: { ! 191: rel_ok = TRUE; ! 192: ! 193: oldrow %= lines; /* mod values into range */ ! 194: oldcol %= columns; ! 195: } ! 196: newrow %= lines; ! 197: newcol %= columns; ! 198: ! 199: best = &seqA; ! 200: try = &seqB; ! 201: ! 202: /* try out direct cursor addressing */ ! 203: ! 204: zero_seq(best); ! 205: add_op(best, CURS_ADDR, newrow, newcol); ! 206: ! 207: /* try out independent row/column addressing */ ! 208: ! 209: if (rel_ok) ! 210: { ! 211: zero_seq(try); ! 212: row(try, oldrow, newrow); ! 213: column(try, oldcol, newcol); ! 214: Make_seq_best(best, try); ! 215: } ! 216: ! 217: zero_seq(&col0seq); /* store seq. to get from c0 to nc */ ! 218: column(&col0seq, 0, newcol); ! 219: ! 220: if(col0seq.cost < INFINITY) /* can get from col0 to newcol */ ! 221: { ! 222: /* try out homing and then row/column */ ! 223: ! 224: if (! rel_ok || newcol < oldcol || newrow < oldrow) ! 225: { ! 226: zero_seq(try); ! 227: add_op(try, CURS_HOME, 1); ! 228: row(try, 0, newrow); ! 229: add_seq(try, &col0seq); ! 230: Make_seq_best(best, try); ! 231: } ! 232: ! 233: /* try out homing to last line and then row/column */ ! 234: ! 235: if (! rel_ok || newcol < oldcol || newrow > oldrow) ! 236: { ! 237: zero_seq(try); ! 238: add_op(try, CURS_TO_LL, 1); ! 239: row(try, lines - 1, newrow); ! 240: add_seq(try, &col0seq); ! 241: Make_seq_best(best, try); ! 242: } ! 243: } ! 244: ! 245: #ifdef TRACE ! 246: if (_tracing) ! 247: _tracef("\tmvcur: result follows"); ! 248: #endif ! 249: ! 250: out_seq(best); ! 251: ! 252: #ifdef TRACE ! 253: if (_tracing) ! 254: _tracef("\tmvcur: end of result"); ! 255: #endif ! 256: } ! 257: ! 258: ! 259: /* ! 260: ** row(outseq, oldrow, newrow) ! 261: ** ! 262: ** row() adds the best sequence for moving ! 263: ** the cursor from oldrow to newrow to seq. ! 264: ** row() considers row_address, parm_up/down_cursor ! 265: ** and cursor_up/down. ! 266: */ ! 267: ! 268: static ! 269: row(outseq, orow, nrow) ! 270: int orow, nrow; /* old, new cursor locations */ ! 271: struct Sequence *outseq; /* where to put the output */ ! 272: { ! 273: struct Sequence seqA, seqB, ! 274: *best, /* best sequence so far */ ! 275: *try; /* next try */ ! 276: int parm_cursor, one_step; ! 277: ! 278: best = &seqA; ! 279: try = &seqB; ! 280: ! 281: if (nrow == orow) ! 282: return; ! 283: ! 284: if (nrow < orow) ! 285: { ! 286: parm_cursor = P_UP_CURS; ! 287: one_step = CURS_UP; ! 288: } ! 289: else ! 290: { ! 291: parm_cursor = P_DOWN_CURS; ! 292: one_step = CURS_DOWN; ! 293: } ! 294: ! 295: /* try out direct row addressing */ ! 296: ! 297: zero_seq(best); ! 298: add_op(best, ROW_ADDR, nrow); ! 299: ! 300: /* try out paramaterized up or down motion */ ! 301: ! 302: if (rel_ok) ! 303: { ! 304: zero_seq(try); ! 305: add_op(try, parm_cursor, abs(orow - nrow)); ! 306: Make_seq_best(best, try); ! 307: } ! 308: /* try getting there one step at a time... */ ! 309: ! 310: if (rel_ok) ! 311: { ! 312: zero_seq(try); ! 313: add_op(try, one_step, abs(orow-nrow)); ! 314: Make_seq_best(best, try); ! 315: } ! 316: ! 317: add_seq(outseq, best); ! 318: } ! 319: ! 320: ! 321: /* ! 322: ** column(outseq, oldcol, newcol) ! 323: ** ! 324: ** column() adds the best sequence for moving ! 325: ** the cursor from oldcol to newcol to outseq. ! 326: ** column() considers column_address, parm_left/right_cursor, ! 327: ** simp_col(), and carriage_return followed by simp_col(). ! 328: */ ! 329: ! 330: static ! 331: column(outseq, ocol, ncol) ! 332: struct Sequence *outseq; /* where to put the output */ ! 333: int ocol, ncol; /* old, new cursor column */ ! 334: { ! 335: struct Sequence seqA, seqB, ! 336: *best, *try; ! 337: int parm_cursor; /* set to either parm_up/down_cursor */ ! 338: ! 339: best = &seqA; ! 340: try = &seqB; ! 341: ! 342: if (ncol == ocol) ! 343: return; ! 344: ! 345: if (ncol < ocol) ! 346: parm_cursor = P_LEFT_CURS; ! 347: else ! 348: parm_cursor = P_RIGHT_CURS; ! 349: ! 350: /* try out direct column addressing */ ! 351: ! 352: zero_seq(best); ! 353: add_op(best, COL_ADDR, ncol); ! 354: ! 355: /* try carriage_return then simp_col() */ ! 356: ! 357: if (! rel_ok || (ncol < ocol)) ! 358: { ! 359: zero_seq(try); ! 360: add_op(try, CARRIAGE_RETURN, 1); ! 361: simp_col(try, 0, ncol); ! 362: Make_seq_best(best, try); ! 363: } ! 364: if (rel_ok) ! 365: { ! 366: /* try out paramaterized left or right motion */ ! 367: ! 368: zero_seq(try); ! 369: add_op(try, parm_cursor, abs(ocol - ncol)); ! 370: Make_seq_best(best, try); ! 371: ! 372: /* try getting there with simp_col() */ ! 373: ! 374: zero_seq(try); ! 375: simp_col(try, ocol, ncol); ! 376: Make_seq_best(best, try); ! 377: } ! 378: ! 379: add_seq(outseq, best); ! 380: } ! 381: ! 382: ! 383: /* ! 384: ** simp_col(outseq, oldcol, newcol) ! 385: ** ! 386: ** simp_col() adds the best simple sequence for getting ! 387: ** from oldcol to newcol to outseq. ! 388: ** simp_col() considers (back_)tab and cursor_left/right. ! 389: ** ! 390: ** Revisions needed: ! 391: ** Simp_col asssumes that the cost of a (back_)tab ! 392: ** is less then the cost of one-stepping to get to the same column. ! 393: ** Should sometimes use overprinting instead of cursor_right. ! 394: */ ! 395: ! 396: static ! 397: simp_col(outseq, oc, nc) ! 398: struct Sequence *outseq; /* place to put sequence */ ! 399: int oc, nc; /* old column, new column */ ! 400: { ! 401: struct Sequence seqA, seqB, tabseq, ! 402: *best, *try; ! 403: int mytab, tabs, onepast, ! 404: one_step, opp_step; ! 405: ! 406: if (! rel_ok) ! 407: { ! 408: outseq->cost = INFINITY; ! 409: return; ! 410: } ! 411: ! 412: if (oc == nc) ! 413: return; ! 414: ! 415: best = &seqA; ! 416: try = &seqB; ! 417: ! 418: if (oc < nc) ! 419: { ! 420: mytab = TAB; ! 421: if (init_tabs > 0 && op_info[TAB] < INFINITY) ! 422: { ! 423: tabs = nc / init_tabs - oc / init_tabs; ! 424: onepast = ((nc / init_tabs) + 1) * init_tabs; ! 425: if (tabs) ! 426: oc = onepast - init_tabs; /* consider it done */ ! 427: } ! 428: else ! 429: tabs = 0; ! 430: ! 431: one_step = CURS_RIGHT; ! 432: opp_step = CURS_LEFT; ! 433: } ! 434: else ! 435: { ! 436: mytab = BACK_TAB; ! 437: if (init_tabs > 0 && op_info[BACK_TAB] < INFINITY) ! 438: { ! 439: tabs = oc / init_tabs - nc / init_tabs; ! 440: onepast = ((nc - 1) / init_tabs) * init_tabs; ! 441: if (tabs) ! 442: oc = onepast + init_tabs; /* consider it done */ ! 443: } ! 444: else ! 445: tabs = 0; ! 446: ! 447: one_step = CURS_LEFT; ! 448: opp_step = CURS_RIGHT; ! 449: } ! 450: ! 451: /* tab as close as possible to nc */ ! 452: ! 453: zero_seq(&tabseq); ! 454: add_op(&tabseq, mytab, tabs); ! 455: ! 456: /* try extra tab and backing up */ ! 457: ! 458: zero_seq(best); ! 459: ! 460: if (onepast >= 0 && onepast < columns) ! 461: { ! 462: add_op(best, mytab, 1); ! 463: add_op(best, opp_step, abs(onepast - nc)); ! 464: } ! 465: else ! 466: best->cost = INFINITY; /* make sure of next swap */ ! 467: ! 468: /* try stepping to nc */ ! 469: ! 470: zero_seq(try); ! 471: add_op(try, one_step, abs(nc - oc)); ! 472: Make_seq_best(best, try); ! 473: ! 474: if (tabseq.cost < INFINITY) ! 475: add_seq(outseq, &tabseq); ! 476: add_seq(outseq, best); ! 477: } ! 478: ! 479: ! 480: /* ! 481: ** zero_seq(seq) ! 482: ** add_seq(seq1, seq2) ! 483: ** out_seq(seq) ! 484: ** ! 485: ** zero_seq() empties seq. ! 486: ** add_seq() adds seq1 to seq2. ! 487: ** out_seq() outputs a sequence. ! 488: */ ! 489: ! 490: static ! 491: zero_seq(seq) ! 492: struct Sequence *seq; ! 493: { ! 494: seq->end = seq->vec; ! 495: seq->cost = 0; ! 496: } ! 497: ! 498: ! 499: static ! 500: add_seq(seq1, seq2) ! 501: register struct Sequence *seq1, *seq2; ! 502: { ! 503: int *vptr; ! 504: ! 505: if(seq1->cost >= INFINITY || seq2->cost >= INFINITY) ! 506: seq1->cost = INFINITY; ! 507: else ! 508: { ! 509: vptr = seq2->vec; ! 510: while (vptr != seq2->end) ! 511: *(seq1->end++) = *(vptr++); ! 512: seq1->cost += seq2->cost; ! 513: } ! 514: } ! 515: ! 516: ! 517: static ! 518: out_seq(seq) ! 519: register struct Sequence *seq; ! 520: { ! 521: char *tparm(); ! 522: register int *opptr; ! 523: int prm[9], ps, p, op, outc(); ! 524: int count; ! 525: char *sequence(); ! 526: ! 527: if (seq->cost >= INFINITY) ! 528: return; ! 529: ! 530: for (opptr = seq->vec; opptr < seq->end; opptr++) ! 531: { ! 532: op = *opptr; /* grab operator */ ! 533: ps = -op_info[op]; ! 534: if(ps > 0) /* parameterized */ ! 535: { ! 536: for (p = 0; p < ps; p++) /* fill in needed parms */ ! 537: prm[p] = *(++opptr); ! 538: ! 539: tputs(tparm(sequence(op), ! 540: prm[0], prm[1], prm[2], prm[3], prm[4], ! 541: prm[5], prm[6], prm[7], prm[8]), 1, outc); ! 542: } ! 543: else ! 544: { ! 545: count = *(++opptr); ! 546: /*rev should save tputs output instead of mult calls */ ! 547: while (count--) /* do count times */ ! 548: tputs(sequence(op), 1, outc); ! 549: } ! 550: } ! 551: } ! 552: ! 553: ! 554: /* ! 555: ** update_ops() ! 556: ** ! 557: ** update_ops() makes sure that ! 558: ** the op_info[] array is updated and initializes ! 559: ** the cost array for SP if needed. ! 560: */ ! 561: ! 562: static ! 563: update_ops() ! 564: { ! 565: char *index(); ! 566: ! 567: if (SP) /* SP structure exists */ ! 568: { ! 569: register int op; ! 570: ! 571: out_file = SP->_ofp; /* set output file pointer */ ! 572: ! 573: if (! SP->_costinit) /* this term not yet assigned costs */ ! 574: { ! 575: loc_init = FALSE; /* if !SP in the future, new term */ ! 576: init_costs(SP->_costs); /* fill term costs */ ! 577: SP->_costinit = TRUE; ! 578: } ! 579: ! 580: for (op = 0; op < NUM_NPARM; op++) ! 581: op_info[op] = SP->_costs[op]; /* set up op_info */ ! 582: ! 583: /* check for newline that might be mapped... */ ! 584: if (SP->_nlmapping && (index(sequence(CURS_DOWN), '\n') != NULL)) ! 585: op_info[CURS_DOWN] = INFINITY; ! 586: } ! 587: else ! 588: { ! 589: out_file = stdout; ! 590: ! 591: if (! loc_init) /* using local costs */ ! 592: { ! 593: loc_init = TRUE; ! 594: init_costs(op_info); /* set up op_info */ ! 595: } ! 596: /* check for newline that might be mapped... */ ! 597: if (index(sequence(CURS_DOWN), '\n') != NULL) ! 598: op_info[CURS_DOWN] = INFINITY; ! 599: } ! 600: } ! 601: ! 602: ! 603: /* ! 604: ** init_costs(costs) ! 605: ** ! 606: ** init_costs() fills the array costs[NUM_NPARM] ! 607: ** with costs calculated by doing tputs() calls. ! 608: */ ! 609: ! 610: static ! 611: init_costs(costs) ! 612: int costs[]; ! 613: { ! 614: register int i; ! 615: int countc(); ! 616: ! 617: for (i = 0; i < NUM_NPARM; i++) ! 618: if(sequence(i) != (char *) 0) ! 619: { ! 620: #ifdef TRACE ! 621: if (_tracing) ! 622: _tracef("\tinit_costs: pricing %d: '%s'", i, sequence(i)); ! 623: #endif ! 624: ! 625: c_count = 0; ! 626: tputs(sequence(i), 1, countc); ! 627: costs[i] = c_count; ! 628: } ! 629: else ! 630: costs[i] = INFINITY; ! 631: } ! 632: ! 633: ! 634: /* ! 635: ** countc() ! 636: ** outc(c) ! 637: ** savec(c) ! 638: ** ! 639: ** countc() increments global var c_count. ! 640: ** outc() outputs a single character. ! 641: ** savec() saves c in *c_save and increments c_save and c_count. ! 642: */ ! 643: ! 644: static ! 645: countc() ! 646: { ! 647: c_count++; ! 648: } ! 649: ! 650: ! 651: static ! 652: outc(c) ! 653: char c; ! 654: { ! 655: fputc(c, out_file); ! 656: } ! 657: ! 658: ! 659: /*rev not yet needed ! 660: static ! 661: savec(c) ! 662: char c; ! 663: { ! 664: *(c_save++) = c; ! 665: c_count++; ! 666: } ! 667: */ ! 668: ! 669: ! 670: /* ! 671: ** add_op(seq, op, p0, p1, ... , p8) ! 672: ** ! 673: ** add_op() adds the operator op and the appropriate ! 674: ** number of paramaters to seq. It also increases the ! 675: ** cost appropriately. ! 676: ** if op has no parameters, p0 is taken to be a count. ! 677: */ ! 678: ! 679: static ! 680: add_op(seq, op, p0, p1, p2, p3, p4, p5, p6, p7, p8) ! 681: struct Sequence *seq; ! 682: int op, p0, p1, p2, p3, p4, p5, p6, p7, p8; ! 683: { ! 684: char *tparm(); ! 685: int num_ps, p; ! 686: ! 687: #ifdef TRACE ! 688: if (_tracing) ! 689: _tracef("\tadd_op(%o,%d,%d,%d) called", seq, op, p0, p1); ! 690: #endif ! 691: ! 692: num_ps = - op_info[op]; /* get parms or -cost */ ! 693: *(seq->end++) = op; ! 694: ! 695: if (num_ps == (- INFINITY) || sequence(op) == (char *) 0) ! 696: seq->cost = INFINITY; ! 697: else ! 698: if (num_ps <= 0) /* no parms, -cost */ ! 699: { ! 700: seq->cost -= p0 * num_ps; /* ADD count * cost */ ! 701: *(seq->end++) = p0; ! 702: } ! 703: else ! 704: { ! 705: int pms[9]; ! 706: ! 707: pms[0] = p0; pms[1] = p1; pms[2] = p2; ! 708: pms[3] = p3; pms[4] = p4; pms[5] = p5; ! 709: pms[6] = p6; pms[7] = p7; pms[8] = p8; ! 710: for(p = 0; p < num_ps; p++) ! 711: *(seq->end++) = pms[p]; ! 712: c_count = 0; ! 713: tputs(tparm(sequence(op), p0, p1, p2, p3, p4, p5, p6, p7, p8), ! 714: 1, countc); ! 715: seq->cost += c_count; ! 716: } ! 717: } ! 718: ! 719: ! 720: /* ! 721: ** char * ! 722: ** sequence(op) ! 723: ** ! 724: ** sequence() returns a pointer to the op's ! 725: ** terminal control sequence. ! 726: */ ! 727: ! 728: static char * ! 729: sequence(op) ! 730: register int op; ! 731: { ! 732: ! 733: switch(op) ! 734: { ! 735: case CARRIAGE_RETURN: ! 736: return (carriage_return); ! 737: case CURS_DOWN: ! 738: return (cursor_down); ! 739: case CURS_HOME: ! 740: return (cursor_home); ! 741: case CURS_LEFT: ! 742: return (cursor_left); ! 743: case CURS_RIGHT: ! 744: return (cursor_right); ! 745: case CURS_TO_LL: ! 746: return (cursor_to_ll); ! 747: case CURS_UP: ! 748: return (cursor_up); ! 749: case TAB: ! 750: return (tab); ! 751: case BACK_TAB: ! 752: return (back_tab); ! 753: case ROW_ADDR: ! 754: return (row_address); ! 755: case COL_ADDR: ! 756: return (column_address); ! 757: case P_DOWN_CURS: ! 758: return (parm_down_cursor); ! 759: case P_LEFT_CURS: ! 760: return (parm_left_cursor); ! 761: case P_RIGHT_CURS: ! 762: return (parm_right_cursor); ! 763: case P_UP_CURS: ! 764: return (parm_up_cursor); ! 765: case CURS_ADDR: ! 766: return (cursor_address); ! 767: default: ! 768: return ((char *) 0); ! 769: } ! 770: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.