OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.1/] [gdb/] [ui-file.c] - Blame information for rev 227

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* UI_FILE - a generic STDIO like output stream.
2
 
3
   Copyright (C) 1999, 2000, 2001, 2002, 2007, 2008, 2009, 2010
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_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_fputs_ftype null_file_fputs;
33
static ui_file_read_ftype null_file_read;
34
static ui_file_flush_ftype null_file_flush;
35
static ui_file_delete_ftype null_file_delete;
36
static ui_file_rewind_ftype null_file_rewind;
37
static ui_file_put_ftype null_file_put;
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_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
  };
52
int ui_file_magic;
53
 
54
struct ui_file *
55
ui_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
 
70
void
71
ui_file_delete (struct ui_file *file)
72
{
73
  file->to_delete (file);
74
  xfree (file);
75
}
76
 
77
static int
78
null_file_isatty (struct ui_file *file)
79
{
80
  return 0;
81
}
82
 
83
static void
84
null_file_rewind (struct ui_file *file)
85
{
86
  return;
87
}
88
 
89
static void
90
null_file_put (struct ui_file *file,
91
               ui_file_put_method_ftype *write,
92
               void *dest)
93
{
94
  return;
95
}
96
 
97
static void
98
null_file_flush (struct ui_file *file)
99
{
100
  return;
101
}
102
 
103
static void
104
null_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
 
131
static long
132
null_file_read (struct ui_file *file,
133
                char *buf,
134
                long sizeof_buf)
135
{
136
  errno = EBADF;
137
  return 0;
138
}
139
 
140
static void
141
null_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
 
154
static void
155
null_file_delete (struct ui_file *file)
156
{
157
  return;
158
}
159
 
160
void *
161
ui_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
 
169
void
170
gdb_flush (struct ui_file *file)
171
{
172
  file->to_flush (file);
173
}
174
 
175
int
176
ui_file_isatty (struct ui_file *file)
177
{
178
  return file->to_isatty (file);
179
}
180
 
181
void
182
ui_file_rewind (struct ui_file *file)
183
{
184
  file->to_rewind (file);
185
}
186
 
187
void
188
ui_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
 
195
void
196
ui_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
 
203
long
204
ui_file_read (struct ui_file *file, char *buf, long length_buf)
205
{
206
  return file->to_read (file, buf, length_buf);
207
}
208
 
209
void
210
fputs_unfiltered (const char *buf, struct ui_file *file)
211
{
212
  file->to_fputs (buf, file);
213
}
214
 
215
void
216
set_ui_file_flush (struct ui_file *file, ui_file_flush_ftype *flush)
217
{
218
  file->to_flush = flush;
219
}
220
 
221
void
222
set_ui_file_isatty (struct ui_file *file, ui_file_isatty_ftype *isatty)
223
{
224
  file->to_isatty = isatty;
225
}
226
 
227
void
228
set_ui_file_rewind (struct ui_file *file, ui_file_rewind_ftype *rewind)
229
{
230
  file->to_rewind = rewind;
231
}
232
 
233
void
234
set_ui_file_put (struct ui_file *file, ui_file_put_ftype *put)
235
{
236
  file->to_put = put;
237
}
238
 
239
void
240
set_ui_file_write (struct ui_file *file,
241
                    ui_file_write_ftype *write)
242
{
243
  file->to_write = write;
244
}
245
 
246
void
247
set_ui_file_read (struct ui_file *file, ui_file_read_ftype *read)
248
{
249
  file->to_read = read;
250
}
251
 
252
void
253
set_ui_file_fputs (struct ui_file *file, ui_file_fputs_ftype *fputs)
254
{
255
  file->to_fputs = fputs;
256
}
257
 
258
void
259
set_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
 
269
struct accumulated_ui_file
270
{
271
  char *buffer;
272
  long length;
273
};
274
 
275
static void
276
do_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
 
