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