Suppress SIGTTOU when handling errors
[external/binutils.git] / gdb / ui-file.c
1 /* UI_FILE - a generic STDIO like output stream.
2
3    Copyright (C) 1999-2019 Free Software Foundation, Inc.
4
5    This file is part of GDB.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program 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    You should have received a copy of the GNU General Public License
18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
19
20 /* Implement the ``struct ui_file'' object.  */
21
22 #include "defs.h"
23 #include "ui-file.h"
24 #include "gdb_obstack.h"
25 #include "gdb_select.h"
26 #include "common/filestuff.h"
27
28 null_file null_stream;
29
30 ui_file::ui_file ()
31 {}
32
33 ui_file::~ui_file ()
34 {}
35
36 void
37 ui_file::printf (const char *format, ...)
38 {
39   va_list args;
40
41   va_start (args, format);
42   vfprintf_unfiltered (this, format, args);
43   va_end (args);
44 }
45
46 void
47 ui_file::putstr (const char *str, int quoter)
48 {
49   fputstr_unfiltered (str, quoter, this);
50 }
51
52 void
53 ui_file::putstrn (const char *str, int n, int quoter)
54 {
55   fputstrn_unfiltered (str, n, quoter, fputc_unfiltered, this);
56 }
57
58 int
59 ui_file::putc (int c)
60 {
61   return fputc_unfiltered (c, this);
62 }
63
64 void
65 ui_file::vprintf (const char *format, va_list args)
66 {
67   vfprintf_unfiltered (this, format, args);
68 }
69
70 \f
71
72 void
73 null_file::write (const char *buf, long sizeof_buf)
74 {
75   /* Discard the request.  */
76 }
77
78 void
79 null_file::puts (const char *)
80 {
81   /* Discard the request.  */
82 }
83
84 void
85 null_file::write_async_safe (const char *buf, long sizeof_buf)
86 {
87   /* Discard the request.  */
88 }
89
90 \f
91
92 void
93 gdb_flush (struct ui_file *file)
94 {
95   file->flush ();
96 }
97
98 int
99 ui_file_isatty (struct ui_file *file)
100 {
101   return file->isatty ();
102 }
103
104 void
105 ui_file_write (struct ui_file *file,
106                 const char *buf,
107                 long length_buf)
108 {
109   file->write (buf, length_buf);
110 }
111
112 void
113 ui_file_write_async_safe (struct ui_file *file,
114                           const char *buf,
115                           long length_buf)
116 {
117   file->write_async_safe (buf, length_buf);
118 }
119
120 long
121 ui_file_read (struct ui_file *file, char *buf, long length_buf)
122 {
123   return file->read (buf, length_buf);
124 }
125
126 void
127 fputs_unfiltered (const char *buf, struct ui_file *file)
128 {
129   file->puts (buf);
130 }
131
132 \f
133
134 string_file::~string_file ()
135 {}
136
137 void
138 string_file::write (const char *buf, long length_buf)
139 {
140   m_string.append (buf, length_buf);
141 }
142
143 \f
144
145 stdio_file::stdio_file (FILE *file, bool close_p)
146 {
147   set_stream (file);
148   m_close_p = close_p;
149 }
150
151 stdio_file::stdio_file ()
152   : m_file (NULL),
153     m_fd (-1),
154     m_close_p (false)
155 {}
156
157 stdio_file::~stdio_file ()
158 {
159   if (m_close_p)
160     fclose (m_file);
161 }
162
163 void
164 stdio_file::set_stream (FILE *file)
165 {
166   m_file = file;
167   m_fd = fileno (file);
168 }
169
170 bool
171 stdio_file::open (const char *name, const char *mode)
172 {
173   /* Close the previous stream, if we own it.  */
174   if (m_close_p)
175     {
176       fclose (m_file);
177       m_close_p = false;
178     }
179
180   gdb_file_up f = gdb_fopen_cloexec (name, mode);
181
182   if (f == NULL)
183     return false;
184
185   set_stream (f.release ());
186   m_close_p = true;
187
188   return true;
189 }
190
191 void
192 stdio_file::flush ()
193 {
194   fflush (m_file);
195 }
196
197 long
198 stdio_file::read (char *buf, long length_buf)
199 {
200   /* Wait until at least one byte of data is available, or we get
201      interrupted with Control-C.  */
202   {
203     fd_set readfds;
204
205     FD_ZERO (&readfds);
206     FD_SET (m_fd, &readfds);
207     if (interruptible_select (m_fd + 1, &readfds, NULL, NULL, NULL) == -1)
208       return -1;
209   }
210
211   return ::read (m_fd, buf, length_buf);
212 }
213
214 void
215 stdio_file::write (const char *buf, long length_buf)
216 {
217   /* Calling error crashes when we are called from the exception framework.  */
218   if (fwrite (buf, length_buf, 1, m_file))
219     {
220       /* Nothing.  */
221     }
222 }
223
224 void
225 stdio_file::write_async_safe (const char *buf, long length_buf)
226 {
227   /* This is written the way it is to avoid a warning from gcc about not using the
228      result of write (since it can be declared with attribute warn_unused_result).
229      Alas casting to void doesn't work for this.  */
230   if (::write (m_fd, buf, length_buf))
231     {
232       /* Nothing.  */
233     }
234 }
235
236 void
237 stdio_file::puts (const char *linebuffer)
238 {
239   /* This host-dependent function (with implementations in
240      posix-hdep.c and mingw-hdep.c) is given the opportunity to
241      process the output first in host-dependent way.  If it does, it
242      should return non-zero, to avoid calling fputs below.  */
243   if (gdb_console_fputs (linebuffer, m_file))
244     return;
245   /* Calling error crashes when we are called from the exception framework.  */
246   if (fputs (linebuffer, m_file))
247     {
248       /* Nothing.  */
249     }
250 }
251
252 bool
253 stdio_file::isatty ()
254 {
255   return ::isatty (m_fd);
256 }
257
258 \f
259
260 /* This is the implementation of ui_file method 'write' for stderr.
261    gdb_stdout is flushed before writing to gdb_stderr.  */
262
263 void
264 stderr_file::write (const char *buf, long length_buf)
265 {
266   gdb_flush (gdb_stdout);
267   stdio_file::write (buf, length_buf);
268 }
269
270 /* This is the implementation of ui_file method 'puts' for stderr.
271    gdb_stdout is flushed before writing to gdb_stderr.  */
272
273 void
274 stderr_file::puts (const char *linebuffer)
275 {
276   gdb_flush (gdb_stdout);
277   stdio_file::puts (linebuffer);
278 }
279
280 stderr_file::stderr_file (FILE *stream)
281   : stdio_file (stream)
282 {}
283
284 \f
285
286 tee_file::tee_file (ui_file *one, bool close_one,
287                     ui_file *two, bool close_two)
288   : m_one (one),
289     m_two (two),
290     m_close_one (close_one),
291     m_close_two (close_two)
292 {}
293
294 tee_file::~tee_file ()
295 {
296   if (m_close_one)
297     delete m_one;
298   if (m_close_two)
299     delete m_two;
300 }
301
302 void
303 tee_file::flush ()
304 {
305   m_one->flush ();
306   m_two->flush ();
307 }
308
309 void
310 tee_file::write (const char *buf, long length_buf)
311 {
312   m_one->write (buf, length_buf);
313   m_two->write (buf, length_buf);
314 }
315
316 void
317 tee_file::write_async_safe (const char *buf, long length_buf)
318 {
319   m_one->write_async_safe (buf, length_buf);
320   m_two->write_async_safe (buf, length_buf);
321 }
322
323 void
324 tee_file::puts (const char *linebuffer)
325 {
326   m_one->puts (linebuffer);
327   m_two->puts (linebuffer);
328 }
329
330 bool
331 tee_file::isatty ()
332 {
333   return m_one->isatty ();
334 }