288
char *
289
ui_file_xstrdup (struct ui_file *file, long *length)
290
{
291
  struct accumulated_ui_file acc;
292
  acc.buffer = NULL;
293
  acc.length = 0;
294
  ui_file_put (file, do_ui_file_xstrdup, &acc);
295
  if (acc.buffer == NULL)
296
    acc.buffer = xstrdup ("");
297
  if (length != NULL)
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
 
306
struct mem_file
307
  {
308
    int *magic;
309
    char *buffer;
310
    int sizeof_buffer;
311
    int length_buffer;
312
  };
313
 
314
static ui_file_rewind_ftype mem_file_rewind;
315
static ui_file_put_ftype mem_file_put;
316
static ui_file_write_ftype mem_file_write;
317
static ui_file_delete_ftype mem_file_delete;
318
static struct ui_file *mem_file_new (void);
319
static int mem_file_magic;
320
 
321
static struct ui_file *
322
mem_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
 
337
static void
338
mem_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
 
349
struct ui_file *
350
mem_fileopen (void)
351
{
352
  return mem_file_new ();
353
}
354
 
355
static void
356
mem_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
 
365
static void
366
mem_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
 
378
void
379
mem_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
 
410
static ui_file_write_ftype stdio_file_write;
411
static ui_file_fputs_ftype stdio_file_fputs;
412
static ui_file_read_ftype stdio_file_read;
413
static ui_file_isatty_ftype stdio_file_isatty;
414
static ui_file_delete_ftype stdio_file_delete;
415
static struct ui_file *stdio_file_new (FILE * file, int close_p);
416
static ui_file_flush_ftype stdio_file_flush;
417
 
418
static int stdio_file_magic;
419
 
420
struct stdio_file
421
  {
422
    int *magic;
423
    FILE *file;
424
    int close_p;
425
  };
426
 
427
static struct ui_file *
428
stdio_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
 
444
static void
445
stdio_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
 
458
static void
459
stdio_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
 
468
static long
469
stdio_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
 
476
  /* For the benefit of Windows, call gdb_select before reading from
477
     the file.  Wait until at least one byte of data is available.
478
     Control-C can interrupt gdb_select, but not read.  */
479
  {
480
    int fd = fileno (stdio->file);
481
    fd_set readfds;
482
    FD_ZERO (&readfds);
483
    FD_SET (fd, &readfds);
484
    if (gdb_select (fd + 1, &readfds, NULL, NULL, NULL) == -1)
485
      return -1;
486
  }
487
 
488
  return read (fileno (stdio->file), buf, length_buf);
489
}
490
 
491
static void
492
stdio_file_write (struct ui_file *file, const char *buf, long length_buf)
493
{
494
  struct stdio_file *stdio = ui_file_data (file);
495
  if (stdio->magic != &stdio_file_magic)
496
    internal_error (__FILE__, __LINE__,
497
                    _("stdio_file_write: bad magic number"));
498
  /* Calling error crashes when we are called from the exception framework.  */
499
  if (fwrite (buf, length_buf, 1, stdio->file))
500
    ;
501
}
502
 
503
static void
504
stdio_file_fputs (const char *linebuffer, struct ui_file *file)
505
{
506
  struct stdio_file *stdio = ui_file_data (file);
507
  if (stdio->magic != &stdio_file_magic)
508
    internal_error (__FILE__, __LINE__,
509
                    _("stdio_file_fputs: bad magic number"));
510
  /* Calling error crashes when we are called from the exception framework.  */
511
  if (fputs (linebuffer, stdio->file))
512
    ;
513
}
514
 
515
static int
516
stdio_file_isatty (struct ui_file *file)
517
{
518
  struct stdio_file *stdio = ui_file_data (file);
519
  if (stdio->magic != &stdio_file_magic)
520
    internal_error (__FILE__, __LINE__,
521
                    _("stdio_file_isatty: bad magic number"));
522
  return (isatty (fileno (stdio->file)));
523
}
524
 
525
/* Like fdopen().  Create a ui_file from a previously opened FILE. */
526
 
