added long/short conversions. DLW

[unix-history] / usr / src / usr.bin / f77 / libF77 / main.c

diff --git a/usr/src/usr.bin/f77/libF77/main.c b/usr/src/usr.bin/f77/libF77/main.c
index 8bf9cde..05f6268 100644 (file)
--- a/usr/src/usr.bin/f77/libF77/main.c
+++ b/usr/src/usr.bin/f77/libF77/main.c
@@ -1,5 +1,5 @@
 /* STARTUP PROCEDURE FOR UNIX FORTRAN PROGRAMS */
 /* STARTUP PROCEDURE FOR UNIX FORTRAN PROGRAMS */

-char id_libF77[] = "@(#)main.c 2.6     %G%";
+char id_libF77[] = "@(#)main.c 2.11    %G%";

 
 #include <stdio.h>
 #include <signal.h>
 
 #include <stdio.h>
 #include <signal.h>


@@ -15,18 +15,15 @@ char **arge;
 {
 int sigdie();
 long int (*sigf)();
 {
 int sigdie();
 long int (*sigf)();

+int signum;

 
 xargc = argc;
 xargv = argv;
 
 xargc = argc;
 xargv = argv;

-signal(SIGFPE, sigdie);        /* ignore underflow, enable overflow */
-signal(SIGIOT, sigdie);
-if((sigf=signal(SIGQUIT, sigdie)) != SIG_DFL) signal(SIGQUIT, sigf);
-if((sigf=signal(SIGINT,  sigdie)) != SIG_DFL) signal(SIGINT,  sigf);
-if((sigf=signal(SIGTERM, sigdie)) != SIG_DFL) signal(SIGTERM, sigf);
-if((sigf=signal(SIGILL,  sigdie)) != SIG_DFL) signal(SIGILL,  sigf);
-if((sigf=signal(SIGEMT,  sigdie)) != SIG_DFL) signal(SIGEMT,  sigf);
-if((sigf=signal(SIGBUS,  sigdie)) != SIG_DFL) signal(SIGBUS,  sigf);
-if((sigf=signal(SIGSEGV, sigdie)) != SIG_DFL) signal(SIGSEGV, sigf);
+
+for (signum=1; signum<=16; signum++)
+{
+       if((sigf=signal(signum, sigdie)) != SIG_DFL) signal(signum, sigf);
+}

 
 #ifdef pdp11
        ldfps(01200); /* detect overflow as an exception */
 
 #ifdef pdp11
        ldfps(01200); /* detect overflow as an exception */


@@ -41,29 +38,33 @@ struct action {
        char *mesg;
        int   core;
 } sig_act[16] = {
        char *mesg;
        int   core;
 } sig_act[16] = {

-       { 0, 0},                        /* SIGHUP  */
+       {"Hangup", 0},                  /* SIGHUP  */

        {"Interrupt!", 0},              /* SIGINT  */
        {"Quit!", 1},                   /* SIGQUIT */
        {"Interrupt!", 0},              /* SIGINT  */
        {"Quit!", 1},                   /* SIGQUIT */

+#ifdef UCBVAX
+       {"Illegal ", 1},                /* SIGILL  */
+#else  UCBVAX

        {"Illegal instruction", 1},     /* SIGILL  */
        {"Illegal instruction", 1},     /* SIGILL  */

-       { 0, 0},                        /* SIGTRAP */
+#endif UCBVAX
+       {"Trace Trap", 1},              /* SIGTRAP */

        {"IOT Trap", 1},                /* SIGIOT  */
        {"EMT Trap", 1},                /* SIGEMT  */
        {"IOT Trap", 1},                /* SIGIOT  */
        {"EMT Trap", 1},                /* SIGEMT  */

-#ifdef UCBVAX
+#ifdef UCBVAX

        {"Arithmetic Exception", 1},    /* SIGFPE  */
        {"Arithmetic Exception", 1},    /* SIGFPE  */

-#else
+#else  UCBVAX

        {"Floating Point Exception", 1},/* SIGFPE  */
        {"Floating Point Exception", 1},/* SIGFPE  */

-#endif
+#endif UCBVAX

        { 0, 0},                        /* SIGKILL */
        {"Bus error", 1},               /* SIGBUS  */
        {"Segmentation violation", 1},  /* SIGSEGV */
        { 0, 0},                        /* SIGKILL */
        {"Bus error", 1},               /* SIGBUS  */
        {"Segmentation violation", 1},  /* SIGSEGV */

-       { 0, 0},                        /* SIGSYS  */
-       { 0, 0},                        /* SIGPIPE */
-       { 0, 0},                        /* SIGALRM */
+       {"Sys arg", 1},                 /* SIGSYS  */
+       {"Open pipe", 0},               /* SIGPIPE */
+       {"Alarm", 0},                   /* SIGALRM */

        {"Terminated", 0},              /* SIGTERM */
        {"Terminated", 0},              /* SIGTERM */

-       { 0, 0},                        /* unassigned */
+       {"Sig 16", 0},                  /* unassigned */

 };
 
 };
 

-#ifdef UCBVAX
+#ifdef UCBVAX

 struct action act_fpe[] = {
        {"Integer overflow", 1},
        {"Integer divide by 0", 1},
 struct action act_fpe[] = {
        {"Integer overflow", 1},
        {"Integer divide by 0", 1},


@@ -76,37 +77,56 @@ struct action act_fpe[] = {
        {"Floating divide by zero", 0},
        {"Floating point underflow", 0},
 };
        {"Floating divide by zero", 0},
        {"Floating point underflow", 0},
 };

-#endif
+
+struct action act_ill[] = {
+       {"addr mode", 1},
+       {"instruction", 1},
+       {"operand", 0},
+};
+#endif UCBVAX

 
 sigdie(s, t, pc)
 int s; int t; long pc;
 {
 extern unit units[];
 register struct action *act = &sig_act[s-1];
 
 sigdie(s, t, pc)
 int s; int t; long pc;
 {
 extern unit units[];
 register struct action *act = &sig_act[s-1];

-/* clear buffers, then print error message */
-f_exit();
+/* print error message, then flush buffers */
+

 if (act->mesg)
        {
 if (act->mesg)
        {

-#ifdef UCBVAX
-       fprintf(units[STDERR].ufd, "%s", act->mesg);
+#ifdef UCBVAX
+       fprintf(units[STDERR].ufd, "*** %s", act->mesg);

        if (s == SIGFPE)
        if (s == SIGFPE)

-               fprintf(units[STDERR].ufd, ": %s\n", act_fpe[t-1].mesg);
-       else
-               putc('\n', units[STDERR].ufd);
-#else
-       fprintf(units[STDERR].ufd, "%s\n", act->mesg);
-#endif
+               {
+               if (t >= 1 && t <= 10)
+                       fprintf(units[STDERR].ufd, ": %s", act_fpe[t-1].mesg);
+               else
+                       fprintf(units[STDERR].ufd, ": Type=%d?", t);
+               }
+       else if (s == SIGILL)
+               {
+               if (t == 4) t = 2;      /* 4.0bsd botch */
+               if (t >= 0 && t <= 2)
+                       fprintf(units[STDERR].ufd, "%s", act_ill[t].mesg);
+               else
+                       fprintf(units[STDERR].ufd, "compat mode: Code=%d", t);
+               }
+       putc('\n', units[STDERR].ufd);
+#else  UCBVAX
+       fprintf(units[STDERR].ufd, "*** %s\n", act->mesg);
+#endif UCBVAX

        }
        }

+f_exit();

 _cleanup();
 
 if(act->core)
        {
        /* now get a core */
 _cleanup();
 
 if(act->core)
        {
        /* now get a core */

-#ifdef VAX
+#if    vax

        signal(SIGILL, SIG_DFL);
        signal(SIGILL, SIG_DFL);

-#else
+#else  vax

        signal(SIGIOT, SIG_DFL);
        signal(SIGIOT, SIG_DFL);

-#endif
+#endif vax

        abort();
        }
 exit(s);
        abort();
        }
 exit(s);