libgfortran/intrinsics/signal.c

   1 /* Implementation of the SIGNAL and ALARM g77 intrinsics
   2    Contributed by François-Xavier Coudert <coudert@clipper.ens.fr>
   3
   4 This file is part of the GNU Fortran 95 runtime library (libgfortran).
   5
   6 Libgfortran is free software; you can redistribute it and/or
   7 modify it under the terms of the GNU General Public
   8 License as published by the Free Software Foundation; either
   9 version 2 of the License, or (at your option) any later version.
  10
  11 In addition to the permissions in the GNU General Public License, the
  12 Free Software Foundation gives you unlimited permission to link the
  13 compiled version of this file into combinations with other programs,
  14 and to distribute those combinations without any restriction coming
  15 from the use of this file.  (The General Public License restrictions
  16 do apply in other respects; for example, they cover modification of
  17 the file, and distribution when not linked into a combine
  18 executable.)
  19
  20 Libgfortran is distributed in the hope that it will be useful,
  21 but WITHOUT ANY WARRANTY; without even the implied warranty of
  22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23 GNU General Public License for more details.
  24
  25 You should have received a copy of the GNU General Public
  26 License along with libgfortran; see the file COPYING.  If not,
  27 write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  28 Boston, MA 02110-1301, USA.  */
  29
  30 #include "config.h"
  31 #include "libgfortran.h"
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #ifdef HAVE_SIGNAL_H
  38 #include <signal.h>
  39 #endif
  40
  41 #ifdef HAVE_INTTYPES_H
  42 #include <inttypes.h>
  43 #endif
  44
  45 #include <errno.h>
  46
  47 #ifdef HAVE_INTPTR_T
  48 # define INTPTR_T intptr_t
  49 #else
  50 # define INTPTR_T int
  51 #endif
  52
  53 /* SIGNAL subroutine with PROCEDURE as handler  */
  54 extern void signal_sub (int *, void (*)(int), int *);
  55 iexport_proto(signal_sub);
  56
  57 void
  58 signal_sub (int *number, void (*handler)(int), int *status)
  59 {
  60 #ifdef HAVE_SIGNAL
  61   INTPTR_T ret;
  62
  63   if (status != NULL)
  64     {
  65       ret = (INTPTR_T) signal (*number, handler);
  66       *status = (int) ret;
  67     }
  68   else
  69     signal (*number, handler);
  70 #else
  71   errno = ENOSYS;
  72   if (status != NULL)
  73     *status = -1;
  74 #endif
  75 }
  76 iexport(signal_sub);
  77
  78
  79 /* SIGNAL subroutine with INTEGER as handler  */
  80 extern void signal_sub_int (int *, int *, int *);
  81 iexport_proto(signal_sub_int);
  82
  83 void
  84 signal_sub_int (int *number, int *handler, int *status)
  85 {
  86 #ifdef HAVE_SIGNAL
  87   INTPTR_T ptr = *handler, ret;
  88
  89   if (status != NULL)
  90     {
  91       ret = (INTPTR_T) signal (*number, (void (*)(int)) ptr);
  92       *status = (int) ret;
  93     }
  94   else
  95     signal (*number, (void (*)(int)) ptr);
  96 #else
  97   errno = ENOSYS;
  98   if (status != NULL)
  99     *status = -1;
 100 #endif
 101 }
 102 iexport(signal_sub_int);
 103
 104
 105 /* SIGNAL function with PROCEDURE as handler  */
 106 extern int signal_func (int *, void (*)(int));
 107 iexport_proto(signal_func);
 108
 109 int
 110 signal_func (int *number, void (*handler)(int))
 111 {
 112   int status;
 113   signal_sub (number, handler, &status);
 114   return status;
 115 }
 116 iexport(signal_func);
 117
 118
 119 /* SIGNAL function with INTEGER as handler  */
 120 extern int signal_func_int (int *, int *);
 121 iexport_proto(signal_func_int);
 122
 123 int
 124 signal_func_int (int *number, int *handler)
 125 {
 126   int status;
 127   signal_sub_int (number, handler, &status);
 128   return status;
 129 }
 130 iexport(signal_func_int);
 131
 132
 133
 134 /* ALARM intrinsic with PROCEDURE as handler  */
 135 extern void alarm_sub (int *, void (*)(int), int *);
 136 iexport_proto(alarm_sub);
 137
 138 void
 139 alarm_sub (int *seconds, void (*handler)(int), int *status)
 140 {
 141 #if defined (SIGALRM) && defined (HAVE_ALARM) && defined (HAVE_SIGNAL)
 142   if (status != NULL)
 143     {
 144       if (signal (SIGALRM, handler) == SIG_ERR)
 145         *status = -1;
 146       else
 147         *status = alarm (*seconds);
 148     }
 149   else
 150     {
 151       signal (SIGALRM, handler);
 152       alarm (*seconds);
 153     }
 154 #else
 155   errno = ENOSYS;
 156   if (status != NULL)
 157     *status = -1;
 158 #endif
 159 }
 160 iexport(alarm_sub);
 161
 162
 163 /* ALARM intrinsic with INTEGER as handler  */
 164 extern void alarm_sub_int (int *, int *, int *);
 165 iexport_proto(alarm_sub_int);
 166
 167 void
 168 alarm_sub_int (int *seconds, int *handler, int *status)
 169 {
 170 #if defined (SIGALRM) && defined (HAVE_ALARM) && defined (HAVE_SIGNAL)
 171   if (status != NULL)
 172     {
 173       if (signal (SIGALRM, (void (*)(int)) *handler) == SIG_ERR)
 174         *status = -1;
 175       else
 176         *status = alarm (*seconds);
 177     }
 178   else
 179     {
 180       signal (SIGALRM, (void (*)(int)) *handler);
 181       alarm (*seconds);
 182     }
 183 #else
 184   errno = ENOSYS;
 185   if (status != NULL)
 186     *status = -1;
 187 #endif
 188 }
 189 iexport(alarm_sub_int);
 190