Upgrade GDB from 7.4.1 to 7.6.1 on the vendor branch
[dragonfly.git] / contrib / gdb-7 / gdb / ui-file.c
1 /* UI_FILE - a generic STDIO like output stream.
2
3    Copyright (C) 1999-2013 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_string.h"
26 #include "gdb_select.h"
27
28 #include <errno.h>
29
30 static ui_file_isatty_ftype null_file_isatty;
31 static ui_file_write_ftype null_file_write;
32 static ui_file_write_ftype null_file_write_async_safe;
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 static ui_file_fseek_ftype null_file_fseek;
40
41 struct ui_file
42   {
43     int *magic;
44     ui_file_flush_ftype *to_flush;
45     ui_file_write_ftype *to_write;
46     ui_file_write_async_safe_ftype *to_write_async_safe;
47     ui_file_fputs_ftype *to_fputs;
48     ui_file_read_ftype *to_read;
49     ui_file_delete_ftype *to_delete;
50     ui_file_isatty_ftype *to_isatty;
51     ui_file_rewind_ftype *to_rewind;
52     ui_file_put_ftype *to_put;
53     ui_file_fseek_ftype *to_fseek;
54     void *to_data;
55   };
56 int ui_file_magic;
57
58 struct ui_file *
59 ui_file_new (void)
60 {
61   struct ui_file *file = xmalloc (sizeof (struct ui_file));
62
63   file->magic = &ui_file_magic;
64   set_ui_file_data (file, NULL, null_file_delete);
65   set_ui_file_flush (file, null_file_flush);
66   set_ui_file_write (file, null_file_write);
67   set_ui_file_write_async_safe (file, null_file_write_async_safe);
68   set_ui_file_fputs (file, null_file_fputs);
69   set_ui_file_read (file, null_file_read);
70   set_ui_file_isatty (file, null_file_isatty);
71   set_ui_file_rewind (file, null_file_rewind);
72   set_ui_file_put (file, null_file_put);
73   set_ui_file_fseek (file, null_file_fseek);
74   return file;
75 }
76
77 void
78 ui_file_delete (struct ui_file *file)
79 {
80   file->to_delete (file);
81   xfree (file);
82 }
83
84 static int
85 null_file_isatty (struct ui_file *file)
86 {
87   return 0;
88 }
89
90 static void
91 null_file_rewind (struct ui_file *file)
92 {
93   return;
94 }
95
96 static void
97 null_file_put (struct ui_file *file,
98                ui_file_put_method_ftype *write,
99                void *dest)
100 {
101   return;
102 }
103
104 static void
105 null_file_flush (struct ui_file *file)
106 {
107   return;
108 }
109
110 static void
111 null_file_write (struct ui_file *file,
112                  const char *buf,
113                  long sizeof_buf)
114 {
115   if (file->to_fputs == null_file_fputs)
116     /* Both the write and fputs methods are null.  Discard the
117        request.  */
118     return;
119   else
120     {
121       /* The fputs method isn't null, slowly pass the write request
122          onto that.  FYI, this isn't as bad as it may look - the
123          current (as of 1999-11-07) printf_* function calls fputc and
124          fputc does exactly the below.  By having a write function it
125          is possible to clean up that code.  */
126       int i;
127       char b[2];
128
129       b[1] = '\0';
130       for (i = 0; i < sizeof_buf; i++)
131         {
132           b[0] = buf[i];
133           file->to_fputs (b, file);
134         }
135       return;
136     }
137 }
138
139 static long
140 null_file_read (struct ui_file *file,
141                 char *buf,
142                 long sizeof_buf)
143 {
144   errno = EBADF;
145   return 0;
146 }
147
148 static void
149 null_file_fputs (const char *buf, struct ui_file *file)
150 {
151   if (file->to_write == null_file_write)
152     /* Both the write and fputs methods are null.  Discard the
153        request.  */
154     return;
155   else
156     {
157       /* The write method was implemented, use that.  */
158       file->to_write (file, buf, strlen (buf));
159     }
160 }
161
162 static void
163 null_file_write_async_safe (struct ui_file *file,
164                             const char *buf,
165                             long sizeof_buf)
166 {
167   return;
168 }
169
170 static void
171 null_file_delete (struct ui_file *file)
172 {
173   return;
174 }
175
176 static int
177 null_file_fseek (struct ui_file *stream, long offset, int whence)
178 {
179   errno = EBADF;
180
181   return -1;
182 }
183
184 void *
185 ui_file_data (struct ui_file *file)
186 {
187   if (file->magic != &ui_file_magic)
188     internal_error (__FILE__, __LINE__,
189                     _("ui_file_data: bad magic number"));
190   return file->to_data;
191 }
192
193 void
194 gdb_flush (struct ui_file *file)
195 {
196   file->to_flush (file);
197 }
198
199 int
200 ui_file_isatty (struct ui_file *file)
201 {
202   return file->to_isatty (file);
203 }
204
205 void
206 ui_file_rewind (struct ui_file *file)
207 {
208   file->to_rewind (file);
209 }
210
211 void
212 ui_file_put (struct ui_file *file,
213               ui_file_put_method_ftype *write,
214               void *dest)
215 {
216   file->to_put (file, write, dest);
217 }
218
219 void
220 ui_file_write (struct ui_file *file,
221                 const char *buf,
222                 long length_buf)
223 {
224   file->to_write (file, buf, length_buf);
225 }
226
227 void
228 ui_file_write_async_safe (struct ui_file *file,
229                           const char *buf,
230                           long length_buf)
231 {
232   file->to_write_async_safe (file, buf, length_buf);
233 }
234
235 long
236 ui_file_read (struct ui_file *file, char *buf, long length_buf)
237 {
238   return file->to_read (file, buf, length_buf); 
239 }
240
241 int
242 ui_file_fseek (struct ui_file *file, long offset, int whence)
243 {
244   return file->to_fseek (file, offset, whence);
245 }
246
247 void
248 fputs_unfiltered (const char *buf, struct ui_file *file)
249 {
250   file->to_fputs (buf, file);
251 }
252
253 void
254 set_ui_file_flush (struct ui_file *file, ui_file_flush_ftype *flush_ptr)
255 {
256   file->to_flush = flush_ptr;
257 }
258
259 void
260 set_ui_file_isatty (struct ui_file *file, ui_file_isatty_ftype *isatty_ptr)
261 {
262   file->to_isatty = isatty_ptr;
263 }
264
265 void
266 set_ui_file_rewind (struct ui_file *file, ui_file_rewind_ftype *rewind_ptr)
267 {
268   file->to_rewind = rewind_ptr;
269 }
270
271 void
272 set_ui_file_put (struct ui_file *file, ui_file_put_ftype *put_ptr)
273 {
274   file->to_put = put_ptr;
275 }
276
277 void
278 set_ui_file_write (struct ui_file *file,
279                     ui_file_write_ftype *write_ptr)
280 {
281   file->to_write = write_ptr;
282 }
283
284 void
285 set_ui_file_write_async_safe (struct ui_file *file,
286                               ui_file_write_async_safe_ftype *write_async_safe_ptr)
287 {
288   file->to_write_async_safe = write_async_safe_ptr;
289 }
290
291 void
292 set_ui_file_read (struct ui_file *file, ui_file_read_ftype *read_ptr)
293 {
294   file->to_read = read_ptr;
295 }
296
297 void
298 set_ui_file_fputs (struct ui_file *file, ui_file_fputs_ftype *fputs_ptr)
299 {
300   file->to_fputs = fputs_ptr;
301 }
302
303 void
304 set_ui_file_fseek (struct ui_file *file, ui_file_fseek_ftype *fseek_ptr)
305 {
306   file->to_fseek = fseek_ptr;
307 }
308
309 void
310 set_ui_file_data (struct ui_file *file, void *data,
311                   ui_file_delete_ftype *delete_ptr)
312 {
313   file->to_data = data;
314   file->to_delete = delete_ptr;
315 }
316
317 /* ui_file utility function for converting a ``struct ui_file'' into
318    a memory buffer.  */
319
320 struct accumulated_ui_file
321 {
322   char *buffer;
323   long length;
324 };
325
326 static void
327 do_ui_file_xstrdup (void *context, const char *buffer, long length)
328 {
329   struct accumulated_ui_file *acc = context;
330
331   if (acc->buffer == NULL)
332     acc->buffer = xmalloc (length + 1);
333   else
334     acc->buffer = xrealloc (acc->buffer, acc->length + length + 1);
335   memcpy (acc->buffer + acc->length, buffer, length);
336   acc->length += length;
337   acc->buffer[acc->length] = '\0';
338 }
339
340 char *
341 ui_file_xstrdup (struct ui_file *file, long *length)
342 {
343   struct accumulated_ui_file acc;
344
345   acc.buffer = NULL;
346   acc.length = 0;
347   ui_file_put (file, do_ui_file_xstrdup, &acc);
348   if (acc.buffer == NULL)
349     acc.buffer = xstrdup ("");
350   if (length != NULL)
351     *length = acc.length;
352   return acc.buffer;
353 }
354
355 static void
356 do_ui_file_obsavestring (void *context, const char *buffer, long length)
357 {
358   struct obstack *obstack = (struct obstack *) context;
359
360   obstack_grow (obstack, buffer, length);
361 }
362
363 char *
364 ui_file_obsavestring (struct ui_file *file, struct obstack *obstack,
365                       long *length)
366 {
367   ui_file_put (file, do_ui_file_obsavestring, obstack);
368   *length = obstack_object_size (obstack);
369   obstack_1grow (obstack, '\0');
370   return obstack_finish (obstack);
371 }
372 \f
373 /* A pure memory based ``struct ui_file'' that can be used an output
374    buffer.  The buffers accumulated contents are available via
375    ui_file_put().  */
376
377 struct mem_file
378   {
379     int *magic;
380     char *buffer;
381     int sizeof_buffer;
382     int length_buffer;
383   };
384
385 static ui_file_rewind_ftype mem_file_rewind;
386 static ui_file_put_ftype mem_file_put;
387 static ui_file_write_ftype mem_file_write;
388 static ui_file_delete_ftype mem_file_delete;
389 static struct ui_file *mem_file_new (void);
390 static int mem_file_magic;
391
392 static struct ui_file *
393 mem_file_new (void)
394 {
395   struct mem_file *stream = XMALLOC (struct mem_file);
396   struct ui_file *file = ui_file_new ();
397
398   set_ui_file_data (file, stream, mem_file_delete);
399   set_ui_file_rewind (file, mem_file_rewind);
400   set_ui_file_put (file, mem_file_put);
401   set_ui_file_write (file, mem_file_write);
402   stream->magic = &mem_file_magic;
403   stream->buffer = NULL;
404   stream->sizeof_buffer = 0;
405   stream->length_buffer = 0;
406   return file;
407 }
408
409 static void
410 mem_file_delete (struct ui_file *file)
411 {
412   struct mem_file *stream = ui_file_data (file);
413
414   if (stream->magic != &mem_file_magic)
415     internal_error (__FILE__, __LINE__,
416                     _("mem_file_delete: bad magic number"));
417   if (stream->buffer != NULL)
418     xfree (stream->buffer);
419   xfree (stream);
420 }
421
422 struct ui_file *
423 mem_fileopen (void)
424 {
425   return mem_file_new ();
426 }
427
428 static void
429 mem_file_rewind (struct ui_file *file)
430 {
431   struct mem_file *stream = ui_file_data (file);
432
433   if (stream->magic != &mem_file_magic)
434     internal_error (__FILE__, __LINE__,
435                     _("mem_file_rewind: bad magic number"));
436   stream->length_buffer = 0;
437 }
438
439 static void
440 mem_file_put (struct ui_file *file,
441               ui_file_put_method_ftype *write,
442               void *dest)
443 {
444   struct mem_file *stream = ui_file_data (file);
445
446   if (stream->magic != &mem_file_magic)
447     internal_error (__FILE__, __LINE__,
448                     _("mem_file_put: bad magic number"));
449   if (stream->length_buffer > 0)
450     write (dest, stream->buffer, stream->length_buffer);
451 }
452
453 void
454 mem_file_write (struct ui_file *file,
455                 const char *buffer,
456                 long length_buffer)
457 {
458   struct mem_file *stream = ui_file_data (file);
459
460   if (stream->magic != &mem_file_magic)
461     internal_error (__FILE__, __LINE__,
462                     _("mem_file_write: bad magic number"));
463   if (stream->buffer == NULL)
464     {
465       stream->length_buffer = length_buffer;
466       stream->sizeof_buffer = length_buffer;
467       stream->buffer = xmalloc (stream->sizeof_buffer);
468       memcpy (stream->buffer, buffer, length_buffer);
469     }
470   else
471     {
472       int new_length = stream->length_buffer + length_buffer;
473
474       if (new_length >= stream->sizeof_buffer)
475         {
476           stream->sizeof_buffer = new_length;
477           stream->buffer = xrealloc (stream->buffer, stream->sizeof_buffer);
478         }
479       memcpy (stream->buffer + stream->length_buffer, buffer, length_buffer);
480       stream->length_buffer = new_length;
481     }
482 }
483 \f
484 /* ``struct ui_file'' implementation that maps directly onto
485    <stdio.h>'s FILE.  */
486
487 static ui_file_write_ftype stdio_file_write;
488 static ui_file_write_async_safe_ftype stdio_file_write_async_safe;
489 static ui_file_fputs_ftype stdio_file_fputs;
490 static ui_file_read_ftype stdio_file_read;
491 static ui_file_isatty_ftype stdio_file_isatty;
492 static ui_file_delete_ftype stdio_file_delete;
493 static struct ui_file *stdio_file_new (FILE *file, int close_p);
494 static ui_file_flush_ftype stdio_file_flush;
495 static ui_file_fseek_ftype stdio_file_fseek;
496
497 static int stdio_file_magic;
498
499 struct stdio_file
500   {
501     int *magic;
502     FILE *file;
503     /* The associated file descriptor is extracted ahead of time for
504        stdio_file_write_async_safe's benefit, in case fileno isn't async-safe.  */
505     int fd;
506     int close_p;
507   };
508
509 static struct ui_file *
510 stdio_file_new (FILE *file, int close_p)
511 {
512   struct ui_file *ui_file = ui_file_new ();
513   struct stdio_file *stdio = xmalloc (sizeof (struct stdio_file));
514
515   stdio->magic = &stdio_file_magic;
516   stdio->file = file;
517   stdio->fd = fileno (file);
518   stdio->close_p = close_p;
519   set_ui_file_data (ui_file, stdio, stdio_file_delete);
520   set_ui_file_flush (ui_file, stdio_file_flush);
521   set_ui_file_write (ui_file, stdio_file_write);
522   set_ui_file_write_async_safe (ui_file, stdio_file_write_async_safe);
523   set_ui_file_fputs (ui_file, stdio_file_fputs);
524   set_ui_file_read (ui_file, stdio_file_read);
525   set_ui_file_isatty (ui_file, stdio_file_isatty);
526   set_ui_file_fseek (ui_file, stdio_file_fseek);
527   return ui_file;
528 }
529
530 static void
531 stdio_file_delete (struct ui_file *file)
532 {
533   struct stdio_file *stdio = ui_file_data (file);
534
535   if (stdio->magic != &stdio_file_magic)
536     internal_error (__FILE__, __LINE__,
537                     _("stdio_file_delete: bad magic number"));
538   if (stdio->close_p)
539     {
540       fclose (stdio->file);
541     }
542   xfree (stdio);
543 }
544
545 static void
546 stdio_file_flush (struct ui_file *file)
547 {
548   struct stdio_file *stdio = ui_file_data (file);
549
550   if (stdio->magic != &stdio_file_magic)
551     internal_error (__FILE__, __LINE__,
552                     _("stdio_file_flush: bad magic number"));
553   fflush (stdio->file);
554 }
555
556 static long
557 stdio_file_read (struct ui_file *file, char *buf, long length_buf)
558 {
559   struct stdio_file *stdio = ui_file_data (file);
560
561   if (stdio->magic != &stdio_file_magic)
562     internal_error (__FILE__, __LINE__,
563                     _("stdio_file_read: bad magic number"));
564
565   /* For the benefit of Windows, call gdb_select before reading from
566      the file.  Wait until at least one byte of data is available.
567      Control-C can interrupt gdb_select, but not read.  */
568   {
569     fd_set readfds;
570     FD_ZERO (&readfds);
571     FD_SET (stdio->fd, &readfds);
572     if (gdb_select (stdio->fd + 1, &readfds, NULL, NULL, NULL) == -1)
573       return -1;
574   }
575
576   return read (stdio->fd, buf, length_buf);
577 }
578
579 static void
580 stdio_file_write (struct ui_file *file, const char *buf, long length_buf)
581 {
582   struct stdio_file *stdio = ui_file_data (file);
583
584   if (stdio->magic != &stdio_file_magic)
585     internal_error (__FILE__, __LINE__,
586                     _("stdio_file_write: bad magic number"));
587   /* Calling error crashes when we are called from the exception framework.  */
588   if (fwrite (buf, length_buf, 1, stdio->file))
589     {
590       /* Nothing.  */
591     }
592 }
593
594 static void
595 stdio_file_write_async_safe (struct ui_file *file,
596                              const char *buf, long length_buf)
597 {
598   struct stdio_file *stdio = ui_file_data (file);
599
600   if (stdio->magic != &stdio_file_magic)
601     {
602       /* gettext isn't necessarily async safe, so we can't use _("error message") here.
603          We could extract the correct translation ahead of time, but this is an extremely
604          rare event, and one of the other stdio_file_* routines will presumably catch
605          the problem anyway.  For now keep it simple and ignore the error here.  */
606       return;
607     }
608
609   /* This is written the way it is to avoid a warning from gcc about not using the
610      result of write (since it can be declared with attribute warn_unused_result).
611      Alas casting to void doesn't work for this.  */
612   if (write (stdio->fd, buf, length_buf))
613     {
614       /* Nothing.  */
615     }
616 }
617
618 static void
619 stdio_file_fputs (const char *linebuffer, struct ui_file *file)
620 {
621   struct stdio_file *stdio = ui_file_data (file);
622
623   if (stdio->magic != &stdio_file_magic)
624     internal_error (__FILE__, __LINE__,
625                     _("stdio_file_fputs: bad magic number"));
626   /* Calling error crashes when we are called from the exception framework.  */
627   if (fputs (linebuffer, stdio->file))
628     {
629       /* Nothing.  */
630     }
631 }
632
633 static int
634 stdio_file_isatty (struct ui_file *file)
635 {
636   struct stdio_file *stdio = ui_file_data (file);
637
638   if (stdio->magic != &stdio_file_magic)
639     internal_error (__FILE__, __LINE__,
640                     _("stdio_file_isatty: bad magic number"));
641   return (isatty (stdio->fd));
642 }
643
644 static int
645 stdio_file_fseek (struct ui_file *file, long offset, int whence)
646 {
647   struct stdio_file *stdio = ui_file_data (file);
648
649   if (stdio->magic != &stdio_file_magic)
650     internal_error (__FILE__, __LINE__,
651                     _("stdio_file_fseek: bad magic number"));
652
653   return fseek (stdio->file, offset, whence);
654 }
655
656 /* Like fdopen().  Create a ui_file from a previously opened FILE.  */
657
658 struct ui_file *
659 stdio_fileopen (FILE *file)
660 {
661   return stdio_file_new (file, 0);
662 }
663
664 struct ui_file *
665 gdb_fopen (char *name, char *mode)
666 {
667   FILE *f = fopen (name, mode);
668
669   if (f == NULL)
670     return NULL;
671   return stdio_file_new (f, 1);
672 }
673
674 /* ``struct ui_file'' implementation that maps onto two ui-file objects.  */
675
676 static ui_file_write_ftype tee_file_write;
677 static ui_file_fputs_ftype tee_file_fputs;
678 static ui_file_isatty_ftype tee_file_isatty;
679 static ui_file_delete_ftype tee_file_delete;
680 static ui_file_flush_ftype tee_file_flush;
681
682 static int tee_file_magic;
683
684 struct tee_file
685   {
686     int *magic;
687     struct ui_file *one, *two;
688     int close_one, close_two;
689   };
690
691 struct ui_file *
692 tee_file_new (struct ui_file *one, int close_one,
693               struct ui_file *two, int close_two)
694 {
695   struct ui_file *ui_file = ui_file_new ();
696   struct tee_file *tee = xmalloc (sizeof (struct tee_file));
697
698   tee->magic = &tee_file_magic;
699   tee->one = one;
700   tee->two = two;
701   tee->close_one = close_one;
702   tee->close_two = close_two;
703   set_ui_file_data (ui_file, tee, tee_file_delete);
704   set_ui_file_flush (ui_file, tee_file_flush);
705   set_ui_file_write (ui_file, tee_file_write);
706   set_ui_file_fputs (ui_file, tee_file_fputs);
707   set_ui_file_isatty (ui_file, tee_file_isatty);
708   return ui_file;
709 }
710
711 static void
712 tee_file_delete (struct ui_file *file)
713 {
714   struct tee_file *tee = ui_file_data (file);
715
716   if (tee->magic != &tee_file_magic)
717     internal_error (__FILE__, __LINE__,
718                     _("tee_file_delete: bad magic number"));
719   if (tee->close_one)
720     ui_file_delete (tee->one);
721   if (tee->close_two)
722     ui_file_delete (tee->two);
723
724   xfree (tee);
725 }
726
727 static void
728 tee_file_flush (struct ui_file *file)
729 {
730   struct tee_file *tee = ui_file_data (file);
731
732   if (tee->magic != &tee_file_magic)
733     internal_error (__FILE__, __LINE__,
734                     _("tee_file_flush: bad magic number"));
735   tee->one->to_flush (tee->one);
736   tee->two->to_flush (tee->two);
737 }
738
739 static void
740 tee_file_write (struct ui_file *file, const char *buf, long length_buf)
741 {
742   struct tee_file *tee = ui_file_data (file);
743
744   if (tee->magic != &tee_file_magic)
745     internal_error (__FILE__, __LINE__,
746                     _("tee_file_write: bad magic number"));
747   ui_file_write (tee->one, buf, length_buf);
748   ui_file_write (tee->two, buf, length_buf);
749 }
750
751 static void
752 tee_file_fputs (const char *linebuffer, struct ui_file *file)
753 {
754   struct tee_file *tee = ui_file_data (file);
755
756   if (tee->magic != &tee_file_magic)
757     internal_error (__FILE__, __LINE__,
758                     _("tee_file_fputs: bad magic number"));
759   tee->one->to_fputs (linebuffer, tee->one);
760   tee->two->to_fputs (linebuffer, tee->two);
761 }
762
763 static int
764 tee_file_isatty (struct ui_file *file)
765 {
766   struct tee_file *tee = ui_file_data (file);
767
768   if (tee->magic != &tee_file_magic)
769     internal_error (__FILE__, __LINE__,
770                     _("tee_file_isatty: bad magic number"));
771
772   return ui_file_isatty (tee->one);
773 }