1 /* Implementation of the SIGNAL and ALARM g77 intrinsics
2 Copyright (C) 2005-2023 Free Software Foundation, Inc.
3 Contributed by François-Xavier Coudert <coudert@clipper.ens.fr>
4
5 This file is part of the GNU Fortran runtime library (libgfortran).
6
7 Libgfortran is free software; you can redistribute it and/or
8 modify it under the terms of the GNU General Public
9 License as published by the Free Software Foundation; either
10 version 3 of the License, or (at your option) any later version.
11
12 Libgfortran is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 Under Section 7 of GPL version 3, you are granted additional
18 permissions described in the GCC Runtime Library Exception, version
19 3.1, as published by the Free Software Foundation.
20
21 You should have received a copy of the GNU General Public License and
22 a copy of the GCC Runtime Library Exception along with this program;
23 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 <http://www.gnu.org/licenses/>. */
25
26 #include "libgfortran.h"
27
28 #ifdef HAVE_UNISTD_H
29 #include <unistd.h>
30 #endif
31
32 #include <signal.h>
33
34 #ifdef HAVE_INTTYPES_H
35 #include <inttypes.h>
36 #endif
37
38 #include <errno.h>
39
40 /* SIGNAL subroutine with PROCEDURE as handler */
41 extern void signal_sub (int *, void (*)(int), int *);
42 iexport_proto(signal_sub);
43
44 void
45 signal_sub (int *number, void (*handler)(int), int *status)
46 {
47 intptr_t ret;
48
49 if (status != NULL)
50 {
51 ret = (intptr_t) signal (*number, handler);
52 *status = (int) ret;
53 }
54 else
55 signal (*number, handler);
56 }
57 iexport(signal_sub);
58
59
60 /* SIGNAL subroutine with INTEGER as handler */
61 extern void signal_sub_int (int *, int *, int *);
62 iexport_proto(signal_sub_int);
63
64 void
65 signal_sub_int (int *number, int *handler, int *status)
66 {
67 intptr_t ptr = *handler, ret;
68
69 if (status != NULL)
70 {
71 ret = (intptr_t) signal (*number, (void (*)(int)) ptr);
72 *status = (int) ret;
73 }
74 else
75 signal (*number, (void (*)(int)) ptr);
76 }
77 iexport(signal_sub_int);
78
79
80 /* SIGNAL function with PROCEDURE as handler */
81 extern int signal_func (int *, void (*)(int));
82 iexport_proto(signal_func);
83
84 int
85 signal_func (int *number, void (*handler)(int))
86 {
87 int status;
88 signal_sub (number, handler, &status);
89 return status;
90 }
91 iexport(signal_func);
92
93
94 /* SIGNAL function with INTEGER as handler */
95 extern int signal_func_int (int *, int *);
96 iexport_proto(signal_func_int);
97
98 int
99 signal_func_int (int *number, int *handler)
100 {
101 int status;
102 signal_sub_int (number, handler, &status);
103 return status;
104 }
105 iexport(signal_func_int);
106
107
108
109 /* ALARM intrinsic with PROCEDURE as handler */
110 extern void alarm_sub_i4 (int *, void (*)(int), GFC_INTEGER_4 *);
111 iexport_proto(alarm_sub_i4);
112
113 void
114 alarm_sub_i4 (int * seconds __attribute__ ((unused)),
115 void (*handler)(int) __attribute__ ((unused)),
116 GFC_INTEGER_4 *status)
117 {
118 #if defined (SIGALRM) && defined (HAVE_ALARM)
119 if (status != NULL)
120 {
121 if (signal (SIGALRM, handler) == SIG_ERR)
122 *status = -1;
123 else
124 *status = alarm (*seconds);
125 }
126 else
127 {
128 signal (SIGALRM, handler);
129 alarm (*seconds);
130 }
131 #else
132 errno = ENOSYS;
133 if (status != NULL)
134 *status = -1;
135 #endif
136 }
137 iexport(alarm_sub_i4);
138
139
140 extern void alarm_sub_i8 (int *, void (*)(int), GFC_INTEGER_8 *);
141 iexport_proto(alarm_sub_i8);
142
143 void
144 alarm_sub_i8 (int *seconds __attribute__ ((unused)),
145 void (*handler)(int) __attribute__ ((unused)),
146 GFC_INTEGER_8 *status)
147 {
148 #if defined (SIGALRM) && defined (HAVE_ALARM)
149 if (status != NULL)
150 {
151 if (signal (SIGALRM, handler) == SIG_ERR)
152 *status = -1;
153 else
154 *status = alarm (*seconds);
155 }
156 else
157 {
158 signal (SIGALRM, handler);
159 alarm (*seconds);
160 }
161 #else
162 errno = ENOSYS;
163 if (status != NULL)
164 *status = -1;
165 #endif
166 }
167 iexport(alarm_sub_i8);
168
169
170 /* ALARM intrinsic with INTEGER as handler */
171 extern void alarm_sub_int_i4 (int *, int *, GFC_INTEGER_4 *);
172 iexport_proto(alarm_sub_int_i4);
173
174 void
175 alarm_sub_int_i4 (int *seconds __attribute__ ((unused)),
176 int *handler __attribute__ ((unused)),
177 GFC_INTEGER_4 *status)
178 {
179 #if defined (SIGALRM) && defined (HAVE_ALARM)
180 if (status != NULL)
181 {
182 if (signal (SIGALRM, (void (*)(int)) (intptr_t) *handler) == SIG_ERR)
183 *status = -1;
184 else
185 *status = alarm (*seconds);
186 }
187 else
188 {
189 signal (SIGALRM, (void (*)(int)) (intptr_t) *handler);
190 alarm (*seconds);
191 }
192 #else
193 errno = ENOSYS;
194 if (status != NULL)
195 *status = -1;
196 #endif
197 }
198 iexport(alarm_sub_int_i4);
199
200
201 extern void alarm_sub_int_i8 (int *, int *, GFC_INTEGER_8 *);
202 iexport_proto(alarm_sub_int_i8);
203
204 void
205 alarm_sub_int_i8 (int *seconds __attribute__ ((unused)),
206 int *handler __attribute__ ((unused)),
207 GFC_INTEGER_8 *status)
208 {
209 #if defined (SIGALRM) && defined (HAVE_ALARM)
210 if (status != NULL)
211 {
212 if (signal (SIGALRM, (void (*)(int)) (intptr_t) *handler) == SIG_ERR)
213 *status = -1;
214 else
215 *status = alarm (*seconds);
216 }
217 else
218 {
219 signal (SIGALRM, (void (*)(int)) (intptr_t) *handler);
220 alarm (*seconds);
221 }
222 #else
223 errno = ENOSYS;
224 if (status != NULL)
225 *status = -1;
226 #endif
227 }
228 iexport(alarm_sub_int_i8);
229