Annotation of freem/src/service.c, revision 1.1
1.1 ! snw 1: /*
! 2: * *
! 3: * * *
! 4: * * *
! 5: * ***************
! 6: * * * * *
! 7: * * MUMPS *
! 8: * * * * *
! 9: * ***************
! 10: * * *
! 11: * * *
! 12: * *
! 13: *
! 14: * service.c
! 15: * terminal and sequential I/O handling,
! 16: * file and global locking
! 17: *
! 18: *
! 19: * Author: Serena Willis <jpw@coherent-logic.com>
! 20: * Copyright (C) 1998 MUG Deutschland
! 21: * Copyright (C) 2020 Coherent Logic Development LLC
! 22: *
! 23: *
! 24: * This file is part of FreeM.
! 25: *
! 26: * FreeM is free software: you can redistribute it and/or modify
! 27: * it under the terms of the GNU Affero Public License as published by
! 28: * the Free Software Foundation, either version 3 of the License, or
! 29: * (at your option) any later version.
! 30: *
! 31: * FreeM is distributed in the hope that it will be useful,
! 32: * but WITHOUT ANY WARRANTY; without even the implied warranty of
! 33: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! 34: * GNU Affero Public License for more details.
! 35: *
! 36: * You should have received a copy of the GNU Affero Public License
! 37: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
! 38: *
! 39: **/
! 40:
! 41: #include <errno.h>
! 42: #include <sys/types.h>
! 43:
! 44: #if !defined(__OpenBSD__) && !defined(__FreeBSD__)
! 45: # include <sys/timeb.h>
! 46: #endif
! 47:
! 48: #include <sys/ioctl.h>
! 49: #include <unistd.h>
! 50: #include <stdlib.h>
! 51:
! 52: #ifdef AMIGA68K
! 53: #include <sys/fcntl.h>
! 54: #endif
! 55:
! 56: #define MAXZAS NESTLEVLS
! 57: #include "mpsdef.h"
! 58:
! 59: #include <time.h>
! 60:
! 61: #ifdef USE_SYS_TIME_H
! 62: #include <sys/time.h>
! 63: #endif
! 64:
! 65: #include "events.h"
! 66:
! 67: long int tell ();
! 68: unsigned alarm ();
! 69: void ris ();
! 70:
! 71:
! 72: #ifdef SCO
! 73: int scosgr (short att, short bwflag);
! 74: #endif
! 75:
! 76: /* system services */
! 77: #include <termios.h>
! 78: #include <fcntl.h>
! 79:
! 80: /* search 'string' for occurence of 'pattrn'
! 81: * return: 0='not found' nbr='pattern begins at nbr' */
! 82: long int find (char *string, char *pattrn)
! 83: {
! 84: short i;
! 85: short j;
! 86: register int k;
! 87: register int l;
! 88:
! 89: i = 0;
! 90:
! 91: while (pattrn[i] != EOL) i++; /* $l of 2nd arg */
! 92:
! 93: if (i == 1) {
! 94:
! 95: l = pattrn[0];
! 96: k = 0;
! 97:
! 98: while (string[k] != EOL) {
! 99:
! 100: if (string[k++] == l) return k;
! 101:
! 102: }
! 103:
! 104: return 0L;
! 105:
! 106: }
! 107:
! 108: j = stlen (string);
! 109:
! 110: for (k = 0; k < j; k++) {
! 111:
! 112: l = 0;
! 113:
! 114:
! 115: l10:
! 116:
! 117: if (string[k + l] != pattrn[l]) continue;
! 118: if (++l < i) goto l10;
! 119:
! 120: return ++k;
! 121:
! 122: }
! 123:
! 124: return 0L;
! 125: } /* end of find() */
! 126:
! 127: /* called by exclusive KILL to search 'exceptions' for occurence of 'variable'
! 128: * return: 1='not found, can be killed' 0='cannot be killed' */
! 129: short int kill_ok (char *exceptions, char *variable)
! 130: {
! 131: short i;
! 132: short j;
! 133: register int k;
! 134: register int l;
! 135:
! 136: j = stlen (exceptions);
! 137: i = stlen (variable);
! 138:
! 139: for (k = 0; k < j; k++) {
! 140:
! 141: for (l = 0; l < i; l++) {
! 142:
! 143: if (exceptions[k + l] != variable[l]) {
! 144:
! 145: if (exceptions[k + l] == SP && variable[l] == DELIM) return FALSE;
! 146:
! 147: goto outerspace;
! 148:
! 149: }
! 150:
! 151: }
! 152:
! 153: return FALSE;
! 154:
! 155:
! 156: outerspace:; /* the semicolon apparently needs to be here in this case. */
! 157: /* break time. */
! 158:
! 159: }
! 160:
! 161: return TRUE;
! 162: } /* end of kill_ok */
! 163:
! 164: /* write this format */
! 165: void write_f (char *intext)
! 166: {
! 167: char outtext[256]; /* output string */
! 168: short l;
! 169: int i;
! 170: char final;
! 171: int csi;
! 172:
! 173: csi = FALSE;
! 174: l = stlen (intext);
! 175:
! 176: if (l < 2) return; /* not recognized */
! 177:
! 178: for (i = 0; i < l; i++) {
! 179:
! 180: if (intext[i] == DELIM) break;
! 181:
! 182: }
! 183:
! 184:
! 185: intext[i] = EOL;
! 186:
! 187: /* CUB - Cursor Backward */
! 188: if (!stcmp (intext, "CUB\201")) {
! 189:
! 190: csi = TRUE;
! 191: final = 'D';
! 192:
! 193: goto end;
! 194:
! 195: }
! 196:
! 197: /* CUD - Cursor Down */
! 198: if (!stcmp (intext, "CUD\201")) {
! 199:
! 200: csi = TRUE;
! 201: final = 'B';
! 202:
! 203: goto end;
! 204:
! 205: }
! 206:
! 207: /* CUF - Cursor Forward */
! 208: if (!stcmp (intext, "CUF\201")) {
! 209:
! 210: csi = TRUE;
! 211: final = 'C';
! 212:
! 213: goto end;
! 214:
! 215: }
! 216:
! 217: /* CUP - Cursor Position */
! 218: /* HVP - Horizontal and vertical Position */
! 219: if (!stcmp (intext, "CUP\201") || !stcmp (intext, "HVP\201")) {
! 220:
! 221: csi = TRUE;
! 222: final = 'H';
! 223:
! 224: goto end;
! 225:
! 226: }
! 227:
! 228: /* CUU - Cursor Up */
! 229: if (!stcmp (intext, "CUU\201")) {
! 230:
! 231: csi = TRUE;
! 232: final = 'A';
! 233:
! 234: goto end;
! 235:
! 236: }
! 237:
! 238: /* DCH - Delete Character */
! 239: if (!stcmp (intext, "DCH\201")) {
! 240:
! 241: csi = TRUE;
! 242: final = 'P';
! 243:
! 244: goto end;
! 245:
! 246: }
! 247:
! 248: /* ICH - Insert Character */
! 249: if (!stcmp (intext, "ICH\201")) {
! 250:
! 251: csi = TRUE;
! 252: final = '@';
! 253:
! 254: goto end;
! 255:
! 256: }
! 257:
! 258: /* DL - Delete Line */
! 259: if (!stcmp (intext, "DL\201")) {
! 260:
! 261: csi = TRUE;
! 262: final = 'M';
! 263:
! 264: goto end;
! 265:
! 266: }
! 267:
! 268: /* IL - Insert Line */
! 269: if (!stcmp (intext, "IL\201")) {
! 270:
! 271: csi = TRUE;
! 272: final = 'L';
! 273:
! 274: goto end;
! 275:
! 276: }
! 277:
! 278: /* SU - Scroll Up = pan down */
! 279: if (!stcmp (intext, "SU\201")) {
! 280:
! 281: csi = TRUE;
! 282: final = 'S';
! 283:
! 284: goto end;
! 285:
! 286: }
! 287:
! 288: /* SD - Scroll Down = pan up */
! 289: if (!stcmp (intext, "SD\201")) {
! 290:
! 291: csi = TRUE;
! 292: final = 'T';
! 293:
! 294: goto end;
! 295:
! 296: }
! 297:
! 298: /* DA - Device Attributes */
! 299: if (!stcmp (intext, "DA\201")) {
! 300:
! 301: csi = TRUE;
! 302: final = 'c';
! 303:
! 304: goto end;
! 305:
! 306: }
! 307:
! 308: /* DSR - Device Status Report */
! 309: if (!stcmp (intext, "DSR\201")) {
! 310:
! 311: csi = TRUE;
! 312: final = 'n';
! 313:
! 314: goto end;
! 315:
! 316: }
! 317:
! 318: /* ED - Erase Display */
! 319: if (!stcmp (intext, "ED\201")) {
! 320:
! 321: csi = TRUE;
! 322: final = 'J';
! 323:
! 324: goto end;
! 325:
! 326: }
! 327:
! 328: /* EL - Erase Line */
! 329: if (!stcmp (intext, "EL\201")) {
! 330:
! 331: csi = TRUE;
! 332: final = 'K';
! 333:
! 334: goto end;
! 335:
! 336: }
! 337:
! 338: /* ECH - Erase Character */
! 339: if (!stcmp (intext, "ECH\201")) {
! 340:
! 341: csi = TRUE;
! 342: final = 'X';
! 343:
! 344: goto end;
! 345:
! 346: }
! 347:
! 348: /* HTS - Horizontal Tabulation Set */
! 349: if (!stcmp (intext, "HTS\201")) {
! 350:
! 351: final = 'H';
! 352:
! 353: goto end;
! 354:
! 355: }
! 356:
! 357: /* IND - Index */
! 358: if (!stcmp (intext, "IND\201")) {
! 359:
! 360: final = 'D';
! 361:
! 362: goto end;
! 363:
! 364: }
! 365:
! 366: /* NEL - NExt Line */
! 367: if (!stcmp (intext, "NEL\201")) {
! 368:
! 369: final = 'E';
! 370:
! 371: goto end;
! 372:
! 373: }
! 374:
! 375: if (!stcmp (intext, "SSA\201")) {
! 376:
! 377: final = 'F';
! 378:
! 379: goto end;
! 380:
! 381: }
! 382:
! 383: if (!stcmp (intext, "ESA\201")) {
! 384:
! 385: final = 'G';
! 386:
! 387: goto end;
! 388:
! 389: }
! 390:
! 391: if (!stcmp (intext, "HTJ\201")) {
! 392:
! 393: final = 'I';
! 394:
! 395: goto end;
! 396:
! 397: }
! 398:
! 399: if (!stcmp (intext, "VTS\201")) {
! 400:
! 401: final = 'J';
! 402:
! 403: goto end;
! 404:
! 405: }
! 406:
! 407: if (!stcmp (intext, "PLD\201")) {
! 408:
! 409: final = 'K';
! 410:
! 411: goto end;
! 412:
! 413: }
! 414:
! 415: if (!stcmp (intext, "PLU\201")) {
! 416:
! 417: final = 'L';
! 418:
! 419: goto end;
! 420:
! 421: }
! 422:
! 423: /* RI - Reverse Index */
! 424: if (!stcmp (intext, "RI\201")) {
! 425:
! 426: final = 'M';
! 427:
! 428: goto end;
! 429:
! 430: }
! 431:
! 432: /* SS2 - Single Shift G2 */
! 433: if (!stcmp (intext, "SS2\201")) {
! 434:
! 435: final = 'N';
! 436:
! 437: goto end;
! 438:
! 439: }
! 440:
! 441: /* SS3 - Single Shift G3 */
! 442: if (!stcmp (intext, "SS3\201")) {
! 443:
! 444: final = 'O';
! 445:
! 446: goto end;
! 447:
! 448: }
! 449:
! 450: /* DCS - Device Control String introducer */
! 451: if (!stcmp (intext, "DCS\201")) {
! 452:
! 453: final = 'P';
! 454:
! 455: goto end;
! 456:
! 457: }
! 458:
! 459: if (!stcmp (intext, "PU1\201")) {
! 460:
! 461: final = 'Q';
! 462:
! 463: goto end;
! 464:
! 465: }
! 466:
! 467: if (!stcmp (intext, "PU2\201")) {
! 468:
! 469: final = 'R';
! 470:
! 471: goto end;
! 472:
! 473: }
! 474:
! 475: if (!stcmp (intext, "STS\201")) {
! 476:
! 477: final = 'S';
! 478:
! 479: goto end;
! 480:
! 481: }
! 482:
! 483: if (!stcmp (intext, "CCH\201")) {
! 484:
! 485: final = 'T';
! 486:
! 487: goto end;
! 488:
! 489: }
! 490:
! 491: if (!stcmp (intext, "MW\201")) {
! 492:
! 493: final = 'U';
! 494:
! 495: goto end;
! 496:
! 497: }
! 498:
! 499: if (!stcmp (intext, "SPA\201")) {
! 500:
! 501: final = 'V';
! 502:
! 503: goto end;
! 504:
! 505: }
! 506:
! 507: if (!stcmp (intext, "EPA\201")) {
! 508:
! 509: final = 'W';
! 510:
! 511: goto end;
! 512:
! 513: }
! 514:
! 515: /* CSI - Command String Introducer */
! 516: if (!stcmp (intext, "CSI\201")) {
! 517:
! 518: final = '[';
! 519:
! 520: goto end;
! 521:
! 522: }
! 523:
! 524: /* ST - device control String Terminator */
! 525: if (!stcmp (intext, "ST\201")) {
! 526:
! 527: final = '\\';
! 528:
! 529: goto end;
! 530:
! 531: }
! 532:
! 533: if (!stcmp (intext, "OSC\201")) {
! 534:
! 535: final = ']';
! 536:
! 537: goto end;
! 538:
! 539: }
! 540:
! 541: if (!stcmp (intext, "PM\201")) {
! 542:
! 543: final = '^';
! 544:
! 545: goto end;
! 546:
! 547: }
! 548:
! 549: if (!stcmp (intext, "APC\201")) {
! 550:
! 551: final = '_';
! 552:
! 553: goto end;
! 554:
! 555: }
! 556:
! 557: /* RIS - Reset to Initial State */
! 558: if (!stcmp (intext, "RIS\201")) {
! 559:
! 560: final = 'c';
! 561:
! 562: goto end;
! 563:
! 564: }
! 565:
! 566: /* RM - Reset Mode */
! 567: if (!stcmp (intext, "RM\201")) {
! 568:
! 569: csi = TRUE;
! 570: final = 'l';
! 571:
! 572: goto end;
! 573:
! 574: }
! 575:
! 576: /* SGR - Select Graphic Rendition */
! 577: if (!stcmp (intext, "SGR\201")) {
! 578:
! 579: csi = TRUE;
! 580: final = 'm';
! 581:
! 582: goto end;
! 583:
! 584: }
! 585:
! 586: /* SM - Set Mode */
! 587: if (!stcmp (intext, "SM\201")) {
! 588:
! 589: csi = TRUE;
! 590: final = 'h';
! 591:
! 592: goto end;
! 593:
! 594: }
! 595:
! 596: /* TBC - Tabulation Clear */
! 597: if (!stcmp (intext, "TBC\201")) {
! 598:
! 599: csi = TRUE;
! 600: final = 'g';
! 601:
! 602: goto end;
! 603:
! 604: }
! 605:
! 606: if (!stcmp (intext, "NUL\201")) {
! 607:
! 608: final = NUL;
! 609:
! 610: goto controls;
! 611:
! 612: }
! 613:
! 614: if (!stcmp (intext, "SOH\201")) {
! 615:
! 616: final = SOH;
! 617:
! 618: goto controls;
! 619:
! 620: }
! 621:
! 622: if (!stcmp (intext, "STX\201")) {
! 623:
! 624: final = STX;
! 625:
! 626: goto controls;
! 627:
! 628: }
! 629:
! 630: if (!stcmp (intext, "ETX\201")) {
! 631:
! 632: final = ETX;
! 633:
! 634: goto controls;
! 635:
! 636: }
! 637:
! 638: if (!stcmp (intext, "EOT\201")) {
! 639:
! 640: final = EOT;
! 641:
! 642: goto controls;
! 643:
! 644: }
! 645:
! 646: if (!stcmp (intext, "ENQ\201")) {
! 647:
! 648: final = ENQ;
! 649:
! 650: goto controls;
! 651:
! 652: }
! 653:
! 654: if (!stcmp (intext, "ACK\201")) {
! 655:
! 656: final = ACK;
! 657:
! 658: goto controls;
! 659:
! 660: }
! 661:
! 662: if (!stcmp (intext, "BEL\201")) {
! 663:
! 664: final = BEL;
! 665:
! 666: goto controls;
! 667:
! 668: }
! 669:
! 670: if (!stcmp (intext, "BS\201")) {
! 671:
! 672: final = BS;
! 673:
! 674: goto controls;
! 675:
! 676: }
! 677:
! 678: if (!stcmp (intext, "HT\201")) {
! 679:
! 680: final = TAB;
! 681:
! 682: goto controls;
! 683:
! 684: }
! 685:
! 686: if (!stcmp (intext, "LF\201")) {
! 687:
! 688: final = LF;
! 689:
! 690: goto controls;
! 691:
! 692: }
! 693:
! 694: if (!stcmp (intext, "VT\201")) {
! 695:
! 696: final = VT;
! 697:
! 698: goto controls;
! 699:
! 700: }
! 701:
! 702: if (!stcmp (intext, "FF\201")) {
! 703:
! 704: final = FF;
! 705:
! 706: goto controls;
! 707:
! 708: }
! 709:
! 710: if (!stcmp (intext, "CR\201")) {
! 711:
! 712: final = CR;
! 713:
! 714: goto controls;
! 715:
! 716: }
! 717:
! 718: if (!stcmp (intext, "SO\201")) {
! 719:
! 720: final = SO;
! 721:
! 722: goto controls;
! 723:
! 724: }
! 725:
! 726: if (!stcmp (intext, "SI\201")) {
! 727:
! 728: final = SI;
! 729:
! 730: goto controls;
! 731:
! 732: }
! 733:
! 734: if (!stcmp (intext, "DLE\201")) {
! 735:
! 736: final = DLE;
! 737:
! 738: goto controls;
! 739:
! 740: }
! 741:
! 742: if (!stcmp (intext, "DC1\201")) {
! 743:
! 744: final = DC1;
! 745:
! 746: goto controls;
! 747:
! 748: }
! 749:
! 750: if (!stcmp (intext, "DC2\201")) {
! 751:
! 752: final = DC2;
! 753:
! 754: goto controls;
! 755:
! 756: }
! 757:
! 758: if (!stcmp (intext, "DC3\201")) {
! 759:
! 760: final = DC3;
! 761:
! 762: goto controls;
! 763:
! 764: }
! 765:
! 766: if (!stcmp (intext, "DC4\201")) {
! 767:
! 768: final = DC4;
! 769:
! 770: goto controls;
! 771:
! 772: }
! 773:
! 774: if (!stcmp (intext, "NAK\201")) {
! 775:
! 776: final = NAK;
! 777:
! 778: goto controls;
! 779:
! 780: }
! 781:
! 782: if (!stcmp (intext, "SYN\201")) {
! 783:
! 784: final = SYN;
! 785:
! 786: goto controls;
! 787:
! 788: }
! 789:
! 790: if (!stcmp (intext, "ETB\201")) {
! 791:
! 792: final = ETB;
! 793:
! 794: goto controls;
! 795:
! 796: }
! 797:
! 798: if (!stcmp (intext, "CAN\201")) {
! 799:
! 800: final = CAN;
! 801:
! 802: goto controls;
! 803:
! 804: }
! 805:
! 806: if (!stcmp (intext, "EM\201")) {
! 807:
! 808: final = EM;
! 809:
! 810: goto controls;
! 811:
! 812: }
! 813:
! 814: if (!stcmp (intext, "SUB\201")) {
! 815:
! 816: final = SUB;
! 817:
! 818: goto controls;
! 819:
! 820: }
! 821:
! 822: if (!stcmp (intext, "ESC\201")) {
! 823:
! 824: final = ESC;
! 825:
! 826: goto controls;
! 827:
! 828: }
! 829:
! 830: if (!stcmp (intext, "FS\201")) {
! 831:
! 832: final = FS;
! 833:
! 834: goto controls;
! 835:
! 836: }
! 837:
! 838: if (!stcmp (intext, "GS\201")) {
! 839:
! 840: final = GS;
! 841:
! 842: goto controls;
! 843:
! 844: }
! 845:
! 846:
! 847: if (!stcmp (intext, "RS\201")) {
! 848:
! 849: final = RS;
! 850:
! 851: goto controls;
! 852:
! 853: }
! 854:
! 855: if (!stcmp (intext, "US\201")) {
! 856:
! 857: final = US;
! 858:
! 859: goto controls;
! 860:
! 861: }
! 862:
! 863: if (!stcmp (intext, "DEL\201")) {
! 864:
! 865: final = DEL;
! 866:
! 867: goto controls;
! 868:
! 869: }
! 870:
! 871: /* DECKPAM Keypad Application Mode */
! 872: if (!stcmp (intext, "DECKPAM\201")) {
! 873:
! 874: final = '=';
! 875:
! 876: goto end;
! 877:
! 878: }
! 879:
! 880: /* DECKPNM Keypad Numeric Mode */
! 881: if (!stcmp (intext, "DECKPNM\201")) {
! 882:
! 883: final = '>';
! 884:
! 885: goto end;
! 886:
! 887: }
! 888:
! 889: /* DECLL Load LEDs */
! 890: if (!stcmp (intext, "DECLL\201")) {
! 891:
! 892: csi = TRUE;
! 893: final = 'q';
! 894:
! 895: goto end;
! 896:
! 897: }
! 898:
! 899: /* DECRC Restore Cursor */
! 900: if (!stcmp (intext, "DECRC\201")) {
! 901:
! 902: final = '8';
! 903:
! 904: goto end;
! 905:
! 906: }
! 907:
! 908: /* DECSC Save Cursor */
! 909: if (!stcmp (intext, "DECSC\201")) {
! 910:
! 911: final = '7';
! 912:
! 913: goto end;
! 914:
! 915: }
! 916:
! 917: /* DECSTBM Set Top & Bottom Margins */
! 918: if (!stcmp (intext, "TBM\201") ||
! 919:
! 920: !stcmp (intext, "DECSTBM\201")) {
! 921:
! 922: csi = TRUE;
! 923: final = 'r';
! 924:
! 925: goto end;
! 926:
! 927: }
! 928:
! 929: /* ZAS Alternate Screen */
! 930: if (!stcmp (intext, "ZAS\201")) {
! 931:
! 932: csi = TRUE;
! 933: final = '~';
! 934:
! 935: goto end;
! 936:
! 937: }
! 938:
! 939: return; /* code not recognized */
! 940:
! 941: controls:
! 942: outtext[0] = final;
! 943: outtext[1] = EOL;
! 944:
! 945: write_m (outtext);
! 946:
! 947: return;
! 948:
! 949: end:
! 950:
! 951: outtext[0] = ESC;
! 952:
! 953: if (csi++) outtext[1] = '[';
! 954:
! 955: while (++i < l) {
! 956:
! 957: if ((outtext[csi] = intext[i]) == DELIM) outtext[csi] = ';';
! 958:
! 959: csi++;
! 960:
! 961: }
! 962:
! 963: outtext[csi++] = final;
! 964: outtext[csi] = EOL;
! 965:
! 966: write_m (outtext);
! 967:
! 968: return;
! 969: } /* end of write_f() */
! 970:
! 971: /* Output on HOME device */
! 972: void writeHOME (char *text)
! 973: {
! 974:
! 975: struct winsize terminal_window;
! 976: static char initflag = TRUE; /* initialisation flag */
! 977: static char esc = 0; /* esc processing flag */
! 978: static char dcs = 0; /* device control processing flag */
! 979:
! 980: static short args[ARGS_IN_ESC];
! 981: static short argcnt = 0;
! 982: static short noargs = TRUE;
! 983: static char tmp[512];
! 984: static short foreground = TRUE; /* foreground flag */
! 985: static struct vtstyp *vts;
! 986:
! 987: /* external struct vtstyp *screen; active screen */
! 988: static struct vtstyp *altscr; /* background screen */
! 989: static struct vtstyp *zases[MAXZAS];
! 990: static int zaslevel = 0;
! 991:
! 992: /* SGR and CSI=cF have ***different*** color codes */
! 993: #ifdef COLOR
! 994: static char coltrans[8] =
! 995: {0, 4, 2, 6, 1, 5, 3, 7};
! 996:
! 997: #endif /* COLOR */
! 998:
! 999:
! 1000: short tmpx;
! 1001: register int ch;
! 1002: register int j;
! 1003: register int i;
! 1004: short k;
! 1005:
! 1006: /* we assume the HOME device is an ASCII machine according
! 1007: * to ANSI X3.4, X3.64 etc with 24 lines and 80 columns
! 1008: * so we look not only at controls as the MUMPS X11.1-1984
! 1009: * demands, but as well at esc sequences and device control
! 1010: * strings.
! 1011: *
! 1012: * In addition we assume, that the terminal cannot handle
! 1013: * tab_clear (CSI 3g) nor tab_set (ESC H) so these functions
! 1014: * are emulated here. For most terminals that might
! 1015: * not be neccesary. With 'PROC_TAB' we may switch versions.
! 1016: *
! 1017: * We support the VT100 on PC-"Terminals"
! 1018: * where there is no TBM so we have to emulate
! 1019: * scoll up /down with LF,RI and autowrap. SGR is somewhat
! 1020: * crazy on the PC and there is a lot of code to fix that.
! 1021: * The PC completely ignores SGRs it does not fully recognize.
! 1022: * E.g. SGR(7,4) will not work while SGR(4,7) at least inverts
! 1023: * the display.
! 1024: * CSI 10 p (invert INVERS at active position)
! 1025: * is being emulated too.
! 1026: * We emulate the terminal software so we have always an image
! 1027: * of the screen in memory. That enables us to have features like
! 1028: * CSI 0 ~ (private sequence: change screen)
! 1029: * CSI 1 ~ (private sequence: output to foreground screen)
! 1030: * CSI 2 ~ (private sequence: output to background screen)
! 1031: * CSI 3 ~ (private sequence: save foreground to background)
! 1032: * CSI 4 ~ (private sequence: screen restore)
! 1033: * and the 'hardcopy function'
! 1034: */
! 1035: if (initflag) {
! 1036:
! 1037: /* TODO: why are we casting to void here? */
! 1038: (void) ioctl(STDOUT_FILENO, TIOCGWINSZ, &terminal_window);
! 1039:
! 1040: n_lines = terminal_window.ws_row;
! 1041: n_columns = terminal_window.ws_col;
! 1042:
! 1043: screen = (struct vtstyp *) calloc (1, sizeof (struct vtstyp));
! 1044:
! 1045: ris (screen);
! 1046: altscr = (struct vtstyp *) calloc (1, sizeof (struct vtstyp));
! 1047:
! 1048: ris (altscr);
! 1049: initflag = FALSE;
! 1050:
! 1051: }
! 1052:
! 1053: opnfile[HOME] = stdout;
! 1054: tmpx = 0;
! 1055: j = 0;
! 1056:
! 1057: while ((ch = text[j++]) != EOL) {
! 1058:
! 1059: if (ch == NUL) continue;
! 1060:
! 1061: if (tmpx > 480) {
! 1062:
! 1063: tmp[tmpx] = EOL;
! 1064: tmpx = 0;
! 1065:
! 1066: if (foreground) m_output (tmp);
! 1067:
! 1068: }
! 1069:
! 1070:
! 1071: if (RightMargin && xpos[HOME] > RightMargin && esc == 0) {
! 1072:
! 1073: --j;
! 1074:
! 1075: tmp[tmpx++] = CR;
! 1076: xpos[HOME] = 0;
! 1077: ch = LF;
! 1078:
! 1079: }
! 1080:
! 1081: /* what in the name of good and holy is this macro abuse nonsense? */
! 1082:
! 1083: #ifdef PROC_TAB
! 1084: if (ch != TAB) tmp[tmpx++] = ch;
! 1085: #else
! 1086: tmp[tmpx++] = ch;
! 1087: #endif /* PROC_TAB */
! 1088:
! 1089:
! 1090: if (UNSIGN (ch) >= SP && ch != DEL) { /* printable characters */
! 1091:
! 1092: if (esc == 0) { /* no esc/dcs in progress; wrap-around */
! 1093:
! 1094: (*screen).screenx[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]] = ch;
! 1095:
! 1096: if ((*screen).savarg == FALSE) {
! 1097:
! 1098:
! 1099: #ifdef COLOR
! 1100: (*screen).screenc[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]] = (*screen).col;
! 1101: #endif /* COLOR */
! 1102:
! 1103: (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]] = (*screen).att;
! 1104:
! 1105: }
! 1106:
! 1107: if (dcs == 0 && ++xpos[HOME] >= n_columns) {
! 1108:
! 1109: xpos[HOME] = 0;
! 1110:
! 1111: if ((*screen).rollflag) goto pLF;
! 1112:
! 1113: ypos[HOME] = (*screen).sc_lo;
! 1114:
! 1115: }
! 1116:
! 1117: continue;
! 1118:
! 1119: }
! 1120:
! 1121: if (esc == 1) { /* esc_sequence in progress */
! 1122:
! 1123: if (ch == '[') { /* CSI command string starts */
! 1124: esc = 2;
! 1125: continue;
! 1126: }
! 1127: else if (ch == 'H') { /* HTS set tab at $X */
! 1128: (*screen).tabs[xpos[HOME]] = 1;
! 1129: }
! 1130: else if (ch == 'M') { /* RI cursor up *//* upper margin of scroll area: scroll down */
! 1131:
! 1132: if (ypos[HOME] == (*screen).sc_up) {
! 1133:
! 1134: k = (*screen).sclines[(*screen).sc_lo];
! 1135:
! 1136: for (i = (*screen).sc_lo; i > (*screen).sc_up; i--) (*screen).sclines[i] = (*screen).sclines[i - 1];
! 1137:
! 1138: (*screen).sclines[(*screen).sc_up] = k;
! 1139:
! 1140: for (i = 0; i < n_columns; i++) {
! 1141:
! 1142: (*screen).screenx[k][i] = SP;
! 1143: (*screen).screena[k][i] = (*screen).att;
! 1144:
! 1145:
! 1146: #ifdef COLOR
! 1147: (*screen).screenc[k][i] = (*screen).col;
! 1148: #endif /* COLOR */
! 1149:
! 1150: }
! 1151:
! 1152: if (foreground) {
! 1153:
! 1154: tmp[tmpx - 2] = EOL;
! 1155: m_output (tmp);
! 1156:
! 1157: tmpx = 0;
! 1158: part_ref (screen, (*screen).sc_up, (*screen).sc_lo);
! 1159:
! 1160: }
! 1161: }
! 1162:
! 1163: if (ypos[HOME] != 0 && ypos[HOME] != (*screen).sc_up) ypos[HOME]--;
! 1164:
! 1165: tmp[tmpx++] = ESC;
! 1166: tmp[tmpx++] = '[';
! 1167:
! 1168: if (ypos[HOME] > 8) tmp[tmpx++] = (1 + ypos[HOME]) / 10 + '0';
! 1169:
! 1170: tmp[tmpx++] = (1 + ypos[HOME]) % 10 + '0';
! 1171:
! 1172: if (xpos[HOME] > 0) {
! 1173:
! 1174: tmp[tmpx++] = ';';
! 1175:
! 1176: if (xpos[HOME] > 8) tmp[tmpx++] = (1 + xpos[HOME]) / 10 + '0';
! 1177:
! 1178: tmp[tmpx++] = (1 + xpos[HOME]) % 10 + '0';
! 1179:
! 1180: }
! 1181:
! 1182: tmp[tmpx++] = 'H';
! 1183:
! 1184: }
! 1185: else if (ch == 'E') { /* NEL new line */
! 1186:
! 1187: /* RI */
! 1188:
! 1189: xpos[HOME] = 0;
! 1190: esc = 0;
! 1191:
! 1192: goto pLF;
! 1193:
! 1194: }
! 1195: else if (ch == 'Q') { /* DCS Device control string */
! 1196: dcs = 1;
! 1197: }
! 1198: else if (ch == '\\') { /* ST String terminator (DCS) */
! 1199: dcs = 0;
! 1200: }
! 1201: else if (ch == '7') { /* DEC CS Cursor Save */
! 1202:
! 1203: (*screen).csx[(*screen).cs] = xpos[HOME];
! 1204: (*screen).csy[(*screen).cs] = ypos[HOME];
! 1205:
! 1206: if (++((*screen).cs) >= CSLEN) (*screen).cs = CSLEN - 1;
! 1207:
! 1208: }
! 1209: else if (ch == '8') { /* DEC CRST Cursor Restore */
! 1210:
! 1211: if (--((*screen).cs) <= 0) (*screen).cs = 0;
! 1212:
! 1213: xpos[HOME] = (*screen).csx[(*screen).cs];
! 1214: ypos[HOME] = (*screen).csy[(*screen).cs];
! 1215:
! 1216: /* make sure cursor is at desired position */
! 1217: tmp[tmpx++] = ESC;
! 1218: tmp[tmpx++] = '[';
! 1219:
! 1220: if (ypos[HOME] > 8) tmp[tmpx++] = (1 + ypos[HOME]) / 10 + '0';
! 1221:
! 1222: tmp[tmpx++] = (1 + ypos[HOME]) % 10 + '0';
! 1223:
! 1224: if (xpos[HOME] > 0) {
! 1225:
! 1226: tmp[tmpx++] = ';';
! 1227:
! 1228: if (xpos[HOME] > 8) tmp[tmpx++] = (1 + xpos[HOME]) / 10 + '0';
! 1229:
! 1230: tmp[tmpx++] = (1 + xpos[HOME]) % 10 + '0';
! 1231:
! 1232: }
! 1233:
! 1234: tmp[tmpx++] = 'H';
! 1235:
! 1236: }
! 1237: else if (ch == 'c') { /* RIS Reset to initial state */
! 1238:
! 1239: esc = 0;
! 1240: dcs = 0;
! 1241: foreground = TRUE;
! 1242: xpos[HOME] = 0;
! 1243: ypos[HOME] = 0;
! 1244:
! 1245: ris (screen);
! 1246:
! 1247: }
! 1248: else if (ch == '(' || ch == ')') {
! 1249: continue;
! 1250: }
! 1251:
! 1252: esc = 0;
! 1253:
! 1254: continue;
! 1255:
! 1256: } /* end if (esc==1) */
! 1257:
! 1258: /* command string (esc [) in progress */
! 1259: /* numeric arguments ? */
! 1260: if (ch >= '0' && ch <= '9') {
! 1261:
! 1262: noargs = FALSE;
! 1263: args[argcnt] = args[argcnt] * 10 + ch - '0';
! 1264:
! 1265: continue;
! 1266:
! 1267: }
! 1268:
! 1269: if (ch == ';') {
! 1270:
! 1271: args[++argcnt] = 0;
! 1272:
! 1273: continue;
! 1274:
! 1275: }
! 1276:
! 1277: if (ch == '=') {
! 1278: esc = 3;
! 1279: continue;
! 1280: } /* color sequence */
! 1281:
! 1282: if (esc == 3) {
! 1283:
! 1284: esc = 0;
! 1285:
! 1286:
! 1287: #ifdef COLOR
! 1288: if (ch == 'F') { /* foreground color */
! 1289:
! 1290: (*screen).col = (((*screen).col & ~017) | (args[0] & 017));
! 1291:
! 1292: tmp[tmpx++] = ESC; /* reverse background */
! 1293: tmp[tmpx++] = '[';
! 1294: tmp[tmpx++] = '=';
! 1295:
! 1296: if (args[0] > 9) tmp[tmpx++] = '0' + (args[0] / 10);
! 1297:
! 1298: tmp[tmpx++] = '0' + (args[0] % 10);
! 1299: tmp[tmpx++] = 'I';
! 1300:
! 1301: continue;
! 1302:
! 1303: }
! 1304:
! 1305: if (ch == 'G') { /* background color */
! 1306:
! 1307: (*screen).col = (((*screen).col & 017) | (args[0] * 16));
! 1308:
! 1309: tmp[tmpx++] = ESC; /* reverse forground */
! 1310: tmp[tmpx++] = '[';
! 1311: tmp[tmpx++] = '=';
! 1312:
! 1313: if (args[0] > 9) tmp[tmpx++] = '0' + (args[0] / 10);
! 1314:
! 1315: tmp[tmpx++] = '0' + (args[0] % 10);
! 1316: tmp[tmpx++] = 'H';
! 1317:
! 1318: continue;
! 1319:
! 1320: }
! 1321: #endif /* COLOR */
! 1322:
! 1323:
! 1324: continue;
! 1325:
! 1326: } /* if (esc == 3) */
! 1327:
! 1328: if (ch < '@') continue;
! 1329:
! 1330: /* check final characters */
! 1331: if (ch == 'A') { /* CUU cursor up */
! 1332:
! 1333: do {
! 1334:
! 1335: if (--ypos[HOME] < 0) ypos[HOME] = 0;
! 1336:
! 1337: }
! 1338: while (--args[0] > 0);
! 1339:
! 1340: }
! 1341: else if (ch == 'B') { /* CUD cursor down */
! 1342:
! 1343: do {
! 1344:
! 1345: if (++ypos[HOME] >= (n_lines - 1)) ypos[HOME] = (n_lines - 1);
! 1346:
! 1347: }
! 1348: while (--args[0] > 0);
! 1349:
! 1350: }
! 1351: else if (ch == 'C') { /* CUF cursor right */
! 1352:
! 1353: do {
! 1354:
! 1355: if (++xpos[HOME] >= n_columns) xpos[HOME] = (n_columns - 1);
! 1356:
! 1357: }
! 1358: while (--args[0] > 0);
! 1359:
! 1360: }
! 1361: else if (ch == 'D') { /* CUB cursor left */
! 1362:
! 1363: do {
! 1364:
! 1365: if (--xpos[HOME] < 0) xpos[HOME] = 0;
! 1366:
! 1367: }
! 1368: while (--args[0] > 0) ;
! 1369:
! 1370: }
! 1371: else if (ch == 'H') { /* CUP cursor position */
! 1372:
! 1373: i = --args[0];
! 1374:
! 1375: if (i < 0) i = 0;
! 1376: if (i <= n_lines) ypos[HOME] = i;
! 1377:
! 1378: i = --args[1];
! 1379:
! 1380: if (i < 0) i = 0;
! 1381: if (i < n_columns) xpos[HOME] = i;
! 1382:
! 1383: }
! 1384: else if (ch == 'K') { /* EL erase line */
! 1385:
! 1386: int k;
! 1387:
! 1388: i = 0;
! 1389: k = n_columns;
! 1390:
! 1391: if (args[0] == 0) i = xpos[HOME];
! 1392: if (args[0] == 1) k = xpos[HOME] + 1;
! 1393:
! 1394: while (i < k) {
! 1395:
! 1396: (*screen).screenx[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = SP;
! 1397: (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = 0; /* not 'att' */
! 1398:
! 1399:
! 1400: #ifdef COLOR
! 1401: (*screen).screenc[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = (*screen).col;
! 1402: #endif /* COLOR */
! 1403:
! 1404: i++;
! 1405:
! 1406: }
! 1407: }
! 1408: else /* TODO: this bogosity must go away. */
! 1409:
! 1410:
! 1411: ED:
! 1412: if (ch == 'J') { /* ED erase display */
! 1413:
! 1414: register int k;
! 1415:
! 1416: #ifdef COLOR
! 1417: unsigned char color;
! 1418: #endif /* COLOR (COLOR is forced on in mpsdef.h or mpsdef0.h) */
! 1419:
! 1420: i = 0;
! 1421: k = n_columns;
! 1422:
! 1423: if (args[0] == 0) i = xpos[HOME];
! 1424: if (args[0] == 1) k = xpos[HOME] + 1;
! 1425:
! 1426:
! 1427: #ifdef COLOR
! 1428: color = (*screen).col;
! 1429: #endif /* COLOR */
! 1430:
! 1431: while (i < k) { /* clear current line */
! 1432:
! 1433: /* TODO: revisit this commented-out section. Was part of the
! 1434: * original support for terminals larger than 80x25.
! 1435: * Possibly responsible for screen state corruption?
! 1436: *
! 1437: * Ref: issue #95
! 1438: * https://gitlab.coherent-logic.com/jpw/freem/-/issues/95
! 1439: */
! 1440: /*
! 1441: (*screen).screenx[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = SP;
! 1442: (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = 0;*/
! 1443:
! 1444: (*screen).screenx[ypos[HOME]][i] = SP;
! 1445: (*screen).screena[ypos[HOME]][i] = 0; /* not 'att' */
! 1446:
! 1447: #ifdef COLOR
! 1448: (*screen).screenc[ypos[HOME]][i] = color;
! 1449: #endif /* COLOR */
! 1450:
! 1451: i++;
! 1452:
! 1453: }
! 1454:
! 1455: /* clear rest of screen */
! 1456: if (args[0] != 1) {
! 1457:
! 1458: for (k = ypos[HOME] + 1; k < n_lines; k++) {
! 1459:
! 1460: for (i = 0; i < n_columns; i++) {
! 1461:
! 1462: /* TODO: revisit; see above */
! 1463: /* (*screen).screenx[(unsigned int) (*screen).sclines[k]][i] = SP; */
! 1464: (*screen).screenx[k][i] = SP;
! 1465: (*screen).screena[k][i] = 0;
! 1466:
! 1467:
! 1468: #ifdef COLOR
! 1469: (*screen).screenc[k][i] = color;
! 1470: #endif /* COLOR */
! 1471:
! 1472: }
! 1473:
! 1474: }
! 1475:
! 1476: }
! 1477:
! 1478: /* clear beginning of screen */
! 1479: if (args[0] != 0) {
! 1480:
! 1481: for (k = 0; k < ypos[HOME]; k++) {
! 1482:
! 1483: for (i = 0; i < n_columns; i++) {
! 1484:
! 1485: (*screen).screenx[k][i] = SP;
! 1486: (*screen).screena[k][i] = 0;
! 1487:
! 1488:
! 1489: #ifdef COLOR
! 1490: (*screen).screenc[k][i] = color;
! 1491: #endif /* COLOR */
! 1492:
! 1493: }
! 1494:
! 1495: }
! 1496:
! 1497: }
! 1498:
! 1499:
! 1500: #ifdef SCO
! 1501: if (foreground) {
! 1502:
! 1503: if ((*screen).lin24) tmp[tmpx - 1] = CAN;
! 1504:
! 1505: tmp[tmpx] = EOL;
! 1506: m_output (tmp);
! 1507:
! 1508: tmpx = 0;
! 1509: part_ref (screen, 0, n_lines - 1);
! 1510:
! 1511: }
! 1512: #endif /* SCO */
! 1513:
! 1514: }
! 1515: /* end ED */
! 1516: else if (ch == 'p') { /* private */
! 1517:
! 1518: if (args[0] == 10) {
! 1519:
! 1520: /* invert 'inverse' at */
! 1521: /* current cursor pos. */
! 1522:
! 1523: (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]] ^= 0100;
! 1524:
! 1525: #ifdef SCO
! 1526:
! 1527: /* now we're in the meat of the really bizarre SCO UNIX terminal I/O stuff.
! 1528: most of this will need to be reworked. */
! 1529:
! 1530: if (foreground) {
! 1531:
! 1532: k = (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]];
! 1533:
! 1534: if (((*screen).att & 01) != (k & 01)) tmp[tmpx++] = (k & 01) ? SO : SI;
! 1535:
! 1536: k = scosgr (k, (*screen).bw);
! 1537:
! 1538: tmp[tmpx++] = ESC;
! 1539: tmp[tmpx++] = '[';
! 1540:
! 1541: if ((*screen).bw) tmp[tmpx++] = '7';
! 1542:
! 1543: tmp[tmpx++] = 'm';
! 1544: tmp[tmpx++] = ESC;
! 1545: tmp[tmpx++] = '[';
! 1546:
! 1547: if (k & 02) {
! 1548: tmp[tmpx++] = '1';
! 1549: tmp[tmpx++] = ';';
! 1550: } /* SCO !!! Yeah, SCO. What of it? Such a useful comment... */
! 1551:
! 1552: if (k & 04) {
! 1553: tmp[tmpx++] = '3';
! 1554: tmp[tmpx++] = ';';
! 1555: }
! 1556:
! 1557: if (k & 010) {
! 1558: tmp[tmpx++] = '4';
! 1559: tmp[tmpx++] = ';';
! 1560: }
! 1561:
! 1562: if (k & 020) {
! 1563: tmp[tmpx++] = '5';
! 1564: tmp[tmpx++] = ';';
! 1565: }
! 1566:
! 1567: if (k & 040) {
! 1568: tmp[tmpx++] = '6';
! 1569: tmp[tmpx++] = ';';
! 1570: }
! 1571:
! 1572: if (k & 0100) {
! 1573: tmp[tmpx++] = '7';
! 1574: tmp[tmpx++] = ';';
! 1575: }
! 1576:
! 1577: if (k & 0200) {
! 1578: tmp[tmpx++] = '8';
! 1579: tmp[tmpx++] = ';';
! 1580: }
! 1581:
! 1582: if (tmp[tmpx - 1] == ';') tmpx--;
! 1583:
! 1584: tmp[tmpx++] = 'm';
! 1585: tmp[tmpx++] = (*screen).screenx[(unsigned int) (*screen).sclines[ypos[HOME]]][xpos[HOME]];
! 1586: tmp[tmpx++] = ESC;
! 1587: tmp[tmpx++] = '[';
! 1588: k = ypos[HOME] + 1;
! 1589:
! 1590: if (k > 9) tmp[tmpx++] = k / 10 + '0';
! 1591:
! 1592: tmp[tmpx++] = k % 10 + '0';
! 1593:
! 1594: if (xpos[HOME]) {
! 1595:
! 1596: tmp[tmpx++] = ';';
! 1597: k = xpos[HOME] + 1;
! 1598:
! 1599: if (k > 9) tmp[tmpx++] = k / 10 + '0';
! 1600:
! 1601: tmp[tmpx++] = k % 10 + '0';
! 1602:
! 1603: }
! 1604:
! 1605: tmp[tmpx++] = 'H';
! 1606:
! 1607: if (k != screen->att) {
! 1608:
! 1609: k = scosgr ((*screen).att, (*screen).bw);
! 1610:
! 1611: tmp[tmpx++] = (k & 01) ? SO : SI;
! 1612: tmp[tmpx++] = ESC;
! 1613: tmp[tmpx++] = '[';
! 1614: tmp[tmpx++] = '0';
! 1615:
! 1616: if (k & 02) {
! 1617: tmp[tmpx++] = ';';
! 1618: tmp[tmpx++] = '1';
! 1619: } /* SCO !!! Again... what about it? */
! 1620:
! 1621: if (k & 04) {
! 1622: tmp[tmpx++] = ';';
! 1623: tmp[tmpx++] = '3';
! 1624: }
! 1625:
! 1626: if (k & 010) {
! 1627: tmp[tmpx++] = ';';
! 1628: tmp[tmpx++] = '4';
! 1629: }
! 1630:
! 1631: if (k & 020) {
! 1632: tmp[tmpx++] = ';';
! 1633: tmp[tmpx++] = '5';
! 1634: }
! 1635:
! 1636: if (k & 040) {
! 1637: tmp[tmpx++] = ';';
! 1638: tmp[tmpx++] = '6';
! 1639: }
! 1640:
! 1641: if (k & 0100) {
! 1642: tmp[tmpx++] = ';';
! 1643: tmp[tmpx++] = '7';
! 1644: }
! 1645:
! 1646: if (k & 0200) {
! 1647: tmp[tmpx++] = ';';
! 1648: tmp[tmpx++] = '8';
! 1649: }
! 1650:
! 1651: tmp[tmpx++] = 'm';
! 1652:
! 1653: }
! 1654:
! 1655: }
! 1656: #endif /* SCO */
! 1657:
! 1658: }
! 1659: }
! 1660: else if (ch == 'r') { /* TBM Top_Bottom Margin */
! 1661:
! 1662: register int k;
! 1663:
! 1664: if (noargs || ((*screen).sc_up = (--args[0])) <= 0) (*screen).sc_up = 0;
! 1665:
! 1666: /* TODO: Revisit. This still appears to be hardcoded to the old fixed terminal size.
! 1667: * Ref issue #95
! 1668: */
! 1669: if (!argcnt || (((*screen).sc_lo = (--args[1])) > 24) || ((*screen).sc_lo == 23 && (*screen).lin24 == TRUE)) {
! 1670: (*screen).sc_lo = (*screen).lin24 ? 23 : 24;
! 1671: }
! 1672:
! 1673: /* restore old cursor position */
! 1674: tmp[tmpx++] = ESC;
! 1675: tmp[tmpx++] = '[';
! 1676: k = ypos[HOME] + 1;
! 1677:
! 1678: if (k > 9) tmp[tmpx++] = k / 10 + '0';
! 1679:
! 1680: tmp[tmpx++] = k % 10 + '0';
! 1681:
! 1682: if (xpos[HOME]) {
! 1683:
! 1684: tmp[tmpx++] = ';';
! 1685: k = xpos[HOME] + 1;
! 1686:
! 1687: if (k > 9) tmp[tmpx++] = k / 10 + '0';
! 1688:
! 1689: tmp[tmpx++] = k % 10 + '0';
! 1690:
! 1691: }
! 1692:
! 1693: tmp[tmpx++] = 'H';
! 1694:
! 1695: }
! 1696: else if (ch == 's') { /* CS Cursor Save */
! 1697:
! 1698: (*screen).csx[(*screen).cs] = xpos[HOME];
! 1699: (*screen).csy[(*screen).cs] = ypos[HOME];
! 1700: (*screen).cssgr[(*screen).cs] = (*screen).att;
! 1701:
! 1702:
! 1703: #ifdef COLOR
! 1704: (*screen).cscol[(*screen).cs] = (*screen).col;
! 1705: #endif /* COLOR */
! 1706:
! 1707: if (++((*screen).cs) >= CSLEN) (*screen).cs = CSLEN - 1;
! 1708:
! 1709: }
! 1710: else if (ch == 'u') {
! 1711:
! 1712: /* CRST Cursor Unsave (if no args) */
! 1713: /* those bloody bastards made 'CSI u' and CSI 0 u' */
! 1714: /* different. flag 'noargs' distinguishes */
! 1715:
! 1716: /* bloody bastards, eh? this whole module is a bloody bastard,
! 1717: * so I seriously have no idea what the hell you're complaining
! 1718: * about, Mr. ha-Ashkenaz.
! 1719: */
! 1720:
! 1721: if (noargs) {
! 1722:
! 1723:
! 1724: #ifdef COLOR
! 1725: int color;
! 1726: #endif /* COLOR */
! 1727:
! 1728: if (--((*screen).cs) <= 0) (*screen).cs = 0;
! 1729:
! 1730: xpos[HOME] = (*screen).csx[(*screen).cs];
! 1731: ypos[HOME] = (*screen).csy[(*screen).cs];
! 1732:
! 1733: (*screen).att = (*screen).cssgr[(*screen).cs];
! 1734:
! 1735:
! 1736: #ifdef COLOR
! 1737: (*screen).col = (*screen).cscol[(*screen).cs];
! 1738: color = (*screen).col;
! 1739: #endif /* COLOR */
! 1740:
! 1741: /* make sure cursor is at desired position */
! 1742: tmp[tmpx++] = ESC;
! 1743: tmp[tmpx++] = '[';
! 1744:
! 1745: if (ypos[HOME] > 8) tmp[tmpx++] = (1 + ypos[HOME]) / 10 + '0';
! 1746:
! 1747: tmp[tmpx++] = (1 + ypos[HOME]) % 10 + '0';
! 1748:
! 1749: if (xpos[HOME] > 0) {
! 1750:
! 1751: tmp[tmpx++] = ';';
! 1752:
! 1753: if (xpos[HOME] > 8) tmp[tmpx++] = (1 + xpos[HOME]) / 10 + '0';
! 1754:
! 1755: tmp[tmpx++] = (1 + xpos[HOME]) % 10 + '0';
! 1756:
! 1757: }
! 1758:
! 1759: tmp[tmpx++] = 'H';
! 1760:
! 1761:
! 1762: #ifdef COLOR
! 1763:
! 1764: /* make sure cursor has right color */
! 1765: tmp[tmpx++] = ESC; /* background color */
! 1766: tmp[tmpx++] = '[';
! 1767: tmp[tmpx++] = '=';
! 1768:
! 1769: if (color / 16 > 9) tmp[tmpx++] = '0' + (color / 16 / 10);
! 1770:
! 1771: tmp[tmpx++] = '0' + (color / 16 % 10);
! 1772: tmp[tmpx++] = 'G';
! 1773: tmp[tmpx++] = ESC; /* reverse foreground col */
! 1774: tmp[tmpx++] = '[';
! 1775: tmp[tmpx++] = '=';
! 1776:
! 1777: if (color / 16 > 9) tmp[tmpx++] = '0' + (color / 16 / 10);
! 1778:
! 1779: tmp[tmpx++] = '0' + (color / 16 % 10);
! 1780: tmp[tmpx++] = 'H';
! 1781: tmp[tmpx++] = ESC; /* foreground color */
! 1782: tmp[tmpx++] = '[';
! 1783: tmp[tmpx++] = '=';
! 1784:
! 1785: if (color % 16 > 9) tmp[tmpx++] = '0' + (color % 16 / 10);
! 1786:
! 1787: tmp[tmpx++] = '0' + (color % 16 % 10);
! 1788: tmp[tmpx++] = 'F';
! 1789: tmp[tmpx++] = ESC; /* reverse background col */
! 1790: tmp[tmpx++] = '[';
! 1791: tmp[tmpx++] = '=';
! 1792:
! 1793: if (color % 16 > 9) tmp[tmpx++] = '0' + (color % 16 / 10);
! 1794:
! 1795: tmp[tmpx++] = '0' + (color % 16 % 10);
! 1796: tmp[tmpx++] = 'I';
! 1797: #endif /* COLOR */
! 1798:
! 1799: }
! 1800: else if (args[0] == 0) {
! 1801:
! 1802: (*screen).lin24 = FALSE;
! 1803:
! 1804: if ((*screen).sc_lo == 23) (*screen).sc_lo = 24;
! 1805:
! 1806: }
! 1807: else if (args[0] == 1) {
! 1808:
! 1809: (*screen).lin24 = TRUE;
! 1810:
! 1811: if ((*screen).sc_lo == 24) (*screen).sc_lo = 23;
! 1812:
! 1813: }
! 1814: else if (args[0] == 8) {
! 1815: (*screen).rollflag = FALSE;
! 1816: }
! 1817: else if (args[0] == 9) {
! 1818: (*screen).rollflag = TRUE;
! 1819: }
! 1820: #ifdef SCO
! 1821: else if (args[0] == 20) {
! 1822:
! 1823: (*screen).bw = FALSE;
! 1824:
! 1825: if (foreground) {
! 1826:
! 1827: tmp[tmpx] = EOL;
! 1828: m_output (tmp);
! 1829:
! 1830: tmpx = 0;
! 1831: part_ref (screen, 0, n_lines - 1);
! 1832:
! 1833: }
! 1834:
! 1835: }
! 1836: else if (args[0] == 21) {
! 1837:
! 1838: (*screen).bw = TRUE;
! 1839:
! 1840: if (foreground) {
! 1841:
! 1842: tmp[tmpx] = EOL;
! 1843: m_output (tmp);
! 1844:
! 1845: tmpx = 0;
! 1846: part_ref (screen, 0, n_lines - 1);
! 1847:
! 1848: }
! 1849:
! 1850: }
! 1851: #endif /* SCO */
! 1852:
! 1853: }
! 1854: else if (ch == 'X') { /* ECH Erase Character */
! 1855:
! 1856: if ((k = args[0]) < 1) k = 1;
! 1857: if ((k + xpos[HOME]) > n_columns) k = n_columns - xpos[HOME];
! 1858:
! 1859: i = xpos[HOME];
! 1860: k = i + k;
! 1861:
! 1862: while (i < k) {
! 1863:
! 1864: (*screen).screenx[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = SP;
! 1865: (*screen).screena[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = 0; /* not 'att' */
! 1866:
! 1867:
! 1868: #ifdef COLOR
! 1869: (*screen).screenc[(unsigned int) (*screen).sclines[ypos[HOME]]][i] = (*screen).col;
! 1870: #endif /* COLOR */
! 1871:
! 1872: i++;
! 1873:
! 1874: }
! 1875:
! 1876: } else if (ch == 'g') { /* TBC Tabulation clear */
! 1877:
! 1878: if (args[0] == 3) {
! 1879: /* clear all */
! 1880: for (i = 0; i < n_columns; (*screen).tabs[i++] = 0) ;
! 1881: }
! 1882: else if (args[0] == 0) {
! 1883: /* clear one */
! 1884: (*screen).tabs[xpos[HOME]] = 0;
! 1885: }
! 1886:
! 1887:
! 1888: #ifdef SCO
! 1889: while (tmpx >= 0) if (tmp[--tmpx] == ESC) break;
! 1890:
! 1891: tmp[tmpx] = NUL;
! 1892: ch = NUL;
! 1893: #endif /* SCO */
! 1894:
! 1895: }
! 1896: else if (ch == 'm') { /* SGR Select Graphic Rendition */
! 1897:
! 1898: (*screen).att &= 01; /* clear att */
! 1899:
! 1900:
! 1901: #ifdef SCO
! 1902: while (tmpx > 0 && tmp[--tmpx] != ESC);
! 1903:
! 1904: ch = CAN;
! 1905: #endif /* SCO */
! 1906:
! 1907: i = argcnt;
! 1908:
! 1909: while (i >= 0) {
! 1910:
! 1911: if (((*screen).savarg = (args[i] == 50))) continue;
! 1912:
! 1913:
! 1914: #ifdef SCO /* process save SGR(1) in position of SGR(2) */
! 1915: if (args[i] == 1) args[i] = 2;
! 1916: #endif /* SCO */
! 1917:
! 1918: #ifdef COLOR
! 1919: if (args[i] > 29 && args[i] < 38) { /* foregr.color */
! 1920: (*screen).col = ((*screen).col & ~017) | coltrans[args[i] - 30];
! 1921: }
! 1922:
! 1923: if (args[i] > 39 && args[i] < 48) { /* backgr.color */
! 1924: (*screen).col = (((*screen).col & 017) | (coltrans[args[i] - 40] * 16));
! 1925: }
! 1926:
! 1927: #endif /* COLOR */
! 1928:
! 1929: if (args[i] > 1 && args[i] < 9) (*screen).att |= (1 << (args[i] - 1));
! 1930: if (args[i] == 0) (*screen).att &= 01; /* clear att */
! 1931:
! 1932: i--;
! 1933:
! 1934: }
! 1935:
! 1936: #ifdef SCO
! 1937: tmp[tmpx++] = ESC;
! 1938: tmp[tmpx++] = '[';
! 1939: if ((*screen).bw) tmp[tmpx++] = '7';
! 1940:
! 1941: tmp[tmpx++] = 'm';
! 1942:
! 1943:
! 1944: #ifdef COLOR
! 1945: tmp[tmpx++] = ESC;
! 1946: tmp[tmpx++] = '[';
! 1947: tmp[tmpx++] = '=';
! 1948: if ((*screen).col / 16 > 9) tmp[tmpx++] = '0' + ((*screen).col / 16 / 10);
! 1949:
! 1950: tmp[tmpx++] = '0' + ((*screen).col / 16 % 10);
! 1951: tmp[tmpx++] = 'G';
! 1952: tmp[tmpx++] = ESC;
! 1953: tmp[tmpx++] = '[';
! 1954: tmp[tmpx++] = '=';
! 1955: if ((*screen).col / 16 > 9) tmp[tmpx++] = '0' + ((*screen).col / 16 / 10);
! 1956:
! 1957: tmp[tmpx++] = '0' + ((*screen).col / 16 % 10);
! 1958: tmp[tmpx++] = 'H';
! 1959: tmp[tmpx++] = ESC;
! 1960: tmp[tmpx++] = '[';
! 1961: tmp[tmpx++] = '=';
! 1962: if ((*screen).col % 16 > 9) tmp[tmpx++] = '0' + ((*screen).col % 16 / 10);
! 1963:
! 1964: tmp[tmpx++] = '0' + ((*screen).col % 16 % 10);
! 1965: tmp[tmpx++] = 'F';
! 1966: tmp[tmpx++] = ESC;
! 1967: tmp[tmpx++] = '[';
! 1968: tmp[tmpx++] = '=';
! 1969: if ((*screen).col % 16 > 9) tmp[tmpx++] = '0' + ((*screen).col % 16 / 10);
! 1970:
! 1971: tmp[tmpx++] = '0' + ((*screen).col % 16 % 10);
! 1972: tmp[tmpx++] = 'I';
! 1973: #endif /* COLOR */
! 1974:
! 1975: if ((*screen).att & ~01) {
! 1976:
! 1977: int j;
! 1978:
! 1979: j = scosgr ((*screen).att & ~01, (*screen).bw);
! 1980:
! 1981: tmp[tmpx++] = ESC;
! 1982: tmp[tmpx++] = '[';
! 1983:
! 1984: if (j & 02) {
! 1985: tmp[tmpx++] = '1';
! 1986: tmp[tmpx++] = ';';
! 1987: }
! 1988:
! 1989: if (j & 04) {
! 1990: tmp[tmpx++] = '3';
! 1991: tmp[tmpx++] = ';';
! 1992: }
! 1993:
! 1994: if (j & 010) {
! 1995: tmp[tmpx++] = '4';
! 1996: tmp[tmpx++] = ';';
! 1997: }
! 1998:
! 1999: if (j & 020) {
! 2000: tmp[tmpx++] = '5';
! 2001: tmp[tmpx++] = ';';
! 2002: }
! 2003:
! 2004: if (j & 040) {
! 2005: tmp[tmpx++] = '6';
! 2006: tmp[tmpx++] = ';';
! 2007: }
! 2008:
! 2009: if (j & 0100) {
! 2010: tmp[tmpx++] = '7';
! 2011: tmp[tmpx++] = ';';
! 2012: }
! 2013:
! 2014: if (j & 0200) {
! 2015: tmp[tmpx++] = '8';
! 2016: tmp[tmpx++] = ';';
! 2017: }
! 2018:
! 2019: if (tmp[tmpx - 1] == ';') tmpx--;
! 2020:
! 2021: tmp[tmpx++] = 'm';
! 2022:
! 2023: }
! 2024: #endif /* SCO */
! 2025:
! 2026: }
! 2027: else if (ch == 'P') { /* DCH Delete Character */
! 2028: int j;
! 2029:
! 2030: if ((j = args[0]) == 0) j = 1;
! 2031:
! 2032: k = (*screen).sclines[ypos[HOME]];
! 2033:
! 2034: for (i = xpos[HOME]; i < (n_columns - j); i++) {
! 2035:
! 2036: (*screen).screenx[k][i] = (*screen).screenx[k][i + j];
! 2037: (*screen).screena[k][i] = (*screen).screena[k][i + j];
! 2038:
! 2039:
! 2040: #ifdef COLOR
! 2041: (*screen).screenc[k][i] = (*screen).screenc[k][i + j];
! 2042: #endif /* COLOR */
! 2043:
! 2044: }
! 2045:
! 2046: for (; i < n_columns; i++) {
! 2047:
! 2048: (*screen).screenx[k][i] = SP;
! 2049: (*screen).screena[k][i] = (*screen).att;
! 2050:
! 2051:
! 2052: #ifdef COLOR
! 2053: (*screen).screenc[k][i] = (*screen).col;
! 2054: #endif /* COLOR */
! 2055:
! 2056: }
! 2057:
! 2058:
! 2059: } else if (ch == '@') { /* ICH Insert Character */
! 2060: int j;
! 2061:
! 2062: if ((j = args[0]) == 0) j = 1;
! 2063:
! 2064: k = (*screen).sclines[ypos[HOME]];
! 2065:
! 2066: for (i = (n_columns - 1); i >= (xpos[HOME] + j); i--) {
! 2067:
! 2068: (*screen).screenx[k][i] = (*screen).screenx[k][i - j];
! 2069: (*screen).screena[k][i] = (*screen).screena[k][i - j];
! 2070:
! 2071:
! 2072: #ifdef COLOR
! 2073: (*screen).screenc[k][i] = (*screen).screenc[k][i - j];
! 2074: #endif /* COLOR */
! 2075:
! 2076: }
! 2077:
! 2078: for (; i >= xpos[HOME]; i--) {
! 2079:
! 2080: (*screen).screenx[k][i] = SP;
! 2081: (*screen).screena[k][i] = (*screen).att;
! 2082:
! 2083:
! 2084: #ifdef COLOR
! 2085: (*screen).screenc[k][i] = (*screen).col;
! 2086: #endif /* COLOR */
! 2087:
! 2088: }
! 2089:
! 2090: } else if (ch == 'M') { /* DL Delete Line */
! 2091: int j = args[0];
! 2092:
! 2093: do {
! 2094:
! 2095: k = (*screen).sclines[ypos[HOME]];
! 2096:
! 2097: for (i = ypos[HOME]; i < (*screen).sc_lo; i++) (*screen).sclines[i] = (*screen).sclines[i + 1];
! 2098:
! 2099: (*screen).sclines[i] = k;
! 2100:
! 2101: for (i = 0; i < n_columns; i++) {
! 2102:
! 2103: (*screen).screenx[k][i] = SP;
! 2104: (*screen).screena[k][i] = (*screen).att;
! 2105:
! 2106:
! 2107: #ifdef COLOR
! 2108: (*screen).screenc[k][i] = (*screen).col;
! 2109: #endif /* COLOR */
! 2110:
! 2111: }
! 2112:
! 2113: } while (--j > 0);
! 2114:
! 2115: xpos[HOME] = 0;
! 2116:
! 2117:
! 2118: #ifdef SCO
! 2119: if (foreground) {
! 2120:
! 2121: tmp[tmpx - 1] = CAN; /* do not send DL */
! 2122: tmp[tmpx] = EOL;
! 2123: m_output (tmp);
! 2124:
! 2125: tmpx = 0;
! 2126: part_ref (screen, (*screen).sc_up, n_lines - 1);
! 2127:
! 2128: }
! 2129:
! 2130: #endif /* SCO */
! 2131:
! 2132: }
! 2133: else if (ch == 'L') { /* IL Insert Line */
! 2134: int j = args[0];
! 2135:
! 2136: do {
! 2137: k = (*screen).sclines[(*screen).sc_lo];
! 2138:
! 2139: for (i = (*screen).sc_lo; i > ypos[HOME]; i--) {
! 2140: (*screen).sclines[i] = (*screen).sclines[i - 1];
! 2141: }
! 2142:
! 2143: (*screen).sclines[ypos[HOME]] = k;
! 2144:
! 2145: for (i = 0; i < n_columns; i++) {
! 2146:
! 2147: (*screen).screenx[k][i] = SP;
! 2148: (*screen).screena[k][i] = (*screen).att;
! 2149:
! 2150:
! 2151: #ifdef COLOR
! 2152: (*screen).screenc[k][i] = (*screen).col;
! 2153: #endif /* COLOR */
! 2154:
! 2155: }
! 2156: } while (--j > 0);
! 2157:
! 2158: xpos[HOME] = 0;
! 2159:
! 2160:
! 2161: #ifdef SCO
! 2162: if (foreground) {
! 2163:
! 2164: tmp[tmpx - 1] = CAN; /* do not send IL */
! 2165: tmp[tmpx] = EOL;
! 2166: m_output (tmp);
! 2167:
! 2168: tmpx = 0;
! 2169: part_ref (screen, (*screen).sc_up, n_lines - 1);
! 2170:
! 2171: }
! 2172: #endif /* SCO */
! 2173:
! 2174: }
! 2175: else if (ch == 'S') { /* SU Scroll up */
! 2176: int j = args[0];
! 2177:
! 2178: do {
! 2179:
! 2180: k = (*screen).sclines[(*screen).sc_up];
! 2181:
! 2182: for (i = (*screen).sc_up; i < (*screen).sc_lo; i++) {
! 2183: (*screen).sclines[i] = (*screen).sclines[i + 1];
! 2184: }
! 2185:
! 2186: (*screen).sclines[i] = k;
! 2187:
! 2188: for (i = 0; i < n_columns; i++) {
! 2189:
! 2190: (*screen).screenx[k][i] = SP;
! 2191: (*screen).screena[k][i] = (*screen).att;
! 2192:
! 2193:
! 2194: #ifdef COLOR
! 2195: (*screen).screenc[k][i] = (*screen).col;
! 2196: #endif /* COLOR */
! 2197:
! 2198: }
! 2199:
! 2200: } while (--j > 0);
! 2201:
! 2202:
! 2203: #ifdef SCO
! 2204: if (foreground) {
! 2205:
! 2206: tmp[tmpx - 1] = 'A'; /* do not send SU */
! 2207: tmp[tmpx] = EOL;
! 2208: m_output (tmp);
! 2209:
! 2210: tmpx = 0;
! 2211: part_ref (screen, (*screen).sc_up, n_lines - 1);
! 2212:
! 2213: }
! 2214: #endif /* SCO */
! 2215:
! 2216: }
! 2217: else if (ch == 'T') { /* SD Scroll down */
! 2218:
! 2219: int j = args[0];
! 2220:
! 2221: do {
! 2222:
! 2223: k = (*screen).sclines[(*screen).sc_lo];
! 2224:
! 2225: for (i = (*screen).sc_lo; i > (*screen).sc_up; i--) {
! 2226: (*screen).sclines[i] = (*screen).sclines[i - 1];
! 2227: }
! 2228:
! 2229: (*screen).sclines[i] = k;
! 2230:
! 2231: for (i = 0; i < n_columns; i++) {
! 2232:
! 2233: (*screen).screenx[k][i] = SP;
! 2234: (*screen).screena[k][i] = (*screen).att;
! 2235:
! 2236:
! 2237: #ifdef COLOR
! 2238: (*screen).screenc[k][i] = (*screen).col;
! 2239: #endif /* COLOR */
! 2240:
! 2241: }
! 2242:
! 2243: } while (--j > 0);
! 2244:
! 2245:
! 2246: #ifdef SCO
! 2247:
! 2248: if (foreground) {
! 2249:
! 2250: tmp[tmpx - 1] = 'A'; /* do not send SD */
! 2251: tmp[tmpx] = EOL;
! 2252: m_output (tmp);
! 2253:
! 2254: tmpx = 0;
! 2255: part_ref (screen, (*screen).sc_up, n_lines - 1);
! 2256:
! 2257: }
! 2258:
! 2259: #endif /* SCO */
! 2260:
! 2261: } else if (ch == 'Z') { /* CBT Cursor backward tab */
! 2262:
! 2263: if ((i = xpos[HOME] - 1) < 1) i = 1;
! 2264:
! 2265: do {
! 2266:
! 2267: while ((*screen).tabs[--i] == 0) {
! 2268:
! 2269: if (i < 0) {
! 2270: i++;
! 2271: break;
! 2272: }
! 2273:
! 2274: }
! 2275:
! 2276: if (i == 0) break;
! 2277:
! 2278: } while (args[0]-- > 0);
! 2279:
! 2280: xpos[HOME] = i;
! 2281:
! 2282:
! 2283: #ifdef PROC_TAB
! 2284: tmp[tmpx++] = CR;
! 2285:
! 2286: if ((xpos[HOME] = i) != 0) {
! 2287:
! 2288: tmp[tmpx++] = ESC;
! 2289: tmp[tmpx++] = '[';
! 2290:
! 2291: if (i > 9) tmp[tmpx++] = i / 10 + '0';
! 2292:
! 2293: tmp[tmpx++] = i % 10 + '0';
! 2294: tmp[tmpx++] = 'C';
! 2295:
! 2296: }
! 2297:
! 2298: #endif /* PROC_TAB */
! 2299:
! 2300: }
! 2301:
! 2302: if (ch != '~') goto zasend;
! 2303:
! 2304: /* ZAS Alternate Screen stuff */
! 2305: /* the following is better programmed with */
! 2306: /* 'switch' but some compilers do not have */
! 2307: /* enough power to swallow the implied stack */
! 2308: /* depth */
! 2309: /* switch (args[0]) */
! 2310:
! 2311: i = args[0];
! 2312:
! 2313: if (i == 1) goto zas1;
! 2314: if (i == 2) goto zas2;
! 2315: if (i == 3) goto zas3;
! 2316: if (i == 4) goto zas4;
! 2317: if (i == 5) goto zas5;
! 2318: if (i != 0) goto zas6;
! 2319:
! 2320: /* zas0: exchange foreground/background */
! 2321: tmp[tmpx] = EOL;
! 2322: tmpx = 0;
! 2323:
! 2324: if (foreground) m_output (tmp);
! 2325:
! 2326: /* exchange parameters of screen */
! 2327: (*screen).Xpos = xpos[HOME];
! 2328: (*screen).Ypos = ypos[HOME];
! 2329:
! 2330: vts = screen;
! 2331: screen = altscr;
! 2332: altscr = vts;
! 2333:
! 2334: xpos[HOME] = (*screen).Xpos;
! 2335: ypos[HOME] = (*screen).Ypos;
! 2336:
! 2337:
! 2338: zas4: /* refresh foreground */
! 2339:
! 2340: tmpx = 0;
! 2341:
! 2342: if (foreground) part_ref (screen, 0, n_lines - 1);
! 2343:
! 2344: goto zasend;
! 2345:
! 2346:
! 2347: zas1: /* foreground screen */
! 2348:
! 2349: if (foreground) goto zasend;
! 2350:
! 2351: foreground = TRUE;
! 2352:
! 2353:
! 2354: pPRIVATE: /* exchange parameters of screen */
! 2355:
! 2356: (*screen).Xpos = xpos[HOME];
! 2357: (*screen).Ypos = ypos[HOME];
! 2358:
! 2359: vts = screen;
! 2360: screen = altscr;
! 2361: altscr = vts;
! 2362:
! 2363: xpos[HOME] = (*screen).Xpos;
! 2364: ypos[HOME] = (*screen).Ypos;
! 2365:
! 2366: tmpx = 0;
! 2367:
! 2368: goto zasend;
! 2369:
! 2370:
! 2371: zas2: /* background screen */
! 2372:
! 2373: if (foreground == FALSE) goto zasend;
! 2374:
! 2375: tmp[tmpx] = EOL;
! 2376: m_output (tmp);
! 2377:
! 2378: foreground = FALSE;
! 2379:
! 2380: goto pPRIVATE;
! 2381:
! 2382:
! 2383: zas3: /* save foreground to back */
! 2384:
! 2385: stcpy0 ((char *) altscr, (const char *) screen, sizeof (struct vtstyp));
! 2386:
! 2387: goto zasend;
! 2388:
! 2389:
! 2390: zas5: /* push screen */
! 2391:
! 2392: if (zaslevel >= MAXZAS) goto zasend;
! 2393:
! 2394: vts = (struct vtstyp *) calloc (1, sizeof (struct vtstyp));
! 2395: zases[zaslevel++] = vts;
! 2396:
! 2397: (*screen).Xpos = xpos[HOME];
! 2398: (*screen).Ypos = ypos[HOME];
! 2399:
! 2400: stcpy0 ((char *) vts, (const char *) screen, sizeof (struct vtstyp));
! 2401:
! 2402: goto zasend;
! 2403:
! 2404:
! 2405: zas6: /* pop screen */
! 2406:
! 2407: if (--zaslevel < 0) {
! 2408: zaslevel = 0;
! 2409: goto zasend;
! 2410: }
! 2411:
! 2412: vts = zases[zaslevel];
! 2413:
! 2414:
! 2415: #ifdef SCO
! 2416: i = (*screen).bw; /* do not pop bw state */
! 2417: #endif /* SCO */
! 2418:
! 2419: stcpy0 ((char *) screen, (const char *) vts, sizeof (struct vtstyp));
! 2420:
! 2421:
! 2422: #ifdef SCO
! 2423: (*screen).bw = i;
! 2424: #endif /* SCO */
! 2425:
! 2426: xpos[HOME] = (*screen).Xpos;
! 2427: ypos[HOME] = (*screen).Ypos;
! 2428:
! 2429: free (vts);
! 2430:
! 2431: goto zas4;
! 2432: /* end zas6 */
! 2433:
! 2434:
! 2435: zasend: /* stuf we do when we're finished doing other zassy things */
! 2436:
! 2437: argcnt = 0;
! 2438: noargs = TRUE;
! 2439: esc = 0;
! 2440:
! 2441: continue;
! 2442:
! 2443: } /* end 'printable' characters */
! 2444:
! 2445: if ((esc = (ch == ESC))) {
! 2446:
! 2447: for (ch = 0; ch < ARGS_IN_ESC; args[ch++] = 0);
! 2448:
! 2449: argcnt = 0;
! 2450: noargs = TRUE;
! 2451:
! 2452: continue;
! 2453:
! 2454: }
! 2455:
! 2456: if (ch == LF) {
! 2457:
! 2458:
! 2459: pLF:
! 2460:
! 2461: if ((ypos[HOME] <= (*screen).sc_up) || (ypos[HOME] > (*screen).sc_lo)) {
! 2462:
! 2463: if (++ypos[HOME] >= (n_lines - 1)) {
! 2464: ypos[HOME] = (n_lines - 1);
! 2465: }
! 2466:
! 2467: if (ch == LF) tmpx--;
! 2468:
! 2469: tmp[tmpx++] = ESC;
! 2470: tmp[tmpx++] = '[';
! 2471:
! 2472: if (ypos[HOME] > 8) tmp[tmpx++] = (1 + ypos[HOME]) / 10 + '0';
! 2473:
! 2474: tmp[tmpx++] = (1 + ypos[HOME]) % 10 + '0';
! 2475:
! 2476: if (xpos[HOME] > 0) {
! 2477:
! 2478: tmp[tmpx++] = ';';
! 2479:
! 2480: if (xpos[HOME] > 8) tmp[tmpx++] = (1 + xpos[HOME]) / 10 + '0';
! 2481:
! 2482: tmp[tmpx++] = (1 + xpos[HOME]) % 10 + '0';
! 2483:
! 2484: }
! 2485:
! 2486: tmp[tmpx++] = 'H';
! 2487:
! 2488: }
! 2489: else if (ypos[HOME] < (*screen).sc_lo) {
! 2490:
! 2491: /* within scroll area */
! 2492: if (++ypos[HOME] >= (n_lines - 1)) {
! 2493: ypos[HOME] = (n_lines - 1);
! 2494: }
! 2495:
! 2496: }
! 2497: else {
! 2498:
! 2499: /* lower margin of scroll area: scroll up */
! 2500: xpos[HOME] = 0;
! 2501:
! 2502:
! 2503: #ifdef SCO
! 2504: if ((ch != LF) && (!(*screen).lin24) && (ypos[HOME] == (*screen).sc_lo) && (ypos[HOME] == n_lines - 1)) {
! 2505: continue;
! 2506: }
! 2507: #endif /* SCO */
! 2508:
! 2509: /* TODO: find out what 'rollflag' is */
! 2510: /* if ((*screen).rollflag==FALSE) continue; */
! 2511: k = (*screen).sclines[(*screen).sc_up];
! 2512:
! 2513: for (i = (*screen).sc_up; i < (*screen).sc_lo; i++) {
! 2514: (*screen).sclines[i] = (*screen).sclines[i + 1];
! 2515: }
! 2516:
! 2517: (*screen).sclines[(*screen).sc_lo] = k;
! 2518:
! 2519: for (i = 0; i < n_columns; i++) {
! 2520:
! 2521: (*screen).screenx[k][i] = SP;
! 2522: (*screen).screena[k][i] = (*screen).att;
! 2523:
! 2524: #ifdef COLOR
! 2525: (*screen).screenc[k][i] = (*screen).col;
! 2526: #endif /* COLOR */
! 2527:
! 2528: }
! 2529:
! 2530:
! 2531: #ifdef SCO
! 2532: tmp[tmpx] = EOL;
! 2533: tmpx = 0;
! 2534:
! 2535: if (foreground) {
! 2536: m_output (tmp);
! 2537: part_ref (screen, (*screen).sc_up, (*screen).sc_lo);
! 2538: }
! 2539: #endif /* SCO */
! 2540:
! 2541: }
! 2542:
! 2543: continue;
! 2544:
! 2545: } /* if (ch == LF) */
! 2546:
! 2547: if (ch == CR) {
! 2548: xpos[HOME] = 0;
! 2549: continue;
! 2550: }
! 2551:
! 2552: if (ch == BS) {
! 2553:
! 2554: if (--xpos[HOME] < 0) xpos[HOME] = 0;
! 2555:
! 2556: continue;
! 2557:
! 2558: }
! 2559:
! 2560: /* FORM FEED: clear screen */
! 2561: if (ch == FF) {
! 2562:
! 2563: xpos[HOME] = 0;
! 2564: ypos[HOME] = 0;
! 2565:
! 2566: ch = 'J';
! 2567:
! 2568: tmp[tmpx - 1] = ESC;
! 2569: tmp[tmpx++] = '[';
! 2570: tmp[tmpx++] = 'H';
! 2571: tmp[tmpx++] = ESC;
! 2572: tmp[tmpx++] = '[';
! 2573: tmp[tmpx++] = ch;
! 2574:
! 2575: args[0] = 0;
! 2576: noargs = TRUE;
! 2577: argcnt = 0;
! 2578:
! 2579: goto ED;
! 2580:
! 2581: }
! 2582:
! 2583: if (ch == TAB) {
! 2584:
! 2585: k = xpos[HOME];
! 2586:
! 2587: if ((i = k + 1) >= n_columns) i = (n_columns - 1);
! 2588:
! 2589: while ((*screen).tabs[i] == 0) {
! 2590:
! 2591: if (i >= n_columns) {
! 2592: i = (n_columns - 1);
! 2593: break;
! 2594: }
! 2595:
! 2596: i++;
! 2597:
! 2598: }
! 2599:
! 2600:
! 2601: #ifdef PROC_TAB
! 2602: if (i != k) {
! 2603:
! 2604: tmp[tmpx++] = CR;
! 2605:
! 2606: if ((xpos[HOME] = i) != 0) {
! 2607:
! 2608: tmp[tmpx++] = ESC;
! 2609: tmp[tmpx++] = '[';
! 2610:
! 2611: if (i > 9) tmp[tmpx++] = i / 10 + '0';
! 2612:
! 2613: tmp[tmpx++] = i % 10 + '0';
! 2614: tmp[tmpx++] = 'C';
! 2615:
! 2616: }
! 2617:
! 2618: }
! 2619: #endif /* PROC_TAB */
! 2620:
! 2621: continue;
! 2622: }
! 2623:
! 2624: /* SI Shift In */
! 2625: if (ch == SI) (*screen).att &= ~01; /* clear SO-Bit */
! 2626:
! 2627: /* SO Shift Out */
! 2628: if (ch == SO) (*screen).att |= 01; /* set SO-Bit */
! 2629:
! 2630: if (ch == CAN) { /* CANcel ESC_esquence */
! 2631: esc = argcnt = noargs = 0;
! 2632: continue;
! 2633: }
! 2634:
! 2635: } /* end while */
! 2636:
! 2637: tmp[tmpx] = EOL;
! 2638:
! 2639: if (foreground) m_output (tmp);
! 2640:
! 2641: return;
! 2642:
! 2643: } /* end writeHOME() */
! 2644:
! 2645:
! 2646: #ifdef SCO
! 2647:
! 2648: /*att screen attributes byte */
! 2649: /*bwflag black_on_white flag */
! 2650: int scosgr (short att, short bwflag)
! 2651: {
! 2652:
! 2653: att = att & ~044; /* suppress SGR(3) and SGR(6) */
! 2654:
! 2655: if (att & 0200) return att & 0201; /* no display */
! 2656: if (bwflag) att ^= 0100; /* toggle inverse */
! 2657: if (att & 0100) return att & 0121; /* inverse, evtl. incl. blink */
! 2658: if (att & 032) return att & 033; /* other valid combinations */
! 2659:
! 2660: return att;
! 2661:
! 2662: } /* end scosgr() */
! 2663:
! 2664: #endif /* SCO */
! 2665:
! 2666: /* init Screen params */
! 2667: void ris (struct vtstyp *scr)
! 2668: {
! 2669: short i;
! 2670: short l;
! 2671:
! 2672: scr->att = 0;
! 2673:
! 2674: #ifdef COLOR
! 2675: scr->col = 7; /* default color is white on black */
! 2676: #endif /* COLOR */
! 2677:
! 2678: scr->Xpos = 0;
! 2679: scr->Ypos = 0;
! 2680:
! 2681: for (i = 0; i < CSLEN; i++) {
! 2682: scr->csx[i] = 0;
! 2683: scr->csy[i] = 0;
! 2684: }
! 2685:
! 2686: scr->cs = 0;
! 2687: scr->sc_up = 0;
! 2688: scr->sc_lo = n_lines;
! 2689:
! 2690: for (i = 0; i <= n_lines; i++) {
! 2691:
! 2692: scr->sclines[i] = i;
! 2693:
! 2694: for (l = 0; l < n_columns; l++) {
! 2695:
! 2696: scr->screenx[i][l] = SP;
! 2697: scr->screena[i][l] = 0;
! 2698:
! 2699:
! 2700: #ifdef COLOR
! 2701: scr->screenc[i][l] = 7; /* default color is white on black */
! 2702: #endif /* COLOR */
! 2703:
! 2704: }
! 2705:
! 2706: }
! 2707:
! 2708: /* TABS */
! 2709: for (i = 0; i <= n_columns; i++) scr->tabs[i] = 0;
! 2710: for (i = 7; i <= n_columns; i += 8) scr->tabs[i] = 1;
! 2711:
! 2712: scr->rollflag = TRUE; /* Roll or Page mode */
! 2713: scr->lin24 = FALSE; /* 24 lines or 25 lines mode (MUST BE FALSE!!!!) */
! 2714: scr->savarg = FALSE;
! 2715:
! 2716: for (i = 0; i < CSLEN; i++) scr->cssgr[i] = FALSE; /* save SGR flag */
! 2717:
! 2718: return;
! 2719:
! 2720: } /* end ris() */
! 2721:
! 2722: /* refresh (foreground) screen partially */
! 2723: void part_ref (struct vtstyp *scr, short from, short to)
! 2724: {
! 2725: short k;
! 2726: short l;
! 2727: short max;
! 2728: unsigned char exa;
! 2729: unsigned char exc;
! 2730: short i;
! 2731: unsigned char *linea;
! 2732: unsigned char *linex;
! 2733: unsigned char *linec;
! 2734: unsigned char ch;
! 2735: unsigned char tmp[1300];
! 2736:
! 2737: /* build up alternate screen */
! 2738: /* reset SGR,TBM;white on black,go HOME; 25 Lines */
! 2739: stcpy (tmp, "\017\033[m\033[37;40m\033[r\033[H\033[0u\201");
! 2740: m_output (tmp);
! 2741:
! 2742:
! 2743: #ifndef PROC_TAB
! 2744:
! 2745: k = 0;
! 2746: i = 0; /* set TABs */
! 2747:
! 2748: tmp[k++] = ESC;
! 2749: tmp[k++] = '[';
! 2750:
! 2751: if (from > 8) tmp[k++] = '0' + (from + 1) / 10;
! 2752:
! 2753: tmp[k++] = '0' + (from + 1) % 10;
! 2754: tmp[k++] = 'H';
! 2755:
! 2756: for (l = 0; l < n_columns; l++) {
! 2757:
! 2758: tmp[k++] = SP;
! 2759:
! 2760: if ((*scr).tabs[l]) {
! 2761:
! 2762: tmp[k++] = ESC;
! 2763: tmp[k++] = 'H';
! 2764:
! 2765: i = k;
! 2766:
! 2767: }
! 2768:
! 2769: }
! 2770:
! 2771: tmp[i++] = CR;
! 2772: tmp[i] = EOL;
! 2773: m_output (tmp);
! 2774:
! 2775: #endif /* PROC_TAB */
! 2776:
! 2777: k = 0;
! 2778:
! 2779: for (i = from; i <= to; i++) {
! 2780:
! 2781: tmp[k++] = ESC; /* CUP(i) */
! 2782: tmp[k++] = '[';
! 2783:
! 2784: if (i > 8) tmp[k++] = (i + 1) / 10 + '0';
! 2785: if (i > 0) tmp[k++] = (i + 1) % 10 + '0';
! 2786:
! 2787: tmp[k++] = 'H';
! 2788:
! 2789: linex = (*scr).screenx[(unsigned int) (*scr).sclines[i]];
! 2790: linea = (*scr).screena[(unsigned int) (*scr).sclines[i]];
! 2791:
! 2792: #ifdef COLOR
! 2793: linec = (*scr).screenc[(unsigned int) (*scr).sclines[i]];
! 2794: #endif /* COLOR */
! 2795:
! 2796: for (max = n_columns - 1; max > 0; max--) {
! 2797:
! 2798: if (linex[max] != SP) break;
! 2799: if (linea[max] != linea[max - 1]) break;
! 2800: if (linec[max] != linec[max - 1]) break;
! 2801:
! 2802: }
! 2803:
! 2804: exa = ~linea[0]; /* dummy value to trigger argument codes on 1st char */
! 2805: exc = ~linec[0]; /* dummy value to trigger argument codes on 1st char */
! 2806:
! 2807: for (l = 0; l <= max; l++) {
! 2808:
! 2809: if (l == (n_columns - 1) && (i == (n_lines))) continue;
! 2810:
! 2811: #ifndef LINUX
! 2812: #ifdef COLOR
! 2813: if (exc != linec[l]) { /* set color */
! 2814:
! 2815: if ((exc / 16) != (linec[l] / 16)) { /* background color */
! 2816:
! 2817: tmp[k++] = ESC;
! 2818: tmp[k++] = '[';
! 2819: tmp[k++] = '=';
! 2820: tmp[k++] = '0';
! 2821:
! 2822: if (linec[l] / 16 > 9) tmp[k++] = '0' + linec[l] / 16 / 10;
! 2823:
! 2824: tmp[k++] = '0' + linec[l] / 16 % 10;
! 2825: tmp[k++] = 'G';
! 2826: tmp[k++] = ESC; /* background == reverse foreground */
! 2827: tmp[k++] = '[';
! 2828: tmp[k++] = '=';
! 2829: tmp[k++] = '0';
! 2830:
! 2831: if (linec[l] / 16 > 9) tmp[k++] = '0' + linec[l] / 16 / 10;
! 2832:
! 2833: tmp[k++] = '0' + linec[l] / 16 % 10;
! 2834: tmp[k++] = 'H';
! 2835:
! 2836: }
! 2837:
! 2838: if ((exc % 16) != (linec[l] % 16)) { /* foreground color */
! 2839:
! 2840: tmp[k++] = ESC;
! 2841: tmp[k++] = '[';
! 2842: tmp[k++] = '=';
! 2843: tmp[k++] = '0';
! 2844:
! 2845: if (linec[l] % 16 > 9) tmp[k++] = '0' + linec[l] % 16 / 10;
! 2846:
! 2847: tmp[k++] = '0' + linec[l] % 16 % 10;
! 2848: tmp[k++] = 'F';
! 2849: tmp[k++] = ESC; /* foreground == reverse background */
! 2850: tmp[k++] = '[';
! 2851: tmp[k++] = '=';
! 2852: tmp[k++] = '0';
! 2853:
! 2854: if (linec[l] % 16 > 9) tmp[k++] = '0' + linec[l] % 16 / 10;
! 2855:
! 2856: tmp[k++] = '0' + linec[l] % 16 % 10;
! 2857: tmp[k++] = 'I';
! 2858:
! 2859: }
! 2860:
! 2861: exc = linec[l];
! 2862:
! 2863: }
! 2864:
! 2865: #endif /* COLOR */
! 2866: #endif /* LINUX */
! 2867:
! 2868: if (exa != linea[l]) { /* set attribute */
! 2869:
! 2870: short p;
! 2871: short xatt;
! 2872:
! 2873: p = exa;
! 2874: exa = linea[l];
! 2875:
! 2876: if ((p & 01) != (exa & 01)) tmp[k++] = (exa & 01) ? SO : SI;
! 2877:
! 2878: if ((p & ~01) != (exa & ~01)) {
! 2879:
! 2880: xatt = exa;
! 2881:
! 2882:
! 2883: #ifdef SCO
! 2884: xatt = scosgr (xatt, (*scr).bw);
! 2885: #endif /* SCO */
! 2886:
! 2887: tmp[k++] = ESC;
! 2888: tmp[k++] = '[';
! 2889:
! 2890:
! 2891: #ifdef SCO
! 2892: if ((*scr).bw) tmp[k++] = '7';
! 2893: #endif /* SCO */
! 2894:
! 2895: tmp[k++] = 'm';
! 2896: tmp[k++] = ESC;
! 2897: tmp[k++] = '[';
! 2898:
! 2899: if (xatt & 02) {
! 2900:
! 2901:
! 2902: #ifdef SCO
! 2903: tmp[k++] = '1';
! 2904: #else
! 2905: tmp[k++] = '2';
! 2906: #endif /* SCO */
! 2907:
! 2908: tmp[k++] = ';';
! 2909: }
! 2910:
! 2911: if (xatt & 04) {
! 2912: tmp[k++] = '3';
! 2913: tmp[k++] = ';';
! 2914: }
! 2915:
! 2916: if (xatt & 010) {
! 2917: tmp[k++] = '4';
! 2918: tmp[k++] = ';';
! 2919: }
! 2920:
! 2921: if (xatt & 020) {
! 2922: tmp[k++] = '5';
! 2923: tmp[k++] = ';';
! 2924: }
! 2925:
! 2926: if (xatt & 040) {
! 2927: tmp[k++] = '6';
! 2928: tmp[k++] = ';';
! 2929: }
! 2930:
! 2931: if (xatt & 0100) {
! 2932: tmp[k++] = '7';
! 2933: tmp[k++] = ';';
! 2934: }
! 2935:
! 2936: if (xatt & 0200) {
! 2937: tmp[k++] = '8';
! 2938: tmp[k++] = ';';
! 2939: }
! 2940:
! 2941: if (tmp[k - 1] == ';') k--;
! 2942:
! 2943: tmp[k++] = 'm';
! 2944:
! 2945: }
! 2946:
! 2947: }
! 2948:
! 2949: tmp[k++] = linex[l];
! 2950:
! 2951: }
! 2952:
! 2953: if (max + 1 < n_columns) {
! 2954: tmp[k++] = ESC;
! 2955: tmp[k++] = '[';
! 2956: tmp[k++] = 'K';
! 2957: }
! 2958:
! 2959: tmp[k] = EOL;
! 2960: k = mcmnd;
! 2961: mcmnd = 'w';
! 2962: ch = (*codptr);
! 2963: *codptr = ',';
! 2964:
! 2965: m_output (tmp);
! 2966:
! 2967: *codptr = ch;
! 2968: mcmnd = k;
! 2969:
! 2970: k = 0;
! 2971:
! 2972: }
! 2973:
! 2974: /* 'saved' cursor position */
! 2975: /* actual cursor position & actual attribute */
! 2976: /* 'flush' output */
! 2977: k = 0;
! 2978:
! 2979:
! 2980: #ifndef SCO
! 2981:
! 2982: tmp[k++] = ESC; /* restore CursorSave Position */
! 2983: tmp[k++] = '[';
! 2984: i = (*scr).csy[(*scr).cs] + 1;
! 2985:
! 2986: if (i > 9) tmp[k++] = '0' + i / 10;
! 2987:
! 2988: tmp[k++] = '0' + i % 10;
! 2989: tmp[k++] = ';';
! 2990:
! 2991: i = (*scr).csx[(*scr).cs] + 1;
! 2992:
! 2993: if (i > 9) tmp[k++] = '0' + i / 10;
! 2994:
! 2995: tmp[k++] = '0' + i % 10;
! 2996: tmp[k++] = 'H';
! 2997: tmp[k++] = ESC; /* DEC Cursor SAVE */
! 2998: tmp[k++] = '7';
! 2999: tmp[k++] = ESC; /* ANSI (?) Cursor SAVE */
! 3000: tmp[k++] = '[';
! 3001: tmp[k++] = 's';
! 3002: tmp[k++] = ESC; /* restore 24/25 line mode */
! 3003: tmp[k++] = '[';
! 3004: tmp[k++] = '0' + (*scr).lin24;
! 3005: tmp[k++] = 'u';
! 3006: tmp[k++] = ESC; /* restore Scroll area */
! 3007: tmp[k++] = '[';
! 3008:
! 3009: if (((*scr).sc_up) > 8) tmp[k++] = '0' + ((*scr).sc_up + 1) / 10;
! 3010:
! 3011: tmp[k++] = '0' + ((*scr).sc_up + 1) % 10;
! 3012: tmp[k++] = ';';
! 3013:
! 3014: if (((*scr).sc_lo) > 8) tmp[k++] = '0' + ((*scr).sc_lo + 1) / 10;
! 3015:
! 3016: tmp[k++] = '0' + ((*scr).sc_lo + 1) % 10;
! 3017: tmp[k++] = 'r';
! 3018:
! 3019: #endif /* not SCO */
! 3020:
! 3021: #ifndef LINUX
! 3022: #ifdef COLOR
! 3023:
! 3024: tmp[k++] = ESC; /* restore foreground color */
! 3025: tmp[k++] = '[';
! 3026: tmp[k++] = '=';
! 3027:
! 3028: if (((*scr).col) % 16 > 9) tmp[k++] = '0' + ((*scr).col) % 16 / 10;
! 3029:
! 3030: tmp[k++] = '0' + ((*scr).col) % 16 % 10;
! 3031: tmp[k++] = 'F';
! 3032: tmp[k++] = ESC; /* restore reverse background color */
! 3033: tmp[k++] = '[';
! 3034: tmp[k++] = '=';
! 3035:
! 3036: if (((*scr).col) % 16 > 9) tmp[k++] = '0' + ((*scr).col) % 16 / 10;
! 3037:
! 3038: tmp[k++] = '0' + ((*scr).col) % 16 % 10;
! 3039: tmp[k++] = 'I';
! 3040: tmp[k++] = ESC; /* restore background color */
! 3041: tmp[k++] = '[';
! 3042: tmp[k++] = '=';
! 3043:
! 3044: if (((*scr).col) / 16 > 9) tmp[k++] = '0' + ((*scr).col) / 16 / 10;
! 3045:
! 3046: tmp[k++] = '0' + ((*scr).col) / 16 % 10;
! 3047: tmp[k++] = 'G';
! 3048: tmp[k++] = ESC; /* restore reverse foreground color */
! 3049: tmp[k++] = '[';
! 3050: tmp[k++] = '=';
! 3051:
! 3052: if (((*scr).col) / 16 > 9) tmp[k++] = '0' + ((*scr).col) / 16 / 10;
! 3053:
! 3054: tmp[k++] = '0' + ((*scr).col) / 16 % 10;
! 3055: tmp[k++] = 'H';
! 3056:
! 3057: #endif /* COLOR */
! 3058: #endif /* LINUX */
! 3059:
! 3060: tmp[k++] = ESC; /* restore CursorPosition */
! 3061: tmp[k++] = '[';
! 3062:
! 3063: if (ypos[HOME] > 8) tmp[k++] = '0' + (ypos[HOME] + 1) / 10;
! 3064:
! 3065: tmp[k++] = '0' + (ypos[HOME] + 1) % 10;
! 3066: tmp[k++] = ';';
! 3067:
! 3068: if (xpos[HOME] > 8) tmp[k++] = '0' + (xpos[HOME] + 1) / 10;
! 3069:
! 3070: tmp[k++] = '0' + (xpos[HOME] + 1) % 10;
! 3071: tmp[k++] = 'H';
! 3072:
! 3073: i = UNSIGN ((*scr).att);
! 3074:
! 3075: tmp[k++] = ((i & 01) ? SO : SI);
! 3076: tmp[k++] = ESC; /* restore graphic attributes */
! 3077: tmp[k++] = '[';
! 3078:
! 3079:
! 3080: #ifdef SCO
! 3081:
! 3082: if ((*scr).bw) tmp[k++] = '7';
! 3083:
! 3084: tmp[k++] = 'm';
! 3085: tmp[k++] = ESC;
! 3086: tmp[k++] = '[';
! 3087:
! 3088: i = scosgr (i, (*scr).bw);
! 3089:
! 3090: if (i & 02) {
! 3091: tmp[k++] = '1';
! 3092: tmp[k++] = ';';
! 3093: }
! 3094:
! 3095: #else
! 3096:
! 3097: if (i & 02) {
! 3098: tmp[k++] = '2';
! 3099: tmp[k++] = ';';
! 3100: }
! 3101:
! 3102: #endif /* SCO */
! 3103:
! 3104: if (i & 04) {
! 3105: tmp[k++] = '3';
! 3106: tmp[k++] = ';';
! 3107: }
! 3108:
! 3109: if (i & 010) {
! 3110: tmp[k++] = '4';
! 3111: tmp[k++] = ';';
! 3112: }
! 3113:
! 3114: if (i & 020) {
! 3115: tmp[k++] = '5';
! 3116: tmp[k++] = ';';
! 3117: }
! 3118:
! 3119: if (i & 040) {
! 3120: tmp[k++] = '6';
! 3121: tmp[k++] = ';';
! 3122: }
! 3123:
! 3124: if (i & 0100) {
! 3125: tmp[k++] = '7';
! 3126: tmp[k++] = ';';
! 3127: }
! 3128:
! 3129: if (i & 0200) {
! 3130: tmp[k++] = '8';
! 3131: tmp[k++] = ';';
! 3132: }
! 3133:
! 3134: if (tmp[k - 1] == ';') k--;
! 3135:
! 3136: tmp[k++] = 'm';
! 3137: tmp[k] = EOL;
! 3138:
! 3139: k = mcmnd;
! 3140: mcmnd = 0;
! 3141:
! 3142: m_output (tmp);
! 3143:
! 3144: mcmnd = k;
! 3145:
! 3146: return;
! 3147:
! 3148: } /* end part_ref() */
! 3149:
! 3150: /* delayed write for higher system throughput */
! 3151: void m_output (char *text)
! 3152: {
! 3153: static char buffer[2048];
! 3154: static int p = 0;
! 3155: char *G;
! 3156: int i;
! 3157: int ch;
! 3158:
! 3159: if (io == HOME) opnfile[io] = stdout;
! 3160:
! 3161: G = SIflag[io] ? G0O[io] : G1O[io];
! 3162:
! 3163: i = 0;
! 3164:
! 3165: while ((ch = text[i++]) != EOL) {
! 3166:
! 3167: ch = UNSIGN (ch);
! 3168:
! 3169: if (ESCflag[io] == FALSE && ch >= NUL && ch < 255) ch = G[ch];
! 3170:
! 3171: buffer[p++] = ch;
! 3172:
! 3173: if (ch == SI) {
! 3174: SIflag[io] = TRUE;
! 3175: G = G0O[io];
! 3176: }
! 3177:
! 3178: if (ch == SO) {
! 3179: SIflag[io] = FALSE;
! 3180: G = G1O[io];
! 3181: }
! 3182:
! 3183: if (ch == ESC) {
! 3184: ESCflag[io] = TRUE;
! 3185: continue;
! 3186: }
! 3187:
! 3188: if (ch == '[' && ESCflag[io]) {
! 3189: ESCflag[io] = 2;
! 3190: continue;
! 3191: }
! 3192:
! 3193: if (ch >= '@' && ch < DEL) ESCflag[io] = FALSE;
! 3194: if (ch != NUL) continue;
! 3195:
! 3196: fputs (buffer, opnfile[io]);
! 3197:
! 3198: p = 0; /* NUL needs special treatment */
! 3199:
! 3200: fputc (NUL, opnfile[io]); /* 'cause unix uses it as delim */
! 3201:
! 3202: }
! 3203:
! 3204: buffer[p] = NUL;
! 3205:
! 3206: if (mcmnd == 'w' && *codptr == ',' && (p < 1536)) return;
! 3207:
! 3208: if (fm_nodelay[io]) {
! 3209:
! 3210: if (setjmp (sjbuf)) {
! 3211: merr_raise (NOWRITE);
! 3212: goto done;
! 3213: }
! 3214:
! 3215: sig_attach (SIGALRM, &ontimo);
! 3216: alarm (3);
! 3217:
! 3218: }
! 3219:
! 3220: fputs (buffer, opnfile[io]);
! 3221:
! 3222: p = 0;
! 3223:
! 3224: if (mcmnd == '*') fputc (EOL, opnfile[io]); /* special treatment for EOL */
! 3225: if (demomode) fputc (d0char, opnfile[io]);
! 3226:
! 3227: fflush (opnfile[io]);
! 3228:
! 3229:
! 3230: done:
! 3231:
! 3232: alarm (0); /* reset alarm request */
! 3233:
! 3234: return;
! 3235:
! 3236: } /* end of m_output() */
! 3237:
! 3238:
! 3239: void write_m (char *text)
! 3240: {
! 3241: static char esc = 0; /* esc processing flag */
! 3242: static char tmp[512];
! 3243: register int i;
! 3244: register int j;
! 3245: register int ch;
! 3246:
! 3247: if (io == HOME) {
! 3248:
! 3249: opnfile[HOME] = stdout;
! 3250:
! 3251: if (frm_filter == FALSE) {
! 3252: writeHOME (text);
! 3253: return;
! 3254: }
! 3255:
! 3256: }
! 3257:
! 3258: /* 'normal' output for devices other than HOME */
! 3259: j = 0;
! 3260: i = 0;
! 3261:
! 3262: while ((ch = text[j++]) != EOL) {
! 3263:
! 3264: tmp[i++] = ch;
! 3265:
! 3266: if (ch >= SP) {
! 3267:
! 3268: if (esc == 0) {
! 3269: xpos[io]++;
! 3270: continue;
! 3271: }
! 3272:
! 3273: if (ch == '[') {
! 3274: esc = 2;
! 3275: continue;
! 3276: }
! 3277:
! 3278: if (ch >= '@' || esc == 1) esc = 0;
! 3279:
! 3280: continue;
! 3281:
! 3282: }
! 3283:
! 3284: esc = (ch == ESC);
! 3285:
! 3286: if (ch == LF) {
! 3287:
! 3288: ypos[io]++;
! 3289:
! 3290: if (crlf[io]) xpos[io] = 0;
! 3291:
! 3292: continue;
! 3293:
! 3294: }
! 3295:
! 3296: if (ch == CR) {
! 3297: xpos[io] = 0;
! 3298: continue;
! 3299: }
! 3300:
! 3301: if (ch == BS) {
! 3302: if (--xpos[io] < 0) xpos[io] = 0;
! 3303: continue;
! 3304: }
! 3305:
! 3306: if (ch == FF) {
! 3307:
! 3308: xpos[io] = 0;
! 3309: ypos[io] = 0;
! 3310:
! 3311: continue;
! 3312:
! 3313: }
! 3314:
! 3315: if (ch == TAB) {
! 3316: xpos[io] += 8 - (xpos[io] % 8);
! 3317: }
! 3318:
! 3319: } /* end while */
! 3320:
! 3321: tmp[i] = EOL;
! 3322:
! 3323: m_output (tmp);
! 3324:
! 3325: xpos[io] &= 0377;
! 3326: ypos[io] &= 0377;
! 3327:
! 3328: return;
! 3329:
! 3330: } /* end of write_m() */
! 3331:
! 3332: /* tab to number 'col' column' */
! 3333: void write_t (short int col)
! 3334: {
! 3335: short int i;
! 3336: short int j;
! 3337: char tmp[256]; /* Not tied to STRLEN necessarily*/
! 3338:
! 3339: if (col <= xpos[io]) return;
! 3340: if (col > (sizeof(tmp)-1)) col = (sizeof(tmp)-1); /* guard against buffer overflow */
! 3341:
! 3342: j = xpos[io];
! 3343: i = 0;
! 3344:
! 3345: while (j++ < col) tmp[i++] = SP;
! 3346:
! 3347: tmp[i] = EOL;
! 3348:
! 3349: write_m (tmp);
! 3350:
! 3351: return;
! 3352:
! 3353: } /* end of write_t() */
! 3354:
! 3355: void ontimo ()
! 3356: { /* handle timeout (for read) */
! 3357: longjmp (sjbuf, 1);
! 3358: } /* end of ontimo() */
! 3359:
! 3360: /* Try to read up to 'length' characters from current 'io'
! 3361: * If 'length' == zero a single character read is performed and
! 3362: * its $ASCII value is returned in 'stuff'.
! 3363: * A negative value of 'timeout' means there's no timeout.
! 3364: * a zero value looks whether a character has been typed in already
! 3365: * a positive value terminates the read after 'timeout' seconds
! 3366: * a timeout will set $TEST to TRUE if successfull, FALSE otherwise
! 3367: *
! 3368: * timeouts 1 .. 3 are done by polling,
! 3369: * higher timeouts request an alarm. that different treatment is
! 3370: * necessary, because timeouts may be up to 2 seconds early.
! 3371: * polling on higher timeouts would be require too much system resources
! 3372: * just for nothing.
! 3373: * maximum timeout is 32767 (2**15-1) seconds (about 9 hrs)
! 3374: * There are no provisions to handle overflow.
! 3375: */
! 3376: void read_m (char *stuff, long read_timeout, short read_timeoutms, short length)
! 3377: {
! 3378: static char previous[2][256] = {{EOL}, {EOL}}; /* all static: longjmp! */
! 3379: static short p_toggle = 0;
! 3380: static char term_key[256] = {EOL, EOL};
! 3381: static short int escptr;
! 3382: static short int single;
! 3383: static short int timoflag; /* timeout flag */
! 3384: static long int timex;
! 3385: static short int timexms;
! 3386: static short int i;
! 3387: static int ch;
! 3388:
! 3389: #ifdef USE_GETTIMEOFDAY
! 3390: static struct timeval timebuffer;
! 3391: #else
! 3392: static struct timeb timebuffer;
! 3393: #endif
! 3394:
! 3395: escptr = 0;
! 3396: single = 0;
! 3397: timoflag = FALSE;
! 3398:
! 3399: /* Not necessarily tied to STRLEN */
! 3400:
! 3401: if (length > 255) length = 255;
! 3402:
! 3403: stuff[length] = EOL;
! 3404: stuff[0] = EOL;
! 3405:
! 3406: if (length < 1) single = length = 1;
! 3407:
! 3408: timex = 0L;
! 3409: timexms = 0;
! 3410:
! 3411: if (io == HOME) opnfile[HOME] = stdin;
! 3412:
! 3413: if (io == HOME && !frm_filter) {
! 3414:
! 3415: if (NOTYPEAHEAD) fflush (stdin); /* ignore previous input */
! 3416:
! 3417: if (read_timeout >= 0) {
! 3418:
! 3419: test = TRUE;
! 3420:
! 3421: if (read_timeout > 2 && read_timeout <= 32767) { /* cave small/large values */
! 3422:
! 3423: if (setjmp (sjbuf)) {
! 3424:
! 3425: test = FALSE;
! 3426: timoflag = TRUE;
! 3427:
! 3428: goto done;
! 3429:
! 3430: }
! 3431:
! 3432: sig_attach (SIGALRM, &ontimo);
! 3433: alarm ((unsigned) read_timeout);
! 3434:
! 3435: read_timeout = (-1L);
! 3436:
! 3437: }
! 3438: else {
! 3439:
! 3440: if (read_timeout >= 0) {
! 3441:
! 3442:
! 3443: #ifdef USE_GETTIMEOFDAY
! 3444:
! 3445: gettimeofday (&timebuffer, NULL); /* get current time */
! 3446:
! 3447: read_timeout += timebuffer.tv_sec; /* target time */
! 3448: read_timeoutms += timebuffer.tv_usec;
! 3449:
! 3450: #else
! 3451:
! 3452: ftime (&timebuffer); /* get current time */
! 3453:
! 3454: read_timeout += timebuffer.time; /* target time */
! 3455: read_timeoutms += timebuffer.millitm;
! 3456:
! 3457: #endif
! 3458:
! 3459: if (read_timeoutms > 999) {
! 3460: read_timeoutms -= 1000;
! 3461: read_timeout++;
! 3462: }
! 3463:
! 3464: }
! 3465:
! 3466: }
! 3467:
! 3468: }
! 3469:
! 3470: zb[0] = EOL;
! 3471: zb[1] = EOL;
! 3472: zcc = FALSE;
! 3473:
! 3474: for (i = 0; i < length; i++) {
! 3475:
! 3476: if (merr () == INRPT) {
! 3477:
! 3478: if (--i < 0) i = 0;
! 3479: stuff[i] = EOL;
! 3480:
! 3481: break;
! 3482: }
! 3483:
! 3484: if (evt_async_enabled && (merr () == ASYNC)) break;
! 3485:
! 3486: /* TODO: remove old FreeM "journaling" nonsense here */
! 3487: if (jour_flag < 0) {
! 3488:
! 3489: if ((ch = fgetc (jouraccess)) == EOF) {
! 3490:
! 3491: jour_flag = 0;
! 3492:
! 3493: fclose (jouraccess);
! 3494:
! 3495: jouraccess = NULL;
! 3496:
! 3497: }
! 3498: else {
! 3499:
! 3500: if (ch == SI) {
! 3501: test = FALSE;
! 3502: break;
! 3503: } /* timeout char */
! 3504:
! 3505: }
! 3506:
! 3507: }
! 3508:
! 3509:
! 3510: if (jour_flag >= 0) {
! 3511:
! 3512: if (ug_buf[HOME][0] != EOL) {
! 3513: ch = ug_buf[HOME][0];
! 3514: stcpy (ug_buf[HOME], &ug_buf[HOME][1]);
! 3515: }
! 3516: else {
! 3517: if (read_timeout >= 0)
! 3518: #ifdef SYSFIVE
! 3519: {
! 3520: if (rdchk0 (&ch) == 1) {
! 3521: }
! 3522: #else
! 3523: {
! 3524:
! 3525: if (rdchk (fileno (stdin)) > 0)
! 3526: ch = getc (stdin);
! 3527: #endif /* SYSFIVE */
! 3528: else {
! 3529:
! 3530: if (read_timeout < 0) {
! 3531:
! 3532: test = FALSE;
! 3533: timoflag = TRUE;
! 3534: stuff[i] = EOL;
! 3535:
! 3536: break;
! 3537:
! 3538: }
! 3539: #ifdef USE_GETTIMEOFDAY
! 3540: gettimeofday (&timebuffer, NULL); /* get current time */
! 3541: if ((read_timeout < timebuffer.tv_sec) ||
! 3542: ((read_timeout == timebuffer.tv_sec) &&
! 3543: (read_timeoutms <= timebuffer.tv_usec))) {
! 3544: #else
! 3545: ftime (&timebuffer); /* get current time */
! 3546: if ((read_timeout < timebuffer.time) ||
! 3547: ((read_timeout == timebuffer.time) &&
! 3548: (read_timeoutms <= timebuffer.millitm))) {
! 3549: #endif
! 3550:
! 3551: test = FALSE;
! 3552: timoflag = TRUE;
! 3553: stuff[i] = EOL;
! 3554: break;
! 3555: }
! 3556:
! 3557: i--;
! 3558: continue;
! 3559:
! 3560: }
! 3561: }
! 3562: else {
! 3563: ch = getc (stdin);
! 3564: }
! 3565: }
! 3566: }
! 3567:
! 3568: if (UNSIGN (ch) == 255) {
! 3569: i--;
! 3570: continue;
! 3571: } /* illegal char */
! 3572:
! 3573: if (CONVUPPER) { /* convert to uppercase ? */
! 3574: if (ch >= 'a' && ch <= 'z') ch -= 32;
! 3575: }
! 3576:
! 3577: /* on CTRL/O suspend execution until next CTRL/O */
! 3578: if (ch == SI && CTRLOPROC) {
! 3579:
! 3580: printf ("\033[8p\033[4u"); /* screen dark, timeout off */
! 3581:
! 3582: while ((ch = getc (stdin)) != SI); /* loop until CTRL/O */
! 3583:
! 3584: printf ("\033[9p\033[5u"); /* screen light, timeout on */
! 3585:
! 3586: i--;
! 3587: continue;
! 3588: }
! 3589:
! 3590: zb[0] = ch;
! 3591:
! 3592: if (single == 0) {
! 3593:
! 3594: if (ch == ESC) {
! 3595:
! 3596: i--;
! 3597:
! 3598: term_key[0] = ESC;
! 3599: escptr = 1;
! 3600:
! 3601: continue;
! 3602:
! 3603: }
! 3604:
! 3605: if (escptr) {
! 3606:
! 3607: short j;
! 3608:
! 3609: i--;
! 3610:
! 3611: term_key[escptr++] = ch;
! 3612: term_key[escptr] = EOL;
! 3613:
! 3614: if (ch == '[' && escptr == 2) continue; /* CSI */
! 3615:
! 3616: /* DECs PF1..PF4 and Keypad application */
! 3617: if (ch == 'O' && PF1flag && escptr == 2) continue;
! 3618: if (escptr > 2 && (ch < '@' || ch >= DEL)) continue;
! 3619:
! 3620: if (ESCSEQPROC) {
! 3621: stcpy (zb, term_key);
! 3622: break;
! 3623: }
! 3624:
! 3625: if (escptr == 2) {
! 3626:
! 3627: if (ch == '9') { /* to begin of string */
! 3628:
! 3629: while (i >= 0) {
! 3630:
! 3631: if (ECHOON) {
! 3632:
! 3633: if (xpos[HOME] > 0) {
! 3634: write_m ("\033[D\201");
! 3635: }
! 3636: else {
! 3637: write_m ("\033M\033[79C\201");
! 3638: }
! 3639:
! 3640: }
! 3641:
! 3642: i--;
! 3643:
! 3644: }
! 3645:
! 3646: escptr = 0;
! 3647:
! 3648: continue;
! 3649:
! 3650: }
! 3651: else if (ch == ':') { /* to end of string */
! 3652:
! 3653: while (stuff[i] != EOL && stuff[i + 1] != EOL) {
! 3654:
! 3655: if (ECHOON) {
! 3656:
! 3657: if (xpos[HOME] < (n_columns - 1)) {
! 3658: write_m ("\033[C\201");
! 3659: }
! 3660: else {
! 3661: write_m ("\012\015\201");
! 3662: }
! 3663:
! 3664: }
! 3665:
! 3666: i++;
! 3667:
! 3668: }
! 3669:
! 3670: escptr = 0;
! 3671:
! 3672: continue;
! 3673:
! 3674: }
! 3675:
! 3676: }
! 3677:
! 3678: if (escptr == 3) {
! 3679:
! 3680: if (ch == 'D') { /* CUB left arrow */
! 3681:
! 3682: if (i >= 0) {
! 3683:
! 3684: if (ECHOON) {
! 3685:
! 3686: if (xpos[HOME] > 0) {
! 3687: write_m (term_key);
! 3688: }
! 3689: else {
! 3690: write_m ("\033M\033[79C\201");
! 3691: }
! 3692:
! 3693: }
! 3694:
! 3695: i--;
! 3696:
! 3697: }
! 3698:
! 3699: escptr = 0;
! 3700:
! 3701: continue;
! 3702:
! 3703: }
! 3704:
! 3705: if (stuff[i + 1] == EOL) {
! 3706: escptr = 0;
! 3707: continue;
! 3708: }
! 3709:
! 3710: if (ch == 'C') { /* CUF right arrow */
! 3711:
! 3712: if (ECHOON) {
! 3713:
! 3714: if (xpos[HOME] < (n_columns - 1)) {
! 3715: write_m (term_key);
! 3716: }
! 3717: else {
! 3718: write_m ("\012\015\201");
! 3719: }
! 3720:
! 3721: }
! 3722:
! 3723: i++;
! 3724:
! 3725: escptr = 0;
! 3726:
! 3727: continue;
! 3728:
! 3729: }
! 3730:
! 3731: if (ch == 'P') { /* DCH Delete Character */
! 3732:
! 3733: ch = i + 1;
! 3734:
! 3735: if (stuff[ch] != EOL) {
! 3736: while ((stuff[ch] = stuff[ch + 1]) != EOL) ch++;
! 3737: }
! 3738:
! 3739: if (ECHOON) {
! 3740:
! 3741: ch = xpos[HOME] + 1;
! 3742: j = ypos[HOME] + 1;
! 3743:
! 3744: stcpy (term_key, &stuff[i + 1]);
! 3745: stcat (term_key, " \033[\201");
! 3746: intstr (&term_key[stlen (term_key)], j);
! 3747: stcat (term_key, ";\201");
! 3748: intstr (&term_key[stlen (term_key)], ch);
! 3749: stcat (term_key, "H\201");
! 3750:
! 3751: write_m (term_key);
! 3752:
! 3753: }
! 3754:
! 3755: escptr = 0;
! 3756:
! 3757: continue;
! 3758:
! 3759: }
! 3760:
! 3761: if (ch == '@') { /* ICH Insert Character */
! 3762:
! 3763: ch = i;
! 3764: while (stuff[ch++] != EOL);
! 3765:
! 3766: while (ch > i) {
! 3767: stuff[ch] = stuff[ch - 1];
! 3768: ch--;
! 3769: }
! 3770:
! 3771: stuff[i + 1] = SP;
! 3772:
! 3773: if (ECHOON) {
! 3774:
! 3775: ch = xpos[HOME] + 1;
! 3776: j = ypos[HOME] + 1;
! 3777:
! 3778: stcpy (term_key, &stuff[i + 1]);
! 3779: stcat (term_key, "\033[\201");
! 3780: intstr (&term_key[stlen (term_key)], j);
! 3781: stcat (term_key, ";\201");
! 3782: intstr (&term_key[stlen (term_key)], ch);
! 3783: stcat (term_key, "H\201");
! 3784:
! 3785: write_m (term_key);
! 3786:
! 3787: }
! 3788:
! 3789: escptr = 0;
! 3790:
! 3791: continue;
! 3792:
! 3793: }
! 3794: }
! 3795:
! 3796: /* VT100 Functionkey */
! 3797: if (ch == '~' && (escptr == 4 || escptr == 5)) {
! 3798:
! 3799: j = term_key[2] - '0';
! 3800:
! 3801: if (term_key[3] != ch) j = j * 10 + term_key[3] - '0';
! 3802: if (j < 1 || j > 44) j = 0;
! 3803:
! 3804: }
! 3805: else {
! 3806: /* SCO Functionkey */
! 3807: j = find ("@ABCDFGHIJKLMNOP0_dTVX ;\"#$%&\'<=*+,-./123UWY\201", &term_key[1]);
! 3808: }
! 3809:
! 3810: escptr = 0;
! 3811:
! 3812: /* key unknown or without a value */
! 3813: if (j == 0 || zfunkey[j - 1][0] == EOL) continue;
! 3814:
! 3815: /* put key in input buffer, ignore overflow */
! 3816: {
! 3817: char tmp[256];
! 3818:
! 3819: stcpy (tmp, ug_buf[HOME]);
! 3820: stcpy (ug_buf[HOME], zfunkey[--j]);
! 3821: stcat (ug_buf[HOME], tmp);
! 3822: }
! 3823:
! 3824: continue;
! 3825: }
! 3826:
! 3827: term_key[0] = ch;
! 3828: term_key[1] = EOL;
! 3829:
! 3830: if (find (LineTerm, term_key)) break;
! 3831:
! 3832: if (ch == BS || ch == DEL) {
! 3833:
! 3834: if (stuff[i] != EOL) { /* DEL within string */
! 3835:
! 3836: if (ch == BS && i > 0) {
! 3837:
! 3838: if (ECHOON) {
! 3839:
! 3840: if (xpos[HOME] > 0) {
! 3841: write_m ("\033[D\201");
! 3842: }
! 3843: else {
! 3844: write_m ("\033M\033[79C\201");
! 3845: }
! 3846:
! 3847: }
! 3848:
! 3849: i--;
! 3850:
! 3851: }
! 3852:
! 3853: ch = i;
! 3854: if (stuff[ch] != EOL) {
! 3855: while ((stuff[ch] = stuff[ch + 1]) != EOL) ch++;
! 3856: }
! 3857:
! 3858: if (ECHOON) {
! 3859:
! 3860: int j;
! 3861:
! 3862: ch = xpos[HOME] + 1;
! 3863: j = ypos[HOME] + 1;
! 3864:
! 3865: stcpy (term_key, &stuff[i]);
! 3866: stcat (term_key, " \033[\201");
! 3867: intstr (&term_key[stlen (term_key)], j);
! 3868: stcat (term_key, ";\201");
! 3869: intstr (&term_key[stlen (term_key)], ch);
! 3870: stcat (term_key, "H\201");
! 3871:
! 3872: write_m (term_key);
! 3873:
! 3874: }
! 3875:
! 3876: continue;
! 3877:
! 3878: }
! 3879:
! 3880: if (i > 0) {
! 3881:
! 3882: if (ECHOON) {
! 3883:
! 3884: if (DELMODE) {
! 3885:
! 3886: if (xpos[HOME] > 0) {
! 3887: write_m ("\010 \010\201");
! 3888: }
! 3889: else {
! 3890: write_m ("\033M\033[79C\033[P\201");
! 3891: }
! 3892:
! 3893: } else {
! 3894: write_m ("\\\201");
! 3895: }
! 3896:
! 3897: }
! 3898:
! 3899: i--;
! 3900:
! 3901: ch = i;
! 3902:
! 3903: while ((stuff[ch] = stuff[ch + 1]) != EOL) ch++;
! 3904:
! 3905: }
! 3906: else if (DELEMPTY) {
! 3907:
! 3908: /* empty string delete? */
! 3909: stuff[0] = EOL;
! 3910: i = 1;
! 3911: term_key[0] = ch;
! 3912:
! 3913: break;
! 3914:
! 3915: }
! 3916:
! 3917: i--;
! 3918:
! 3919: continue;
! 3920:
! 3921: }
! 3922:
! 3923: if (ch == NAK || ch == DC2) { /* CTRL/U deletes all input */
! 3924:
! 3925: while (stuff[i] != EOL) {
! 3926:
! 3927: if (ECHOON) {
! 3928:
! 3929: if (xpos[HOME] < (n_columns - 1)) {
! 3930: write_m ("\033[C\201");
! 3931: }
! 3932: else {
! 3933: write_m ("\012\015\201");
! 3934: }
! 3935:
! 3936: }
! 3937:
! 3938: i++;
! 3939:
! 3940: }
! 3941:
! 3942: while (i > 0) {
! 3943:
! 3944: if (ECHOON) {
! 3945:
! 3946: if (DELMODE) {
! 3947:
! 3948: if (xpos[HOME] > 0) {
! 3949: write_m ("\010 \010\201");
! 3950: }
! 3951: else {
! 3952: write_m ("\033M\033[79C\033[P\201");
! 3953: }
! 3954:
! 3955: }
! 3956: else {
! 3957: write_m ("\\\201");
! 3958: }
! 3959:
! 3960: }
! 3961:
! 3962: stuff[i--] = EOL;
! 3963:
! 3964: }
! 3965:
! 3966: stuff[i--] = EOL;
! 3967:
! 3968: if (ch == NAK) continue;
! 3969:
! 3970: /* (ch==DC2) *//* CTRL/R Retypes last input */
! 3971:
! 3972: i = stcpy (stuff, previous[p_toggle]);
! 3973:
! 3974: stuff[i--] = EOL;
! 3975:
! 3976: toggle (p_toggle);
! 3977:
! 3978: if (ECHOON) write_m (stuff);
! 3979:
! 3980: continue;
! 3981: }
! 3982:
! 3983: if (ch == STX && (zbreakon || hardcopy)) {
! 3984:
! 3985: if (zbreakon) zbflag = TRUE;
! 3986:
! 3987: if (i > 0) {
! 3988: if (ECHOON) write_m ("\010 \010\201");
! 3989: }
! 3990:
! 3991: i--;
! 3992:
! 3993: continue;
! 3994:
! 3995: }
! 3996:
! 3997: if (ch == BrkKey) { /* CTRL/C may interrupt */
! 3998:
! 3999: i--;
! 4000:
! 4001: if (breakon) {
! 4002:
! 4003: stuff[i] = EOL;
! 4004: merr_raise (INRPT);
! 4005:
! 4006: return;
! 4007:
! 4008: }
! 4009:
! 4010: continue;
! 4011: }
! 4012:
! 4013: /* ignore non programmed CTRL/ key ?? */
! 4014: if (ch < SP && (ch != TAB || nstx) && NOCTRLS) { /* TAB may be a programmed key */
! 4015: i--;
! 4016: continue;
! 4017: }
! 4018:
! 4019: } /* if (single == 0) */
! 4020:
! 4021: if (stuff[i] == EOL) stuff[i + 1] = EOL;
! 4022: if (ch < 255) ch = (SIflag[io] ? G0I[io] : G1I[io])[UNSIGN (ch)];
! 4023:
! 4024: stuff[i] = ch;
! 4025:
! 4026: if (ECHOON) {
! 4027:
! 4028: term_key[0] = ch;
! 4029: term_key[1] = EOL;
! 4030:
! 4031: write_m (term_key);
! 4032:
! 4033: }
! 4034:
! 4035: } /* ??????????? may need to run through preprocessor to see where the heck this goes */
! 4036: }
! 4037: else { /* $io != HOME */
! 4038: int fd;
! 4039: int fdstat;
! 4040:
! 4041: fd = 0;
! 4042:
! 4043:
! 4044: #if defined(SYSFIVE) && !defined(__AMIGA) && !defined(MSDOS)
! 4045:
! 4046: if (read_timeout >= 0) {
! 4047:
! 4048: fd = fileno (opnfile[io]);
! 4049: fdstat = fcntl (fd, F_GETFL);
! 4050:
! 4051: fcntl (fd, F_SETFL, fdstat | O_NDELAY);
! 4052:
! 4053: }
! 4054:
! 4055: #endif /* SYSFIVE */
! 4056:
! 4057: for (i = 0; i < length; i++) {
! 4058:
! 4059: if (merr () == INRPT) {
! 4060:
! 4061: if (--i < 0) i = 0;
! 4062:
! 4063: stuff[i] = EOL;
! 4064:
! 4065: break;
! 4066:
! 4067: }
! 4068:
! 4069: if (ug_buf[io][0] != EOL) {
! 4070: ch = ug_buf[io][0];
! 4071: stcpy (ug_buf[io], &ug_buf[io][1]);
! 4072: }
! 4073: else if (read_timeout >= 0)
! 4074: {
! 4075: test = TRUE;
! 4076:
! 4077: #ifdef SYSFIVE
! 4078: if (fread (&ch, 1, 1, opnfile[io]) < 1)
! 4079: #else
! 4080: if (rdchk (fileno (opnfile[io])) == 0 || ((ch = fgetc (opnfile[io])) == EOF))
! 4081: #endif /* SYSFIVE */
! 4082:
! 4083: {
! 4084: if (--read_timeout < 0) {
! 4085:
! 4086: test = FALSE;
! 4087: timoflag = TRUE;
! 4088: stuff[i] = EOL;
! 4089:
! 4090: break;
! 4091:
! 4092: }
! 4093:
! 4094: sleep (1);
! 4095:
! 4096: i--;
! 4097:
! 4098: continue;
! 4099:
! 4100: }
! 4101:
! 4102: ch = UNSIGN (ch);
! 4103: }
! 4104: else {
! 4105: ch = fgetc (opnfile[io]);
! 4106: }
! 4107:
! 4108: stuff[i] = ch;
! 4109:
! 4110: if (ch == EOF) {
! 4111: /* EOF halts filtered mps */
! 4112: if ((io == HOME) && frm_filter) merr_raise (INRPT);
! 4113:
! 4114: stuff[i] = EOL;
! 4115:
! 4116: break;
! 4117: }
! 4118:
! 4119: if (single) break;
! 4120:
! 4121: if (ch == LF && crlf[io]) {
! 4122: i--;
! 4123: continue;
! 4124: }
! 4125:
! 4126: if ((ch == CR) || (ch == LF)) {
! 4127: int ch0;
! 4128:
! 4129: stuff[i] = EOL;
! 4130:
! 4131: /* if input terminates with CR/LF or LF/CR take both */
! 4132: /* as a single termination character. So it is possible */
! 4133: /* to get correct input from files written by mumps */
! 4134: /* itself with CR/LF line termination */
! 4135:
! 4136: #if defined(SYSFIVE) && !defined(__AMIGA) && !defined(MSDOS)
! 4137:
! 4138: if (fd == 0) {
! 4139:
! 4140: fd = fileno (opnfile[io]);
! 4141: fdstat = fcntl (fd, F_GETFL);
! 4142:
! 4143: fcntl (fd, F_SETFL, fdstat | O_NDELAY);
! 4144:
! 4145: }
! 4146:
! 4147: if (fread (&ch0, 1, 1, opnfile[io]) == 1) {
! 4148: ch0 = UNSIGN (ch0);
! 4149:
! 4150: #else
! 4151: #if !defined(__AMIGA) && !defined(MSDOS)
! 4152:
! 4153: if (rdchk (fileno (opnfile[io])) == 1) {
! 4154: ch0 = fgetc (opnfile[io]);
! 4155:
! 4156: #else
! 4157:
! 4158: #if defined(__AMIGA)
! 4159:
! 4160: if (rdchk0 (fileno (opnfile[io])) == 1) {
! 4161: ch0 = fgetc (opnfile[io]);
! 4162: #endif
! 4163:
! 4164: #endif /* __AMIGA */
! 4165:
! 4166: #if defined(MSDOS)
! 4167: if (1) {
! 4168: ch0 = fgetc (opnfile[io]);
! 4169: #endif
! 4170:
! 4171: #endif /* SYSFIVE */
! 4172:
! 4173: if ((ch == CR && ch0 != LF) || (ch == LF && ch0 != CR))
! 4174: ungetc (ch0, opnfile[io]);
! 4175: }
! 4176:
! 4177: break;
! 4178: }
! 4179:
! 4180: if (UNSIGN (stuff[i]) < 255)
! 4181: stuff[i] = (SIflag[io] ? G0I[io] : G1I[io])[UNSIGN (stuff[i])];
! 4182: }
! 4183:
! 4184: #if defined(SYSFIVE) && !defined(__AMIGA)
! 4185: if (fd) fcntl (fd, F_SETFL, fdstat);
! 4186: #endif /* SYSFIVE */
! 4187:
! 4188: } /* if ((ch == CR) || (ch == LF)) */
! 4189:
! 4190:
! 4191: done:
! 4192:
! 4193: alarm (0); /* reset alarm request */
! 4194:
! 4195: if (io == HOME && jour_flag > 0) {
! 4196:
! 4197: char tmp[256];
! 4198:
! 4199: tmp[stcpy (tmp, stuff)] = NUL;
! 4200: fputs (tmp, jouraccess);
! 4201:
! 4202: if (timoflag) {
! 4203:
! 4204: tmp[0] = SI;
! 4205: tmp[1] = NUL; /* CTRL/O as timeout char */
! 4206:
! 4207: fputs (tmp, jouraccess);
! 4208:
! 4209: }
! 4210: else if ((i < length) || (stuff[0] == NUL && zb[0] == ESC)) {
! 4211:
! 4212: /* save termination char if meaningful */
! 4213: tmp[stcpy (tmp, zb)] = NUL;
! 4214: fputs (tmp, jouraccess);
! 4215:
! 4216: }
! 4217:
! 4218: }
! 4219:
! 4220: if (single) { /* to ASCII */
! 4221:
! 4222: if (timoflag) {
! 4223: stuff[0] = '-';
! 4224: stuff[1] = '1';
! 4225: stuff[2] = EOL;
! 4226: }
! 4227: else {
! 4228: intstr (stuff, UNSIGN (stuff[0]));
! 4229: }
! 4230:
! 4231: }
! 4232: else if (io == HOME && stuff[0] != EOL) {
! 4233: stcpy (previous[toggle (p_toggle)], stuff);
! 4234: }
! 4235:
! 4236: return;
! 4237:
! 4238: } /* end of read_m() */
! 4239:
! 4240: #if defined(SYSFIVE)
! 4241: /* UNIX system V has no 'rdchk' function. We must do it ourselves */
! 4242:
! 4243: #if !defined(__AMIGA) && !defined(MSDOS)
! 4244:
! 4245: int rdchk0 (int *data)
! 4246: {
! 4247: static int x;
! 4248: static int firsttime = TRUE;
! 4249: int retcode;
! 4250: char ch;
! 4251:
! 4252: if (firsttime) {
! 4253: x = fcntl (0, F_GETFL);
! 4254: firsttime = FALSE;
! 4255: }
! 4256:
! 4257: fcntl (0, F_SETFL, x | O_NDELAY);
! 4258:
! 4259: retcode = read (0, &ch, 1);
! 4260:
! 4261: fcntl (0, F_SETFL, x);
! 4262:
! 4263: *data = (retcode > 0) ? ch : NUL;
! 4264:
! 4265: return retcode;
! 4266:
! 4267: } /* end rdchk0() */
! 4268:
! 4269: #else
! 4270:
! 4271: int rdchk0 (int *data)
! 4272: {
! 4273: /* TODO: flesh out on m68k-amigaos */
! 4274: return TRUE;
! 4275: }
! 4276:
! 4277: #endif
! 4278:
! 4279: /******************************************************************************/
! 4280: /* under XENIX the system has an intrinsic function 'locking'. */
! 4281: /* under UNIX System V it must be done with fcntl. */
! 4282: /* the difference is, that the XENIX locking blocks all other accesses */
! 4283: /* whereas UNIX System V gives only protection if all users of a file */
! 4284: /* use 'locking'. */
! 4285: /* since 'fcntl' is not properly documented, the outcome in any cases of */
! 4286: /* errors is uncertain. */
! 4287:
! 4288: #ifdef AMIGA68K
! 4289:
! 4290: int locking (int fd, int action, long count)
! 4291: {
! 4292: /* TODO: flesh out on m68k-amigaos */
! 4293: return 0;
! 4294: }
! 4295:
! 4296: #else
! 4297:
! 4298: /* fd = file descriptor of file to be locked */
! 4299: /* action = action to be performed */
! 4300: /* count area to be locked */
! 4301: int locking (int fd, int action, long count)
! 4302: {
! 4303:
! 4304: struct flock lock;
! 4305:
! 4306: lock.l_whence = 1; /* lock from current position */
! 4307: lock.l_start = 0;
! 4308: lock.l_len = count;
! 4309: lock.l_pid = getpid ();
! 4310:
! 4311: if (lonelyflag) return 0; /* no LOCK if single user */
! 4312:
! 4313: switch (action) {
! 4314:
! 4315:
! 4316: case 0: /* LK_UNLK free previously locked area */
! 4317:
! 4318: lock.l_type = F_UNLCK;
! 4319: fcntl (fd, F_SETLK, &lock);
! 4320:
! 4321: break;
! 4322:
! 4323:
! 4324: case 1: /* LK_LOCK lock against others reading and writing my data */
! 4325:
! 4326: lock.l_type = F_WRLCK;
! 4327: fcntl (fd, F_SETLKW, &lock);
! 4328:
! 4329: break;
! 4330:
! 4331:
! 4332: case 2: /* LK_NBLCK lock against others reading and writing my data, don't block */
! 4333:
! 4334: lock.l_type = F_WRLCK;
! 4335: fcntl (fd, F_SETLK, &lock);
! 4336:
! 4337: break;
! 4338:
! 4339:
! 4340: case 3: /* LK_RLCK lock against others writing my data */
! 4341:
! 4342: lock.l_type = F_RDLCK;
! 4343: fcntl (fd, F_SETLKW, &lock);
! 4344:
! 4345: break;
! 4346:
! 4347:
! 4348: case 4: /* LK_NBRLCK lock against others writing my data, don't block */
! 4349:
! 4350: lock.l_type = F_RDLCK;
! 4351: fcntl (fd, F_SETLK, &lock);
! 4352:
! 4353: break;
! 4354:
! 4355: }
! 4356:
! 4357: return 0; /* action properly performed */
! 4358:
! 4359: } /* end locking() */
! 4360:
! 4361: #endif
! 4362:
! 4363: #ifdef OLDUNIX
! 4364:
! 4365: /* set io_parameters to mumps/unix conventions */
! 4366: /* action: 0 = UNIX; 1 = MUMPS */
! 4367: void set_io (short action)
! 4368: {
! 4369: if (lio_mode == action) return;
! 4370:
! 4371: static char del;
! 4372: static char fs;
! 4373: struct termio tpara;
! 4374:
! 4375: if (frm_filter) return; /* nothing special if used as filter */
! 4376:
! 4377: fflush (stdin);
! 4378: fflush (stdout);
! 4379: fflush (stderr);
! 4380:
! 4381: ioctl (0, TCGETA, &tpara); /* get paramters */
! 4382:
! 4383: if (action == UNIX) {
! 4384:
! 4385: lio_mode = UNIX;
! 4386:
! 4387: tpara.c_lflag |= (ECHO | ICANON); /* enable echo/no cbreak mode */
! 4388: tpara.c_iflag |= ICRNL; /* cr-lf mapping */
! 4389: tpara.c_oflag |= ONLCR; /* cr-lf mapping */
! 4390: tpara.c_cc[VINTR] = del; /* interrupt */
! 4391: tpara.c_cc[VQUIT] = fs; /* quit */
! 4392: tpara.c_cc[VMIN] = EOT;
! 4393: tpara.c_cc[VTIME] = -1;
! 4394:
! 4395: }
! 4396: else { /* action == MUMPS */
! 4397:
! 4398: lio_mode = MUMPS;
! 4399:
! 4400: tpara.c_lflag &= (~(ECHO | ICANON)); /* disable echo/cbreak mode */
! 4401: tpara.c_iflag &= ~ICRNL; /* cr-lf mapping */
! 4402: tpara.c_oflag &= ~ONLCR; /* cr-lf mapping */
! 4403: del = tpara.c_cc[VINTR]; /* save previous state of */
! 4404: fs = tpara.c_cc[VQUIT]; /* quit and interrupt */
! 4405: tpara.c_cc[VINTR] = BrkKey; /* interrupt = CTRL/C */
! 4406: tpara.c_cc[VQUIT] = (zbreakon || hardcopy) ? STX : -1; /* zbreak/hardcopy */
! 4407: tpara.c_cc[VMIN] = 1;
! 4408: tpara.c_cc[VTIME] = 1;
! 4409:
! 4410: }
! 4411:
! 4412: ioctl (0, TCSETA, &tpara);
! 4413:
! 4414: return;
! 4415:
! 4416: } /* end of set_io() */
! 4417:
! 4418:
! 4419: /* break_char: */
! 4420: /* -1 = break disabled */
! 4421: /* ETX = MUMPS break */
! 4422: /* DEL = UNIX quit */
! 4423: void set_break (short break_char)
! 4424: {
! 4425: struct termio arg;
! 4426:
! 4427: ioctl (0, TCGETA, &arg);
! 4428:
! 4429: arg.c_cc[VINTR] = break_char; /* interrupt = CTRL/C */
! 4430:
! 4431: ioctl (0, TCSETA, &arg);
! 4432:
! 4433: return;
! 4434:
! 4435: } /* end of set_break() */
! 4436:
! 4437: /* quit_char: */
! 4438: /* -1 = quit disabled */
! 4439: /* STX = MUMPS CTRL/B */
! 4440: /* DEL = UNIX quit */
! 4441: void set_zbreak (short quit_char)
! 4442: {
! 4443: struct termio arg;
! 4444:
! 4445: ioctl (0, TCGETA, &arg);
! 4446:
! 4447: arg.c_cc[VQUIT] = quit_char;
! 4448:
! 4449: ioctl (0, TCSETA, &arg);
! 4450:
! 4451: return;
! 4452:
! 4453: } /* end of set_zbreak() */
! 4454:
! 4455: #else
! 4456:
! 4457: void set_io (short action) /* set io_parameters to mumps/unix conventions */
! 4458: {
! 4459: static struct termios unixtermio;
! 4460: struct termios termios_p;
! 4461:
! 4462: if (lio_mode == action) return;
! 4463:
! 4464: if (frm_filter) return; /* nothing special if used as filter */
! 4465:
! 4466: if (action == UNIX) {
! 4467: lio_mode = UNIX;
! 4468:
! 4469: tcsetattr (0, TCSADRAIN, &unixtermio);
! 4470: }
! 4471: else { /* action == MUMPS */
! 4472: lio_mode = MUMPS;
! 4473:
! 4474: tcgetattr (0, &unixtermio); /* get unix paramters */
! 4475: tcgetattr (0, &termios_p); /* get paramters */
! 4476:
! 4477: termios_p.c_lflag &= (~(ECHO | ICANON)); /* disable echo/cbreak mode */
! 4478: termios_p.c_iflag &= ~ICRNL; /* cr-lf mapping */
! 4479: termios_p.c_oflag &= ~ONLCR; /* cr-lf mapping */
! 4480: termios_p.c_cc[VINTR] = BrkKey; /* interrupt = CTRL/C */
! 4481: termios_p.c_cc[VQUIT] = (zbreakon || hardcopy) ? STX : -1; /* zbreak/hardcopy */
! 4482: termios_p.c_cc[VMIN] = 1;
! 4483: termios_p.c_cc[VTIME] = 1;
! 4484:
! 4485: tcsetattr (0, TCSADRAIN, &termios_p); /* set paramters */
! 4486:
! 4487: }
! 4488:
! 4489: return;
! 4490:
! 4491: } /* end of set_io() */
! 4492:
! 4493: void set_break (short break_char)
! 4494: {
! 4495: struct termios termios_p;
! 4496:
! 4497: tcgetattr (0, &termios_p);
! 4498:
! 4499: termios_p.c_cc[VINTR] = break_char; /* interrupt = CTRL/C */
! 4500:
! 4501: tcsetattr (0, TCSADRAIN, &termios_p); /* set paramters */
! 4502:
! 4503: return;
! 4504:
! 4505: } /* end of set_break() */
! 4506:
! 4507: void set_zbreak (short quit_char)
! 4508: {
! 4509:
! 4510: struct termios termios_p;
! 4511:
! 4512: tcgetattr (0, &termios_p);
! 4513:
! 4514: termios_p.c_cc[VQUIT] = quit_char;
! 4515:
! 4516: tcsetattr (0, TCSADRAIN, &termios_p); /* set paramters */
! 4517:
! 4518: return;
! 4519:
! 4520: } /* end of set_zbreak() */
! 4521:
! 4522: #endif /* OLDUNIX */
! 4523:
! 4524: #else
! 4525:
! 4526: /* same for XENIX */
! 4527: void set_io (short action) /* set io_parameters to mumps/unix conventions */
! 4528: {
! 4529: static char del;
! 4530: static char fs;
! 4531: struct sgttyb tt;
! 4532: struct tchars tc;
! 4533:
! 4534: if (frm_filter) return; /* nothing special if used as filter */
! 4535:
! 4536: fflush (stdin);
! 4537: fflush (stdout);
! 4538: fflush (stderr);
! 4539:
! 4540: ioctl (0, TIOCGETP, &tt);
! 4541: ioctl (0, TIOCGETC, &tc);
! 4542:
! 4543: if (action == UNIX) {
! 4544:
! 4545: tt.sg_flags &= ~02; /* no cbreak mode */
! 4546: tt.sg_flags |= (010 | 020); /* echo ; CR to LF map */
! 4547: tc.t_quitc = fs; /* quit */
! 4548: tc.t_intrc = del; /* interrupt */
! 4549:
! 4550: /* we desperately tried to do it with DEL - but it didn't work */
! 4551:
! 4552: }
! 4553: else { /* action == MUMPS */
! 4554:
! 4555: tt.sg_flags |= 02; /* cbreak mode */
! 4556: tt.sg_flags &= (~010 & ~020); /* 10 no echo; 20 no CR map */
! 4557: del = tc.t_intrc; /* save previous state of */
! 4558: fs = tc.t_quitc; /* quit and interrupt */
! 4559: tc.t_intrc = BrkKey; /* interrupt = CTRL/C */
! 4560: tc.t_quitc = (zbreakon || hardcopy) ? STX : -1; /* zbreak/hardcopy */
! 4561:
! 4562: }
! 4563:
! 4564: ioctl (0, TIOCSETP, &tt);
! 4565: ioctl (0, TIOCSETC, &tc);
! 4566:
! 4567: } /* end of set_io() */
! 4568:
! 4569: void set_break (short break_char)
! 4570: {
! 4571: struct tchars tc;
! 4572:
! 4573: ioctl (0, TIOCGETC, &tc);
! 4574:
! 4575: tc.t_intrc = break_char;
! 4576:
! 4577: ioctl (0, TIOCSETC, &tc);
! 4578:
! 4579: return;
! 4580:
! 4581: } /* end of set_break */
! 4582:
! 4583: void set_zbreak (short quit_char)
! 4584: {
! 4585: struct tchars tc;
! 4586:
! 4587:
! 4588: ioctl (0, TIOCGETC, &tc);
! 4589:
! 4590: tc.t_quitc = quit_char;
! 4591:
! 4592: ioctl (0, TIOCSETC, &tc);
! 4593:
! 4594: return;
! 4595:
! 4596: } /* end of set_zbreak */
! 4597:
! 4598: #endif /* SYSFIVE */
! 4599:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to service.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src