527
struct ui_file *
528
stdio_fileopen (FILE *file)
529
{
530
  return stdio_file_new (file, 0);
531
}
532
 
533
struct ui_file *
534
gdb_fopen (char *name, char *mode)
535
{
536
  FILE *f = fopen (name, mode);
537
  if (f == NULL)
538
    return NULL;
539
  return stdio_file_new (f, 1);
540
}
541
 
542
/* ``struct ui_file'' implementation that maps onto two ui-file objects.  */
543
 
544
static ui_file_write_ftype tee_file_write;
545
static ui_file_fputs_ftype tee_file_fputs;
546
static ui_file_isatty_ftype tee_file_isatty;
547
static ui_file_delete_ftype tee_file_delete;
548
static ui_file_flush_ftype tee_file_flush;
549
 
550
static int tee_file_magic;
551
 
552
struct tee_file
553
  {
554
    int *magic;
555
    struct ui_file *one, *two;
556
    int close_one, close_two;
557
  };
558
 
559
struct ui_file *
560
tee_file_new (struct ui_file *one, int close_one,
561
              struct ui_file *two, int close_two)
562
{
563
  struct ui_file *ui_file = ui_file_new ();
564
  struct tee_file *tee = xmalloc (sizeof (struct tee_file));
565
  tee->magic = &tee_file_magic;
566
  tee->one = one;
567
  tee->two = two;
568
  tee->close_one = close_one;
569
  tee->close_two = close_two;
570
  set_ui_file_data (ui_file, tee, tee_file_delete);
571
  set_ui_file_flush (ui_file, tee_file_flush);
572
  set_ui_file_write (ui_file, tee_file_write);
573
  set_ui_file_fputs (ui_file, tee_file_fputs);
574
  set_ui_file_isatty (ui_file, tee_file_isatty);
575
  return ui_file;
576
}
577
 
578
static void
579
tee_file_delete (struct ui_file *file)
580
{
581
  struct tee_file *tee = ui_file_data (file);
582
  if (tee->magic != &tee_file_magic)
583
    internal_error (__FILE__, __LINE__,
584
                    _("tee_file_delete: bad magic number"));
585
  if (tee->close_one)
586
    ui_file_delete (tee->one);
587
  if (tee->close_two)
588
    ui_file_delete (tee->two);
589
 
590
  xfree (tee);
591
}
592
 
593
static void
594
tee_file_flush (struct ui_file *file)
595
{
596
  struct tee_file *tee = ui_file_data (file);
597
  if (tee->magic != &tee_file_magic)
598
    internal_error (__FILE__, __LINE__,
599
                    _("tee_file_flush: bad magic number"));
600
  tee->one->to_flush (tee->one);
601
  tee->two->to_flush (tee->two);
602
}
603
 
604
static void
605
tee_file_write (struct ui_file *file, const char *buf, long length_buf)
606
{
607
  struct tee_file *tee = ui_file_data (file);
608
  if (tee->magic != &tee_file_magic)
609
    internal_error (__FILE__, __LINE__,
610
                    _("tee_file_write: bad magic number"));
611
  ui_file_write (tee->one, buf, length_buf);
612
  ui_file_write (tee->two, buf, length_buf);
613
}
614
 
615
static void
616
tee_file_fputs (const char *linebuffer, struct ui_file *file)
617
{
618
  struct tee_file *tee = ui_file_data (file);
619
  if (tee->magic != &tee_file_magic)
620
    internal_error (__FILE__, __LINE__,
621
                    _("tee_file_fputs: bad magic number"));
622
  tee->one->to_fputs (linebuffer, tee->one);
623
  tee->two->to_fputs (linebuffer, tee->two);
624
}
625
 
626
static int
627
tee_file_isatty (struct ui_file *file)
628
{
629
  struct tee_file *tee = ui_file_data (file);
630
  if (tee->magic != &tee_file_magic)
631
    internal_error (__FILE__, __LINE__,
632
                    _("tee_file_isatty: bad magic number"));
633
  return (0);
634
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.