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