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

Subversion Repositories or1k

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

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.