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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [gdb-5.3/] [sim/] [common/] [sim-io.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 1181 sfurman 
/* The common simulator framework for GDB, the GNU Debugger.
2 
 
3 
   Copyright 2002 Free Software Foundation, Inc.
4 
 
5 
   Contributed by Andrew Cagney and Red Hat.
6 
 
7 
   This file is part of GDB.
8 
 
9 
   This program is free software; you can redistribute it and/or modify
10 
   it under the terms of the GNU General Public License as published by
11 
   the Free Software Foundation; either version 2 of the License, or
12 
   (at your option) any later version.
13 
 
14 
   This program is distributed in the hope that it will be useful,
15 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
16 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17 
   GNU General Public License for more details.
18 
 
19 
   You should have received a copy of the GNU General Public License
20 
   along with this program; if not, write to the Free Software
21 
   Foundation, Inc., 59 Temple Place - Suite 330,
22 
   Boston, MA 02111-1307, USA.  */
23 
 
24 
 
25 
#include "sim-main.h"
26 
#include "sim-io.h"
27 
#include "targ-vals.h"
28 
 
29 
#include <errno.h>
30 
#if HAVE_FCNTL_H
31 
#include <fcntl.h>
32 
#endif
33 
 
34 
#if HAVE_UNISTD_H
35 
#include <unistd.h>
36 
#endif
37 
 
38 
/* Define the rate at which the simulator should poll the host
39 
   for a quit. */
40 
#ifndef POLL_QUIT_INTERVAL
41 
#define POLL_QUIT_INTERVAL 0x10
42 
#endif
43 
 
44 
static int poll_quit_count = POLL_QUIT_INTERVAL;
45 
 
46 
/* See the file include/callbacks.h for a description */
47 
 
48 
 
49 
int
50 
sim_io_init(SIM_DESC sd)
51 
{
52 
  return STATE_CALLBACK (sd)->init (STATE_CALLBACK (sd));
53 
}
54 
 
55 
 
56 
int
57 
sim_io_shutdown(SIM_DESC sd)
58 
{
59 
  return STATE_CALLBACK (sd)->shutdown (STATE_CALLBACK (sd));
60 
}
61 
 
62 
 
63 
int
64 
sim_io_unlink(SIM_DESC sd,
65 
              const char *f1)
66 
{
67 
  return STATE_CALLBACK (sd)->unlink (STATE_CALLBACK (sd), f1);
68 
}
69 
 
70 
 
71 
long
72 
sim_io_time(SIM_DESC sd,
73 
            long *t)
74 
{
75 
  return STATE_CALLBACK (sd)->time (STATE_CALLBACK (sd), t);
76 
}
77 
 
78 
 
79 
int
80 
sim_io_system(SIM_DESC sd, const char *s)
81 
{
82 
  return STATE_CALLBACK (sd)->system (STATE_CALLBACK (sd), s);
83 
}
84 
 
85 
 
86 
int
87 
sim_io_rename(SIM_DESC sd,
88 
              const char *f1,
89 
              const char *f2)
90 
{
91 
  return STATE_CALLBACK (sd)->rename (STATE_CALLBACK (sd), f1, f2);
92 
}
93 
 
94 
 
95 
int
96 
sim_io_write_stdout(SIM_DESC sd,
97 
                    const char *buf,
98 
                    int len)
99 
{
100 
  switch (CURRENT_STDIO) {
101 
  case DO_USE_STDIO:
102 
    return STATE_CALLBACK (sd)->write_stdout (STATE_CALLBACK (sd), buf, len);
103 
    break;
104 
  case DONT_USE_STDIO:
105 
    return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 1, buf, len);
106 
    break;
107 
  default:
108 
    sim_io_error (sd, "sim_io_write_stdout: unaccounted switch\n");
109 
    break;
110 
  }
111 
  return 0;
112 
}
113 
 
114 
 
115 
void
116 
sim_io_flush_stdout(SIM_DESC sd)
117 
{
118 
  switch (CURRENT_STDIO) {
119 
  case DO_USE_STDIO:
120 
    STATE_CALLBACK (sd)->flush_stdout (STATE_CALLBACK (sd));
121 
    break;
122 
  case DONT_USE_STDIO:
123 
    break;
124 
  default:
125 
    sim_io_error (sd, "sim_io_flush_stdout: unaccounted switch\n");
126 
    break;
127 
  }
128 
}
129 
 
