gdb/ui-file.c - gdb

Global variables defined

Data types defined

Functions defined

Source code

  1. /* UI_FILE - a generic STDIO like output stream.

  3.    Copyright (C) 1999-2015 Free Software Foundation, Inc.

  5.    This file is part of GDB.

  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.

  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.

  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/>.  */

  20. /* Implement the ``struct ui_file'' object.  */

  22. #include "defs.h"
  23. #include "ui-file.h"
  24. #include "gdb_obstack.h"
  25. #include "gdb_select.h"
  26. #include "filestuff.h"

  28. ‌static ui_file_isatty_ftype null_file_isatty;
  29. ‌static ui_file_write_ftype null_file_write;
  30. ‌static ui_file_write_ftype null_file_write_async_safe;
  31. ‌static ui_file_fputs_ftype null_file_fputs;
  32. ‌static ui_file_read_ftype null_file_read;
  33. ‌static ui_file_flush_ftype null_file_flush;
  34. ‌static ui_file_delete_ftype null_file_delete;
  35. ‌static ui_file_rewind_ftype null_file_rewind;
  36. ‌static ui_file_put_ftype null_file_put;
  37. ‌static ui_file_fseek_ftype null_file_fseek;

  39. ‌struct ui_file
  40.   {
  41.     int *magic;
  42.     ui_file_flush_ftype *to_flush;
  43.     ui_file_write_ftype *to_write;
  44.     ui_file_write_async_safe_ftype *to_write_async_safe;
  45.     ui_file_fputs_ftype *to_fputs;
  46.     ui_file_read_ftype *to_read;
  47.     ui_file_delete_ftype *to_delete;
  48.     ui_file_isatty_ftype *to_isatty;
  49.     ui_file_rewind_ftype *to_rewind;
  50.     ui_file_put_ftype *to_put;
  51.     ui_file_fseek_ftype *to_fseek;
  52.     void *to_data;
  53.   };
  54. ‌int ui_file_magic;

  56. struct ui_file *
  57. ‌ui_file_new (void)
  58. {
  59.   struct ui_file *file = xmalloc (sizeof (struct ui_file));

  61.   file->magic = &ui_file_magic;
  62.   set_ui_file_data (file, NULL, null_file_delete);
  63.   set_ui_file_flush (file, null_file_flush);
  64.   set_ui_file_write (file, null_file_write);
  65.   set_ui_file_write_async_safe (file, null_file_write_async_safe);
  66.   set_ui_file_fputs (file, null_file_fputs);
  67.   set_ui_file_read (file, null_file_read);
  68.   set_ui_file_isatty (file, null_file_isatty);
  69.   set_ui_file_rewind (file, null_file_rewind);
  70.   set_ui_file_put (file, null_file_put);
  71.   set_ui_file_fseek (file, null_file_fseek);
  72.   return file;
  73. }

  75. void
  76. ‌ui_file_delete (struct ui_file *file)
  77. {
  78.   file->to_delete (file);
  79.   xfree (file);
  80. }

  82. static int
  83. ‌null_file_isatty (struct ui_file *file)
  84. {
  85.   return 0;
  86. }

  88. static void
  89. ‌null_file_rewind (struct ui_file *file)
  90. {
  91.   return;
  92. }

  94. static void
  95. ‌null_file_put (struct ui_file *file,
  96.                ui_file_put_method_ftype *write,
  97.                void *dest)
  98. {
  99.   return;
  100. }

  102. static void
  103. ‌null_file_flush (struct ui_file *file)
  104. {
  105.   return;
  106. }

  108. static void
  109. ‌null_file_write (struct ui_file *file,
  110.                  const char *buf,
  111.                  long sizeof_buf)
  112. {
  113.   if (file->to_fputs == null_file_fputs)
  114.     /* Both the write and fputs methods are null.  Discard the
  115.        request.  */
  116.     return;
  117.   else
  118.     {
  119.       /* The fputs method isn't null, slowly pass the write request
  120.          onto that.  FYI, this isn't as bad as it may look - the
  121.          current (as of 1999-11-07) printf_* function calls fputc and
  122.          fputc does exactly the below.  By having a write function it
  123.          is possible to clean up that code.  */
  124.       int i;
  125.       char b[2];

  127.       b[1] = '\0';
  128.       for (i = 0; i < sizeof_buf; i++)
  129.         {
  130.           b[0] = buf[i];
  131.           file->to_fputs (b, file);
  132.         }
  133.       return;
  134.     }
  135. }

  137. static long
  138. ‌null_file_read (struct ui_file *file,
  139.                 char *buf,
  140.                 long sizeof_buf)
  141. {
  142.   errno = EBADF;
  143.   return 0;
  144. }

  146. static void
  147. ‌null_file_fputs (const char *buf, struct ui_file *file)
  148. {
  149.   if (file->to_write == null_file_write)
  150.     /* Both the write and fputs methods are null.  Discard the
  151.        request.  */
  152.     return;
  153.   else
  154.     {
  155.       /* The write method was implemented, use that.  */
  156.       file->to_write (file, buf, strlen (buf));
  157.     }
  158. }

  160. static void
  161. ‌null_file_write_async_safe (struct ui_file *file,
  162.                             const char *buf,
  163.                             long sizeof_buf)
  164. {
  165.   return;
  166. }

  168. static void
  169. ‌null_file_delete (struct ui_file *file)
  170. {
  171.   return;
  172. }

  174. static int
  175. ‌null_file_fseek (struct ui_file *stream, long offset, int whence)
  176. {
  177.   errno = EBADF;

  179.   return -1;
  180. }

  182. void *
  183. ‌ui_file_data (struct ui_file *file)
  184. {
  185.   if (file->magic != &ui_file_magic)
  186.     internal_error (__FILE__, __LINE__,
  187.                     _("ui_file_data: bad magic number"));
  188.   return file->to_data;
  189. }

  191. void
  192. ‌gdb_flush (struct ui_file *file)
  193. {
  194.   file->to_flush (file);
  195. }

  197. int
  198. ‌ui_file_isatty (struct ui_file *file)
  199. {
  200.   return file->to_isatty (file);
  201. }

  203. void
  204. ‌ui_file_rewind (struct ui_file *file)
  205. {
  206.   file->to_rewind (file);
  207. }

  209. void
  210. ‌ui_file_put (struct ui_file *file,
  211.               ui_file_put_method_ftype *write,
  212.               void *dest)
  213. {
  214.   file->to_put (file, write, dest);
  215. }

  217. void
  218. ‌ui_file_write (struct ui_file *file,
  219.                 const char *buf,
  220.                 long length_buf)
  221. {
  222.   file->to_write (file, buf, length_buf);
  223. }

  225. void
  226. ‌ui_file_write_for_put (void *data, const char *buffer, long length_buffer)
  227. {
  228.   ui_file_write (data, buffer, length_buffer);
  229. }

  231. void
  232. ‌ui_file_write_async_safe (struct ui_file *file,
  233.                           const char *buf,
  234.                           long length_buf)
  235. {
  236.   file->to_write_async_safe (file, buf, length_buf);
  237. }

  239. long
  240. ‌ui_file_read (struct ui_file *file, char *buf, long length_buf)
  241. {
  242.   return file->to_read (file, buf, length_buf);
  243. }

  245. int
  246. ‌ui_file_fseek (struct ui_file *file, long offset, int whence)
  247. {
  248.   return file->to_fseek (file, offset, whence);
  249. }

  251. void
  252. ‌fputs_unfiltered (const char *buf, struct ui_file *file)
  253. {
  254.   file->to_fputs (buf, file);
  255. }

  257. void
  258. ‌set_ui_file_flush (struct ui_file *file, ui_file_flush_ftype *flush_ptr)
  259. {
  260.   file->to_flush = flush_ptr;
  261. }

  263. void
  264. ‌set_ui_file_isatty (struct ui_file *file, ui_file_isatty_ftype *isatty_ptr)
  265. {
  266.   file->to_isatty = isatty_ptr;
  267. }

  269. void
  270. ‌set_ui_file_rewind (struct ui_file *file, ui_file_rewind_ftype *rewind_ptr)
  271. {
  272.   file->to_rewind = rewind_ptr;
  273. }

  275. void
  276. ‌set_ui_file_put (struct ui_file *file, ui_file_put_ftype *put_ptr)
  277. {
  278.   file->to_put = put_ptr;
  279. }

  281. void
  282. ‌set_ui_file_write (struct ui_file *file,
  283.                     ui_file_write_ftype *write_ptr)
  284. {
  285.   file->to_write = write_ptr;
  286. }

  288. void
  289. ‌set_ui_file_write_async_safe (struct ui_file *file,
  290.                               ui_file_write_async_safe_ftype *write_async_safe_ptr)
  291. {
  292.   file->to_write_async_safe = write_async_safe_ptr;
  293. }

  295. void
  296. ‌set_ui_file_read (struct ui_file *file, ui_file_read_ftype *read_ptr)
  297. {
  298.   file->to_read = read_ptr;
  299. }

  301. void
  302. ‌set_ui_file_fputs (struct ui_file *file, ui_file_fputs_ftype *fputs_ptr)
  303. {
  304.   file->to_fputs = fputs_ptr;
  305. }

  307. void
  308. ‌set_ui_file_fseek (struct ui_file *file, ui_file_fseek_ftype *fseek_ptr)
  309. {
  310.   file->to_fseek = fseek_ptr;
  311. }

  313. void
  314. ‌set_ui_file_data (struct ui_file *file, void *data,
  315.                   ui_file_delete_ftype *delete_ptr)
  316. {
  317.   file->to_data = data;
  318.   file->to_delete = delete_ptr;
  319. }

  321. /* ui_file utility function for converting a ``struct ui_file'' into
  322.    a memory buffer.  */

  324. ‌struct accumulated_ui_file
  325. {
  326.   char *buffer;
  327.   long length;
  328. };

  330. static void
  331. ‌do_ui_file_xstrdup (void *context, const char *buffer, long length)
  332. {
  333.   struct accumulated_ui_file *acc = context;

  335.   if (acc->buffer == NULL)
  336.     acc->buffer = xmalloc (length + 1);
  337.   else
  338.     acc->buffer = xrealloc (acc->buffer, acc->length + length + 1);
  339.   memcpy (acc->buffer + acc->length, buffer, length);
  340.   acc->length += length;
  341.   acc->buffer[acc->length] = '\0';
  342. }

  344. char *
  345. ‌ui_file_xstrdup (struct ui_file *file, long *length)
  346. {
  347.   struct accumulated_ui_file acc;

  349.   acc.buffer = NULL;
  350.   acc.length = 0;
  351.   ui_file_put (file, do_ui_file_xstrdup, &acc);
  352.   if (acc.buffer == NULL)
  353.     acc.buffer = xstrdup ("");
  354.   if (length != NULL)
  355.     *length = acc.length;
  356.   return acc.buffer;
  357. }

  359. static void
  360. ‌do_ui_file_obsavestring (void *context, const char *buffer, long length)
  361. {
  362.   struct obstack *obstack = (struct obstack *) context;

  364.   obstack_grow (obstack, buffer, length);
  365. }

  367. char *
  368. ‌ui_file_obsavestring (struct ui_file *file, struct obstack *obstack,
  369.                       long *length)
  370. {
  371.   ui_file_put (file, do_ui_file_obsavestring, obstack);
  372.   *length = obstack_object_size (obstack);
  373.   obstack_1grow (obstack, '\0');
  374.   return obstack_finish (obstack);
  375. }

  377. /* A pure memory based ``struct ui_file'' that can be used an output
  378.    buffer.  The buffers accumulated contents are available via
  379.    ui_file_put().  */

  381. ‌struct mem_file
  382.   {
  383.     int *magic;
  384.     char *buffer;
  385.     int sizeof_buffer;
  386.     int length_buffer;
  387.   };

  389. ‌static ui_file_rewind_ftype mem_file_rewind;
  390. ‌static ui_file_put_ftype mem_file_put;
  391. ‌static ui_file_write_ftype mem_file_write;
  392. ‌static ui_file_delete_ftype mem_file_delete;
  393. static struct ui_file *mem_file_new (void);
  394. ‌static int mem_file_magic;

  396. static struct ui_file *
  397. ‌mem_file_new (void)
  398. {
  399.   struct mem_file *stream = XNEW (struct mem_file);
  400.   struct ui_file *file = ui_file_new ();

  402.   set_ui_file_data (file, stream, mem_file_delete);
  403.   set_ui_file_rewind (file, mem_file_rewind);
  404.   set_ui_file_put (file, mem_file_put);
  405.   set_ui_file_write (file, mem_file_write);
  406.   stream->magic = &mem_file_magic;
  407.   stream->buffer = NULL;
  408.   stream->sizeof_buffer = 0;
  409.   stream->length_buffer = 0;
  410.   return file;
  411. }

  413. static void
  414. ‌mem_file_delete (struct ui_file *file)
  415. {
  416.   struct mem_file *stream = ui_file_data (file);

  418.   if (stream->magic != &mem_file_magic)
  419.     internal_error (__FILE__, __LINE__,
  420.                     _("mem_file_delete: bad magic number"));
  421.   if (stream->buffer != NULL)
  422.     xfree (stream->buffer);
  423.   xfree (stream);
  424. }

  426. struct ui_file *
  427. ‌mem_fileopen (void)
  428. {
  429.   return mem_file_new ();
  430. }

  432. static void
  433. ‌mem_file_rewind (struct ui_file *file)
  434. {
  435.   struct mem_file *stream = ui_file_data (file);

  437.   if (stream->magic != &mem_file_magic)
  438.     internal_error (__FILE__, __LINE__,
  439.                     _("mem_file_rewind: bad magic number"));
  440.   stream->length_buffer = 0;
  441. }

  443. static void
  444. ‌mem_file_put (struct ui_file *file,
  445.               ui_file_put_method_ftype *write,
  446.               void *dest)
  447. {
  448.   struct mem_file *stream = ui_file_data (file);

  450.   if (stream->magic != &mem_file_magic)
  451.     internal_error (__FILE__, __LINE__,
  452.                     _("mem_file_put: bad magic number"));
  453.   if (stream->length_buffer > 0)
  454.     write (dest, stream->buffer, stream->length_buffer);
  455. }

  457. void
  458. ‌mem_file_write (struct ui_file *file,
  459.                 const char *buffer,
  460.                 long length_buffer)
  461. {
  462.   struct mem_file *stream = ui_file_data (file);

  464.   if (stream->magic != &mem_file_magic)
  465.     internal_error (__FILE__, __LINE__,
  466.                     _("mem_file_write: bad magic number"));
  467.   if (stream->buffer == NULL)
  468.     {
  469.       stream->length_buffer = length_buffer;
  470.       stream->sizeof_buffer = length_buffer;
  471.       stream->buffer = xmalloc (stream->sizeof_buffer);
  472.       memcpy (stream->buffer, buffer, length_buffer);
  473.     }
  474.   else
  475.     {
  476.       int new_length = stream->length_buffer + length_buffer;

  478.       if (new_length >= stream->sizeof_buffer)
  479.         {
  480.           stream->sizeof_buffer = new_length;
  481.           stream->buffer = xrealloc (stream->buffer, stream->sizeof_buffer);
  482.         }
  483.       memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
  484.       stream->length_buffer = new_length;
  485.     }
  486. }

  488. /* ``struct ui_file'' implementation that maps directly onto
  489.    <stdio.h>'s FILE.  */

  491. ‌static ui_file_write_ftype stdio_file_write;
  492. ‌static ui_file_write_async_safe_ftype stdio_file_write_async_safe;
  493. ‌static ui_file_fputs_ftype stdio_file_fputs;
  494. ‌static ui_file_read_ftype stdio_file_read;
  495. ‌static ui_file_isatty_ftype stdio_file_isatty;
  496. ‌static ui_file_delete_ftype stdio_file_delete;
  497. static struct ui_file *stdio_file_new (FILE *file, int close_p);
  498. ‌static ui_file_flush_ftype stdio_file_flush;
  499. ‌static ui_file_fseek_ftype stdio_file_fseek;

  501. ‌static int stdio_file_magic;

  503. ‌struct stdio_file
  504.   {
  505.     int *magic;
  506.     FILE *file;
  507.     /* The associated file descriptor is extracted ahead of time for
  508.        stdio_file_write_async_safe's benefit, in case fileno isn't async-safe.  */
  509.     int fd;
  510.     int close_p;
  511.   };

  513. static struct ui_file *
  514. ‌stdio_file_new (FILE *file, int close_p)
  515. {
  516.   struct ui_file *ui_file = ui_file_new ();
  517.   struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));

  519.   stdio->magic = &stdio_file_magic;
  520.   stdio->file = file;
  521.   stdio->fd = fileno (file);
  522.   stdio->close_p = close_p;
  523.   set_ui_file_data (ui_file, stdio, stdio_file_delete);
  524.   set_ui_file_flush (ui_file, stdio_file_flush);
  525.   set_ui_file_write (ui_file, stdio_file_write);
  526.   set_ui_file_write_async_safe (ui_file, stdio_file_write_async_safe);
  527.   set_ui_file_fputs (ui_file, stdio_file_fputs);
  528.   set_ui_file_read (ui_file, stdio_file_read);
  529.   set_ui_file_isatty (ui_file, stdio_file_isatty);
  530.   set_ui_file_fseek (ui_file, stdio_file_fseek);
  531.   return ui_file;
  532. }

  534. static void
  535. ‌stdio_file_delete (struct ui_file *file)
  536. {
  537.   struct stdio_file *stdio = ui_file_data (file);

  539.   if (stdio->magic != &stdio_file_magic)
  540.     internal_error (__FILE__, __LINE__,
  541.                     _("stdio_file_delete: bad magic number"));
  542.   if (stdio->close_p)
  543.     {
  544.       fclose (stdio->file);
  545.     }
  546.   xfree (stdio);
  547. }

  549. static void
  550. ‌stdio_file_flush (struct ui_file *file)
  551. {
  552.   struct stdio_file *stdio = ui_file_data (file);

  554.   if (stdio->magic != &stdio_file_magic)
  555.     internal_error (__FILE__, __LINE__,
  556.                     _("stdio_file_flush: bad magic number"));
  557.   fflush (stdio->file);
  558. }

  560. static long
  561. ‌stdio_file_read (struct ui_file *file, char *buf, long length_buf)
  562. {
  563.   struct stdio_file *stdio = ui_file_data (file);

  565.   if (stdio->magic != &stdio_file_magic)
  566.     internal_error (__FILE__, __LINE__,
  567.                     _("stdio_file_read: bad magic number"));

  569.   /* For the benefit of Windows, call gdb_select before reading from
  570.      the file.  Wait until at least one byte of data is available.
  571.      Control-C can interrupt gdb_select, but not read.  */
  572.   {
  573.     fd_set readfds;
  574.     FD_ZERO (&readfds);
  575.     FD_SET (stdio->fd, &readfds);
  576.     if (gdb_select (stdio->fd + 1, &readfds, NULL, NULL, NULL) == -1)
  577.       return -1;
  578.   }

  580.   return read (stdio->fd, buf, length_buf);
  581. }

  583. static void
  584. ‌stdio_file_write (struct ui_file *file, const char *buf, long length_buf)
  585. {
  586.   struct stdio_file *stdio = ui_file_data (file);

  588.   if (stdio->magic != &stdio_file_magic)
  589.     internal_error (__FILE__, __LINE__,
  590.                     _("stdio_file_write: bad magic number"));
  591.   /* Calling error crashes when we are called from the exception framework.  */
  592.   if (fwrite (buf, length_buf, 1, stdio->file))
  593.     {
  594.       /* Nothing.  */
  595.     }
  596. }

  598. static void
  599. ‌stdio_file_write_async_safe (struct ui_file *file,
  600.                              const char *buf, long length_buf)
  601. {
  602.   struct stdio_file *stdio = ui_file_data (file);

  604.   if (stdio->magic != &stdio_file_magic)
  605.     {
  606.       /* gettext isn't necessarily async safe, so we can't use _("error message") here.
  607.          We could extract the correct translation ahead of time, but this is an extremely
  608.          rare event, and one of the other stdio_file_* routines will presumably catch
  609.          the problem anyway.  For now keep it simple and ignore the error here.  */
  610.       return;
  611.     }

  613.   /* This is written the way it is to avoid a warning from gcc about not using the
  614.      result of write (since it can be declared with attribute warn_unused_result).
  615.      Alas casting to void doesn't work for this.  */
  616.   if (write (stdio->fd, buf, length_buf))
  617.     {
  618.       /* Nothing.  */
  619.     }
  620. }

  622. static void
  623. ‌stdio_file_fputs (const char *linebuffer, struct ui_file *file)
  624. {
  625.   struct stdio_file *stdio = ui_file_data (file);

  627.   if (stdio->magic != &stdio_file_magic)
  628.     internal_error (__FILE__, __LINE__,
  629.                     _("stdio_file_fputs: bad magic number"));
  630.   /* Calling error crashes when we are called from the exception framework.  */
  631.   if (fputs (linebuffer, stdio->file))
  632.     {
  633.       /* Nothing.  */
  634.     }
  635. }

  637. static int
  638. ‌stdio_file_isatty (struct ui_file *file)
  639. {
  640.   struct stdio_file *stdio = ui_file_data (file);

  642.   if (stdio->magic != &stdio_file_magic)
  643.     internal_error (__FILE__, __LINE__,
  644.                     _("stdio_file_isatty: bad magic number"));
  645.   return (isatty (stdio->fd));
  646. }

  648. static int
  649. ‌stdio_file_fseek (struct ui_file *file, long offset, int whence)
  650. {
  651.   struct stdio_file *stdio = ui_file_data (file);

  653.   if (stdio->magic != &stdio_file_magic)
  654.     internal_error (__FILE__, __LINE__,
  655.                     _("stdio_file_fseek: bad magic number"));

  657.   return fseek (stdio->file, offset, whence);
  658. }

  660. #ifdef __MINGW32__
  661. /* This is the implementation of ui_file method to_write for stderr.
  662.    gdb_stdout is flushed before writing to gdb_stderr.  */

  664. static void
  665. ‌stderr_file_write (struct ui_file *file, const char *buf, long length_buf)
  666. {
  667.   gdb_flush (gdb_stdout);
  668.   stdio_file_write (file, buf, length_buf);
  669. }

  671. /* This is the implementation of ui_file method to_fputs for stderr.
  672.    gdb_stdout is flushed before writing to gdb_stderr.  */

  674. static void
  675. ‌stderr_file_fputs (const char *linebuffer, struct ui_file *file)
  676. {
  677.   gdb_flush (gdb_stdout);
  678.   stdio_file_fputs (linebuffer, file);
  679. }
  680. #endif

  682. struct ui_file *
  683. ‌stderr_fileopen (void)
  684. {
  685.   struct ui_file *ui_file = stdio_fileopen (stderr);

  687. #ifdef __MINGW32__
  688.   /* There is no real line-buffering on Windows, see
  689.      http://msdn.microsoft.com/en-us/library/86cebhfs%28v=vs.71%29.aspx
  690.      so the stdout is either fully-buffered or non-buffered.  We can't
  691.      make stdout non-buffered, because of two concerns,
  692.      1.  non-buffering hurts performance,
  693.      2.  non-buffering may change GDB's behavior when it is interacting
  694.      with front-end, such as Emacs.

  696.      We decided to leave stdout as fully buffered, but flush it first
  697.      when something is written to stderr.  */

  699.   /* Method 'to_write_async_safe' is not overwritten, because there's
  700.      no way to flush a stream in an async-safe manner.  Fortunately,
  701.      it doesn't really matter, because:
  702.      - that method is only used for printing internal debug output
  703.        from signal handlers.
  704.      - Windows hosts don't have a concept of async-safeness.  Signal
  705.        handlers run in a separate thread, so they can call
  706.        the regular non-async-safe output routines freely.  */
  707.   set_ui_file_write (ui_file, stderr_file_write);
  708.   set_ui_file_fputs (ui_file, stderr_file_fputs);
  709. #endif

  711.   return ui_file;
  712. }

  714. /* Like fdopen().  Create a ui_file from a previously opened FILE.  */

  716. struct ui_file *
  717. ‌stdio_fileopen (FILE *file)
  718. {
  719.   return stdio_file_new (file, 0);
  720. }

  722. struct ui_file *
  723. ‌gdb_fopen (const char *name, const char *mode)
  724. {
  725.   FILE *f = gdb_fopen_cloexec (name, mode);

  727.   if (f == NULL)
  728.     return NULL;
  729.   return stdio_file_new (f, 1);
  730. }

  732. /* ``struct ui_file'' implementation that maps onto two ui-file objects.  */

  734. ‌static ui_file_write_ftype tee_file_write;
  735. ‌static ui_file_fputs_ftype tee_file_fputs;
  736. ‌static ui_file_isatty_ftype tee_file_isatty;
  737. ‌static ui_file_delete_ftype tee_file_delete;
  738. ‌static ui_file_flush_ftype tee_file_flush;

  740. ‌static int tee_file_magic;

  742. ‌struct tee_file
  743.   {
  744.     int *magic;
  745.     struct ui_file *one, *two;
  746.     int close_one, close_two;
  747.   };

  749. struct ui_file *
  750. ‌tee_file_new (struct ui_file *one, int close_one,
  751.               struct ui_file *two, int close_two)
  752. {
  753.   struct ui_file *ui_file = ui_file_new ();
  754.   struct tee_file *tee = xmalloc (sizeof (struct tee_file));

  756.   tee->magic = &tee_file_magic;
  757.   tee->one = one;
  758.   tee->two = two;
  759.   tee->close_one = close_one;
  760.   tee->close_two = close_two;
  761.   set_ui_file_data (ui_file, tee, tee_file_delete);
  762.   set_ui_file_flush (ui_file, tee_file_flush);
  763.   set_ui_file_write (ui_file, tee_file_write);
  764.   set_ui_file_fputs (ui_file, tee_file_fputs);
  765.   set_ui_file_isatty (ui_file, tee_file_isatty);
  766.   return ui_file;
  767. }

  769. static void
  770. ‌tee_file_delete (struct ui_file *file)
  771. {
  772.   struct tee_file *tee = ui_file_data (file);

  774.   if (tee->magic != &tee_file_magic)
  775.     internal_error (__FILE__, __LINE__,
  776.                     _("tee_file_delete: bad magic number"));
  777.   if (tee->close_one)
  778.     ui_file_delete (tee->one);
  779.   if (tee->close_two)
  780.     ui_file_delete (tee->two);

  782.   xfree (tee);
  783. }

  785. static void
  786. ‌tee_file_flush (struct ui_file *file)
  787. {
  788.   struct tee_file *tee = ui_file_data (file);

  790.   if (tee->magic != &tee_file_magic)
  791.     internal_error (__FILE__, __LINE__,
  792.                     _("tee_file_flush: bad magic number"));
  793.   tee->one->to_flush (tee->one);
  794.   tee->two->to_flush (tee->two);
  795. }

  797. static void
  798. ‌tee_file_write (struct ui_file *file, const char *buf, long length_buf)
  799. {
  800.   struct tee_file *tee = ui_file_data (file);

  802.   if (tee->magic != &tee_file_magic)
  803.     internal_error (__FILE__, __LINE__,
  804.                     _("tee_file_write: bad magic number"));
  805.   ui_file_write (tee->one, buf, length_buf);
  806.   ui_file_write (tee->two, buf, length_buf);
  807. }

  809. static void
  810. ‌tee_file_fputs (const char *linebuffer, struct ui_file *file)
  811. {
  812.   struct tee_file *tee = ui_file_data (file);

  814.   if (tee->magic != &tee_file_magic)
  815.     internal_error (__FILE__, __LINE__,
  816.                     _("tee_file_fputs: bad magic number"));
  817.   tee->one->to_fputs (linebuffer, tee->one);
  818.   tee->two->to_fputs (linebuffer, tee->two);
  819. }

  821. static int
  822. ‌tee_file_isatty (struct ui_file *file)
  823. {
  824.   struct tee_file *tee = ui_file_data (file);

  826.   if (tee->magic != &tee_file_magic)
  827.     internal_error (__FILE__, __LINE__,
  828.                     _("tee_file_isatty: bad magic number"));

  830.   return ui_file_isatty (tee->one);
  831. }