gdb/ui-file.c

   1 /* UI_FILE - a generic STDIO like output stream.
   2
   3    Copyright (C) 1999-2017 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 "filestuff.h"
  27
  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;
  38
  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;
  55
  56 struct ui_file *
  57 ui_file_new (void)
  58 {
  59   struct ui_file *file = XNEW (struct ui_file);
  60
  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 }
  74
  75 void
  76 ui_file_delete (struct ui_file *file)
  77 {
  78   file->to_delete (file);
  79   xfree (file);
  80 }
  81
  82 static int
  83 null_file_isatty (struct ui_file *file)
  84 {
  85   return 0;
  86 }
  87
  88 static void
  89 null_file_rewind (struct ui_file *file)
  90 {
  91   return;
  92 }
  93
  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 }
 101
 102 static void
 103 null_file_flush (struct ui_file *file)
 104 {
 105   return;
 106 }
 107
 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];
 126
 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 }
 136
 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 }
 145
 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 }
 159
 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 }
 167
 168 static void
 169 null_file_delete (struct ui_file *file)
 170 {
 171   return;
 172 }
 173
 174 static int
 175 null_file_fseek (struct ui_file *stream, long offset, int whence)
 176 {
 177   errno = EBADF;
 178
 179   return -1;
 180 }
 181
 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 }
 190
 191 void
 192 gdb_flush (struct ui_file *file)
 193 {
 194   file->to_flush (file);
 195 }
 196
 197 int
 198 ui_file_isatty (struct ui_file *file)
 199 {
 200   return file->to_isatty (file);
 201 }
 202
 203 void
 204 ui_file_rewind (struct ui_file *file)
 205 {
 206   file->to_rewind (file);
 207 }
 208
 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 }
 216
 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 }
 224
 225 void
 226 ui_file_write_for_put (void *data, const char *buffer, long length_buffer)
 227 {
 228   ui_file_write ((struct ui_file *) data, buffer, length_buffer);
 229 }
 230
 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 }
 238
 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 }
 244
 245 int
 246 ui_file_fseek (struct ui_file *file, long offset, int whence)
 247 {
 248   return file->to_fseek (file, offset, whence);
 249 }
 250
 251 void
 252 fputs_unfiltered (const char *buf, struct ui_file *file)
 253 {
 254   file->to_fputs (buf, file);
 255 }
 256
 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 }
 262
 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 }
 268
 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 }
 274
 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 }
 280
 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 }
 287
 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 }
 294
 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 }
 300
 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 }
 306
 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 }
 312
 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 }
 320
 321 /* ui_file utility function for converting a ``struct ui_file'' into
 322    a memory buffer.  */
 323
 324 struct accumulated_ui_file
 325 {
 326   char *buffer;
 327   long length;
 328 };
 329
 330 static void
 331 do_ui_file_xstrdup (void *context, const char *buffer, long length)
 332 {
 333   struct accumulated_ui_file *acc = (struct accumulated_ui_file *) context;
 334
 335   if (acc->buffer == NULL)
 336     acc->buffer = (char *) xmalloc (length + 1);
 337   else
 338     acc->buffer = (char *) 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 }
 343
 344 char *
 345 ui_file_xstrdup (struct ui_file *file, long *length)
 346 {
 347   struct accumulated_ui_file acc;
 348
 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 }
 358
 359 /* ui_file utility function for converting a ``struct ui_file'' into a
 360    std:string.  */
 361
 362 static void
 363 do_ui_file_as_string (void *context, const char *buffer, long length)
 364 {
 365   std::string *str = (std::string *) context;
 366
 367   *str = std::string (buffer, length);
 368 }
 369
 370 /* See ui-file.h.  */
 371
 372 std::string
 373 ui_file_as_string (struct ui_file *file)
 374 {
 375   std::string str;
 376
 377   ui_file_put (file, do_ui_file_as_string, &str);
 378   return str;
 379 }
 380
 381 static void
 382 do_ui_file_obsavestring (void *context, const char *buffer, long length)
 383 {
 384   struct obstack *obstack = (struct obstack *) context;
 385
 386   obstack_grow (obstack, buffer, length);
 387 }
 388
 389 char *
 390 ui_file_obsavestring (struct ui_file *file, struct obstack *obstack,
 391                       long *length)
 392 {
 393   ui_file_put (file, do_ui_file_obsavestring, obstack);
 394   *length = obstack_object_size (obstack);
 395   obstack_1grow (obstack, '\0');
 396   return (char *) obstack_finish (obstack);
 397 }
 398 \f
 399 /* A pure memory based ``struct ui_file'' that can be used an output
 400    buffer.  The buffers accumulated contents are available via
 401    ui_file_put().  */
 402
 403 struct mem_file
 404   {
 405     int *magic;
 406     char *buffer;
 407     int sizeof_buffer;
 408     int length_buffer;
 409   };
 410
 411 static ui_file_rewind_ftype mem_file_rewind;
 412 static ui_file_put_ftype mem_file_put;
 413 static ui_file_write_ftype mem_file_write;
 414 static ui_file_delete_ftype mem_file_delete;
 415 static struct ui_file *mem_file_new (void);
 416 static int mem_file_magic;
 417
 418 static struct ui_file *
 419 mem_file_new (void)
 420 {
 421   struct mem_file *stream = XNEW (struct mem_file);
 422   struct ui_file *file = ui_file_new ();
 423
 424   set_ui_file_data (file, stream, mem_file_delete);
 425   set_ui_file_rewind (file, mem_file_rewind);
 426   set_ui_file_put (file, mem_file_put);
 427   set_ui_file_write (file, mem_file_write);
 428   stream->magic = &mem_file_magic;
 429   stream->buffer = NULL;
 430   stream->sizeof_buffer = 0;
 431   stream->length_buffer = 0;
 432   return file;
 433 }
 434
 435 static void
 436 mem_file_delete (struct ui_file *file)
 437 {
 438   struct mem_file *stream = (struct mem_file *) ui_file_data (file);
 439
 440   if (stream->magic != &mem_file_magic)
 441     internal_error (__FILE__, __LINE__,
 442                     _("mem_file_delete: bad magic number"));
 443   if (stream->buffer != NULL)
 444     xfree (stream->buffer);
 445   xfree (stream);
 446 }
 447
 448 struct ui_file *
 449 mem_fileopen (void)
 450 {
 451   return mem_file_new ();
 452 }
 453
 454 static void
 455 mem_file_rewind (struct ui_file *file)
 456 {
 457   struct mem_file *stream = (struct mem_file *) ui_file_data (file);
 458
 459   if (stream->magic != &mem_file_magic)
 460     internal_error (__FILE__, __LINE__,
 461                     _("mem_file_rewind: bad magic number"));
 462   stream->length_buffer = 0;
 463 }
 464
 465 static void
 466 mem_file_put (struct ui_file *file,
 467               ui_file_put_method_ftype *write,
 468               void *dest)
 469 {
 470   struct mem_file *stream = (struct mem_file *) ui_file_data (file);
 471
 472   if (stream->magic != &mem_file_magic)
 473     internal_error (__FILE__, __LINE__,
 474                     _("mem_file_put: bad magic number"));
 475   if (stream->length_buffer > 0)
 476     write (dest, stream->buffer, stream->length_buffer);
 477 }
 478
 479 void
 480 mem_file_write (struct ui_file *file,
 481                 const char *buffer,
 482                 long length_buffer)
 483 {
 484   struct mem_file *stream = (struct mem_file *) ui_file_data (file);
 485
 486   if (stream->magic != &mem_file_magic)
 487     internal_error (__FILE__, __LINE__,
 488                     _("mem_file_write: bad magic number"));
 489   if (stream->buffer == NULL)
 490     {
 491       stream->length_buffer = length_buffer;
 492       stream->sizeof_buffer = length_buffer;
 493       stream->buffer = (char *) xmalloc (stream->sizeof_buffer);
 494       memcpy (stream->buffer, buffer, length_buffer);
 495     }
 496   else
 497     {
 498       int new_length = stream->length_buffer + length_buffer;
 499
 500       if (new_length >= stream->sizeof_buffer)
 501         {
 502           stream->sizeof_buffer = new_length;
 503           stream->buffer
 504             = (char *) xrealloc (stream->buffer, stream->sizeof_buffer);
 505         }
 506       memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
 507       stream->length_buffer = new_length;
 508     }
 509 }
 510 \f
 511 /* ``struct ui_file'' implementation that maps directly onto
 512    <stdio.h>'s FILE.  */
 513
 514 static ui_file_write_ftype stdio_file_write;
 515 static ui_file_write_async_safe_ftype stdio_file_write_async_safe;
 516 static ui_file_fputs_ftype stdio_file_fputs;
 517 static ui_file_read_ftype stdio_file_read;
 518 static ui_file_isatty_ftype stdio_file_isatty;
 519 static ui_file_delete_ftype stdio_file_delete;
 520 static struct ui_file *stdio_file_new (FILE *file, int close_p);
 521 static ui_file_flush_ftype stdio_file_flush;
 522 static ui_file_fseek_ftype stdio_file_fseek;
 523
 524 static int stdio_file_magic;
 525
 526 struct stdio_file
 527   {
 528     int *magic;
 529     FILE *file;
 530     /* The associated file descriptor is extracted ahead of time for
 531        stdio_file_write_async_safe's benefit, in case fileno isn't async-safe.  */
 532     int fd;
 533     int close_p;
 534   };
 535
 536 static struct ui_file *
 537 stdio_file_new (FILE *file, int close_p)
 538 {
 539   struct ui_file *ui_file = ui_file_new ();
 540   struct stdio_file *stdio = XNEW (struct stdio_file);
 541
 542   stdio->magic = &stdio_file_magic;
 543   stdio->file = file;
 544   stdio->fd = fileno (file);
 545   stdio->close_p = close_p;
 546   set_ui_file_data (ui_file, stdio, stdio_file_delete);
 547   set_ui_file_flush (ui_file, stdio_file_flush);
 548   set_ui_file_write (ui_file, stdio_file_write);
 549   set_ui_file_write_async_safe (ui_file, stdio_file_write_async_safe);
 550   set_ui_file_fputs (ui_file, stdio_file_fputs);
 551   set_ui_file_read (ui_file, stdio_file_read);
 552   set_ui_file_isatty (ui_file, stdio_file_isatty);
 553   set_ui_file_fseek (ui_file, stdio_file_fseek);
 554   return ui_file;
 555 }
 556
 557 static void
 558 stdio_file_delete (struct ui_file *file)
 559 {
 560   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 561
 562   if (stdio->magic != &stdio_file_magic)
 563     internal_error (__FILE__, __LINE__,
 564                     _("stdio_file_delete: bad magic number"));
 565   if (stdio->close_p)
 566     {
 567       fclose (stdio->file);
 568     }
 569   xfree (stdio);
 570 }
 571
 572 static void
 573 stdio_file_flush (struct ui_file *file)
 574 {
 575   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 576
 577   if (stdio->magic != &stdio_file_magic)
 578     internal_error (__FILE__, __LINE__,
 579                     _("stdio_file_flush: bad magic number"));
 580   fflush (stdio->file);
 581 }
 582
 583 static long
 584 stdio_file_read (struct ui_file *file, char *buf, long length_buf)
 585 {
 586   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 587
 588   if (stdio->magic != &stdio_file_magic)
 589     internal_error (__FILE__, __LINE__,
 590                     _("stdio_file_read: bad magic number"));
 591
 592   /* Wait until at least one byte of data is available, or we get
 593      interrupted with Control-C.  */
 594   {
 595     fd_set readfds;
 596
 597     FD_ZERO (&readfds);
 598     FD_SET (stdio->fd, &readfds);
 599     if (interruptible_select (stdio->fd + 1, &readfds, NULL, NULL, NULL) == -1)
 600       return -1;
 601   }
 602
 603   return read (stdio->fd, buf, length_buf);
 604 }
 605
 606 static void
 607 stdio_file_write (struct ui_file *file, const char *buf, long length_buf)
 608 {
 609   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 610
 611   if (stdio->magic != &stdio_file_magic)
 612     internal_error (__FILE__, __LINE__,
 613                     _("stdio_file_write: bad magic number"));
 614   /* Calling error crashes when we are called from the exception framework.  */
 615   if (fwrite (buf, length_buf, 1, stdio->file))
 616     {
 617       /* Nothing.  */
 618     }
 619 }
 620
 621 static void
 622 stdio_file_write_async_safe (struct ui_file *file,
 623                              const char *buf, long length_buf)
 624 {
 625   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 626
 627   if (stdio->magic != &stdio_file_magic)
 628     {
 629       /* gettext isn't necessarily async safe, so we can't use _("error message") here.
 630          We could extract the correct translation ahead of time, but this is an extremely
 631          rare event, and one of the other stdio_file_* routines will presumably catch
 632          the problem anyway.  For now keep it simple and ignore the error here.  */
 633       return;
 634     }
 635
 636   /* This is written the way it is to avoid a warning from gcc about not using the
 637      result of write (since it can be declared with attribute warn_unused_result).
 638      Alas casting to void doesn't work for this.  */
 639   if (write (stdio->fd, buf, length_buf))
 640     {
 641       /* Nothing.  */
 642     }
 643 }
 644
 645 static void
 646 stdio_file_fputs (const char *linebuffer, struct ui_file *file)
 647 {
 648   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 649
 650   if (stdio->magic != &stdio_file_magic)
 651     internal_error (__FILE__, __LINE__,
 652                     _("stdio_file_fputs: bad magic number"));
 653   /* Calling error crashes when we are called from the exception framework.  */
 654   if (fputs (linebuffer, stdio->file))
 655     {
 656       /* Nothing.  */
 657     }
 658 }
 659
 660 static int
 661 stdio_file_isatty (struct ui_file *file)
 662 {
 663   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 664
 665   if (stdio->magic != &stdio_file_magic)
 666     internal_error (__FILE__, __LINE__,
 667                     _("stdio_file_isatty: bad magic number"));
 668   return (isatty (stdio->fd));
 669 }
 670
 671 static int
 672 stdio_file_fseek (struct ui_file *file, long offset, int whence)
 673 {
 674   struct stdio_file *stdio = (struct stdio_file *) ui_file_data (file);
 675
 676   if (stdio->magic != &stdio_file_magic)
 677     internal_error (__FILE__, __LINE__,
 678                     _("stdio_file_fseek: bad magic number"));
 679
 680   return fseek (stdio->file, offset, whence);
 681 }
 682
 683 #ifdef __MINGW32__
 684 /* This is the implementation of ui_file method to_write for stderr.
 685    gdb_stdout is flushed before writing to gdb_stderr.  */
 686
 687 static void
 688 stderr_file_write (struct ui_file *file, const char *buf, long length_buf)
 689 {
 690   gdb_flush (gdb_stdout);
 691   stdio_file_write (file, buf, length_buf);
 692 }
 693
 694 /* This is the implementation of ui_file method to_fputs for stderr.
 695    gdb_stdout is flushed before writing to gdb_stderr.  */
 696
 697 static void
 698 stderr_file_fputs (const char *linebuffer, struct ui_file *file)
 699 {
 700   gdb_flush (gdb_stdout);
 701   stdio_file_fputs (linebuffer, file);
 702 }
 703 #endif
 704
 705 struct ui_file *
 706 stderr_fileopen (FILE *stream)
 707 {
 708   struct ui_file *ui_file = stdio_fileopen (stream);
 709
 710 #ifdef __MINGW32__
 711   /* There is no real line-buffering on Windows, see
 712      http://msdn.microsoft.com/en-us/library/86cebhfs%28v=vs.71%29.aspx
 713      so the stdout is either fully-buffered or non-buffered.  We can't
 714      make stdout non-buffered, because of two concerns,
 715      1.  non-buffering hurts performance,
 716      2.  non-buffering may change GDB's behavior when it is interacting
 717      with front-end, such as Emacs.
 718
 719      We decided to leave stdout as fully buffered, but flush it first
 720      when something is written to stderr.  */
 721
 722   /* Method 'to_write_async_safe' is not overwritten, because there's
 723      no way to flush a stream in an async-safe manner.  Fortunately,
 724      it doesn't really matter, because:
 725      - that method is only used for printing internal debug output
 726        from signal handlers.
 727      - Windows hosts don't have a concept of async-safeness.  Signal
 728        handlers run in a separate thread, so they can call
 729        the regular non-async-safe output routines freely.  */
 730   set_ui_file_write (ui_file, stderr_file_write);
 731   set_ui_file_fputs (ui_file, stderr_file_fputs);
 732 #endif
 733
 734   return ui_file;
 735 }
 736
 737 /* Like fdopen().  Create a ui_file from a previously opened FILE.  */
 738
 739 struct ui_file *
 740 stdio_fileopen (FILE *file)
 741 {
 742   return stdio_file_new (file, 0);
 743 }
 744
 745 struct ui_file *
 746 gdb_fopen (const char *name, const char *mode)
 747 {
 748   FILE *f = gdb_fopen_cloexec (name, mode);
 749
 750   if (f == NULL)
 751     return NULL;
 752   return stdio_file_new (f, 1);
 753 }
 754
 755 /* ``struct ui_file'' implementation that maps onto two ui-file objects.  */
 756
 757 static ui_file_write_ftype tee_file_write;
 758 static ui_file_fputs_ftype tee_file_fputs;
 759 static ui_file_isatty_ftype tee_file_isatty;
 760 static ui_file_delete_ftype tee_file_delete;
 761 static ui_file_flush_ftype tee_file_flush;
 762
 763 static int tee_file_magic;
 764
 765 struct tee_file
 766   {
 767     int *magic;
 768     struct ui_file *one, *two;
 769     int close_one, close_two;
 770   };
 771
 772 struct ui_file *
 773 tee_file_new (struct ui_file *one, int close_one,
 774               struct ui_file *two, int close_two)
 775 {
 776   struct ui_file *ui_file = ui_file_new ();
 777   struct tee_file *tee = XNEW (struct tee_file);
 778
 779   tee->magic = &tee_file_magic;
 780   tee->one = one;
 781   tee->two = two;
 782   tee->close_one = close_one;
 783   tee->close_two = close_two;
 784   set_ui_file_data (ui_file, tee, tee_file_delete);
 785   set_ui_file_flush (ui_file, tee_file_flush);
 786   set_ui_file_write (ui_file, tee_file_write);
 787   set_ui_file_fputs (ui_file, tee_file_fputs);
 788   set_ui_file_isatty (ui_file, tee_file_isatty);
 789   return ui_file;
 790 }
 791
 792 static void
 793 tee_file_delete (struct ui_file *file)
 794 {
 795   struct tee_file *tee = (struct tee_file *) ui_file_data (file);
 796
 797   if (tee->magic != &tee_file_magic)
 798     internal_error (__FILE__, __LINE__,
 799                     _("tee_file_delete: bad magic number"));
 800   if (tee->close_one)
 801     ui_file_delete (tee->one);
 802   if (tee->close_two)
 803     ui_file_delete (tee->two);
 804
 805   xfree (tee);
 806 }
 807
 808 static void
 809 tee_file_flush (struct ui_file *file)
 810 {
 811   struct tee_file *tee = (struct tee_file *) ui_file_data (file);
 812
 813   if (tee->magic != &tee_file_magic)
 814     internal_error (__FILE__, __LINE__,
 815                     _("tee_file_flush: bad magic number"));
 816   tee->one->to_flush (tee->one);
 817   tee->two->to_flush (tee->two);
 818 }
 819
 820 static void
 821 tee_file_write (struct ui_file *file, const char *buf, long length_buf)
 822 {
 823   struct tee_file *tee = (struct tee_file *) ui_file_data (file);
 824
 825   if (tee->magic != &tee_file_magic)
 826     internal_error (__FILE__, __LINE__,
 827                     _("tee_file_write: bad magic number"));
 828   ui_file_write (tee->one, buf, length_buf);
 829   ui_file_write (tee->two, buf, length_buf);
 830 }
 831
 832 static void
 833 tee_file_fputs (const char *linebuffer, struct ui_file *file)
 834 {
 835   struct tee_file *tee = (struct tee_file *) ui_file_data (file);
 836
 837   if (tee->magic != &tee_file_magic)
 838     internal_error (__FILE__, __LINE__,
 839                     _("tee_file_fputs: bad magic number"));
 840   tee->one->to_fputs (linebuffer, tee->one);
 841   tee->two->to_fputs (linebuffer, tee->two);
 842 }
 843
 844 static int
 845 tee_file_isatty (struct ui_file *file)
 846 {
 847   struct tee_file *tee = (struct tee_file *) ui_file_data (file);
 848
 849   if (tee->magic != &tee_file_magic)
 850     internal_error (__FILE__, __LINE__,
 851                     _("tee_file_isatty: bad magic number"));
 852
 853   return ui_file_isatty (tee->one);
 854 }