130 
 
131 
int
132 
sim_io_write_stderr(SIM_DESC sd,
133 
                    const char *buf,
134 
                    int len)
135 
{
136 
  switch (CURRENT_STDIO) {
137 
  case DO_USE_STDIO:
138 
    return STATE_CALLBACK (sd)->write_stderr (STATE_CALLBACK (sd), buf, len);
139 
    break;
140 
  case DONT_USE_STDIO:
141 
    return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), 2, buf, len);
142 
    break;
143 
  default:
144 
    sim_io_error (sd, "sim_io_write_stderr: unaccounted switch\n");
145 
    break;
146 
  }
147 
  return 0;
148 
}
149 
 
150 
 
151 
void
152 
sim_io_flush_stderr(SIM_DESC sd)
153 
{
154 
  switch (CURRENT_STDIO) {
155 
  case DO_USE_STDIO:
156 
    STATE_CALLBACK (sd)->flush_stderr (STATE_CALLBACK (sd));
157 
    break;
158 
  case DONT_USE_STDIO:
159 
    break;
160 
  default:
161 
    sim_io_error (sd, "sim_io_flush_stderr: unaccounted switch\n");
162 
    break;
163 
  }
164 
}
165 
 
166 
 
167 
int
168 
sim_io_write(SIM_DESC sd,
169 
             int fd,
170 
             const char *buf,
171 
             int len)
172 
{
173 
  return STATE_CALLBACK (sd)->write (STATE_CALLBACK (sd), fd, buf, len);
174 
}
175 
 
176 
 
177 
int
178 
sim_io_read_stdin(SIM_DESC sd,
179 
                  char *buf,
180 
                  int len)
181 
{
182 
  switch (CURRENT_STDIO) {
183 
  case DO_USE_STDIO:
184 
    return STATE_CALLBACK (sd)->read_stdin (STATE_CALLBACK (sd), buf, len);
185 
    break;
186 
  case DONT_USE_STDIO:
187 
    return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), 0, buf, len);
188 
    break;
189 
  default:
190 
    sim_io_error (sd, "sim_io_read_stdin: unaccounted switch\n");
191 
    break;
192 
  }
193 
  return 0;
194 
}
195 
 
196 
 
197 
int
198 
sim_io_read(SIM_DESC sd, int fd,
199 
            char *buf,
200 
            int len)
201 
{
202 
  return STATE_CALLBACK (sd)->read (STATE_CALLBACK (sd), fd, buf, len);
203 
}
204 
 
205 
 
206 
int
207 
sim_io_open(SIM_DESC sd,
208 
            const char *name,
209 
            int flags)
210 
{
211 
  return STATE_CALLBACK (sd)->open (STATE_CALLBACK (sd), name, flags);
212 
}
213 
 
214 
 
215 
int
216 
sim_io_lseek(SIM_DESC sd,
217 
             int fd,
218 
             long off,
219 
             int way)
220 
{
221 
  return STATE_CALLBACK (sd)->lseek (STATE_CALLBACK (sd), fd, off, way);
222 
}
223 
 
224 
 
225 
int
226 
sim_io_isatty(SIM_DESC sd,
227 
              int fd)
228 
{
229 
  return STATE_CALLBACK (sd)->isatty (STATE_CALLBACK (sd), fd);
230 
}
231 
 
232 
 
233 
int
234 
sim_io_get_errno(SIM_DESC sd)
235 
{
236 
  return STATE_CALLBACK (sd)->get_errno (STATE_CALLBACK (sd));
237 
}
238 
 
239 
 
240 
int
241 
sim_io_close(SIM_DESC sd,
242 
             int fd)
243 
{
244 
  return STATE_CALLBACK (sd)->close (STATE_CALLBACK (sd), fd);
245 
}
246 
 
247 
 
248 
void
249 
sim_io_printf(SIM_DESC sd,
250 
              const char *fmt,
251 
              ...)
252 
{
253 
  va_list ap;
254 
  va_start(ap, fmt);
255 
  STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
256 
  va_end(ap);
257 
}
258 
 
259 
 
260 
void
261 
sim_io_vprintf(SIM_DESC sd,
262 
               const char *fmt,
263 
               va_list ap)
264 
{
265 
  STATE_CALLBACK (sd)->vprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
266 
}
267 
 
268 
 
