Annotation of freem/src/init.c, revision 1.1.1.1
1.1 snw 1: /*
2: * *
3: * * *
4: * * *
5: * ***************
6: * * * * *
7: * * MUMPS *
8: * * * * *
9: * ***************
10: * * *
11: * * *
12: * *
13: *
14: * init.c
15: * FreeM initialization
16: *
17: *
18: * Author: Serena Willis <jpw@coherent-logic.com>
19: * Copyright (C) 1998 MUG Deutschland
20: * Copyright (C) 2020 Coherent Logic Development LLC
21: *
22: *
23: * This file is part of FreeM.
24: *
25: * FreeM is free software: you can redistribute it and/or modify
26: * it under the terms of the GNU Affero Public License as published by
27: * the Free Software Foundation, either version 3 of the License, or
28: * (at your option) any later version.
29: *
30: * FreeM is distributed in the hope that it will be useful,
31: * but WITHOUT ANY WARRANTY; without even the implied warranty of
32: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
33: * GNU Affero Public License for more details.
34: *
35: * You should have received a copy of the GNU Affero Public License
36: * along with FreeM. If not, see <https://www.gnu.org/licenses/>.
37: *
38: **/
39:
40: #include <stdio.h>
41: #include <stdlib.h>
42: #include <string.h>
43: #include <unistd.h>
44: #include <limits.h>
45: #include <sys/types.h>
46: #include <sys/stat.h>
47: #include <pwd.h>
48: #include <time.h>
49: #include <errno.h>
50: #include <sys/ioctl.h>
51: #include <termios.h>
52:
53: #include "config.h"
54:
55: #if defined(HAVE_MWAPI_MOTIF)
56: # include <Xm/Xm.h>
57: #endif
58:
59: #include "mpsdef.h"
60: #include "transact.h"
61: #include "namespace.h"
62: #include "events.h"
63: #include "mdebug.h"
64: #include "shmmgr.h"
65: #include "locktab.h"
66: #include "jobtab.h"
67: #include "datatypes.h"
68: #include "objects.h"
69:
70: #ifdef HAVE_LIBREADLINE
71: # if defined(HAVE_READLINE_READLINE_H)
72: # include <readline/readline.h>
73: # elif defined(HAVE_READLINE_H)
74: # include <readline.h>
75: # else /* !defined(HAVE_READLINE_H) */
76: extern char *readline ();
77: # endif /* !defined(HAVE_READLINE_H) */
78: char *cmdline = NULL;
79: #else /* !defined(HAVE_READLINE_READLINE_H) */
80: /* no readline */
81: #endif /* HAVE_LIBREADLINE */
82:
83: #ifdef HAVE_READLINE_HISTORY
84: # if defined(HAVE_READLINE_HISTORY_H)
85: # include <readline/history.h>
86: # elif defined(HAVE_HISTORY_H)
87: # include <history.h>
88: # else /* !defined(HAVE_HISTORY_H) */
89: extern void add_history ();
90: extern int write_history ();
91: extern int read_history ();
92: # endif /* defined(HAVE_READLINE_HISTORY_H) */
93: /* no history */
94: #endif /* HAVE_READLINE_HISTORY */
95:
96: #if defined(HAVE_WIRINGPI_H)
97: # include <wiringPi.h>
98: #endif
99:
100: #if !defined(PATH_MAX) && defined(_SCO_DS)
101: # define PATH_MAX 4096
102: #endif
103:
104: #if !defined(PATH_MAX) && defined(__gnu_hurd__)
105: # define PATH_MAX 1024
106: #endif
107:
108: #if !defined(PATH_MAX) && defined(__sun__)
109: # include <limits.h>
110: #endif
111:
112: #if defined(__NetBSD__) || defined(__FreeBSD__) || defined(__OpenBSD__)
113: # include <sys/syslimits.h>
114: #endif
115:
116: #define SHMKEY 0x990120
117: #define SHMSIZ 1048576
118:
119: void init_process(void);
120: void init_devtable(void);
121: void init_signals(void);
122: void init_timezone(void);
123: void init_freem_path(void);
124:
125: #if defined(HAVE_LIBREADLINE)
126: void init_readline(void);
127: #endif
128:
129: void init_execution_context(void);
130: void init_io(void);
131: void init_random_number(void);
132: void init_ztrap(void);
133: void init_ssvn(void);
134: void init_terminal(void);
135: void init_estack(void);
136:
137: void init_mwapi(void);
138:
139: short init (char *namespace_name)
140: {
141: short retval;
142:
143: init_process ();
144: init_devtable ();
145: init_signals ();
146: init_freem_path ();
147: init_timezone ();
148:
149: #if defined(HAVE_LIBREADLINE)
150: init_readline ();
151: #endif
152:
153: init_execution_context ();
154:
155: if (run_daemon == FALSE) {
156: init_io ();
157: }
158:
159: init_random_number ();
160: init_ztrap ();
161:
162: retval = shm_init (shm_init_size);
163:
164: if (retval == SHMS_GET_ERR) {
165: fprintf (stderr, "init: error initializing shared memory [errno %d]\r\n", errno);
166: exit (1);
167: }
168:
169: symtab_init ();
170: tp_init ();
171:
172: set_namespace (namespace_name, FALSE);
173:
174: if (first_process) {
175: fprintf (stderr, "init: we are the first process in the environment (pid %d)\r\n", pid);
176: }
177:
178: if (first_process) fprintf (stderr, "init: initializing job table\r\n");
179: jobtab_init ();
180:
181: if (first_process) fprintf (stderr, "init: adding job to job table\r\n");
182: job_init (FALSE);
183:
184: if (first_process) fprintf (stderr, "init: initializing structured system variables\r\n");
185: init_ssvn ();
186:
187: if (first_process) fprintf (stderr, "init: initializing terminal\r\n");
188: init_terminal ();
189:
190: if (first_process) fprintf (stderr, "init: initializing asynchronous events\r\n");
191: evt_init ();
192:
193: if (first_process) fprintf (stderr, "init: initializing debugger\r\n");
194: dbg_init ();
195:
196: if (first_process) fprintf (stderr, "init: initializing error stack\r\n");
197: init_estack();
198:
199: etrap[0] = EOL;
200: ecode[0] = EOL;
201: estack = 0;
202:
203: init_mwapi();
204:
205: if (merr () == OK) {
206: return TRUE;
207: }
208:
209: return FALSE;
210: }
211:
212: void init_process (void)
213: {
214: pid = getpid (); /* get $J = process ID */
215: umask (0); /* protection bits mask to full rights */
216: snprintf (fp_conversion, 9, "%%.%df\201", DBL_DIG);
217:
218: if (fp_mode) {
219: zprecise = DBL_DIG;
220: }
221: else {
222: zprecise = 100;
223: }
224: }
225:
226: void init_devtable (void)
227: {
228: register int i;
229: register int j;
230:
231: for (j = 0; j <= MAXDEV; j++) { /* init. translation tables */
232:
233: for (i = 0; i < 256; i++) {
234: G0I[j][i] = (char) i;
235: G0O[j][i] = (char) i;
236: G1I[j][i] = (char) i;
237: G1O[j][i] = (char) i;
238: }
239:
240: G0I[j][UNSIGN (EOL)] = NUL;
241: G0O[j][UNSIGN (EOL)] = NUL;
242: G1I[j][UNSIGN (EOL)] = NUL;
243: G1O[j][UNSIGN (EOL)] = NUL;
244: G0I[j][UNSIGN (DELIM)] = NUL;
245: G0O[j][UNSIGN (DELIM)] = NUL;
246: G1I[j][UNSIGN (DELIM)] = NUL;
247: G1O[j][UNSIGN (DELIM)] = NUL;
248: G0I[j][256] = EOL;
249: G0O[j][256] = EOL;
250: G1I[j][256] = EOL;
251: G1O[j][256] = EOL;
252:
253: }
254:
255: #ifdef SCO
256: #ifndef HACK_NOXLATE
257: G0I[HOME][245] = 64;
258: G0O[HOME][64] = 245; /* Paragraph */
259: G0I[HOME][142] = 91;
260: G0O[HOME][91] = 142; /* A umlaut */
261: G0I[HOME][153] = 92;
262: G0O[HOME][92] = 153; /* O umlaut */
263: G0I[HOME][154] = 93;
264: G0O[HOME][93] = 154; /* U umlaut */
265: G0I[HOME][132] = 123;
266: G0O[HOME][123] = 132; /* a umlaut */
267: G0I[HOME][148] = 124;
268: G0O[HOME][124] = 148; /* o umlaut */
269: G0I[HOME][129] = 125;
270: G0O[HOME][125] = 129; /* u umlaut */
271: G0I[HOME][225] = 126;
272: G0O[HOME][126] = 225; /* sharp s */
273: #endif/*HACK_NOXLATE*/
274:
275: /* DEC Special graphics */
276: G1I[HOME][254] = 96;
277: G1O[HOME][96] = 254; /* diamond */
278: G1I[HOME][176] = 97;
279: G1O[HOME][97] = 176; /* checker board */
280: G1I[HOME][241] = 99;
281: G1O[HOME][99] = 241; /* FF */
282: G1I[HOME][242] = 100;
283: G1O[HOME][100] = 242; /* CR */
284: G1I[HOME][243] = 101;
285: G1O[HOME][101] = 243; /* LF */
286: G1I[HOME][248] = 102;
287: G1O[HOME][102] = 248; /* degree sign */
288: G1I[HOME][241] = 103;
289: G1O[HOME][103] = 241; /* plus minus */
290: G1I[HOME][244] = 104;
291: G1O[HOME][104] = 244; /* NL */
292: G1I[HOME][251] = 105;
293: G1O[HOME][105] = 251; /* VT */
294: G1I[HOME][217] = 106;
295: G1O[HOME][106] = 217; /* lower right corner */
296: G1I[HOME][191] = 107;
297: G1O[HOME][107] = 191; /* upper right corner */
298: G1I[HOME][218] = 108;
299: G1O[HOME][108] = 218; /* upper left corner */
300: G1I[HOME][192] = 109;
301: G1O[HOME][109] = 192; /* lower left corner */
302: G1I[HOME][197] = 110;
303: G1O[HOME][110] = 197; /* cross */
304: G1I[HOME][200] = 111;
305: G1O[HOME][111] = 200; /* linescan 5 */
306: G1I[HOME][201] = 112;
307: G1O[HOME][112] = 201; /* linescan 4 */
308: G1I[HOME][196] = 113;
309: G1O[HOME][113] = 196; /* linescan 3 */
310: G1I[HOME][202] = 114;
311: G1O[HOME][114] = 202; /* linescan 2 */
312: G1I[HOME][203] = 115;
313: G1O[HOME][115] = 203; /* linescan 1 */
314: G1I[HOME][195] = 116;
315: G1O[HOME][116] = 195; /* left junction */
316: G1I[HOME][180] = 117;
317: G1O[HOME][117] = 180; /* right junction */
318: G1I[HOME][193] = 118;
319: G1O[HOME][118] = 193; /* lower junction */
320: G1I[HOME][194] = 119;
321: G1O[HOME][119] = 194; /* upper junction */
322: G1I[HOME][179] = 120;
323: G1O[HOME][120] = 179; /* vertival bar */
324: G1I[HOME][243] = 121;
325: G1O[HOME][121] = 243; /* lower equals */
326: G1I[HOME][242] = 122;
327: G1O[HOME][122] = 242; /* greater equals */
328: G1I[HOME][227] = 123;
329: G1O[HOME][123] = 227; /* pi */
330: G1I[HOME][246] = 124;
331: G1O[HOME][124] = 246; /* not equals */
332: G1I[HOME][128] = 125;
333: G1O[HOME][125] = 128; /* euro sign */
334: G1I[HOME][250] = 126;
335: G1O[HOME][126] = 250; /* centered dot */
336: #endif /* SCO */
337: }
338:
339: void init_signals (void)
340: {
341: sig_init ();
342: }
343:
344: void init_timezone (void)
345: {
346:
347: struct tm lt;
348: struct tm gt;
349:
350: unsigned long gmt;
351: unsigned long lmt;
352:
353: long clock;
354:
355: #ifdef __CYGWIN__
356:
357: tzset (); /* may be required in order */
358: /* to guarantee _timezone set */
359: #else
360:
361: clock = time (0L);
362: lt = *localtime (&clock);
363: gt = *gmtime (&clock);
364:
365: /* This is awkward but I think it is portable: steve_morris */
366: gmt = gt.tm_year * 365;
367: gmt = (gmt + gt.tm_yday) * 24;
368: gmt = (gmt + gt.tm_hour) * 60;
369: gmt = (gmt + gt.tm_min);
370:
371: lmt = lt.tm_year * 365;
372: lmt = (lmt + lt.tm_yday) * 24;
373: lmt = (lmt + lt.tm_hour) * 60;
374: lmt = (lmt + lt.tm_min);
375:
376: FreeM_timezone = (gmt - lmt) * 60;
377: tzoffset = -FreeM_timezone;
378:
379: #endif /* __CYGWIN__ */
380:
381:
382: }
383:
384: void init_freem_path (void)
385: {
386:
387: if((freem_path = malloc(PATH_MAX + 1)) == NULL) {
388: fprintf(stderr, "Can't allocate freem_path. Exiting.");
389:
390: exit(1);
391: }
392:
393: freem_path[0] = NUL;
394:
395: /* check where I'm being executed from */
396: #ifdef __linux__
397: readlink ("/proc/self/exe", freem_path, PATH_MAX);
398: #endif
399: #ifdef __FreeBSD__
400: readlink ("/proc/curproc/file", freem_path, PATH_MAX);
401: #endif
402: #ifdef __sun
403: readlink ("/proc/self/path/a.out", freem_path, PATH_MAX);
404: #endif
405:
406: if(freem_path[0] == NUL) {
407: /* we don't know where we came from */
408: }
409:
410: getcwd (curdir, PATHLEN);
411: stcnv_c2m (curdir);
412:
413: }
414:
415: #if defined(HAVE_LIBREADLINE)
416: void init_readline (void)
417: {
418: uid_t uid = geteuid ();
419: struct passwd *pw = getpwuid (uid);
420: char *pw_buf;
421:
422: pw_buf = (char *) calloc (strlen(pw->pw_dir) + 1, sizeof(char));
423: strcpy (pw_buf, pw->pw_dir);
424:
425: snprintf (history_file, 256, "%s/.freem_history", pw_buf);
426:
427: free (pw_buf);
428:
429: using_history ();
430: read_history (history_file);
431: }
432: #endif
433:
434: void init_execution_context (void)
435: {
436: register int i;
437:
438: obj_init ();
439:
440: merr_clear ();
441:
442: codptr = code;
443: code[0] = EOL; /* init code_pointer */
444: partition = calloc ((unsigned) (PSIZE + 2), 1);
445:
446: if (partition == NULL) exit (2); /* could not allocate stuff... */
447:
448: for (i = 0; i < MAXNO_OF_RBUF; i++) {
449: rbuf_flags[i].standard = standard;
450: }
451:
452: for (i = 0; i < NESTLEVLS; i++) {
453: extr_types[i] = DT_STRING;
454: }
455:
456: symlen = PSIZE;
457: s = &partition[PSIZE] - 256; /* pointer to symlen_offset */
458: argptr = partition; /* pointer to beg of tmp-storage */
459:
460: svntable = calloc ((unsigned) (UDFSVSIZ + 1), 1);
461: if (svntable == NULL) exit (2); /* could not allocate stuff... */
462:
463: svnlen = UDFSVSIZ; /* begin of udf_svn_table */
464: buff = calloc ((unsigned) NO_OF_RBUF * (unsigned) PSIZE0, 1); /* routine buffer pool */
465: if (buff == NULL) exit (2); /* could not allocate stuff... */
466:
467:
468: newstack = calloc ((unsigned) NSIZE, 1);
469: if (newstack == NULL) exit (2); /* could not allocate stuff... */
470:
471: #ifdef DEBUG_NEWPTR
472: printf("Allocating newptr stack...\r\n");
473: #endif
474:
475: newptr = newstack;
476: newlimit = newstack + NSIZE - 1024;
477:
478:
479: namstck = calloc ((unsigned) NESTLEVLS * 13, 1);
480: if (namstck == NULL) exit (2); /* could not allocate stuff... */
481:
482: *namstck = EOL;
483: *(namstck + 1) = EOL;
484: namptr = namstck; /* routine name stack pointer */
485: framstck = calloc ((unsigned) NESTLEVLS * 256, 1);
486: if (framstck == NULL) exit (2); /* could not allocate stuff... */
487:
488: *framstck = EOL;
489: *(framstck + 1) = EOL;
490: dofrmptr = framstck; /* DO_frame stack pointer */
491: cmdstack = calloc ((unsigned) NESTLEVLS * 256, 1);
492: if (cmdstack == NULL) exit (2); /* could not allocate stuff... */
493:
494: cmdptr = cmdstack; /* command stack */
495:
496: rouend = rouins = rouptr = buff;
497: roucur = buff + (NO_OF_RBUF * PSIZE0 + 1);
498: *rouptr = EOL;
499: *(rouptr + 1) = EOL;
500: *(rouptr + 2) = EOL;
501:
502: err_suppl[0] = EOL; /* empty out supplemental error info */
503: }
504:
505: void init_estack (void)
506: {
507: stcpy (merr_stack[0].PLACE, "xecline()\201");
508: }
509:
510: #if defined(HAVE_MWAPI_MOTIF)
511: void init_mwapi (void)
512: {
513: /*
514: if (getenv("DISPLAY") != NULL) {
515: gtk_init (0, NULL);
516: }
517: */
518: //TODO: init Motif/libXt
519: }
520: #else
521: void init_mwapi (void)
522: {
523: return;
524: }
525: #endif
526:
527: void init_io (void)
528: {
529: register int i;
530:
531: /* initialize screen */
532: setbuf (stdin, NULL); /* no input buffering */
533: glvnflag.all = 0L;
534: stcpy (buff, "\201");
535: writeHOME (buff);
536: sq_modes[0] = '+';
537: for (i = 0; i <= MAXDEV; ug_buf[i++][0] = EOL); /* init read-buffers */
538:
539: crlf[HOME] = frm_filter;
540:
541: if (hardcopy) zbreakon = ENABLE; /* enable CTRL/B */
542:
543: set_io (MUMPS); /* set i/o parameters */
544:
545: #if !defined(__AMIGA)
546: if (ttyname (HOME)) { /* for $IO of HOME */
547: strcpy (dev[HOME], ttyname (HOME));
548: dev[HOME][strlen (dev[HOME])] = EOL;
549: }
550: else {
551: dev[HOME][0] = EOL; /* ...we are in a pipe */
552: }
553: #else
554: strcpy (dev[HOME], "CONSOLE:");
555: #endif
556:
557: /* init function keys */
558: for (i = 0; i < 44; zfunkey[i++][0] = EOL);
559: }
560:
561: void init_random_number (void)
562: {
563:
564: srand (time (NULL));
565:
566: if ((nrandom = time (0L) * getpid ()) < 0) {
567: nrandom = (-nrandom);
568: }
569:
570: }
571:
572: void init_ztrap (void)
573: {
574:
575: if (frm_filter) {
576: ztrap[0][0] = EOL; /* no default ztrap for filters */
577: }
578: else if (startuprou[0] == '^') {
579: stcpy (ztrap[0], startuprou);
580: }
581: else {
582: stcpy (ztrap[0], "^%SYSINIT\201");
583: }
584:
585: /* $ZT to be xecuted on startup */
586:
587: stcpy (ztrap[NESTLEVLS + 1], ztrap[0]); /* DSM V.2 error trapping */
588:
589: }
590:
591: void init_ssvn(void)
592: {
593: ssvn_job_update ();
594: ssvn_display_update ();
595: ssvn_routine_update ();
596: ssvn_library_update ();
597: if (first_process) ssvn_system_update ();
598: }
599:
600: void init_terminal(void)
601: {
602: xpos[HOME] = 80;
603: ypos[HOME] = 24;
604: }
605:
606: void reset_terminal(void)
607: {
608: struct termio tpara;
609:
610: ioctl (0, TCGETA, &tpara);
611:
612: tpara.c_lflag |= (ECHO | ICANON); /* enable echo/no cbreak mode */
613: tpara.c_iflag |= ICRNL; /* cr-lf mapping */
614: tpara.c_oflag |= ONLCR; /* cr-lf mapping */
615: tpara.c_cc[VMIN] = EOT;
616: tpara.c_cc[VTIME] = -1;
617:
618: ioctl (0, TCSETA, &tpara);
619: }
620:
621: void cleanup (void)
622: {
623: char k_buf[256];
624: int ch;
625:
626: /* remove this job's entry from ^$JOB SSVN */
627: snprintf (k_buf, 255, "^$JOB\202%d\201", pid);
628: symtab_shm (kill_sym, k_buf, " \201");
629:
630: reset_terminal ();
631:
632: if (tp_level > 0) {
633:
634: if (direct_mode == TRUE) {
635: fprintf (stderr, "UNCOMMITTED TRANSACTIONS EXIST:\n\n");
636: tp_tdump ();
637: set_io (UNIX);
638: fprintf (stderr, "\nWould you like to c)ommit or r)ollback the above transactions and their operations? ($TLEVEL = %d) ", tp_level);
639:
640: for (;;) {
641: ch = fgetc (stdin);
642:
643: if (ch == 'c' || ch == 'C') {
644: while (tp_level > 0) tp_tcommit ();
645:
646: fprintf (stderr, "\n\nTransactions have been committed.\n");
647:
648: break;
649: }
650: else if (ch == 'r' || ch == 'R') {
651: tp_trollback (tp_level);
652:
653: fprintf (stderr, "\n\nTransactions have been rolled back.\n");
654:
655: break;
656: }
657: else {
658: fprintf (stderr, "\n\nInvalid input '%c'. Must choose c)ommit or r)ollback.\n", ch);
659: }
660: }
661: }
662: else {
663: fprintf (stderr, "Uncommitted transactions exist. Rolling back.\n");
664: tp_trollback (tp_level);
665: }
666: }
667:
668: #if defined(HAVE_LIBREADLINE)
669: write_history (history_file);
670: #endif
671:
672: locktab_unlock_all ();
673: job_remove (pid);
674:
675: shm_exit ();
676:
677: if (run_daemon == TRUE) {
678:
679: if (pid_fd != -1) {
680: lockf (pid_fd, F_ULOCK, 0);
681: close (pid_fd);
682: }
683:
684: if (pid_file_path != NULL) {
685: unlink (pid_file_path);
686: }
687:
688: }
689:
690:
691:
692: free (buff); /* free previously allocated space */
693: free (svntable);
694: if (partition) free (partition);
695: if (apartition) free (apartition);
696:
697:
698: free (newstack);
699:
700:
701: if (v22size) free (v22ali);
702:
703: return;
704: } /* end of cleanup */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to init.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Coherent Logic Development] / freem / src