1 /* ide-debugger-fallbacks.c
2 *
3 * Copyright 2017-2019 Christian Hergert <chergert@redhat.com>
4 *
5 * This program is free software: you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation, either version 3 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
17 *
18 * SPDX-License-Identifier: GPL-3.0-or-later
19 */
20
21 #define G_LOG_DOMAIN "ide-debugger-fallbacks"
22
23 #include "config.h"
24
25 #include "ide-debugger.h"
26 #include "ide-debugger-private.h"
27
28 void
_ide_debugger_real_list_frames_async(IdeDebugger * self,IdeDebuggerThread * thread,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)29 _ide_debugger_real_list_frames_async (IdeDebugger *self,
30 IdeDebuggerThread *thread,
31 GCancellable *cancellable,
32 GAsyncReadyCallback callback,
33 gpointer user_data)
34 {
35 g_assert (IDE_IS_DEBUGGER (self));
36 g_assert (!thread || IDE_IS_DEBUGGER_THREAD (thread));
37 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
38
39 g_task_report_new_error (self, callback, user_data,
40 _ide_debugger_real_list_frames_async,
41 G_IO_ERROR,
42 G_IO_ERROR_NOT_SUPPORTED,
43 "Listing stack frames is not supported");
44 }
45
46 GPtrArray *
_ide_debugger_real_list_frames_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)47 _ide_debugger_real_list_frames_finish (IdeDebugger *self,
48 GAsyncResult *result,
49 GError **error)
50 {
51 g_assert (IDE_IS_DEBUGGER (self));
52 g_assert (G_IS_ASYNC_RESULT (result));
53
54 return g_task_propagate_pointer (G_TASK (result), error);
55 }
56
57 void
_ide_debugger_real_interrupt_async(IdeDebugger * self,IdeDebuggerThreadGroup * thread_group,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)58 _ide_debugger_real_interrupt_async (IdeDebugger *self,
59 IdeDebuggerThreadGroup *thread_group,
60 GCancellable *cancellable,
61 GAsyncReadyCallback callback,
62 gpointer user_data)
63 {
64 g_assert (IDE_IS_DEBUGGER (self));
65 g_assert (!thread_group || IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
66 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
67
68 g_task_report_new_error (self, callback, user_data,
69 _ide_debugger_real_interrupt_async,
70 G_IO_ERROR,
71 G_IO_ERROR_NOT_SUPPORTED,
72 "Interrupting inferior is not supported");
73 }
74
75 gboolean
_ide_debugger_real_interrupt_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)76 _ide_debugger_real_interrupt_finish (IdeDebugger *self,
77 GAsyncResult *result,
78 GError **error)
79 {
80 g_assert (IDE_IS_DEBUGGER (self));
81 g_assert (G_IS_TASK (result));
82
83 return g_task_propagate_boolean (G_TASK (result), error);
84 }
85
86 void
_ide_debugger_real_send_signal_async(IdeDebugger * self,gint signum,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)87 _ide_debugger_real_send_signal_async (IdeDebugger *self,
88 gint signum,
89 GCancellable *cancellable,
90 GAsyncReadyCallback callback,
91 gpointer user_data)
92 {
93 g_assert (IDE_IS_DEBUGGER (self));
94 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
95
96 g_task_report_new_error (self, callback, user_data,
97 _ide_debugger_real_send_signal_async,
98 G_IO_ERROR,
99 G_IO_ERROR_NOT_SUPPORTED,
100 "Sending signals to inferior is not supported");
101 }
102
103 gboolean
_ide_debugger_real_send_signal_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)104 _ide_debugger_real_send_signal_finish (IdeDebugger *self,
105 GAsyncResult *result,
106 GError **error)
107 {
108 g_assert (IDE_IS_DEBUGGER (self));
109 g_assert (G_IS_TASK (result));
110
111 return g_task_propagate_boolean (G_TASK (result), error);
112 }
113
114 void
_ide_debugger_real_modify_breakpoint_async(IdeDebugger * self,IdeDebuggerBreakpointChange change,IdeDebuggerBreakpoint * breakpoint,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)115 _ide_debugger_real_modify_breakpoint_async (IdeDebugger *self,
116 IdeDebuggerBreakpointChange change,
117 IdeDebuggerBreakpoint *breakpoint,
118 GCancellable *cancellable,
119 GAsyncReadyCallback callback,
120 gpointer user_data)
121 {
122 g_assert (IDE_IS_DEBUGGER (self));
123 g_assert (IDE_IS_DEBUGGER_BREAKPOINT_CHANGE (change));
124 g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
125 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
126
127 g_task_report_new_error (self, callback, user_data,
128 _ide_debugger_real_modify_breakpoint_async,
129 G_IO_ERROR,
130 G_IO_ERROR_NOT_SUPPORTED,
131 "Modifying breakpoints is not supported");
132 }
133
134 gboolean
_ide_debugger_real_modify_breakpoint_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)135 _ide_debugger_real_modify_breakpoint_finish (IdeDebugger *self,
136 GAsyncResult *result,
137 GError **error)
138 {
139 g_assert (IDE_IS_DEBUGGER (self));
140 g_assert (G_IS_TASK (result));
141
142 return g_task_propagate_boolean (G_TASK (result), error);
143 }
144
145 void
_ide_debugger_real_list_locals_async(IdeDebugger * self,IdeDebuggerThread * thread,IdeDebuggerFrame * frame,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)146 _ide_debugger_real_list_locals_async (IdeDebugger *self,
147 IdeDebuggerThread *thread,
148 IdeDebuggerFrame *frame,
149 GCancellable *cancellable,
150 GAsyncReadyCallback callback,
151 gpointer user_data)
152 {
153 g_assert (IDE_IS_DEBUGGER (self));
154 g_assert (IDE_IS_DEBUGGER_THREAD (thread));
155 g_assert (IDE_IS_DEBUGGER_FRAME (frame));
156 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
157
158 g_task_report_new_error (self, callback, user_data,
159 _ide_debugger_real_list_locals_async,
160 G_IO_ERROR,
161 G_IO_ERROR_NOT_SUPPORTED,
162 "Listing locals is not supported");
163 }
164
165 GPtrArray *
_ide_debugger_real_list_locals_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)166 _ide_debugger_real_list_locals_finish (IdeDebugger *self,
167 GAsyncResult *result,
168 GError **error)
169 {
170 g_assert (IDE_IS_DEBUGGER (self));
171 g_assert (G_IS_TASK (result));
172
173 return g_task_propagate_pointer (G_TASK (result), error);
174 }
175
176 void
_ide_debugger_real_list_params_async(IdeDebugger * self,IdeDebuggerThread * thread,IdeDebuggerFrame * frame,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)177 _ide_debugger_real_list_params_async (IdeDebugger *self,
178 IdeDebuggerThread *thread,
179 IdeDebuggerFrame *frame,
180 GCancellable *cancellable,
181 GAsyncReadyCallback callback,
182 gpointer user_data)
183 {
184 g_assert (IDE_IS_DEBUGGER (self));
185 g_assert (IDE_IS_DEBUGGER_THREAD (thread));
186 g_assert (IDE_IS_DEBUGGER_FRAME (frame));
187 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
188
189 g_task_report_new_error (self, callback, user_data,
190 _ide_debugger_real_list_locals_async,
191 G_IO_ERROR,
192 G_IO_ERROR_NOT_SUPPORTED,
193 "Listing locals is not supported");
194 }
195
196 GPtrArray *
_ide_debugger_real_list_params_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)197 _ide_debugger_real_list_params_finish (IdeDebugger *self,
198 GAsyncResult *result,
199 GError **error)
200 {
201 g_assert (IDE_IS_DEBUGGER (self));
202 g_assert (G_IS_TASK (result));
203
204 return g_task_propagate_pointer (G_TASK (result), error);
205 }
206
207 void
_ide_debugger_real_list_registers_async(IdeDebugger * self,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)208 _ide_debugger_real_list_registers_async (IdeDebugger *self,
209 GCancellable *cancellable,
210 GAsyncReadyCallback callback,
211 gpointer user_data)
212 {
213 g_assert (IDE_IS_DEBUGGER (self));
214 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
215
216 g_task_report_new_error (self, callback, user_data,
217 _ide_debugger_real_list_registers_async,
218 G_IO_ERROR,
219 G_IO_ERROR_NOT_SUPPORTED,
220 "Listing registers is not supported");
221 }
222
223 GPtrArray *
_ide_debugger_real_list_registers_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)224 _ide_debugger_real_list_registers_finish (IdeDebugger *self,
225 GAsyncResult *result,
226 GError **error)
227 {
228 g_assert (IDE_IS_DEBUGGER (self));
229 g_assert (G_IS_TASK (result));
230
231 return g_task_propagate_pointer (G_TASK (result), error);
232 }
233
234 void
_ide_debugger_real_disassemble_async(IdeDebugger * self,const IdeDebuggerAddressRange * range,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)235 _ide_debugger_real_disassemble_async (IdeDebugger *self,
236 const IdeDebuggerAddressRange *range,
237 GCancellable *cancellable,
238 GAsyncReadyCallback callback,
239 gpointer user_data)
240 {
241 g_assert (IDE_IS_DEBUGGER (self));
242 g_assert (range != NULL);
243 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
244
245 g_task_report_new_error (self, callback, user_data,
246 _ide_debugger_real_disassemble_async,
247 G_IO_ERROR,
248 G_IO_ERROR_NOT_SUPPORTED,
249 "Disassembly is not supported");
250 }
251
252 GPtrArray *
_ide_debugger_real_disassemble_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)253 _ide_debugger_real_disassemble_finish (IdeDebugger *self,
254 GAsyncResult *result,
255 GError **error)
256 {
257 g_assert (IDE_IS_DEBUGGER (self));
258 g_assert (G_IS_TASK (result));
259
260 return g_task_propagate_pointer (G_TASK (result), error);
261 }
262
263 void
_ide_debugger_real_interpret_async(IdeDebugger * self,const gchar * command,GCancellable * cancellable,GAsyncReadyCallback callback,gpointer user_data)264 _ide_debugger_real_interpret_async (IdeDebugger *self,
265 const gchar *command,
266 GCancellable *cancellable,
267 GAsyncReadyCallback callback,
268 gpointer user_data)
269 {
270 g_assert (IDE_IS_DEBUGGER (self));
271 g_assert (command != NULL);
272 g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
273
274 g_task_report_new_error (self, callback, user_data,
275 _ide_debugger_real_interpret_async,
276 G_IO_ERROR,
277 G_IO_ERROR_NOT_SUPPORTED,
278 "Interpret command is not supported");
279 }
280
281 gboolean
_ide_debugger_real_interpret_finish(IdeDebugger * self,GAsyncResult * result,GError ** error)282 _ide_debugger_real_interpret_finish (IdeDebugger *self,
283 GAsyncResult *result,
284 GError **error)
285 {
286 g_assert (IDE_IS_DEBUGGER (self));
287 g_assert (G_IS_TASK (result));
288
289 return g_task_propagate_boolean (G_TASK (result), error);
290 }
291