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