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