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