gdb/ui-file.c

   1 /* UI_FILE - a generic STDIO like output stream.
   2
   3    Copyright (C) 1999, 2000, 2001, 2002, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 /* Implement the ``struct ui_file'' object.  */
  22
  23 #include "defs.h"
  24 #include "ui-file.h"
  25 #include "gdb_obstack.h"
  26 #include "gdb_string.h"
  27 #include "gdb_select.h"
  28
  29 #include <errno.h>
  30
  31 static ui_file_isatty_ftype null_file_isatty;
  32 static ui_file_write_ftype null_file_write;
  33 static ui_file_fputs_ftype null_file_fputs;
  34 static ui_file_read_ftype null_file_read;
  35 static ui_file_flush_ftype null_file_flush;
  36 static ui_file_delete_ftype null_file_delete;
  37 static ui_file_rewind_ftype null_file_rewind;
  38 static ui_file_put_ftype null_file_put;
  39
  40 struct ui_file
  41   {
  42     int *magic;
  43     ui_file_flush_ftype *to_flush;
  44     ui_file_write_ftype *to_write;
  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     void *to_data;
  52   };
  53 int ui_file_magic;
  54
  55 struct ui_file *
  56 ui_file_new (void)
  57 {
  58   struct ui_file *file = xmalloc (sizeof (struct ui_file));
  59
  60   file->magic = &ui_file_magic;
  61   set_ui_file_data (file, NULL, null_file_delete);
  62   set_ui_file_flush (file, null_file_flush);
  63   set_ui_file_write (file, null_file_write);
  64   set_ui_file_fputs (file, null_file_fputs);
  65   set_ui_file_read (file, null_file_read);
  66   set_ui_file_isatty (file, null_file_isatty);
  67   set_ui_file_rewind (file, null_file_rewind);
  68   set_ui_file_put (file, null_file_put);
  69   return file;
  70 }
  71
  72 void
  73 ui_file_delete (struct ui_file *file)
  74 {
  75   file->to_delete (file);
  76   xfree (file);
  77 }
  78
  79 static int
  80 null_file_isatty (struct ui_file *file)
  81 {
  82   return 0;
  83 }
  84
  85 static void
  86 null_file_rewind (struct ui_file *file)
  87 {
  88   return;
  89 }
  90
  91 static void
  92 null_file_put (struct ui_file *file,
  93                ui_file_put_method_ftype *write,
  94                void *dest)
  95 {
  96   return;
  97 }
  98
  99 static void
 100 null_file_flush (struct ui_file *file)
 101 {
 102   return;
 103 }
 104
 105 static void
 106 null_file_write (struct ui_file *file,
 107                  const char *buf,
 108                  long sizeof_buf)
 109 {
 110   if (file->to_fputs == null_file_fputs)
 111     /* Both the write and fputs methods are null.  Discard the
 112        request.  */
 113     return;
 114   else
 115     {
 116       /* The fputs method isn't null, slowly pass the write request
 117          onto that.  FYI, this isn't as bad as it may look - the
 118          current (as of 1999-11-07) printf_* function calls fputc and
 119          fputc does exactly the below.  By having a write function it
 120          is possible to clean up that code.  */
 121       int i;
 122       char b[2];
 123
 124       b[1] = '\0';
 125       for (i = 0; i < sizeof_buf; i++)
 126         {
 127           b[0] = buf[i];
 128           file->to_fputs (b, file);
 129         }
 130       return;
 131     }
 132 }
 133
 134 static long
 135 null_file_read (struct ui_file *file,
 136                 char *buf,
 137                 long sizeof_buf)
 138 {
 139   errno = EBADF;
 140   return 0;
 141 }
 142
 143 static void
 144 null_file_fputs (const char *buf, struct ui_file *file)
 145 {
 146   if (file->to_write == null_file_write)
 147     /* Both the write and fputs methods are null.  Discard the
 148        request.  */
 149     return;
 150   else
 151     {
 152       /* The write method was implemented, use that.  */
 153       file->to_write (file, buf, strlen (buf));
 154     }
 155 }
 156
 157 static void
 158 null_file_delete (struct ui_file *file)
 159 {
 160   return;
 161 }
 162
 163 void *
 164 ui_file_data (struct ui_file *file)
 165 {
 166   if (file->magic != &ui_file_magic)
 167     internal_error (__FILE__, __LINE__,
 168                     _("ui_file_data: bad magic number"));
 169   return file->to_data;
 170 }
 171
 172 void
 173 gdb_flush (struct ui_file *file)
 174 {
 175   file->to_flush (file);
 176 }
 177
 178 int
 179 ui_file_isatty (struct ui_file *file)
 180 {
 181   return file->to_isatty (file);
 182 }
 183
 184 void
 185 ui_file_rewind (struct ui_file *file)
 186 {
 187   file->to_rewind (file);
 188 }
 189
 190 void
 191 ui_file_put (struct ui_file *file,
 192               ui_file_put_method_ftype *write,
 193               void *dest)
 194 {
 195   file->to_put (file, write, dest);
 196 }
 197
 198 void
 199 ui_file_write (struct ui_file *file,
 200                 const char *buf,
 201                 long length_buf)
 202 {
 203   file->to_write (file, buf, length_buf);
 204 }
 205
 206 long
 207 ui_file_read (struct ui_file *file, char *buf, long length_buf)
 208 {
 209   return file->to_read (file, buf, length_buf);
 210 }
 211
 212 void
 213 fputs_unfiltered (const char *buf, struct ui_file *file)
 214 {
 215   file->to_fputs (buf, file);
 216 }
 217
 218 void
 219 set_ui_file_flush (struct ui_file *file, ui_file_flush_ftype *flush)
 220 {
 221   file->to_flush = flush;
 222 }
 223
 224 void
 225 set_ui_file_isatty (struct ui_file *file, ui_file_isatty_ftype *isatty)
 226 {
 227   file->to_isatty = isatty;
 228 }
 229
 230 void
 231 set_ui_file_rewind (struct ui_file *file, ui_file_rewind_ftype *rewind)
 232 {
 233   file->to_rewind = rewind;
 234 }
 235
 236 void
 237 set_ui_file_put (struct ui_file *file, ui_file_put_ftype *put)
 238 {
 239   file->to_put = put;
 240 }
 241
 242 void
 243 set_ui_file_write (struct ui_file *file,
 244                     ui_file_write_ftype *write)
 245 {
 246   file->to_write = write;
 247 }
 248
 249 void
 250 set_ui_file_read (struct ui_file *file, ui_file_read_ftype *read)
 251 {
 252   file->to_read = read;
 253 }
 254
 255 void
 256 set_ui_file_fputs (struct ui_file *file, ui_file_fputs_ftype *fputs)
 257 {
 258   file->to_fputs = fputs;
 259 }
 260
 261 void
 262 set_ui_file_data (struct ui_file *file, void *data,
 263                   ui_file_delete_ftype *delete)
 264 {
 265   file->to_data = data;
 266   file->to_delete = delete;
 267 }
 268
 269 /* ui_file utility function for converting a ``struct ui_file'' into
 270    a memory buffer.  */
 271
 272 struct accumulated_ui_file
 273 {
 274   char *buffer;
 275   long length;
 276 };
 277
 278 static void
 279 do_ui_file_xstrdup (void *context, const char *buffer, long length)
 280 {
 281   struct accumulated_ui_file *acc = context;
 282
 283   if (acc->buffer == NULL)
 284     acc->buffer = xmalloc (length + 1);
 285   else
 286     acc->buffer = xrealloc (acc->buffer, acc->length + length + 1);
 287   memcpy (acc->buffer + acc->length, buffer, length);
 288   acc->length += length;
 289   acc->buffer[acc->length] = '\0';
 290 }
 291
 292 char *
 293 ui_file_xstrdup (struct ui_file *file, long *length)
 294 {
 295   struct accumulated_ui_file acc;
 296
 297   acc.buffer = NULL;
 298   acc.length = 0;
 299   ui_file_put (file, do_ui_file_xstrdup, &acc);
 300   if (acc.buffer == NULL)
 301     acc.buffer = xstrdup ("");
 302   if (length != NULL)
 303     *length = acc.length;
 304   return acc.buffer;
 305 }
 306
 307 static void
 308 do_ui_file_obsavestring (void *context, const char *buffer, long length)
 309 {
 310   struct obstack *obstack = (struct obstack *) context;
 311
 312   obstack_grow (obstack, buffer, length);
 313 }
 314
 315 char *
 316 ui_file_obsavestring (struct ui_file *file, struct obstack *obstack,
 317                       long *length)
 318 {
 319   ui_file_put (file, do_ui_file_obsavestring, obstack);
 320   *length = obstack_object_size (obstack);
 321   obstack_1grow (obstack, '\0');
 322   return obstack_finish (obstack);
 323 }
 324 \f
 325 /* A pure memory based ``struct ui_file'' that can be used an output
 326    buffer.  The buffers accumulated contents are available via
 327    ui_file_put().  */
 328
 329 struct mem_file
 330   {
 331     int *magic;
 332     char *buffer;
 333     int sizeof_buffer;
 334     int length_buffer;
 335   };
 336
 337 static ui_file_rewind_ftype mem_file_rewind;
 338 static ui_file_put_ftype mem_file_put;
 339 static ui_file_write_ftype mem_file_write;
 340 static ui_file_delete_ftype mem_file_delete;
 341 static struct ui_file *mem_file_new (void);
 342 static int mem_file_magic;
 343
 344 static struct ui_file *
 345 mem_file_new (void)
 346 {
 347   struct mem_file *stream = XMALLOC (struct mem_file);
 348   struct ui_file *file = ui_file_new ();
 349
 350   set_ui_file_data (file, stream, mem_file_delete);
 351   set_ui_file_rewind (file, mem_file_rewind);
 352   set_ui_file_put (file, mem_file_put);
 353   set_ui_file_write (file, mem_file_write);
 354   stream->magic = &mem_file_magic;
 355   stream->buffer = NULL;
 356   stream->sizeof_buffer = 0;
 357   stream->length_buffer = 0;
 358   return file;
 359 }
 360
 361 static void
 362 mem_file_delete (struct ui_file *file)
 363 {
 364   struct mem_file *stream = ui_file_data (file);
 365
 366   if (stream->magic != &mem_file_magic)
 367     internal_error (__FILE__, __LINE__,
 368                     _("mem_file_delete: bad magic number"));
 369   if (stream->buffer != NULL)
 370     xfree (stream->buffer);
 371   xfree (stream);
 372 }
 373
 374 struct ui_file *
 375 mem_fileopen (void)
 376 {
 377   return mem_file_new ();
 378 }
 379
 380 static void
 381 mem_file_rewind (struct ui_file *file)
 382 {
 383   struct mem_file *stream = ui_file_data (file);
 384
 385   if (stream->magic != &mem_file_magic)
 386     internal_error (__FILE__, __LINE__,
 387                     _("mem_file_rewind: bad magic number"));
 388   stream->length_buffer = 0;
 389 }
 390
 391 static void
 392 mem_file_put (struct ui_file *file,
 393               ui_file_put_method_ftype *write,
 394               void *dest)
 395 {
 396   struct mem_file *stream = ui_file_data (file);
 397
 398   if (stream->magic != &mem_file_magic)
 399     internal_error (__FILE__, __LINE__,
 400                     _("mem_file_put: bad magic number"));
 401   if (stream->length_buffer > 0)
 402     write (dest, stream->buffer, stream->length_buffer);
 403 }
 404
 405 void
 406 mem_file_write (struct ui_file *file,
 407                 const char *buffer,
 408                 long length_buffer)
 409 {
 410   struct mem_file *stream = ui_file_data (file);
 411
 412   if (stream->magic != &mem_file_magic)
 413     internal_error (__FILE__, __LINE__,
 414                     _("mem_file_write: bad magic number"));
 415   if (stream->buffer == NULL)
 416     {
 417       stream->length_buffer = length_buffer;
 418       stream->sizeof_buffer = length_buffer;
 419       stream->buffer = xmalloc (stream->sizeof_buffer);
 420       memcpy (stream->buffer, buffer, length_buffer);
 421     }
 422   else
 423     {
 424       int new_length = stream->length_buffer + length_buffer;
 425
 426       if (new_length >= stream->sizeof_buffer)
 427         {
 428           stream->sizeof_buffer = new_length;
 429           stream->buffer = xrealloc (stream->buffer, stream->sizeof_buffer);
 430         }
 431       memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
 432       stream->length_buffer = new_length;
 433     }
 434 }
 435 \f
 436 /* ``struct ui_file'' implementation that maps directly onto
 437    <stdio.h>'s FILE.  */
 438
 439 static ui_file_write_ftype stdio_file_write;
 440 static ui_file_fputs_ftype stdio_file_fputs;
 441 static ui_file_read_ftype stdio_file_read;
 442 static ui_file_isatty_ftype stdio_file_isatty;
 443 static ui_file_delete_ftype stdio_file_delete;
 444 static struct ui_file *stdio_file_new (FILE *file, int close_p);
 445 static ui_file_flush_ftype stdio_file_flush;
 446
 447 static int stdio_file_magic;
 448
 449 struct stdio_file
 450   {
 451     int *magic;
 452     FILE *file;
 453     int close_p;
 454   };
 455
 456 static struct ui_file *
 457 stdio_file_new (FILE *file, int close_p)
 458 {
 459   struct ui_file *ui_file = ui_file_new ();
 460   struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));
 461
 462   stdio->magic = &stdio_file_magic;
 463   stdio->file = file;
 464   stdio->close_p = close_p;
 465   set_ui_file_data (ui_file, stdio, stdio_file_delete);
 466   set_ui_file_flush (ui_file, stdio_file_flush);
 467   set_ui_file_write (ui_file, stdio_file_write);
 468   set_ui_file_fputs (ui_file, stdio_file_fputs);
 469   set_ui_file_read (ui_file, stdio_file_read);
 470   set_ui_file_isatty (ui_file, stdio_file_isatty);
 471   return ui_file;
 472 }
 473
 474 static void
 475 stdio_file_delete (struct ui_file *file)
 476 {
 477   struct stdio_file *stdio = ui_file_data (file);
 478
 479   if (stdio->magic != &stdio_file_magic)
 480     internal_error (__FILE__, __LINE__,
 481                     _("stdio_file_delete: bad magic number"));
 482   if (stdio->close_p)
 483     {
 484       fclose (stdio->file);
 485     }
 486   xfree (stdio);
 487 }
 488
 489 static void
 490 stdio_file_flush (struct ui_file *file)
 491 {
 492   struct stdio_file *stdio = ui_file_data (file);
 493
 494   if (stdio->magic != &stdio_file_magic)
 495     internal_error (__FILE__, __LINE__,
 496                     _("stdio_file_flush: bad magic number"));
 497   fflush (stdio->file);
 498 }
 499
 500 static long
 501 stdio_file_read (struct ui_file *file, char *buf, long length_buf)
 502 {
 503   struct stdio_file *stdio = ui_file_data (file);
 504
 505   if (stdio->magic != &stdio_file_magic)
 506     internal_error (__FILE__, __LINE__,
 507                     _("stdio_file_read: bad magic number"));
 508
 509   /* For the benefit of Windows, call gdb_select before reading from
 510      the file.  Wait until at least one byte of data is available.
 511      Control-C can interrupt gdb_select, but not read.  */
 512   {
 513     int fd = fileno (stdio->file);
 514
 515     fd_set readfds;
 516     FD_ZERO (&readfds);
 517     FD_SET (fd, &readfds);
 518     if (gdb_select (fd + 1, &readfds, NULL, NULL, NULL) == -1)
 519       return -1;
 520   }
 521
 522   return read (fileno (stdio->file), buf, length_buf);
 523 }
 524
 525 static void
 526 stdio_file_write (struct ui_file *file, const char *buf, long length_buf)
 527 {
 528   struct stdio_file *stdio = ui_file_data (file);
 529
 530   if (stdio->magic != &stdio_file_magic)
 531     internal_error (__FILE__, __LINE__,
 532                     _("stdio_file_write: bad magic number"));
 533   /* Calling error crashes when we are called from the exception framework.  */
 534   if (fwrite (buf, length_buf, 1, stdio->file))
 535     ;
 536 }
 537
 538 static void
 539 stdio_file_fputs (const char *linebuffer, struct ui_file *file)
 540 {
 541   struct stdio_file *stdio = ui_file_data (file);
 542
 543   if (stdio->magic != &stdio_file_magic)
 544     internal_error (__FILE__, __LINE__,
 545                     _("stdio_file_fputs: bad magic number"));
 546   /* Calling error crashes when we are called from the exception framework.  */
 547   if (fputs (linebuffer, stdio->file))
 548     ;
 549 }
 550
 551 static int
 552 stdio_file_isatty (struct ui_file *file)
 553 {
 554   struct stdio_file *stdio = ui_file_data (file);
 555
 556   if (stdio->magic != &stdio_file_magic)
 557     internal_error (__FILE__, __LINE__,
 558                     _("stdio_file_isatty: bad magic number"));
 559   return (isatty (fileno (stdio->file)));
 560 }
 561
 562 /* Like fdopen().  Create a ui_file from a previously opened FILE.  */
 563
 564 struct ui_file *
 565 stdio_fileopen (FILE *file)
 566 {
 567   return stdio_file_new (file, 0);
 568 }
 569
 570 struct ui_file *
 571 gdb_fopen (char *name, char *mode)
 572 {
 573   FILE *f = fopen (name, mode);
 574
 575   if (f == NULL)
 576     return NULL;
 577   return stdio_file_new (f, 1);
 578 }
 579
 580 /* ``struct ui_file'' implementation that maps onto two ui-file objects.  */
 581
 582 static ui_file_write_ftype tee_file_write;
 583 static ui_file_fputs_ftype tee_file_fputs;
 584 static ui_file_isatty_ftype tee_file_isatty;
 585 static ui_file_delete_ftype tee_file_delete;
 586 static ui_file_flush_ftype tee_file_flush;
 587
 588 static int tee_file_magic;
 589
 590 struct tee_file
 591   {
 592     int *magic;
 593     struct ui_file *one, *two;
 594     int close_one, close_two;
 595   };
 596
 597 struct ui_file *
 598 tee_file_new (struct ui_file *one, int close_one,
 599               struct ui_file *two, int close_two)
 600 {
 601   struct ui_file *ui_file = ui_file_new ();
 602   struct tee_file *tee = xmalloc (sizeof (struct tee_file));
 603
 604   tee->magic = &tee_file_magic;
 605   tee->one = one;
 606   tee->two = two;
 607   tee->close_one = close_one;
 608   tee->close_two = close_two;
 609   set_ui_file_data (ui_file, tee, tee_file_delete);
 610   set_ui_file_flush (ui_file, tee_file_flush);
 611   set_ui_file_write (ui_file, tee_file_write);
 612   set_ui_file_fputs (ui_file, tee_file_fputs);
 613   set_ui_file_isatty (ui_file, tee_file_isatty);
 614   return ui_file;
 615 }
 616
 617 static void
 618 tee_file_delete (struct ui_file *file)
 619 {
 620   struct tee_file *tee = ui_file_data (file);
 621
 622   if (tee->magic != &tee_file_magic)
 623     internal_error (__FILE__, __LINE__,
 624                     _("tee_file_delete: bad magic number"));
 625   if (tee->close_one)
 626     ui_file_delete (tee->one);
 627   if (tee->close_two)
 628     ui_file_delete (tee->two);
 629
 630   xfree (tee);
 631 }
 632
 633 static void
 634 tee_file_flush (struct ui_file *file)
 635 {
 636   struct tee_file *tee = ui_file_data (file);
 637
 638   if (tee->magic != &tee_file_magic)
 639     internal_error (__FILE__, __LINE__,
 640                     _("tee_file_flush: bad magic number"));
 641   tee->one->to_flush (tee->one);
 642   tee->two->to_flush (tee->two);
 643 }
 644
 645 static void
 646 tee_file_write (struct ui_file *file, const char *buf, long length_buf)
 647 {
 648   struct tee_file *tee = ui_file_data (file);
 649
 650   if (tee->magic != &tee_file_magic)
 651     internal_error (__FILE__, __LINE__,
 652                     _("tee_file_write: bad magic number"));
 653   ui_file_write (tee->one, buf, length_buf);
 654   ui_file_write (tee->two, buf, length_buf);
 655 }
 656
 657 static void
 658 tee_file_fputs (const char *linebuffer, struct ui_file *file)
 659 {
 660   struct tee_file *tee = ui_file_data (file);
 661
 662   if (tee->magic != &tee_file_magic)
 663     internal_error (__FILE__, __LINE__,
 664                     _("tee_file_fputs: bad magic number"));
 665   tee->one->to_fputs (linebuffer, tee->one);
 666   tee->two->to_fputs (linebuffer, tee->two);
 667 }
 668
 669 static int
 670 tee_file_isatty (struct ui_file *file)
 671 {
 672   struct tee_file *tee = ui_file_data (file);
 673
 674   if (tee->magic != &tee_file_magic)
 675     internal_error (__FILE__, __LINE__,
 676                     _("tee_file_isatty: bad magic number"));
 677
 678   return ui_file_isatty (tee->one);
 679 }