Annotation of freem/src/views.c, revision 1.7
1.1 snw 1: /*
1.7 ! snw 2: * $Id: views.c,v 1.6 2025/03/09 19:50:47 snw Exp $
1.1 snw 3: * implementation of VIEW command and $VIEW intrinsic function
4: *
5: *
1.5 snw 6: * Author: Serena Willis <snw@coherent-logic.com>
1.1 snw 7: * Copyright (C) 1998 MUG Deutschland
1.6 snw 8: * Copyright (C) 2020, 2025 Coherent Logic Development LLC
1.1 snw 9: *
10: *
11: * This file is part of FreeM.
12: *
13: * FreeM is free software: you can redistribute it and/or modify
14: * it under the terms of the GNU Affero Public License as published by
15: * the Free Software Foundation, either version 3 of the License, or
16: * (at your option) any later version.
17: *
18: * FreeM is distributed in the hope that it will be useful,
19: * but WITHOUT ANY WARRANTY; without even the implied warranty of
20: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21: * GNU Affero Public License for more details.
22: *
23: * You should have received a copy of the GNU Affero Public License
24: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
25: *
1.7 ! snw 26: * $Log: views.c,v $
! 27: * Revision 1.6 2025/03/09 19:50:47 snw
! 28: * Second phase of REUSE compliance and header reformat
! 29: *
1.6 snw 30: *
31: * SPDX-FileCopyrightText: (C) 2025 Coherent Logic Development LLC
32: * SPDX-License-Identifier: AGPL-3.0-or-later
1.1 snw 33: **/
34:
35: #include <stdlib.h>
36:
37: #include "mpsdef.h"
38: #include "mwapi_window.h"
39:
40: #define LOCK 'l'
41:
42: /* system services */
43:
44: #include <signal.h>
45:
46: #if !defined(__APPLE__) && !defined(__gnu_hurd__) && !defined(EMSCRIPTEN)
47: # if defined(__FreeBSD__) || defined(__NetBSD__) || defined(__OpenBSD__) || defined(__AMIGA)
48: # include <termios.h>
49: # if !defined(__AMIGA)
50: # define TCGETA TIOCGETA
51: # define TCSETA TIOCSETA
52: # endif
53: # define termio termios
54: # else
55: # if !defined(MSDOS)
56: # include <termio.h>
57: # endif
58: # endif
59: #else
60: # include <termios.h>
61: #endif
62:
63:
64: #ifdef __CYGWIN__
65: #include <errno.h>
66: #endif /* __CYGWIN__ */
1.2 snw 67: #include <errno.h> /* snw */
68:
1.4 snw 69: #if defined(__NetBSD__) || defined(__OpenBSD__)
1.2 snw 70: #include <sys/ioctl.h>
71: #endif
1.1 snw 72:
73: #include <fcntl.h>
74: #include <unistd.h>
75: #include <time.h>
76: #include <string.h>
77: #include <stdio.h>
78: #include "shmmgr.h"
79:
80: /* 01/18/99 rlf Apparently, tell disappeared with libc-6 */
81: #if defined(LINUX_GLIBC) || defined(__APPLE__)
82:
83: long int tell (int fd)
84: {
85: return lseek (fd, 0, SEEK_CUR);
86: }
87:
88: #else
89: long int tell ();
90: #endif /* LINUX_GLIBC */
91:
92:
93: #if defined(MWAPI_GTK)
94: void destroy(GtkWidget* widget, gpointer data)
95: {
96: gtk_main_quit();
97: }
98: #endif
99:
100:
1.3 snw 101: void view_com (void)
1.1 snw 102: {
103: /* process VIEW command */
104:
105: char tmp[256];
106: char tmp2[256];
107: int arg1;
108: register long int i;
109: register long int j;
110: register long int ch;
111:
112: if (*codptr == SP || *codptr == EOL) { /* no argument form of VIEW */
113: merr_raise (ARGER);
114: return;
115: }
116:
117: expr (STRING);
118:
119: arg1 = intexpr (argptr);
120:
121: if (merr () > OK) return;
122:
123: if (*codptr == ':') {
124:
125: codptr++;
126:
127: expr (STRING);
128:
129: if (merr () > OK) return;
130:
131: switch (arg1) {
132:
133:
134: /* VIEW 52: G0 input translation table */
135: case 52:
136:
137: stcpy0 (G0I[io], argptr, 256L);
138:
139: for (i = 0; i < 256; i++) {
140:
141: if (G0I[io][i] == EOL) {
142:
143: while (i < 256) {
144: G0I[io][i] = (char) i;
145: i++;
146: }
147:
148: break;
149: }
150:
151: }
152:
153: break;
154:
155:
156: /* VIEW 53: G0 output translation table */
157: case 53:
158:
159: stcpy0 (G0O[io], argptr, 256L);
160:
161: for (i = 0; i < 256; i++) {
162:
163: if (G0O[io][i] == EOL) {
164:
165: while (i < 256) {
166: G0O[io][i] = (char) i;
167: i++;
168: }
169:
170: break;
171: }
172:
173: }
174:
175: break;
176:
177:
178: /* VIEW 54: G1 input translation table */
179: case 54:
180:
181: stcpy0 (G1I[io], argptr, 256L);
182:
183: for (i = 0; i < 256; i++) {
184:
185: if (G1I[io][i] == EOL) {
186:
187: while (i < 256) {
188: G1I[io][i] = (char) i;
189: i++;
190: }
191:
192: break;
193:
194: }
195:
196: }
197:
198: break;
199:
200:
201: /* VIEW 55: G1 output translation table */
202: case 55:
203:
204: stcpy0 (G1O[io], argptr, 256L);
205:
206: for (i = 0; i < 256; i++) {
207:
208: if (G1O[io][i] == EOL) {
209:
210: while (i < 256) {
211: G1O[io][i] = (char) i;
212: i++;
213: }
214:
215: break;
216:
217: }
218:
219: }
220:
221: break;
222:
223:
224: /* VIEW 62: random: seed number */
225: case 62:
226:
227: i = intexpr (argptr);
228:
229: if (merr () == MXNUM) return;
230:
231: if (i < 0) {
232: merr_raise (ARGER);
233: }
234: else {
235: nrandom = i;
236: }
237:
238: break;
239:
240:
241: /* VIEW 63: random: parameter a */
242: case 63:
243:
244: i = intexpr (argptr);
245:
246: if (merr () == MXNUM) return;
247:
248: if (i <= 0) {
249: merr_raise (ARGER);
250: }
251: else {
252: ran_a = i;
253: }
254:
255: break;
256:
257:
258: /* VIEW 64: random: parameter b */
259: case 64:
260:
261: i = intexpr (argptr);
262:
263: if (merr () == MXNUM) return;
264:
265: if (i < 0) {
266: merr_raise (ARGER);
267: }
268: else {
269: ran_b = i;
270: }
271:
272: break;
273:
274:
275: /* VIEW 65: random: parameter c */
276: case 65:
277:
278: i = intexpr (argptr);
279:
280: if (merr () == MXNUM) return;
281:
282: if (i <= 0) {
283: merr_raise (ARGER);
284: }
285: else {
286: ran_c = i;
287: }
288:
289: break;
290:
291:
292: /* VIEW 66: SIGTERM handling flag */
293: case 66:
294:
295: killerflag = tvexpr (argptr);
296:
297: break;
298:
299:
300: /* VIEW 67: SIGHUP handling flag */
301: case 67:
302:
303: huperflag = tvexpr (argptr);
304:
305: break;
306:
307:
308: /* ... reserved ... */
309:
310: /* VIEW 70: ZSORT/ZSYNTAX flag */
311: case 70:
312:
313: s_fun_flag = tvexpr (argptr);
314:
315: break;
316:
317:
318: /* VIEW 71: ZNEXT/ZNAME flag */
319: case 71:
320:
321: n_fun_flag = tvexpr (argptr);
322:
323: break;
324:
325:
326: /* VIEW 72: ZPREVIOUS/ZPIECE flag */
327: case 72:
328:
329: p_fun_flag = tvexpr (argptr);
330:
331: break;
332:
333:
334: /* VIEW 73: ZDATA/ZDATE flag */
335: case 73:
336:
337: d_fun_flag = tvexpr (argptr);
338:
339: break;
340:
341:
342: /* VIEW 79: old ZJOB vs. new ZJOB flag */
343: case 79:
344:
345: zjobflag = tvexpr (argptr);
346:
347: break;
348:
349:
350: /* VIEW 80: 7 vs. 8 bit flag */
351: case 80:
352:
353: eightbit = tvexpr (argptr);
354:
355: break;
356:
357:
358: /* VIEW 81: PF1 flag */
359: case 81:
360:
361: PF1flag = tvexpr (argptr);
362:
363: break;
364:
365:
366: /* VIEW 82: not used */
367: /* VIEW 83: text in $ZE flag */
368: case 83:
369:
370: etxtflag = tvexpr (argptr);
371:
372: break;
373:
374:
375: /* VIEW 84: not used */
376: /* VIEW 85: not used */
377: /* VIEW 86: not used */
378:
379: case 87: /* VIEW 87: date type definition */
380:
381: i = intexpr (argptr);
382:
383: if (i < 0 || i >= NO_DATETYPE) {
384: merr_raise (ARGER);
385: return;
386: }
387:
388: if (*codptr != ':') {
389: datetype = i;
390: break;
391: }
392:
393: if (i == 0) {
394: merr_raise (ARGER);
395: return;
396: }
397:
398: codptr++;
399:
400: expr (STRING);
401:
402: j = intexpr (argptr);
403:
404: if (*codptr != ':') {
405: merr_raise (ARGER);
406: return;
407: }
408:
409: codptr++;
410:
411: expr (STRING);
412:
413: if (j > 0 && j < 15 && stlen (argptr) > MONTH_LEN) {
414: merr_raise (M75);
415: }
416: else if (j > 0 && j < 13) {
417: stcpy (month[i][j - 1], argptr);
418: }
419: else if (j == 13) {
420: stcpy (dat1char[i], argptr);
421: }
422: else if (j == 14) {
423: stcpy (dat2char[i], argptr);
424: }
425: else if (j == 15) {
426: dat3char[i] = (*argptr);
427: }
428: else if (j == 16) {
429:
430: if ((j = intexpr (argptr)) < 0 || j > 2) {
431: merr_raise (ARGER);
432: return;
433: }
434:
435: dat4flag[i] = j;
436:
437: }
438: else if (j == 17) {
439: dat5flag[i] = tvexpr (argptr);
440: }
441: else if (j == 18) {
442: if ((j = intexpr (argptr) + 672411L) <= 0L) {
443: merr_raise (ARGER);
444: return;
445: }
446: datGRbeg[i] = j;
447: }
448: else {
449: merr_raise (ARGER);
450: }
451:
452: if (merr () > OK) return;
453:
454: break;
455:
456:
457: case 88: /* VIEW 88: time type definition */
458:
459: i = intexpr (argptr);
460:
461: if (i < 0 || i >= NO_TIMETYPE) {
462: merr_raise (ARGER);
463: return;
464: }
465:
466: if (*codptr != ':') {
467: timetype = i;
468: break;
469: }
470:
471: codptr++;
472:
473: expr (STRING);
474:
475: j = intexpr (argptr);
476:
477: if (*codptr != ':') {
478: merr_raise (ARGER);
479: return;
480: }
481:
482: codptr++;
483:
484: expr (STRING);
485:
486: if (j == 1) {
487: tim1char[i] = (*argptr);
488: }
489: else if (j == 2) {
490: tim2char[i] = (*argptr);
491: }
492: else if (j == 3) {
493: tim3char[i] = (*argptr);
494: }
495: else if (j == 4) {
496: tim4flag[i] = tvexpr (argptr);
497: }
498: else if (j == 5) {
499: tim5flag[i] = tvexpr (argptr);
500: }
501: else {
502: merr_raise (ARGER);
503: }
504:
505: if (merr () > OK) return;
506:
507: break;
508:
509:
510: case 91: /* VIEW 91: missing QUIT expr default expression */
511:
512: stcpy (exfdefault, argptr);
513:
514: break;
515:
516:
517: case 92: /* VIEW 92: EUR2DEM: type mismatch error */
518:
519: typemmflag = tvexpr (argptr);
520:
521: break;
522:
523:
524: case 93: /* VIEW 93: zkey production rule definition */
525:
526: i = intexpr (argptr);
527:
528: if (i < 1 || i > NO_V93) {
529: merr_raise (ARGER);
530: return;
531: }
532:
533: if (*codptr != ':') {
534: v93 = i;
535: break;
536: }
537:
538: codptr++;
539:
540: expr (STRING);
541:
542: stcpy (v93a[i - 1], argptr);
543:
544: break;
545:
546:
547: case 96: /* VIEW 96: global prefix */
548:
549: if (stlen (argptr) > MONTH_LEN) {
550: merr_raise (M75);
551: }
552: else {
553: stcpy (glo_prefix, argptr);
554: }
555:
556: break;
557:
558:
559: case 97: /* VIEW 97: global postfix */
560:
561: if (stlen (argptr) > MONTH_LEN) {
562: merr_raise (M75);
563: }
564: else {
565: stcpy (glo_ext, argptr);
566: }
567:
568: break;
569:
570:
571: case 98: /* VIEW 98: routine extension */
572:
573: if (stlen (argptr) > MONTH_LEN) {
574: merr_raise (M75);
575: }
576: else {
577: stcpy (rou_ext, argptr);
578: }
579:
580: break;
581:
582:
583: case 101: /* VIEW 101: set ierr */
584:
585: merr_raise (intexpr (argptr));
586:
587: break;
588:
589: case 102: /* VIEW 102 set deferred_ierr */
590:
591: deferred_ierr = intexpr (argptr);
592:
593: break;
594:
595:
596: case 103: /* MERGE to ^$WINDOW complete. Parameter is empty (for all windows) or string for window name in subscript 1 */
597: #if defined(MWAPI_GTK)
598: mwapi_on_merge_complete (argptr);
599: #endif
600: break;
601:
602:
603:
604: #if !defined(__APPLE__) && !defined(__gnu_hurd__) && !defined(__AMIGA) && !defined(EMSCRIPTEN) && !defined(MSDOS)
605:
606: case 113: /* VIEW 113: set termio infos */
607: {
608:
609: struct termio tpara;
610:
611: i = intexpr (argptr);
612:
613: if (i < 1 || i > MAXDEV) {
614: merr_raise (NODEVICE);
615: }
616: else if (devopen[i] == 0) {
617: merr_raise (NOPEN);
618: }
619: else if (*codptr != ':') {
620: merr_raise (ARGER);
621: }
622: else {
623:
624: codptr++;
625:
626: expr (STRING);
627:
628: j = intexpr (argptr);
629:
630: }
631:
632: if (merr () > OK) return;
633:
634: ioctl (fileno (opnfile[i]), TCGETA, &tpara);
635:
636: j = 0;
637:
638: tpara.c_iflag = intexpr (argptr);
639:
640: while ((ch = argptr[j]) != EOL) {
641:
642: j++;
643:
644: if (ch == ':') break;
645:
646: }
647:
648: tpara.c_oflag = intexpr (&argptr[j]);
649:
650: while ((ch = argptr[j]) != EOL) {
651:
652: j++;
653:
654: if (ch == ':') break;
655:
656: }
657:
658: tpara.c_cflag = intexpr (&argptr[j]);
659:
660: while ((ch = argptr[j]) != EOL) {
661:
662: j++;
663:
664: if (ch == ':') break;
665:
666: }
667:
668: tpara.c_lflag = intexpr (&argptr[j]);
669:
670: ioctl (fileno (opnfile[i]), TCSETA, &tpara);
671:
672: return;
673:
674: }
675:
676: #endif /* __APPLE__ */
677:
678:
679: /* VIEW 133: remember ZLOAD directory on ZSAVE */
680: case 133:
681:
682: zsavestrategy = tvexpr (argptr);
683:
684: return;
685:
686:
687: default:
688:
689: merr_raise (ARGER);
690: return;
691:
692: } /* end switch one parameter VIEWs */
693: }
694: else { /* no parameters VIEWs */
695:
696: switch (arg1) {
697:
698:
699: /* VIEW 21: close all globals */
700: case 21:
701:
702: close_all_globals ();
703:
704: return;
705:
706:
707:
708: /* VIEW 29: symtab copy */
709: case 29: /* get space if needed */
710:
711: if (apartition == NULL) apartition = calloc ((unsigned) (PSIZE + 1), 1);
712:
713: for (i = 0; i <= PSIZE; i++) apartition[i] = partition[i];
714:
715: asymlen = symlen;
716:
717: for (i = 0; i < 128; i++) aalphptr[i] = alphptr[i];
718:
719: return;
720:
721: }
722:
723: merr_raise (ARGER);
724: return;
725:
726: }
727:
728: return;
729: } /* end view_com() */
730:
731: /*
732: * f = number of arguments
733: * a = the arguments
734: */
735: void view_fun (int f, char *a) /* process VIEW function */
736: {
737: int i;
738:
739: if (standard) {
740: merr_raise (NOSTAND);
741: return;
742: } /* non_standard */
743:
744: if (f == 1) {
745:
746: f = intexpr (a);
747:
748: switch (f) {
749:
750: /* $V(21) returns size of last global */
751: case 21:
752:
753: if (oldfil[inuse][0] != NUL) {
754:
755: lseek (olddes[inuse], 0L, 2);
756: lintstr (a, (long) tell (olddes[inuse]));
757:
758: }
759: else {
760: *a = EOL;
761: }
762:
763: break;
764:
765:
766: /* $V(22): number of v22_aliases */
767: case 22:
768:
769: i = 0;
770: f = 0;
771:
772: while (f < v22ptr) {
773: i++;
774: f += UNSIGN (v22ali[f]) + 1;
775: }
776:
777: intstr (a, i);
778:
779: break;
780:
781:
782: /* $V(23): contents of 'input buffer' */
783: case 23:
784:
785: stcpy (a, ug_buf[io]);
786: break;
787:
788:
789: /* $V(24)/$V(25) number of screen lines */
790: case 24:
791: case 25:
792:
793: intstr (a, N_LINES);
794: break;
795:
796:
797: /* $V(26): DO-FOR-XEC stack pointer */
798: case 26:
799:
800: intstr (a, nstx);
801: break;
802:
803:
804: /* $V(27): DO-FOR-XEC stack pointer (copy on error) */
805: case 27:
806:
807: intstr (a, nesterr);
808: break;
809:
810:
811: /* $V(30): number of mumps arguments */
812: case 30:
813:
814: intstr (a, m_argc);
815: break;
816:
817:
818: /* $V(31): environment variables */
819: case 31:
820:
821: f = 0;
822:
823: while (m_envp[f] && m_envp[f][0] != NUL) f++;
824:
825: intstr (a, f);
826: break;
827:
828:
829: /* $V(52): G0 input translation table */
830: case 52:
831:
832: stcpy0 (a, G0I[io], 257L);
833: a[255] = EOL;
834: break;
835:
836:
837: /* $V(53): G0 output translation table */
838: case 53:
839:
840: stcpy0 (a, G0O[io], 257L);
841: a[255] = EOL;
842:
843: break;
844:
845:
846: /* $V(54): G1 input translation table */
847: case 54:
848:
849: stcpy0 (a, G1I[io], 257L);
850: a[255] = EOL;
851:
852: break;
853:
854:
855: /* $V(55): G1 output translation table */
856: case 55:
857:
858: stcpy0 (a, G1O[io], 257L);
859: a[255] = EOL;
860:
861: break;
862:
863:
864: /* $V(60): partial pattern match flag */
865: case 60:
866:
867: intstr (a, pattrnflag);
868: break;
869:
870:
871: /* $V(61): partial pattern supplement character */
872: case 61:
873:
874: a[0] = pattrnchar;
875: a[1] = EOL;
876:
877: break;
878:
879:
880: /* $V(62): random: seed number */
881: case 62:
882:
883: lintstr (a, nrandom);
884: break;
885:
886:
887: /* $V(63): random: parameter a */
888: case 63:
889:
890: lintstr (a, ran_a);
891: break;
892:
893:
894: /* $V(64): random: parameter b */
895: case 64:
896:
897: lintstr (a, ran_b);
898: break;
899:
900:
901: /* $V(65): random: parameter c */
902: case 65:
903:
904: lintstr (a, ran_c);
905: break;
906:
907:
908: /* $V(66): SIGTERM handling flag */
909: case 66:
910:
911: intstr (a, killerflag);
912: break;
913:
914:
915: /* $V(67): SIGHUP handling flag */
916: case 67:
917:
918: intstr (a, huperflag);
919: break;
920:
921:
922: /* ... reserved ... */
923:
924:
925: /* $V(70): ZSORT/ZSYNTAX flag */
926: case 70:
927:
928: intstr (a, s_fun_flag);
929: break;
930:
931:
932: /* $V(71): ZNEXT/ZNAME flag */
933: case 71:
934:
935: intstr (a, n_fun_flag);
936: break;
937:
938:
939: /* $V(72): ZPREVIOUS/ZPIECE flag */
940: case 72:
941:
942: intstr (a, p_fun_flag);
943: break;
944:
945:
946: /* $V(73): ZDATA/ZDATE flag */
947: case 73:
948:
949: intstr (a, d_fun_flag);
950: break;
951:
952:
953: /* ... reserved ... */
954:
955:
956: /* $V(79): old ZJOB vs. new ZJOB flag */
957: case 79:
958:
959: intstr (a, zjobflag);
960: break;
961:
962:
963: /* $V(80): 7 vs. 8 bit flag */
964: case 80:
965:
966: intstr (a, eightbit);
967: break;
968:
969:
970: /* $V(81): PF1 flag */
971: case 81:
972:
973: intstr (a, PF1flag);
974: break;
975:
976:
977: /* $V(82): order counter */
978: case 82:
979:
980: intstr (a, ordercounter);
981: break;
982:
983:
984: /* $V(83): text in $ZE flag */
985: case 83:
986:
987: intstr (a, etxtflag);
988: break;
989:
990:
991: /* $V(84): path of current routine */
992: case 84: /* look whether we know where the routine came from */
993:
994: for (i = 0; i < NO_OF_RBUF; i++) {
995:
996: int j;
997:
998: if (pgms[i][0] == 0) {
999: *a = EOL;
1000: return;
1001: } /* buffer empty */
1002:
1003: j = 0;
1004:
1005: while (rou_name[j] == pgms[i][j]) {
1006:
1007: if (rou_name[j++] == EOL) {
1008:
1009: stcpy (a, path[i]);
1010: i = stlen (a);
1011:
1012: if (i > 0) a[i - 1] = EOL;
1013:
1014: return;
1015:
1016: }
1017:
1018: }
1019:
1020: }
1021:
1022: *a = EOL;
1023:
1024: break; /* not found */
1025:
1026:
1027: /* $V(85): path of last global */
1028: case 85:
1029:
1030: if (oldfil[inuse][0]) {
1031: stcpy (a, oldfil[inuse]);
1032: }
1033: else {
1034: *a = EOL;
1035: }
1036:
1037: i = 0;
1038:
1039: while (a[i] != EOL) {
1040:
1041: if (a[i] == '^') {
1042:
1043: if (i > 0) {
1044: i--;
1045: }
1046:
1047: a[i] = EOL;
1048:
1049: break;
1050:
1051: }
1052:
1053: i++;
1054:
1055: }
1056:
1057: break;
1058:
1059:
1060: /* $V(86): path of current device */
1061: case 86:
1062:
1063: stcpy (a, act_oucpath[io]);
1064: break;
1065:
1066:
1067: /* $V(87): date type definitions */
1068: case 87:
1069:
1070: intstr (a, datetype);
1071: break;
1072:
1073:
1074: /* $V(88): date type definitions */
1075: case 88:
1076:
1077: intstr (a, timetype);
1078: break;
1079:
1080:
1081: /* $V(91): missig QUIT expr default expression */
1082: case 91:
1083:
1084: stcpy (a, exfdefault);
1085: break;
1086:
1087:
1088: /* $V(92): type mismatch error */
1089: case 92:
1090:
1091: intstr (a, typemmflag);
1092: break;
1093:
1094:
1095: /* $V(93): zkey production default rule definition */
1096: case 93:
1097:
1098: lintstr (a, v93);
1099: break;
1100:
1101:
1102: /* $V(98): routine extention */
1103: case 98:
1104:
1105: stcpy (a, rou_ext);
1106: break;
1107:
1108: /* $V(100): exit status of last kill */
1109: case 100:
1110:
1111: intstr (a, v100);
1112: break;
1113:
1114: /* $V(114): Number of rows in terminal */
1115: case 114:
1116:
1117: intstr (a, n_lines);
1118: break;
1119:
1120:
1121: /* $V(115): Number of columns in terminal */
1122: case 115:
1123:
1124: intstr (a, n_columns);
1125: break;
1126:
1127:
1128: /* $V(133): remember ZLOAD directory on ZSAVE */
1129: case 133:
1130:
1131: intstr (a, zsavestrategy);
1132: break;
1133:
1134:
1135: default:
1136:
1137: merr_raise (ARGER);
1138: return;
1139:
1140: }
1141:
1142: return;
1143: }
1144:
1145: if (f == 2) {
1146:
1147: char tmp[256];
1148:
1149: stcpy (tmp, argstck[arg + 1]);
1150:
1151: i = intexpr (argstck[arg + 1]);
1152: f = intexpr (a);
1153:
1154: if (merr () == MXNUM) return;
1155:
1156: if (f == 16) {
1157:
1158: if (i <= OK || i >= MAXERR) {
1159: merr_raise (ARGER);
1160: return;
1161: }
1162: else {
1163: stcpy (a, errmes[i]);
1164: }
1165:
1166: }
1167: else if (f == 22) { /* return v22_alias entry */
1168:
1169: if (i) { /* give one of the names which are aliases */
1170:
1171: f = 0;
1172:
1173: while (f < v22ptr) {
1174:
1175: i--;
1176:
1177: if (i == 0) {
1178: stcpy (a, &v22ali[f + 1]);
1179: return;
1180: }
1181:
1182: f += UNSIGN (v22ali[f]) + 1;
1183:
1184: }
1185:
1186: a[0] = EOL;
1187:
1188: return; /* that number had no entry in the table */
1189:
1190: }
1191:
1192: if (tstglvn (tmp) == FALSE) {
1193: merr_raise (INVREF);
1194: return;
1195: }
1196:
1197: if (v22ptr) { /* there are aliases */
1198:
1199: int k, j;
1200:
1201: i = 0;
1202:
1203: while (i < v22ptr) {
1204:
1205: k = i + UNSIGN (v22ali[i]) + 1;
1206: j = 0; /* is current reference an alias ??? */
1207:
1208: while (v22ali[++i] == tmp[j]) {
1209:
1210: if (v22ali[i] == EOL) break;
1211:
1212: j++;
1213:
1214: }
1215:
1216: /* yes, it is, return it */
1217: if (v22ali[i] == EOL && tmp[j] == EOL) {
1218: stcpy (a, &v22ali[i + 1]);
1219: return;
1220: }
1221:
1222: i = k;
1223:
1224: }
1225:
1226: }
1227:
1228: a[0] = EOL; /* entry was not in the table */
1229:
1230: return;
1231:
1232: }
1233: else if (f == 24) { /* return screen line */
1234:
1235: if (i < -N_LINES || i > N_LINES || i == 0) {
1236: *a = EOL;
1237: }
1238: else if (i < 0) {
1239:
1240: stcpy0 (a, (*screen).screena[(unsigned int) (*screen).sclines[-i - 1]], (long) N_COLUMNS);
1241: a[80] = EOL;
1242:
1243: return;
1244:
1245: }
1246: else {
1247:
1248: stcpy0 (a, (*screen).screenx[(unsigned int) (*screen).sclines[i - 1]], (long) N_COLUMNS);
1249: a[80] = EOL;
1250:
1251: return;
1252:
1253: }
1254: }
1255: else if (f == 25) { /* return screen line with attribute */
1256:
1257: i--;
1258:
1259: if (i < 0 || i >= N_LINES) {
1260: *a = EOL;
1261: }
1262: else {
1263: v25 (a, i);
1264: }
1265:
1266: return;
1267:
1268: }
1269: else if (f == 26) { /* $V(26) returns DO-FOR-XEC stack pointer */
1270:
1271: if (i < 1 || i > nstx) {
1272: merr_raise (ARGER);
1273: return;
1274: }
1275:
1276: getraddress (a, i);
1277:
1278: return;
1279:
1280: } /* $V(27) returns DO-FOR-XEC stack pointer(error state) */
1281: else if (f == 27) {
1282:
1283: if (i < 1 || i > nesterr) {
1284: merr_raise (ARGER);
1285: return;
1286: }
1287:
1288: stcpy (a, callerr[i]);
1289:
1290: return;
1291:
1292: }
1293: else if (f == 30) { /* $V(30): arguments of mumps */
1294:
1295: if (i < 1 || i > m_argc) {
1296: merr_raise (ARGER);
1297: return;
1298: }
1299:
1300: strcpy (a, m_argv[i - 1]);
1301: a[strlen (a)] = EOL;
1302:
1303: return;
1304:
1305: /* guard against very long environment name=value entries */
1306: }
1307: else if (f == 31) { /* $V(31): environment variables */
1308:
1309: f = 0;
1310:
1311: while (m_envp[f] && m_envp[f++][0] != NUL) {
1312:
1313: if (f != i) continue;
1314:
1315: if ((f = strlen (m_envp[i - 1])) > STRLEN) {
1316: merr_raise (M75);
1317: return;
1318: }
1319:
1320: strcpy (a, m_envp[i - 1]);
1321: a[f] = EOL;
1322:
1323: return;
1324:
1325: }
1326:
1327: merr_raise (ARGER);
1328: return;
1329:
1330: }
1331: else if (f == 93) { /* $V(93): zkey production rule definition */
1332:
1333: if (i <= 0 || i > NO_V93) {
1334: merr_raise (ARGER);
1335: }
1336: else {
1337: strcpy (a, v93a[i - 1]);
1338: }
1339:
1340: return;
1341:
1342: }
1343: #if !defined(__APPLE__) && !defined(__gnu_hurd__) && !defined(__AMIGA) && !defined(EMSCRIPTEN) && !defined(MSDOS)
1344: else if (f == 113) { /* $V(113): get termio infos */
1345:
1346: struct termio tpara;
1347:
1348: if (i < 1 || i > MAXDEV) {
1349: merr_raise (NODEVICE);
1350: return;
1351: }
1352:
1353: if (devopen[i] == 0) {
1354: merr_raise (NOPEN);
1355: return;
1356: }
1357:
1358: ioctl (fileno (opnfile[i]), TCGETA, &tpara);
1359:
1360: intstr (a, tpara.c_iflag);
1361: i = stlen (a);
1362: a[i++] = ':';
1363:
1364: intstr (&a[i], tpara.c_oflag);
1365: i = stlen (a);
1366: a[i++] = ':';
1367:
1368: intstr (&a[i], tpara.c_cflag);
1369: i = stlen (a);
1370: a[i++] = ':';
1371:
1372: intstr (&a[i], tpara.c_lflag);
1373:
1374: return;
1375:
1376: }
1377: #endif
1378: else {
1379: merr_raise (ARGER);
1380: return;
1381: }
1382:
1383: }
1384: else if (f == 3) {
1385:
1386: char tmp[256];
1387:
1388: stcpy (tmp, argstck[arg + 2]);
1389: i = intexpr (argstck[arg + 1]);
1390: f = intexpr (a);
1391:
1392: if (merr () == MXNUM) return;
1393:
1394: if (f == 87) { /* $V(87): date type definitions */
1395:
1396: if (i < 0 || i >= NO_DATETYPE) {
1397: merr_raise (ARGER);
1398: return;
1399: }
1400:
1401: f = intexpr (tmp);
1402:
1403: if (f > 0 && f < 13) {
1404: stcpy (a, month[i][f - 1]);
1405: return;
1406: }
1407:
1408: switch (f) {
1409:
1410:
1411: case 13:
1412:
1413: {
1414: stcpy (a, dat1char[i]);
1415: return;
1416: }
1417:
1418:
1419: case 14:
1420:
1421: {
1422: stcpy (a, dat2char[i]);
1423: return;
1424: }
1425:
1426:
1427: case 15:
1428:
1429: {
1430: a[0] = dat3char[i];
1431: a[1] = EOL;
1432:
1433: return;
1434: }
1435:
1436:
1437: case 16:
1438:
1439: {
1440: a[0] = dat4flag[i] + '0';
1441: a[1] = EOL;
1442:
1443: return;
1444: }
1445:
1446:
1447: case 17:
1448:
1449: {
1450: a[0] = dat5flag[i] + '0';
1451: a[1] = EOL;
1452:
1453: return;
1454: }
1455:
1456:
1457: case 18:
1458:
1459: {
1460: lintstr (a, datGRbeg[i] - 672411L);
1461: return;
1462: }
1463:
1464:
1465: }
1466: }
1467: else if (f == 88) { /* $V(88): time type definitions */
1468:
1469: if (i < 0 || i >= NO_TIMETYPE) {
1470: merr_raise (ARGER);
1471: return;
1472: }
1473:
1474: f = intexpr (tmp);
1475:
1476: switch (f) {
1477: case 1:
1478:
1479: {
1480: a[0] = tim1char[i];
1481: a[1] = EOL;
1482:
1483: return;
1484: }
1485:
1486:
1487: case 2:
1488:
1489: {
1490: a[0] = tim2char[i];
1491: a[1] = EOL;
1492:
1493: return;
1494: }
1495:
1496:
1497: case 3:
1498:
1499: {
1500: a[0] = tim3char[i];
1501: a[1] = EOL;
1502:
1503: return;
1504: }
1505:
1506:
1507: case 4:
1508:
1509: {
1510: a[0] = tim4flag[i] + '0';
1511: a[1] = EOL;
1512:
1513: return;
1514: }
1515:
1516:
1517: case 5:
1518:
1519: {
1520: a[0] = tim5flag[i] + '0';
1521: a[1] = EOL;
1522:
1523: return;
1524: }
1525:
1526:
1527: }
1528:
1529: }
1530:
1531: merr_raise (ARGER);
1532: return;
1533:
1534: }
1535: else {
1536: merr_raise (FUNARG);
1537: return;
1538: }
1539:
1540: return;
1541: } /* end view_fun() */
1542:
1543:
1544: void m_tolower (char *str)
1545: {
1546: int ch;
1547:
1548: while ((ch = *str) != EOL) {
1549:
1550: ch = *str;
1551:
1552: if (ch <= 'Z' && ch >= 'A') {
1553: ch += 32;
1554: *str = ch;
1555: }
1556:
1557: str++;
1558:
1559: }
1560:
1561: return;
1562:
1563: } /* end tolower() */
1564:
1565:
1566: /*
1567: * size = desired size for 'partition'
1568: */
1569: short int newpsize (long size)
1570: {
1571: char *newpart = NULL;
1572: char *anewpart = NULL;
1573: long dif, j;
1574:
1575: if (size == PSIZE) return 0; /* nothing changes */
1576: if (size <= (PSIZE - symlen + 512)) return 0; /* cannot decrease it now */
1577: if (apartition && size <= (PSIZE - asymlen + 512)) return 0; /* cannot decrease it now */
1578:
1579: if (writing_mb) {
1580: newpart = shm_alloc ((size_t) (size+1));
1581: }
1582: else {
1583: newpart = calloc ((unsigned) (size + 1), 1);
1584: }
1585:
1586: if (newpart == NULL) return 1; /* could not allocate stuff */
1587:
1588: if (apartition) {
1589:
1590: anewpart = calloc ((unsigned) (size + 1), 1);
1591:
1592: if (anewpart == NULL) {
1593: free (newpart);
1594: return 1;
1595: }
1596: /* no more space */
1597:
1598: }
1599:
1600: dif = argptr - partition + 256;
1601:
1602: if (dif > PSIZE) dif = PSIZE;
1603:
1604: stcpy0 (newpart, partition, dif); /* intermediate results */
1605: dif = size - PSIZE;
1606: stcpy0 (&newpart[symlen + dif], &partition[symlen], PSIZE - symlen);
1607:
1608: if (apartition) stcpy0 (&anewpart[asymlen + dif], &apartition[asymlen], PSIZE - asymlen);
1609:
1610: for (j = '%'; j <= 'z'; j++) { /* update alphpointers */
1611:
1612: if (alphptr[j]) alphptr[j] += dif;
1613: if (aalphptr[j]) aalphptr[j] += dif;
1614:
1615: }
1616:
1617: PSIZE = size;
1618: symlen += dif;
1619: asymlen += dif;
1620:
1621: if (writing_mb) {
1622: shm_free (partition);
1623: }
1624: else {
1625: free (partition); /* free previously allocated space */
1626: }
1627:
1628: if (apartition) free (apartition); /* free previously allocated space */
1629:
1630: dif = newpart - partition;
1631: partition = newpart;
1632:
1633: if (apartition) apartition = anewpart;
1634:
1635: s = &partition[symlen] - 256; /* pointer to symlen_offset */
1636: argptr += dif; /* pointer to beg of tmp-storage */
1637:
1638: for (j = 0; j <= PARDEPTH; j++) {
1639:
1640: if (argstck[j]) argstck[j] += dif;
1641:
1642: }
1643:
1644: return 0;
1645:
1646: } /* end newpsize() */
1647:
1648: /* change size of svn_table to 'size' */
1649: short int newusize (long size)
1650: {
1651:
1652: char *newsvn;
1653: long dif, j;
1654:
1655: if (size <= (UDFSVSIZ - svnlen)) return 0; /* cannot decrease it now */
1656: if (size == UDFSVSIZ) return 0; /* nothing changes */
1657:
1658: newsvn = calloc ((unsigned) (size + 1), 1);
1659:
1660: if (newsvn == NULL) return 1; /* could not allocate stuff */
1661:
1662: stcpy0 (newsvn, svntable, svnlen); /* intermediate results */
1663: dif = size - UDFSVSIZ;
1664: stcpy0 (&newsvn[svnlen + dif], &svntable[svnlen], UDFSVSIZ - svnlen);
1665:
1666: for (j = '%'; j <= 'z'; j++) { /* update svn_alphpointers */
1667: if (svnaptr[j]) svnaptr[j] += dif;
1668: }
1669:
1670: UDFSVSIZ = size;
1671: svnlen += dif;
1672:
1673: free (svntable); /* free previously allocated space */
1674:
1675: svntable = newsvn;
1676:
1677: return 0;
1678:
1679: } /* end newusize() */
1680:
1681: /*
1682: * allocate 'nbrbuf' routine buffers
1683: * of 'size' bytes
1684: */
1685: short int newrsize (long size, long nbrbuf)
1686: {
1687:
1688: char *newrbuf;
1689: int i;
1690: long dif;
1691: unsigned long total;
1692:
1693: if (size <= (rouend - rouptr + 1)) return 0; /* making it smaller would be a mistake */
1694:
1695: if (nbrbuf > MAXNO_OF_RBUF) nbrbuf = MAXNO_OF_RBUF;
1696:
1697: total = (unsigned) nbrbuf *(unsigned) size;
1698:
1699: /* some overflow ??? */
1700: if ((total / (unsigned) size) != (unsigned) nbrbuf) {
1701: merr_raise (ARGER);
1702: return 1;
1703: }
1704:
1705: newrbuf = calloc (total, 1); /* routine buffer pool */
1706:
1707: while (newrbuf == NULL) { /* could not allocate stuff... */
1708:
1709: if (--nbrbuf < 2) return 1; /* ...so try with less buffers */
1710:
1711: total = (unsigned) nbrbuf *(unsigned) size;
1712:
1713: newrbuf = calloc (total, 1);
1714:
1715: }
1716:
1717: /* clear all routine buffers but one */
1718: for (i = 0; i < MAXNO_OF_RBUF; i++) { /* empty routine buffers */
1719: pgms[i][0] = 0;
1720: ages[i] = 0L;
1721: }
1722:
1723: /* transfer to new buffer */
1724: stcpy0 (newrbuf, rouptr, (long) (rouend - rouptr + 1));
1725:
1726: dif = newrbuf - rouptr;
1727: rouend += dif;
1728: ends[0] = rouend;
1729:
1730: stcpy (pgms[0], rou_name);
1731:
1732: rouins += dif;
1733:
1734: if (roucur == (buff + (NO_OF_RBUF * PSIZE0 + 1))) {
1735: roucur = newrbuf + (nbrbuf * size + 1);
1736: }
1737: else {
1738: roucur += dif;
1739: }
1740:
1741: rouptr = newrbuf;
1742:
1743: free (buff); /* free previously allocated space */
1744:
1745: buff = newrbuf;
1746: NO_OF_RBUF = nbrbuf;
1747: PSIZE0 = size;
1748:
1749: return 0;
1750:
1751: } /* end newrsize() */
1752:
1753:
1754: void zreplace (char *a, char *b, char *c)
1755: {
1756: long int ch, f, l, m, n;
1757: char d[256];
1758:
1759: if (b[0] == EOL) return; /* 2nd argument was empty */
1760:
1761: l = stlen (c); /* length of 3rd argument */
1762: n = 0;
1763: f = 0;
1764:
1765: for (;;) {
1766:
1767: m = 0;
1768:
1769: while ((ch = a[f + m]) == b[m] && ch != EOL) m++;
1770:
1771: if (b[m] == EOL) {
1772:
1773: if (n + l > STRLEN) {
1774: merr_raise (M75);
1775: return;
1776: }
1777:
1778: stcpy0 (&d[n], c, l);
1779:
1780: n += l;
1781: f += m;
1782:
1783: }
1784: else {
1785:
1786: m = 1;
1787:
1788: if (n + 1 > STRLEN) {
1789: merr_raise (M75);
1790: return;
1791: }
1792:
1793: d[n++] = a[f++];
1794:
1795: }
1796:
1797: if (a[f] == EOL) break;
1798:
1799: }
1800:
1801: d[n] = EOL;
1802: stcpy (a, d);
1803:
1804: return;
1805:
1806: } /* end zreplace() */
1807:
1808: short int tstglvn (char *a) /* tests whether 'a' is a proper unsubscripted glvn */
1809: {
1810: int i, ch;
1811:
1812: i = 0;
1813:
1814: if (a[0] == '^') {
1815:
1816: while (((ch = a[++i]) >= 'A' && ch <= 'Z') ||
1817: (ch >= 'a' && ch <= 'z') ||
1818: (ch >= '0' && ch <= '9') ||
1819: ((ch == '%' && i == 1) ||
1820: (standard == 0 &&
1821: (((ch == '.' || ch == '/') && i == 1) ||
1822: (((ch == '/' && a[i - 1] != '/') ||
1823: (ch == '%' && a[i - 1] == '/')) &&
1824: (a[1] == '.' || a[1] == '/'))))));
1825:
1826: return a[i] == EOL;
1827:
1828: }
1829:
1830: if ((ch = a[i++]) != '%' && (ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) return FALSE;
1831:
1832: while ((ch = a[i++]) != EOL) {
1833:
1834: if ((ch < '0' || ch > '9') && (ch < 'A' || ch > 'Z') && (ch < 'a' || ch > 'z')) {
1835: return FALSE;
1836: }
1837:
1838: }
1839:
1840: return TRUE;
1841:
1842: } /* end tstnam() */
1843:
1844: void zname (char *a, char *b)
1845: {
1846: int i, j, f, n;
1847:
1848: i = 0;
1849: j = 0;
1850: f = FALSE; /* we are in name section (vs.subscr.) */
1851: n = FALSE; /* part is numeric (vs.alphabetic) */
1852:
1853: while ((a[i] = b[j++]) != EOL) {
1854:
1855: if (a[i] == '"') a[++i] = '"';
1856:
1857: if (a[i] == DELIM) {
1858:
1859: if (f) {
1860:
1861: if (n == FALSE) a[i++] = '"';
1862:
1863: if (i >= (STRLEN-2)/*was 253*/) {
1864: a[i] = EOL;
1865: merr_raise (M75);
1866:
1867: return;
1868: }
1869:
1870: a[i] = ',';
1871:
1872: if ((n = znamenumeric (&b[j])) == FALSE) a[++i] = '"';
1873:
1874: }
1875: else {
1876:
1877: a[i] = '(';
1878: f = TRUE;
1879:
1880: if ((n = znamenumeric (&b[j])) == FALSE) a[++i] = '"';
1881:
1882: }
1883:
1884: }
1885:
1886: if (++i >= STRLEN) {
1887:
1888: a[STRLEN] = EOL;
1889:
1890: if (b[j] != EOL) {
1891: merr_raise (M75);
1892: return;
1893: }
1894:
1895: }
1896:
1897: }
1898:
1899: if (f) {
1900:
1901: if (i > (STRLEN-2) /* was 253 */) {
1902: merr_raise (M75);
1903: return;
1904: }
1905:
1906: if (n == FALSE) a[i++] = '"';
1907:
1908: a[i++] = ')';
1909: a[i] = EOL;
1910:
1911: }
1912:
1913: return;
1914:
1915: } /* end zname() */
1916:
1917: /* boolean function that tests whether str is a canonical numeric */
1918: short int znamenumeric (char *str)
1919: {
1920:
1921: register int ptr = 0;
1922: register int ch;
1923: register int point;
1924:
1925: if (str[0] == '-') ptr = 1;
1926:
1927: if (str[ptr] == EOL) return FALSE;
1928: if (str[ptr] == DELIM) return FALSE;
1929: if (str[ptr] == '0') return str[1] == EOL || str[1] == DELIM; /* leading zero */
1930:
1931: point = FALSE;
1932:
1933: while ((ch = str[ptr++]) != EOL && ch != DELIM) {
1934:
1935: if (ch > '9') return FALSE;
1936:
1937: if (ch < '0') {
1938:
1939: if (ch != '.') return FALSE;
1940: if (point) return FALSE; /* multiple points */
1941:
1942: point = TRUE;
1943:
1944: }
1945:
1946: }
1947:
1948: if (point) {
1949: if ((ch = str[ptr - 2]) == '0') return FALSE; /* trailing zero */
1950: if (ch == '.') return FALSE; /* trailing point */
1951: }
1952:
1953: return TRUE;
1954:
1955: } /* end of znamenumeric() */
1956:
1957: void procv22 (char *key) /* process v22 translation */
1958: {
1959: int i, j, k1;
1960: char tmp1[256];
1961:
1962: if (*key == EOL || *key == 0) return;
1963:
1964: i = 0;
1965: j = 0;
1966:
1967: while (i < v22ptr) {
1968:
1969: k1 = i + UNSIGN (v22ali[i]) + 1;
1970:
1971: /* is current reference an alias ??? */
1972:
1973: j = 0;
1974:
1975: while (v22ali[++i] == key[j]) {
1976:
1977: if (v22ali[i] == EOL) break;
1978:
1979: j++;
1980: }
1981:
1982: /* yes, it is, so resolve it now! */
1983: if (v22ali[i] == EOL && (key[j] == EOL || key[j] == DELIM)) {
1984:
1985: stcpy (tmp1, key);
1986: stcpy (key, &v22ali[i + 1]);
1987: stcat (key, &tmp1[j]);
1988:
1989: i = 0;
1990:
1991: continue; /* try again, it might be a double alias! */
1992:
1993: }
1994:
1995: i = k1;
1996:
1997: }
1998:
1999: return;
2000:
2001: } /* end of procv22() */
2002:
2003: void v25 (char *a, int i)
2004: {
2005: short c, exc, k, l, p;
2006:
2007: k = 0;
2008: exc = ~((*screen).screena[(unsigned int) (*screen).sclines[i]][0]);
2009:
2010: for (l = 0; l < N_COLUMNS; l++) {
2011:
2012: p = exc;
2013: exc = (*screen).screena[(unsigned int) (*screen).sclines[i]][l];
2014: c = (*screen).screenx[(unsigned int) (*screen).sclines[i]][l];
2015:
2016: #ifdef NEVER
2017:
2018: /* this may result in a problem, when in a system */
2019: /* different G0O/G1O sets are in use !!! */
2020: if (((exc == 1 && (p == 0)) || ((exc == 0) && (p == 1))) && (G0O[HOME][c] == G1O[HOME][c])) {
2021: exc = p; /* if char looks same in SI/SO, delay SI/SO */
2022: }
2023:
2024: #endif /* NEVER */
2025:
2026: if (exc != p) { /* set attribute */
2027:
2028: #ifdef SCO
2029:
2030: p = p & ~04; /* suppress SGR(3) */
2031:
2032: if (p & 0200) p = p & 0201; /* no display */
2033: if (p & 0100) p = p & 0101; /* inverse */
2034:
2035: #endif /* SCO */
2036:
2037: if ((p & 01) != (exc & 01)) a[k++] = (exc & 01) ? SO : SI;
2038:
2039: if ((p & ~01) != (exc & ~01)) {
2040:
2041: a[k++] = ESC;
2042: a[k++] = '[';
2043:
2044: for (p = 1; p < 8; p++) {
2045:
2046: if (exc & (1 << p)) {
2047:
2048: #ifdef SCO
2049:
2050: if (p == 1) {
2051: a[k++] = '1';
2052: a[k++] = ';';
2053:
2054: continue;
2055: }
2056:
2057: #endif /* SCO */
2058:
2059: a[k++] = '1' + p;
2060: a[k++] = ';';
2061:
2062: }
2063:
2064: }
2065:
2066: if (a[k - 1] == ';') k--;
2067:
2068: a[k++] = 'm';
2069: }
2070:
2071: }
2072:
2073: a[k++] = c;
2074:
2075: }
2076:
2077: if (exc & 01) a[k++] = SI;
2078:
2079: a[k] = EOL;
2080:
2081: return;
2082:
2083: } /* end of v25() */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to views.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src