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