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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [gdb/] [wrapper.c] - Blame information for rev 1771

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 578 markom 
/* Longjump free calls to gdb internal routines.
2 
   Copyright 1999, 2000 Free Software Foundation, Inc.
3 
 
4 
   This program is free software; you can redistribute it and/or modify
5 
   it under the terms of the GNU General Public License as published by
6 
   the Free Software Foundation; either version 2 of the License, or
7 
   (at your option) any later version.
8 
 
9 
   This program is distributed in the hope that it will be useful,
10 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
11 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12 
   GNU General Public License for more details.
13 
 
14 
   You should have received a copy of the GNU General Public License
15 
   along with this program; if not, write to the Free Software
16 
   Foundation, Inc., 59 Temple Place - Suite 330,
17 
   Boston, MA 02111-1307, USA.  */
18 
 
19 
#include "defs.h"
20 
#include "value.h"
21 
#include "wrapper.h"
22 
 
23 
/* Use this struct to pass arguments to wrapper routines. We assume
24 
   (arbitrarily) that no gdb function takes more than ten arguments. */
25 
struct gdb_wrapper_arguments
26 
  {
27 
 
28 
    /* Pointer to some result from the gdb function call, if any */
29 
    union wrapper_results
30 
      {
31 
        int   integer;
32 
        void *pointer;
33 
      } result;
34 
 
35 
 
36 
    /* The list of arguments. */
37 
    union wrapper_args
38 
      {
39 
        int   integer;
40 
        void *pointer;
41 
      } args[10];
42 
  };
43 
 
44 
static int wrap_parse_exp_1 (char *);
45 
 
46 
static int wrap_evaluate_expression (char *);
47 
 
48 
static int wrap_value_fetch_lazy (char *);
49 
 
50 
static int wrap_value_equal (char *);
51 
 
52 
static int wrap_value_assign (char *);
53 
 
54 
static int wrap_value_subscript (char *);
55 
 
56 
static int wrap_value_ind (char *opaque_arg);
57 
 
58 
static int wrap_parse_and_eval_type (char *);
59 
 
60 
int
61 
gdb_parse_exp_1 (char **stringptr, struct block *block, int comma,
62 
                 struct expression **expression)
63 
{
64 
  struct gdb_wrapper_arguments args;
65 
  args.args[0].pointer = stringptr;
66 
  args.args[1].pointer = block;
67 
  args.args[2].integer = comma;
68 
 
69 
  if (!catch_errors ((catch_errors_ftype *) wrap_parse_exp_1, &args,
70 
                     "", RETURN_MASK_ERROR))
71 
    {
72 
      /* An error occurred */
73 
      return 0;
74 
    }
75 
 
76 
  *expression = (struct expression *) args.result.pointer;
77 
  return 1;
78 
 
79 
}
80 
 
81 
static int
82 
wrap_parse_exp_1 (char *argptr)
83 
{
84 
  struct gdb_wrapper_arguments *args
85 
    = (struct gdb_wrapper_arguments *) argptr;
86 
  args->result.pointer = parse_exp_1((char **) args->args[0].pointer,
87 
                                     (struct block *) args->args[1].pointer,
88 
                                     args->args[2].integer);
89 
  return 1;
90 
}
91 
 
92 
int
93 
gdb_evaluate_expression (struct expression *exp, value_ptr *value)
94 
{
95 
  struct gdb_wrapper_arguments args;
96 
  args.args[0].pointer = exp;
97 
 
98 
  if (!catch_errors ((catch_errors_ftype *) wrap_evaluate_expression, &args,
99 
                     "", RETURN_MASK_ERROR))
100 
    {
101 
      /* An error occurred */
102 
      return 0;
103 
    }
104 
 
105 
  *value = (value_ptr) args.result.pointer;
106 
  return 1;
107 
}
108 
 
109 
static int
110 
wrap_evaluate_expression (char *a)
111 
{
112 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
113 
 
114 
  (args)->result.pointer =
115 
    (char *) evaluate_expression ((struct expression *) args->args[0].pointer);
116 
  return 1;
117 
}
118 
 
119 
int
120 
gdb_value_fetch_lazy (value_ptr value)
121 
{
122 
  struct gdb_wrapper_arguments args;
123 
 
124 
  args.args[0].pointer = value;
125 
  return catch_errors ((catch_errors_ftype *) wrap_value_fetch_lazy, &args,
126 
                       "", RETURN_MASK_ERROR);
127 
}
128 
 
129 
static int
130 
wrap_value_fetch_lazy (char *a)
131 
{
132 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
133 
 
134 
  value_fetch_lazy ((value_ptr) (args)->args[0].pointer);
135 
  return 1;
136 
}
137 
 
