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