1 /* UI_FILE - a generic STDIO like output stream. 2 Copyright (C) 1999-2019 Free Software Foundation, Inc. 3 4 This file is part of GDB. 5 6 This program is free software; you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #ifndef UI_FILE_H 20 #define UI_FILE_H 21 22 #include <string> 23 #include "ui-style.h" 24 25 /* The abstract ui_file base class. */ 26 27 class ui_file 28 { 29 public: 30 ui_file (); 31 virtual ~ui_file () = 0; 32 33 /* Public non-virtual API. */ 34 35 void printf (const char *, ...) ATTRIBUTE_PRINTF (2, 3); 36 37 /* Print a string whose delimiter is QUOTER. Note that these 38 routines should only be called for printing things which are 39 independent of the language of the program being debugged. */ 40 void putstr (const char *str, int quoter); 41 42 void putstrn (const char *str, int n, int quoter); 43 44 int putc (int c); 45 46 void vprintf (const char *, va_list) ATTRIBUTE_PRINTF (2, 0); 47 48 /* Methods below are both public, and overridable by ui_file 49 subclasses. */ 50 51 virtual void write (const char *buf, long length_buf) = 0; 52 53 /* This version of "write" is safe for use in signal handlers. It's 54 not guaranteed that all existing output will have been flushed 55 first. Implementations are also free to ignore some or all of 56 the request. puts_async is not provided as the async versions 57 are rarely used, no point in having both for a rarely used 58 interface. */ 59 virtual void write_async_safe (const char *buf, long length_buf) 60 { gdb_assert_not_reached ("write_async_safe"); } 61 62 /* Some ui_files override this to provide a efficient implementation 63 that avoids a strlen. */ 64 virtual void puts (const char *str) 65 { this->write (str, strlen (str)); } 66 67 virtual long read (char *buf, long length_buf) 68 { gdb_assert_not_reached ("can't read from this file type"); } 69 70 virtual bool isatty () 71 { return false; } 72 73 virtual void flush () 74 {} 75 }; 76 77 typedef std::unique_ptr<ui_file> ui_file_up; 78 79 /* A ui_file that writes to nowhere. */ 80 81 class null_file : public ui_file 82 { 83 public: 84 void write (const char *buf, long length_buf) override; 85 void write_async_safe (const char *buf, long sizeof_buf) override; 86 void puts (const char *str) override; 87 }; 88 89 /* A preallocated null_file stream. */ 90 extern null_file null_stream; 91 92 extern void gdb_flush (ui_file *); 93 94 extern int ui_file_isatty (struct ui_file *); 95 96 extern void ui_file_write (struct ui_file *file, const char *buf, 97 long length_buf); 98 99 extern void ui_file_write_async_safe (struct ui_file *file, const char *buf, 100 long length_buf); 101 102 extern long ui_file_read (struct ui_file *file, char *buf, long length_buf); 103 104 extern int gdb_console_fputs (const char *, FILE *); 105 106 /* A std::string-based ui_file. Can be used as a scratch buffer for 107 collecting output. */ 108 109 class string_file : public ui_file 110 { 111 public: 112 string_file () {} 113 ~string_file () override; 114 115 /* Override ui_file methods. */ 116 117 void write (const char *buf, long length_buf) override; 118 119 long read (char *buf, long length_buf) override 120 { gdb_assert_not_reached ("a string_file is not readable"); } 121 122 /* string_file-specific public API. */ 123 124 /* Accesses the std::string containing the entire output collected 125 so far. 126 127 Returns a non-const reference so that it's easy to move the 128 string contents out of the string_file. E.g.: 129 130 string_file buf; 131 buf.printf (....); 132 buf.printf (....); 133 return std::move (buf.string ()); 134 */ 135 std::string &string () { return m_string; } 136 137 /* Provide a few convenience methods with the same API as the 138 underlying std::string. */ 139 const char *data () const { return m_string.data (); } 140 const char *c_str () const { return m_string.c_str (); } 141 size_t size () const { return m_string.size (); } 142 bool empty () const { return m_string.empty (); } 143 void clear () { return m_string.clear (); } 144 145 private: 146 /* The internal buffer. */ 147 std::string m_string; 148 }; 149 150 /* A ui_file implementation that maps directly onto <stdio.h>'s FILE. 151 A stdio_file can either own its underlying file, or not. If it 152 owns the file, then destroying the stdio_file closes the underlying 153 file, otherwise it is left open. */ 154 155 class stdio_file : public ui_file 156 { 157 public: 158 /* Create a ui_file from a previously opened FILE. CLOSE_P 159 indicates whether the underlying file should be closed when the 160 stdio_file is destroyed. */ 161 explicit stdio_file (FILE *file, bool close_p = false); 162 163 /* Create an stdio_file that is not managing any file yet. Call 164 open to actually open something. */ 165 stdio_file (); 166 167 ~stdio_file () override; 168 169 /* Open NAME in mode MODE, and own the resulting file. Returns true 170 on success, false otherwise. If the stdio_file previously owned 171 a file, it is closed. */ 172 bool open (const char *name, const char *mode); 173 174 void flush () override; 175 176 void write (const char *buf, long length_buf) override; 177 178 void write_async_safe (const char *buf, long length_buf) override; 179 180 void puts (const char *) override; 181 182 long read (char *buf, long length_buf) override; 183 184 bool isatty () override; 185 186 private: 187 /* Sets the internal stream to FILE, and saves the FILE's file 188 descriptor in M_FD. */ 189 void set_stream (FILE *file); 190 191 /* The file. */ 192 FILE *m_file; 193 194 /* The associated file descriptor is extracted ahead of time for 195 stdio_file::write_async_safe's benefit, in case fileno isn't 196 async-safe. */ 197 int m_fd; 198 199 /* If true, M_FILE is closed on destruction. */ 200 bool m_close_p; 201 }; 202 203 typedef std::unique_ptr<stdio_file> stdio_file_up; 204 205 /* Like stdio_file, but specifically for stderr. 206 207 This exists because there is no real line-buffering on Windows, see 208 <http://msdn.microsoft.com/en-us/library/86cebhfs%28v=vs.71%29.aspx> 209 so the stdout is either fully-buffered or non-buffered. We can't 210 make stdout non-buffered, because of two concerns: 211 212 1. Non-buffering hurts performance. 213 2. Non-buffering may change GDB's behavior when it is interacting 214 with a front-end, such as Emacs. 215 216 We leave stdout as fully buffered, but flush it first when 217 something is written to stderr. 218 219 Note that the 'write_async_safe' method is not overridden, because 220 there's no way to flush a stream in an async-safe manner. 221 Fortunately, it doesn't really matter, because: 222 223 1. That method is only used for printing internal debug output 224 from signal handlers. 225 226 2. Windows hosts don't have a concept of async-safeness. Signal 227 handlers run in a separate thread, so they can call the regular 228 non-async-safe output routines freely. 229 */ 230 class stderr_file : public stdio_file 231 { 232 public: 233 explicit stderr_file (FILE *stream); 234 235 /* Override the output routines to flush gdb_stdout before deferring 236 to stdio_file for the actual outputting. */ 237 void write (const char *buf, long length_buf) override; 238 void puts (const char *linebuffer) override; 239 }; 240 241 /* A ui_file implementation that maps onto two ui-file objects. */ 242 243 class tee_file : public ui_file 244 { 245 public: 246 /* Create a file which writes to both ONE and TWO. CLOSE_ONE and 247 CLOSE_TWO indicate whether the original files should be closed 248 when the new file is closed. */ 249 tee_file (ui_file *one, bool close_one, 250 ui_file *two, bool close_two); 251 ~tee_file () override; 252 253 void write (const char *buf, long length_buf) override; 254 void write_async_safe (const char *buf, long length_buf) override; 255 void puts (const char *) override; 256 257 bool isatty () override; 258 void flush () override; 259 260 private: 261 /* The two underlying ui_files, and whether they should each be 262 closed on destruction. */ 263 ui_file *m_one, *m_two; 264 bool m_close_one, m_close_two; 265 }; 266 267 #endif 268