269 
void
270 
sim_io_eprintf(SIM_DESC sd,
271 
              const char *fmt,
272 
              ...)
273 
{
274 
  va_list ap;
275 
  va_start(ap, fmt);
276 
  STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
277 
  va_end(ap);
278 
}
279 
 
280 
 
281 
void
282 
sim_io_evprintf(SIM_DESC sd,
283 
                const char *fmt,
284 
                va_list ap)
285 
{
286 
  STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
287 
}
288 
 
289 
 
290 
void
291 
sim_io_error(SIM_DESC sd,
292 
             const char *fmt,
293 
             ...)
294 
{
295 
  if (sd == NULL || STATE_CALLBACK (sd) == NULL) {
296 
    va_list ap;
297 
    va_start(ap, fmt);
298 
    vfprintf (stderr, fmt, ap);
299 
    va_end(ap);
300 
    fprintf (stderr, "\n");
301 
    abort ();
302 
  }
303 
  else {
304 
    va_list ap;
305 
    va_start(ap, fmt);
306 
    STATE_CALLBACK (sd)->evprintf_filtered (STATE_CALLBACK (sd), fmt, ap);
307 
    va_end(ap);
308 
    STATE_CALLBACK (sd)->error (STATE_CALLBACK (sd), "");
309 
  }
310 
}
311 
 
312 
 
313 
void
314 
sim_io_poll_quit(SIM_DESC sd)
315 
{
316 
  if (STATE_CALLBACK (sd)->poll_quit != NULL && poll_quit_count-- < 0)
317 
    {
318 
      poll_quit_count = POLL_QUIT_INTERVAL;
319 
      if (STATE_CALLBACK (sd)->poll_quit (STATE_CALLBACK (sd)))
320 
        sim_stop (sd);
321 
    }
322 
}
323 
 
324 
 
325 
/* Based on gdb-4.17/sim/ppc/main.c:sim_io_read_stdin().
326 
 
327 
   FIXME: Should not be calling fcntl() or grubbing around inside of
328 
   ->fdmap and ->errno.
329 
 
330 
   FIXME: Some completly new mechanism for handling the general
331 
   problem of asynchronous IO is needed.
332 
 
333 
   FIXME: This function does not supress the echoing (ECHO) of input.
334 
   Consequently polled input is always displayed.
335 
 
336 
   FIXME: This function does not perform uncooked reads.
337 
   Consequently, data will not be read until an EOLN character has
338 
   been entered. A cntrl-d may force the early termination of a line */
339 
 
340 
 
341 
int
342 
sim_io_poll_read (SIM_DESC sd,
343 
                  int sim_io_fd,
344 
                  char *buf,
345 
                  int sizeof_buf)
346 
{
347 
#if defined(O_NDELAY) && defined(F_GETFL) && defined(F_SETFL)
348 
  int fd = STATE_CALLBACK (sd)->fdmap[sim_io_fd];
349 
  int flags;
350 
  int status;
351 
  int nr_read;
352 
  int result;
353 
  STATE_CALLBACK (sd)->last_errno = 0;
354 
  /* get the old status */
355 
  flags = fcntl (fd, F_GETFL, 0);
356 
  if (flags == -1)
357 
    {
358 
      perror ("sim_io_poll_read");
359 
      return 0;
360 
    }
361 
  /* temp, disable blocking IO */
362 
  status = fcntl (fd, F_SETFL, flags | O_NDELAY);
363 
  if (status == -1)
364 
    {
365 
      perror ("sim_io_read_stdin");
366 
      return 0;
367 
    }
368 
  /* try for input */
369 
  nr_read = read (fd, buf, sizeof_buf);
370 
  if (nr_read >= 0)
371 
    {
372 
      /* printf ("<nr-read=%d>\n", nr_read); */
373 
      result = nr_read;
374 
    }
375 
  else
376 
    { /* nr_read < 0 */
377 
      result = -1;
378 
      STATE_CALLBACK (sd)->last_errno = errno;
379 
    }
380 
  /* return to regular vewing */
381 
  status = fcntl (fd, F_SETFL, flags);
382 
  if (status == -1)
383 
    {
384 
      perror ("sim_io_read_stdin");
385 
      /* return 0; */
386 
    }
387 
  return result;
388 
#else
389 
  return sim_io_read (sd, sim_io_fd, buf, sizeof_buf);
390 
#endif
391 
}

powered by: WebSVN 2.1.0

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