![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to main.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / lib / libF77|
Return to main.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / lib / libF77 |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: *
6: * @(#)main.c 5.5 5/29/90
7: */
8: #include <stdio.h>
9: #include <signal.h>
10: #include "../libI77/fiodefs.h"
11:
12: extern int errno;
13: char *getenv();
14: int xargc;
15: char **xargv;
16:
17: main(argc, argv, arge)
18: int argc;
19: char **argv;
20: char **arge;
21: {
22: void sigdie();
23: sig_t sigf;
24: int signum;
25:
26: xargc = argc;
27: xargv = argv;
28:
29: for (signum=1; signum<=16; signum++)
30: {
31: if((sigf=signal(signum, sigdie)) != SIG_DFL) signal(signum, sigf);
32: }
33:
34: #ifdef pdp11
35: ldfps(01200); /* detect overflow as an exception */
36: #endif
37:
38: f_init();
39: MAIN_();
40: f_exit();
41: return 0;
42: }
43:
44: struct action {
45: char *mesg;
46: int core;
47: } sig_act[16] = {
48: {"Hangup", 0}, /* SIGHUP */
49: {"Interrupt!", 0}, /* SIGINT */
50: {"Quit!", 1}, /* SIGQUIT */
51: {"Illegal ", 1}, /* SIGILL */
52: {"Trace Trap", 1}, /* SIGTRAP */
53: {"IOT Trap", 1}, /* SIGIOT */
54: {"EMT Trap", 1}, /* SIGEMT */
55: {"Arithmetic Exception", 1}, /* SIGFPE */
56: { 0, 0}, /* SIGKILL */
57: {"Bus error", 1}, /* SIGBUS */
58: {"Segmentation violation", 1}, /* SIGSEGV */
59: {"Sys arg", 1}, /* SIGSYS */
60: {"Open pipe", 0}, /* SIGPIPE */
61: {"Alarm", 0}, /* SIGALRM */
62: {"Terminated", 0}, /* SIGTERM */
63: {"Sig 16", 0}, /* unassigned */
64: };
65:
66: #ifdef tahoe
67: /* The following arrays are defined & used assuming that signal codes are
68: 1 to 5 for SIGFPE, and 0 to 3 for SIGILL.
69: Actually ILL_ALIGN_FAULT=14, and is mapped to 3. */
70:
71: #define N_ACT_ILL 4 /* number of entries in act_ill[] */
72: #define N_ACT_FPE 5 /* number of entries in act_fpe[] */
73: #define ILL_ALIGN_FAULT 14
74:
75: struct action act_fpe[] = {
76: {"Integer overflow", 1},
77: {"Integer divide by 0", 1},
78: {"Floating divide by zero", 1},
79: {"Floating point overflow", 1},
80: {"Floating point underflow", 1},
81: };
82:
83: #else vax || pdp11
84:
85: struct action act_fpe[] = {
86: {"Integer overflow", 1},
87: {"Integer divide by 0", 1},
88: {"Floating point overflow trap", 1},
89: {"Floating divide by zero trap", 1},
90: {"Floating point underflow trap", 1},
91: {"Decimal overflow", 1},
92: {"Subscript range", 1},
93: {"Floating point overflow", 0},
94: {"Floating divide by zero", 0},
95: {"Floating point underflow", 0},
96: };
97: #endif vax || pdp11
98:
99: struct action act_ill[] = {
100: {"addr mode", 1},
101: {"instruction", 1},
102: {"operand", 0},
103: #ifdef tahoe
104: {"alignment", 1},
105: #endif tahoe
106: };
107:
108: #if (defined(vax) || defined(tahoe))
109: void
110: sigdie(s, t, sc)
111: int s; int t; struct sigcontext *sc;
112:
113: #else pdp11
114:
115: void
116: sigdie(s, t, pc)
117: int s; int t; long pc;
118:
119: #endif pdp11
120: {
121: extern unit units[];
122: register struct action *act = &sig_act[s-1];
123: /* print error message, then flush buffers */
124:
125: if (s == SIGHUP || s == SIGINT || s == SIGQUIT)
126: signal(s, SIG_IGN); /* don't allow it again */
127: else
128: signal(s, SIG_DFL); /* shouldn't happen again, but ... */
129:
130: if (act->mesg)
131: {
132: fprintf(units[STDERR].ufd, "*** %s", act->mesg);
133: if (s == SIGFPE)
134: {
135: #ifndef tahoe
136: if (t >= 1 && t <= 10)
137: #else tahoe
138: if ((t-1) >= 0 && t < N_ACT_FPE)
139: #endif tahoe
140: fprintf(units[STDERR].ufd, ": %s", act_fpe[t-1].mesg);
141: else
142: fprintf(units[STDERR].ufd, ": Type=%d?", t);
143: }
144: else if (s == SIGILL)
145: {
146: #ifndef tahoe
147: if (t == 4) t = 2; /* 4.0bsd botch */
148: if (t >= 0 && t <= 2)
149: #else tahoe
150: if (t == ILL_ALIGN_FAULT) /* ILL_ALIGN_FAULT maps to last
151: t = N_ACT_ILL-1; entry in act_ill[] */
152: if (t >= 0 && t < N_ACT_ILL)
153: #endif tahoe
154: fprintf(units[STDERR].ufd, "%s", act_ill[t].mesg);
155: else
156: fprintf(units[STDERR].ufd, "compat mode: Code=%d", t);
157: }
158: putc('\n', units[STDERR].ufd);
159: }
160: f77_abort( s, act->core );
161: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.