138 
int
139 
gdb_value_equal (value_ptr val1, value_ptr val2, int *result)
140 
{
141 
  struct gdb_wrapper_arguments args;
142 
 
143 
  args.args[0].pointer = val1;
144 
  args.args[1].pointer = val2;
145 
 
146 
  if (!catch_errors ((catch_errors_ftype *) wrap_value_equal, &args,
147 
                     "", RETURN_MASK_ERROR))
148 
    {
149 
      /* An error occurred */
150 
      return 0;
151 
    }
152 
 
153 
  *result = args.result.integer;
154 
  return 1;
155 
}
156 
 
157 
static int
158 
wrap_value_equal (char *a)
159 
{
160 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
161 
  value_ptr val1, val2;
162 
 
163 
  val1 = (value_ptr) (args)->args[0].pointer;
164 
  val2 = (value_ptr) (args)->args[1].pointer;
165 
 
166 
  (args)->result.integer = value_equal (val1, val2);
167 
  return 1;
168 
}
169 
 
170 
int
171 
gdb_value_assign (value_ptr val1, value_ptr val2, value_ptr *result)
172 
{
173 
  struct gdb_wrapper_arguments args;
174 
 
175 
  args.args[0].pointer = val1;
176 
  args.args[1].pointer = val2;
177 
 
178 
  if (!catch_errors ((catch_errors_ftype *) wrap_value_assign, &args,
179 
                     "", RETURN_MASK_ERROR))
180 
    {
181 
      /* An error occurred */
182 
      return 0;
183 
    }
184 
 
185 
  *result = (value_ptr) args.result.pointer;
186 
  return 1;
187 
}
188 
 
189 
static int
190 
wrap_value_assign (char *a)
191 
{
192 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
193 
  value_ptr val1, val2;
194 
 
195 
  val1 = (value_ptr) (args)->args[0].pointer;
196 
  val2 = (value_ptr) (args)->args[1].pointer;
197 
 
198 
  (args)->result.pointer = value_assign (val1, val2);
199 
  return 1;
200 
}
201 
 
202 
int
203 
gdb_value_subscript (value_ptr val1, value_ptr val2, value_ptr *rval)
204 
{
205 
  struct gdb_wrapper_arguments args;
206 
 
207 
  args.args[0].pointer = val1;
208 
  args.args[1].pointer = val2;
209 
 
210 
  if (!catch_errors ((catch_errors_ftype *) wrap_value_subscript, &args,
211 
                     "", RETURN_MASK_ERROR))
212 
    {
213 
      /* An error occurred */
214 
      return 0;
215 
    }
216 
 
217 
  *rval = (value_ptr) args.result.pointer;
218 
  return 1;
219 
}
220 
 
221 
static int
222 
wrap_value_subscript (char *a)
223 
{
224 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
225 
  value_ptr val1, val2;
226 
 
227 
  val1 = (value_ptr) (args)->args[0].pointer;
228 
  val2 = (value_ptr) (args)->args[1].pointer;
229 
 
230 
  (args)->result.pointer = value_subscript (val1, val2);
231 
  return 1;
232 
}
233 
 
234 
int
235 
gdb_value_ind (value_ptr val, value_ptr *rval)
236 
{
237 
  struct gdb_wrapper_arguments args;
238 
 
239 
  args.args[0].pointer = val;
240 
 
241 
  if (!catch_errors ((catch_errors_ftype *) wrap_value_ind, &args,
242 
                     "", RETURN_MASK_ERROR))
243 
    {
244 
      /* An error occurred */
245 
      return 0;
246 
    }
247 
 
248 
  *rval = (value_ptr) args.result.pointer;
249 
  return 1;
250 
}
251 
 
252 
static int
253 
wrap_value_ind (char *opaque_arg)
254 
{
255 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) opaque_arg;
256 
  value_ptr val;
257 
 
258 
  val = (value_ptr) (args)->args[0].pointer;
259 
  (args)->result.pointer = value_ind (val);
260 
  return 1;
261 
}
262 
 
263 
int
264 
gdb_parse_and_eval_type (char *p, int length, struct type **type)
265 
{
266 
  struct gdb_wrapper_arguments args;
267 
  args.args[0].pointer = p;
268 
  args.args[1].integer = length;
269 
 
270 
  if (!catch_errors ((catch_errors_ftype *) wrap_parse_and_eval_type, &args,
271 
                     "", RETURN_MASK_ALL))
272 
    {
273 
      /* An error occurred */
274 
      return 0;
275 
    }
276 
 
277 
  *type = (struct type *) args.result.pointer;
278 
  return 1;
279 
}
280 
 
281 
static int
282 
wrap_parse_and_eval_type (char *a)
283 
{
284 
  struct gdb_wrapper_arguments *args = (struct gdb_wrapper_arguments *) a;
285 
 
286 
  char *p = (char *) args->args[0].pointer;
287 
  int length = args->args[1].integer;
288 
 
289 
  args->result.pointer = (char *) parse_and_eval_type (p, length);
290 
 
291 
  return 1;
292 
}

powered by: WebSVN 2.1.0

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