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