[gnome-builder/wip/chergert/bug1: 9/42] gdb: add gdb based debugger implementation
- From: Christian Hergert <chergert src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [gnome-builder/wip/chergert/bug1: 9/42] gdb: add gdb based debugger implementation
- Date: Wed, 30 Aug 2017 06:30:27 +0000 (UTC)
commit d6f0a64c851b11facb3d697f5dc516235e8b8235
Author: Christian Hergert <chergert redhat com>
Date: Sat Aug 26 19:44:22 2017 -0700
gdb: add gdb based debugger implementation
This is a fairly minimal implementation. There is plenty more we can do
as we extend the IdeDebugger API for things like variable hover,
visualizers, and more.
meson_options.txt | 1 +
plugins/gdb/gbp-gdb-debugger.c | 2744 ++++++++++++++
plugins/gdb/gbp-gdb-debugger.h | 52 +
plugins/gdb/gbp-gdb-plugin.c | 27 +
plugins/gdb/gdb.plugin | 9 +
plugins/gdb/gdbwire.c | 7895 ++++++++++++++++++++++++++++++++++++++++
plugins/gdb/gdbwire.h | 3149 ++++++++++++++++
plugins/gdb/meson.build | 21 +
plugins/meson.build | 2 +
9 files changed, 13900 insertions(+), 0 deletions(-)
---
diff --git a/meson_options.txt b/meson_options.txt
index 38ac26c..6e35550 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -41,6 +41,7 @@ option('with_find_other_file', type: 'boolean')
option('with_flatpak', type: 'boolean')
option('with_fpaste', type: 'boolean')
option('with_gcc', type: 'boolean')
+option('with_gdb', type: 'boolean')
option('with_gettext', type: 'boolean')
option('with_git', type: 'boolean')
option('with_gnome_code_assistance', type: 'boolean')
diff --git a/plugins/gdb/gbp-gdb-debugger.c b/plugins/gdb/gbp-gdb-debugger.c
new file mode 100644
index 0000000..b2f0de8
--- /dev/null
+++ b/plugins/gdb/gbp-gdb-debugger.c
@@ -0,0 +1,2744 @@
+/* gbp-gdb-debugger.c
+ *
+ * Copyright (C) 2017 Christian Hergert <chergert redhat com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#define G_LOG_DOMAIN "gbp-gdb-debugger"
+
+#include <dazzle.h>
+#include <string.h>
+
+#include "gdbwire.h"
+#include "gbp-gdb-debugger.h"
+
+#define READ_BUFFER_LEN 4096
+
+struct _GbpGdbDebugger
+{
+ IdeDebugger parent_instance;
+
+ GIOStream *io_stream;
+ gchar *read_buffer;
+ GCancellable *read_cancellable;
+ GHashTable *register_names;
+
+ DzlSignalGroup *runner_signals;
+
+ /* This is the number for the fd in the inferrior process.
+ * It is not opened/owned by this instance (as it is in a
+ * different process space). No need to close.
+ */
+ gint mapped_fd;
+
+ struct gdbwire_mi_parser *parser;
+
+ GQueue writequeue;
+ GQueue cmdqueue;
+ guint cmdseq;
+};
+
+typedef struct
+{
+ GMainContext *context;
+ struct gdbwire_mi_output *output;
+ GError **error;
+ gboolean completed;
+} SyncHandle;
+
+G_DEFINE_TYPE (GbpGdbDebugger, gbp_gdb_debugger, IDE_TYPE_DEBUGGER)
+
+static void
+gbp_gdb_debugger_panic (GbpGdbDebugger *self)
+{
+ GList *list;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+
+ list = self->cmdqueue.head;
+
+ self->cmdqueue.head = NULL;
+ self->cmdqueue.tail = NULL;
+ self->cmdqueue.length = 0;
+
+ for (const GList *iter = list; iter != NULL; iter = iter->next)
+ {
+ g_autoptr(GTask) task = iter->data;
+
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_FAILED,
+ "There was a communication failure");
+ }
+
+ g_list_free (list);
+}
+
+static gboolean
+gbp_gdb_debugger_unwrap (const struct gdbwire_mi_output *output,
+ GError **error)
+{
+ if (output == NULL)
+ return FALSE;
+
+ if (output->variant.result_record->result_class == GDBWIRE_MI_ERROR)
+ {
+ const gchar *msg = output->line;
+
+ if (output->variant.result_record->result != NULL &&
+ output->variant.result_record->result->kind == GDBWIRE_MI_CSTRING)
+ msg = output->variant.result_record->result->variant.cstring;
+
+ g_set_error_literal (error,
+ G_IO_ERROR,
+ G_IO_ERROR_FAILED,
+ msg);
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static GTask *
+gbp_gdb_debugger_find_task (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+ g_assert (output->line != NULL);
+
+ /* Ignore thread switches */
+ if (g_str_has_prefix (output->line, "9999^"))
+ return NULL;
+
+ if (g_ascii_isdigit (output->line[0]))
+ {
+ g_autofree gchar *id = NULL;
+ guint i;
+
+ for (i = 1; g_ascii_isdigit (output->line[i]); i++)
+ continue;
+
+ id = g_strndup (output->line, i);
+
+ for (GList *iter = self->cmdqueue.head; iter; iter = iter->next)
+ {
+ GTask *task = iter->data;
+ const gchar *task_id = g_task_get_task_data (task);
+
+ if (strcmp (id, task_id) == 0)
+ {
+ g_queue_delete_link (&self->cmdqueue, iter);
+ return task;
+ }
+ }
+ }
+
+ return NULL;
+}
+
+static void
+gbp_gdb_debugger_cache_register_names (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT &&
+ output->variant.result_record->result->kind == GDBWIRE_MI_LIST &&
+ g_strcmp0 (output->variant.result_record->result->variable, "register-names") == 0)
+ {
+ const struct gdbwire_mi_result *res = output->variant.result_record->result;
+ const struct gdbwire_mi_result *iter;
+ g_autoptr(GHashTable) hash = NULL;
+ guint i = 0;
+
+ hash = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
+
+ for (iter = res->variant.result; iter; iter = iter->next, i++)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ g_hash_table_insert (hash,
+ g_strdup_printf ("%u", i),
+ g_strdup (iter->variant.cstring));
+ }
+
+ g_clear_pointer (&self->register_names, g_hash_table_unref);
+ self->register_names = g_steal_pointer (&hash);
+ }
+}
+
+static void
+gbp_gdb_debugger_handle_result (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ g_autoptr(GTask) task = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output->kind == GDBWIRE_MI_OUTPUT_RESULT);
+ g_assert (output->line != NULL);
+
+ task = gbp_gdb_debugger_find_task (self, output);
+
+ if (task != NULL)
+ {
+ g_task_return_pointer (task, output, (GDestroyNotify)gdbwire_mi_output_free);
+ return;
+ }
+
+ if (!g_str_has_prefix (output->line, "9999^"))
+ g_warning ("No reply found for: %s\n", output->line);
+
+ gdbwire_mi_output_free (output);
+}
+
+static void
+gbp_gdb_debugger_handle_thread_group (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output,
+ struct gdbwire_mi_async_record *rec)
+{
+ g_autoptr(IdeDebuggerThreadGroup) thread_group = NULL;
+ const struct gdbwire_mi_result *iter;
+ const gchar *id = NULL;
+ const gchar *pid = NULL;
+ const gchar *exit_code = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+ g_assert (rec != NULL);
+
+ for (iter = rec->result; iter != NULL; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "id") == 0)
+ id = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "pid") == 0)
+ pid = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "exit-code") == 0)
+ exit_code = iter->variant.cstring;
+ }
+ }
+
+ thread_group = ide_debugger_thread_group_new (id);
+ ide_debugger_thread_group_set_pid (thread_group, pid);
+ ide_debugger_thread_group_set_exit_code (thread_group, exit_code);
+
+ switch ((gint)rec->async_class)
+ {
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED:
+ ide_debugger_emit_thread_group_added (IDE_DEBUGGER (self), thread_group);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED:
+ ide_debugger_emit_thread_group_exited (IDE_DEBUGGER (self), thread_group);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED:
+ ide_debugger_emit_thread_group_removed (IDE_DEBUGGER (self), thread_group);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED:
+ ide_debugger_emit_thread_group_started (IDE_DEBUGGER (self), thread_group);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+gbp_gdb_debugger_handle_thread (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output,
+ struct gdbwire_mi_async_record *rec)
+{
+ g_autoptr(IdeDebuggerThread) thread = NULL;
+ const struct gdbwire_mi_result *iter;
+ const gchar *id = NULL;
+ const gchar *group_id = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+ g_assert (rec != NULL);
+
+ for (iter = rec->result; iter != NULL; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "id") == 0)
+ id = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "group-id") == 0)
+ group_id = iter->variant.cstring;
+ }
+ }
+
+ thread = ide_debugger_thread_new (id);
+ ide_debugger_thread_set_group (thread, group_id);
+
+ switch ((gint)rec->async_class)
+ {
+ case GDBWIRE_MI_ASYNC_THREAD_CREATED:
+ ide_debugger_emit_thread_added (IDE_DEBUGGER (self), thread);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_EXITED:
+ ide_debugger_emit_thread_removed (IDE_DEBUGGER (self), thread);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_SELECTED:
+ ide_debugger_emit_thread_selected (IDE_DEBUGGER (self), thread);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static IdeDebuggerBreakMode
+parse_mode_from_string (const gchar *str)
+{
+ if (str == NULL || g_str_equal (str, "breakpoint"))
+ return IDE_DEBUGGER_BREAK_BREAKPOINT;
+ else if (g_str_equal (str, "countpoint"))
+ return IDE_DEBUGGER_BREAK_COUNTPOINT;
+ else if (g_str_equal (str, "watchpoint"))
+ return IDE_DEBUGGER_BREAK_WATCHPOINT;
+ else
+ return IDE_DEBUGGER_BREAK_BREAKPOINT;
+}
+
+static IdeDebuggerDisposition
+parse_disposition_from_string (const gchar *str)
+{
+ if (str != NULL)
+ {
+ if (g_str_equal (str, "dis"))
+ return IDE_DEBUGGER_DISPOSITION_DISABLE;
+ else if (g_str_equal (str, "del"))
+ return IDE_DEBUGGER_DISPOSITION_DELETE_NEXT_HIT;
+ else if (g_str_equal (str, "keep"))
+ return IDE_DEBUGGER_DISPOSITION_KEEP;
+ else if (g_str_equal (str, "dstp"))
+ return IDE_DEBUGGER_DISPOSITION_DELETE_NEXT_STOP;
+ }
+
+ return IDE_DEBUGGER_DISPOSITION_KEEP;
+}
+
+static void
+gbp_gdb_debugger_handle_breakpoint (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output,
+ struct gdbwire_mi_result *res,
+ enum gdbwire_mi_async_class klass)
+{
+ g_autoptr(IdeDebuggerBreakpoint) breakpoint = NULL;
+ const struct gdbwire_mi_result *iter;
+ G_GNUC_UNUSED const gchar *fullname = NULL;
+ G_GNUC_UNUSED const gchar *original_location = NULL;
+ gboolean enabled = FALSE;
+ const gchar *id = NULL;
+ const gchar *type = NULL;
+ const gchar *disp = NULL;
+ const gchar *addr = NULL;
+ const gchar *times = NULL;
+ const gchar *func = NULL;
+ const gchar *file = NULL;
+ const gchar *line = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+
+ for (iter = res; iter != NULL; iter = iter->next)
+ {
+ try_again:
+
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "id") == 0 ||
+ g_strcmp0 (iter->variable, "number") == 0)
+ id = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "type") == 0)
+ type = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "disp") == 0)
+ disp = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "enabled") == 0)
+ enabled = (iter->variant.cstring[0] == 'y');
+ else if (g_strcmp0 (iter->variable, "addr") == 0)
+ addr = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "times") == 0)
+ times = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "func") == 0)
+ func = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "file") == 0)
+ file = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "fullname") == 0)
+ fullname = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "line") == 0)
+ line = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "original-location") == 0)
+ original_location = iter->variant.cstring;
+ }
+ else if (iter->kind == GDBWIRE_MI_TUPLE)
+ {
+ /* Dive into the bkpt={} if we got one */
+ if (g_strcmp0 (iter->variable, "bkpt") == 0)
+ {
+ iter = iter->variant.result;
+ goto try_again;
+ }
+ }
+ }
+
+ breakpoint = ide_debugger_breakpoint_new (id);
+
+ ide_debugger_breakpoint_set_mode (breakpoint, parse_mode_from_string (type));
+ ide_debugger_breakpoint_set_disposition (breakpoint, parse_disposition_from_string (disp));
+ ide_debugger_breakpoint_set_address (breakpoint, addr);
+ ide_debugger_breakpoint_set_function (breakpoint, func);
+ ide_debugger_breakpoint_set_file (breakpoint, file);
+ ide_debugger_breakpoint_set_enabled (breakpoint, enabled);
+
+ if (line != NULL)
+ ide_debugger_breakpoint_set_line (breakpoint, g_ascii_strtoll (line, NULL, 10));
+
+ if (times != NULL)
+ ide_debugger_breakpoint_set_count (breakpoint, g_ascii_strtoll (times, NULL, 10));
+
+ switch ((gint)klass)
+ {
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED:
+ ide_debugger_emit_breakpoint_added (IDE_DEBUGGER (self), breakpoint);
+ break;
+
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED:
+ ide_debugger_emit_breakpoint_removed (IDE_DEBUGGER (self), breakpoint);
+ break;
+
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED:
+ ide_debugger_emit_breakpoint_modified (IDE_DEBUGGER (self), breakpoint);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+gbp_gdb_debugger_handle_stopped (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output,
+ struct gdbwire_mi_async_record *rec)
+{
+ IdeDebuggerStopReason stop_reason;
+ g_autoptr(IdeDebuggerBreakpoint) breakpoint = NULL;
+ G_GNUC_UNUSED const gchar *thread_id = NULL;
+ const struct gdbwire_mi_result *iter;
+ const gchar *id = NULL;
+ const gchar *reason = NULL;
+ const gchar *disp = NULL;
+ const gchar *func = NULL;
+ const gchar *address = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+ g_assert (rec != NULL);
+
+ /*
+ * Example:
+ *
+ * *stopped,reason="breakpoint-hit",disp="keep",bkptno="1",
+ * frame={addr="0x0000555555572c70",func="main",args=[]},
+ * thread-id="1",stopped-threads="all",core="2"
+ */
+
+ for (iter = rec->result; iter != NULL; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "thread-id") == 0)
+ thread_id = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "reason") == 0)
+ reason = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "disp") == 0)
+ disp = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "bkptno") == 0)
+ id = iter->variant.cstring;
+ }
+ else if (iter->kind == GDBWIRE_MI_TUPLE)
+ {
+ if (g_strcmp0 (iter->variable, "frame") == 0)
+ {
+ const struct gdbwire_mi_result *subiter;
+
+ /*
+ * So the question here ... is should we inflate an entire
+ * stack frame instance for this, or simply stash it in the
+ * breakpoint function property ...
+ *
+ * We will have another way to get stack frames, so we don't
+ * exactly need it here...
+ */
+
+ for (subiter = iter->variant.result; subiter != NULL; subiter = subiter->next)
+ {
+ if (subiter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (subiter->variable, "func") == 0)
+ func = subiter->variant.cstring;
+ else if (g_strcmp0 (subiter->variable, "address") == 0)
+ address = subiter->variant.cstring;
+ }
+ }
+ }
+ }
+ }
+
+ if (FALSE) {}
+ else if (g_strcmp0 (reason, "exited-normally") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_EXITED_NORMALLY;
+ else if (g_strcmp0 (reason, "breakpoint-hit") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_BREAKPOINT_HIT;
+ else if (g_strcmp0 (reason, "function-finished") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_FUNCTION_FINISHED;
+ else if (g_strcmp0 (reason, "location-reached") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_LOCATION_REACHED;
+ else if (g_strcmp0 (reason, "exited-signaled") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_EXITED_SIGNALED;
+ else if (g_strcmp0 (reason, "exited") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_EXITED;
+ else if (g_strcmp0 (reason, "exited-normally") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_EXITED_NORMALLY;
+ else if (g_strcmp0 (reason, "signal-received") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_SIGNAL_RECEIVED;
+ else if (g_strcmp0 (reason, "solib-event") == 0 ||
+ g_strcmp0 (reason, "fork") == 0 ||
+ g_strcmp0 (reason, "vfork") == 0 ||
+ g_strcmp0 (reason, "syscall-entry") == 0 ||
+ g_strcmp0 (reason, "syscall-return") == 0 ||
+ g_strcmp0 (reason, "exec") == 0)
+ stop_reason = IDE_DEBUGGER_STOP_CATCH;
+ else
+ stop_reason = IDE_DEBUGGER_STOP_UNKNOWN;
+
+ breakpoint = ide_debugger_breakpoint_new (id);
+ ide_debugger_breakpoint_set_thread (breakpoint, thread_id);
+ ide_debugger_breakpoint_set_address (breakpoint, address);
+ ide_debugger_breakpoint_set_function (breakpoint, func);
+ ide_debugger_breakpoint_set_disposition (breakpoint, parse_disposition_from_string (disp));
+
+ gbp_gdb_debugger_reload_breakpoints (self);
+
+ ide_debugger_emit_stopped (IDE_DEBUGGER (self), stop_reason, breakpoint);
+}
+
+static void
+gbp_gdb_debugger_handle_library (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output,
+ struct gdbwire_mi_async_record *rec)
+{
+ g_autoptr(IdeDebuggerLibrary) library = NULL;
+ const struct gdbwire_mi_result *iter;
+ G_GNUC_UNUSED const gchar *thread_group = NULL;
+ G_GNUC_UNUSED const gchar *symbols_loaded = NULL;
+ const gchar *target_name = NULL;
+ const gchar *host_name = NULL;
+ g_autoptr(GArray) ranges = NULL;
+ const gchar *id = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+ g_assert (rec != NULL);
+
+ /*
+ * Example:
+ *
+ * Async record of a library loading looks something like this:
+ *
+ * =library-loaded,id="/lib64/libfreebl3.so",target-name="/lib64/libfreebl3.so",
+ * host-name="/lib64/libfreebl3.so",symbols-loaded="0",
+ * thread-group="i1",ranges=[{from="0x00007fffdfdfdab0",to="0x00007fffdfdfe1f0"}]
+ */
+
+ ranges = g_array_new (FALSE, FALSE, sizeof (IdeDebuggerAddressRange));
+
+ for (iter = rec->result; iter != NULL; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "id") == 0)
+ id = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "target-name") == 0)
+ target_name = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "host-name") == 0)
+ host_name = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "symbols-loaded") == 0)
+ symbols_loaded = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "thread-group") == 0)
+ thread_group = iter->variant.cstring;
+ }
+ else if (iter->kind == GDBWIRE_MI_LIST)
+ {
+ const struct gdbwire_mi_result *liter;
+
+ if (g_strcmp0 (iter->variable, "ranges") == 0)
+ {
+ for (liter = iter->variant.result; liter; liter = liter->next)
+ {
+ if (liter->kind == GDBWIRE_MI_TUPLE)
+ {
+ const struct gdbwire_mi_result *titer;
+ IdeDebuggerAddressRange range = { 0 };
+
+ for (titer = liter->variant.result; titer; titer = titer->next)
+ {
+ if (titer->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (titer->variable, "from") == 0)
+ range.from = ide_debugger_address_parse (titer->variant.cstring);
+ else if (g_strcmp0 (titer->variable, "to") == 0)
+ range.to = ide_debugger_address_parse (titer->variant.cstring);
+ }
+ }
+
+ if (range.from != IDE_DEBUGGER_ADDRESS_INVALID &&
+ range.to != IDE_DEBUGGER_ADDRESS_INVALID)
+ g_array_append_val (ranges, range);
+ }
+ }
+ }
+ }
+ }
+
+ library = ide_debugger_library_new (id);
+
+ ide_debugger_library_set_host_name (library, host_name);
+ ide_debugger_library_set_target_name (library, target_name);
+
+ for (guint i = 0; i < ranges->len; i++)
+ {
+ const IdeDebuggerAddressRange *range = &g_array_index (ranges, IdeDebuggerAddressRange, i);
+
+ ide_debugger_library_add_range (library, range);
+ }
+
+ if (rec->async_class == GDBWIRE_MI_ASYNC_LIBRARY_LOADED)
+ ide_debugger_emit_library_loaded (IDE_DEBUGGER (self), library);
+ else if (rec->async_class == GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED)
+ ide_debugger_emit_library_unloaded (IDE_DEBUGGER (self), library);
+ else
+ g_assert_not_reached ();
+}
+
+static void
+gbp_gdb_debugger_handle_oob_async_notify (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ struct gdbwire_mi_async_record *rec;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output->kind == GDBWIRE_MI_OUTPUT_OOB);
+ g_assert (output->variant.oob_record->kind == GDBWIRE_MI_ASYNC);
+ g_assert (output->variant.oob_record->variant.async_record->kind == GDBWIRE_MI_NOTIFY ||
+ output->variant.oob_record->variant.async_record->kind == GDBWIRE_MI_EXEC);
+
+ rec = output->variant.oob_record->variant.async_record;
+
+ /* Handle information about things like new breakpoints, etc */
+
+ switch (rec->async_class)
+ {
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED:
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED:
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED:
+ case GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED:
+ gbp_gdb_debugger_handle_thread_group (self, output, rec);
+ break;
+
+ case GDBWIRE_MI_ASYNC_THREAD_CREATED:
+ case GDBWIRE_MI_ASYNC_THREAD_EXITED:
+ case GDBWIRE_MI_ASYNC_THREAD_SELECTED:
+ gbp_gdb_debugger_handle_thread (self, output, rec);
+ break;
+
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED:
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED:
+ case GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED:
+ gbp_gdb_debugger_handle_breakpoint (self, output, rec->result, rec->async_class);
+ break;
+
+ case GDBWIRE_MI_ASYNC_RUNNING:
+ ide_debugger_emit_running (IDE_DEBUGGER (self));
+
+ if (!ide_debugger_get_selected_thread (IDE_DEBUGGER (self)))
+ {
+ g_autoptr(IdeDebuggerThread) thread = ide_debugger_thread_new ("1");
+
+ /* GDB doesn't notify us of our first selected thread */
+ ide_debugger_emit_thread_selected (IDE_DEBUGGER (self), thread);
+ }
+
+ break;
+
+ case GDBWIRE_MI_ASYNC_STOPPED:
+ gbp_gdb_debugger_handle_stopped (self, output, rec);
+ break;
+
+ case GDBWIRE_MI_ASYNC_LIBRARY_LOADED:
+ case GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED:
+ gbp_gdb_debugger_handle_library (self, output, rec);
+ break;
+
+ case GDBWIRE_MI_ASYNC_CMD_PARAM_CHANGED:
+ case GDBWIRE_MI_ASYNC_DOWNLOAD:
+ case GDBWIRE_MI_ASYNC_MEMORY_CHANGED:
+ case GDBWIRE_MI_ASYNC_RECORD_STARTED:
+ case GDBWIRE_MI_ASYNC_RECORD_STOPPED:
+ case GDBWIRE_MI_ASYNC_TRACEFRAME_CHANGED:
+ case GDBWIRE_MI_ASYNC_TSV_CREATED:
+ case GDBWIRE_MI_ASYNC_TSV_DELETED:
+ case GDBWIRE_MI_ASYNC_TSV_MODIFIED:
+ break;
+
+ case GDBWIRE_MI_ASYNC_UNSUPPORTED:
+ default:
+ g_return_if_reached ();
+ }
+}
+
+static void
+gbp_gdb_debugger_handle_oob_async_record (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output->kind == GDBWIRE_MI_OUTPUT_OOB);
+ g_assert (output->variant.oob_record->kind == GDBWIRE_MI_ASYNC);
+
+ switch (output->variant.oob_record->variant.async_record->kind)
+ {
+ case GDBWIRE_MI_STATUS:
+ /* discard */
+ break;
+
+ case GDBWIRE_MI_EXEC:
+ case GDBWIRE_MI_NOTIFY:
+ gbp_gdb_debugger_handle_oob_async_notify (self, output);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+
+static void
+gbp_gdb_debugger_handle_oob (GbpGdbDebugger *self,
+ struct gdbwire_mi_output *output)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output->kind == GDBWIRE_MI_OUTPUT_OOB);
+
+ switch (output->variant.oob_record->kind)
+ {
+ case GDBWIRE_MI_ASYNC:
+ gbp_gdb_debugger_handle_oob_async_record (self, output);
+ break;
+
+ case GDBWIRE_MI_STREAM:
+ {
+ IdeDebuggerStream stream = IDE_DEBUGGER_EVENT_LOG;
+ g_autoptr(GBytes) content = NULL;
+ const gchar *data;
+ gsize len;
+
+ if (output->variant.oob_record->variant.stream_record->kind == GDBWIRE_MI_CONSOLE)
+ stream = IDE_DEBUGGER_CONSOLE;
+ else if (output->variant.oob_record->variant.stream_record->kind == GDBWIRE_MI_LOG)
+ stream = IDE_DEBUGGER_EVENT_LOG;
+ else if (output->variant.oob_record->variant.stream_record->kind == GDBWIRE_MI_TARGET)
+ stream = IDE_DEBUGGER_TARGET;
+
+ data = output->variant.oob_record->variant.stream_record->cstring;
+ len = strlen (data);
+ content = g_bytes_new (data, len);
+
+ ide_debugger_emit_log (IDE_DEBUGGER (self), stream, content);
+ }
+ break;
+
+ default:
+ g_return_if_reached ();
+ }
+}
+
+static void
+gbp_gdb_debugger_output_callback (void *context,
+ struct gdbwire_mi_output *output)
+{
+ GbpGdbDebugger *self = context;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (output != NULL);
+
+ switch (output->kind)
+ {
+ case GDBWIRE_MI_OUTPUT_PARSE_ERROR:
+ g_warning ("Failed to parse gdb communication: %s", output->line);
+ gdbwire_mi_output_free (output);
+ gbp_gdb_debugger_panic (self);
+ break;
+
+ case GDBWIRE_MI_OUTPUT_OOB:
+ gbp_gdb_debugger_handle_oob (self, output);
+ gdbwire_mi_output_free (output);
+ break;
+
+ case GDBWIRE_MI_OUTPUT_RESULT:
+ /* handle result steals output pointer */
+ gbp_gdb_debugger_handle_result (self, output);
+ break;
+
+ case GDBWIRE_MI_OUTPUT_PROMPT:
+ /* Ignore prompt for now */
+ gdbwire_mi_output_free (output);
+ break;
+
+ default:
+ g_warning ("Unhandled output type: %d", output->kind);
+ gdbwire_mi_output_free (output);
+ }
+}
+
+static void
+gbp_gdb_debugger_list_breakpoints_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GPtrArray) ar = NULL;
+ g_autoptr(GError) error = NULL;
+ struct gdbwire_mi_command *command = NULL;
+ struct gdbwire_mi_output *output;
+ enum gdbwire_result res = GDBWIRE_LOGIC;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL)
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ return;
+ }
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT)
+ res = gdbwire_get_mi_command (GDBWIRE_MI_BREAK_INFO,
+ output->variant.result_record,
+ &command);
+
+ if (res != GDBWIRE_OK)
+ {
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_INVAL,
+ "Invalid reply from gdb");
+ return;
+ }
+
+ g_assert (command != NULL);
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ if (command->kind == GDBWIRE_MI_BREAK_INFO)
+ {
+ const struct gdbwire_mi_breakpoint *iter;
+
+ for (iter = command->variant.break_info.breakpoints; iter; iter = iter->next)
+ {
+ g_autoptr(IdeDebuggerBreakpoint) breakpoint = NULL;
+ IdeDebuggerDisposition disp;
+
+ breakpoint = ide_debugger_breakpoint_new (iter->number);
+
+ ide_debugger_breakpoint_set_address (breakpoint, iter->address);
+ ide_debugger_breakpoint_set_function (breakpoint, iter->func_name);
+ ide_debugger_breakpoint_set_file (breakpoint, iter->file);
+ ide_debugger_breakpoint_set_line (breakpoint, iter->line);
+ ide_debugger_breakpoint_set_count (breakpoint, iter->times);
+
+ switch (iter->disposition)
+ {
+ case GDBWIRE_MI_BP_DISP_DELETE:
+ disp = IDE_DEBUGGER_DISPOSITION_DELETE_NEXT_HIT;
+ break;
+
+ case GDBWIRE_MI_BP_DISP_DELETE_NEXT_STOP:
+ disp = IDE_DEBUGGER_DISPOSITION_DELETE_NEXT_STOP;
+ break;
+
+ case GDBWIRE_MI_BP_DISP_DISABLE:
+ disp = IDE_DEBUGGER_DISPOSITION_DISABLE;
+ break;
+
+ case GDBWIRE_MI_BP_DISP_UNKNOWN:
+ case GDBWIRE_MI_BP_DISP_KEEP:
+ default:
+ disp = IDE_DEBUGGER_DISPOSITION_KEEP;
+ break;
+ }
+
+ ide_debugger_breakpoint_set_disposition (breakpoint, disp);
+
+ g_ptr_array_add (ar, g_steal_pointer (&breakpoint));
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+ gdbwire_mi_command_free (command);
+ gdbwire_mi_output_free (output);
+}
+
+static void
+gbp_gdb_debugger_reload_breakpoints_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GError) error = NULL;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_warning ("%s", error->message);
+ goto cleanup;
+ }
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT &&
+ output->variant.result_record != NULL &&
+ output->variant.result_record->result_class == GDBWIRE_MI_DONE &&
+ output->variant.result_record->result != NULL &&
+ output->variant.result_record->result->kind == GDBWIRE_MI_TUPLE)
+ {
+ struct gdbwire_mi_result *tuple = output->variant.result_record->result;
+ struct gdbwire_mi_result *iter;
+
+ for (iter = tuple->variant.result; iter != NULL; iter = iter->next)
+ {
+ if (g_strcmp0 (iter->variable, "body") == 0 && iter->kind == GDBWIRE_MI_LIST)
+ {
+ struct gdbwire_mi_result *liter;
+
+ for (liter = iter->variant.result; liter != NULL; liter = liter->next)
+ {
+ if (g_strcmp0 (liter->variable, "bkpt") == 0)
+ gbp_gdb_debugger_handle_breakpoint (self,
+ output,
+ liter,
+ GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED);
+ }
+ }
+ }
+ }
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+/*
+ * gbp_gdb_debugger_reload_breakpoints:
+ * @self: a #GbpGdbDebugger
+ *
+ * Forces a reload of the breakpoints, emitting "breakpoint-modifed" for
+ * modified breakpoints and "breakpoint-inserted" for new ones.
+ *
+ * This is processed asynchronously.
+ */
+void
+gbp_gdb_debugger_reload_breakpoints (GbpGdbDebugger *self)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ "-break-list",
+ NULL,
+ gbp_gdb_debugger_reload_breakpoints_cb,
+ NULL);
+}
+
+static void
+gbp_gdb_debugger_list_breakpoints_async (IdeDebugger *debugger,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_list_breakpoints_async);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ "-break-info",
+ cancellable,
+ gbp_gdb_debugger_list_breakpoints_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_list_breakpoints_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_insert_breakpoint_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+ return;
+ }
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT &&
+ output->variant.result_record != NULL &&
+ output->variant.result_record->result != NULL)
+ {
+ gbp_gdb_debugger_handle_breakpoint (self,
+ output,
+ output->variant.result_record->result,
+ GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED);
+ g_task_return_boolean (task, TRUE);
+ }
+ else
+ {
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_FAILED,
+ "Failed to decode breakpoint reply");
+ }
+
+ gdbwire_mi_output_free (output);
+}
+
+static void
+gbp_gdb_debugger_insert_breakpoint_async (IdeDebugger *debugger,
+ IdeDebuggerBreakpoint *breakpoint,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GString) command = NULL;
+ g_autoptr(GTask) task = NULL;
+ const gchar *func;
+ const gchar *file;
+ const gchar *spec;
+ const gchar *thread;
+ guint line;
+
+ g_assert (IDE_IS_DEBUGGER (debugger));
+ g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_insert_breakpoint_async);
+ g_task_set_return_on_cancel (task, TRUE);
+
+ command = g_string_new ("-break-insert");
+
+ if (ide_debugger_breakpoint_get_enabled (breakpoint))
+ g_string_append (command, " -d");
+
+ if (NULL != (func = ide_debugger_breakpoint_get_function (breakpoint)))
+ g_string_append_printf (command, " --function %s", func);
+
+ if (NULL != (file = ide_debugger_breakpoint_get_file (breakpoint)))
+ g_string_append_printf (command, " --file %s", file);
+
+ if (0 != (line = ide_debugger_breakpoint_get_line (breakpoint)))
+ g_string_append_printf (command, " --line %u", line);
+
+ if (0 != (thread = ide_debugger_breakpoint_get_thread (breakpoint)))
+ g_string_append_printf (command, " -p %s", thread);
+
+ if (0 != (spec = ide_debugger_breakpoint_get_spec (breakpoint)))
+ g_string_append_printf (command, " -c %s", spec);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command->str,
+ cancellable,
+ gbp_gdb_debugger_insert_breakpoint_cb,
+ g_steal_pointer (&task));
+}
+
+static gboolean
+gbp_gdb_debugger_insert_breakpoint_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_remove_breakpoint_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ {
+ const gchar *id = g_task_get_task_data (task);
+ g_autoptr(IdeDebuggerBreakpoint) breakpoint = NULL;
+
+ g_assert (id != NULL);
+
+ breakpoint = ide_debugger_breakpoint_new (id);
+ ide_debugger_emit_breakpoint_removed (IDE_DEBUGGER (self), breakpoint);
+
+ g_task_return_boolean (task, TRUE);
+ }
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_remove_breakpoint_async (IdeDebugger *debugger,
+ IdeDebuggerBreakpoint *breakpoint,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+ const gchar *id;
+
+ g_assert (IDE_IS_DEBUGGER (self));
+ g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ id = ide_debugger_breakpoint_get_id (breakpoint);
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_remove_breakpoint_async);
+ g_task_set_task_data (task, g_strdup (id), g_free);
+ g_task_set_return_on_cancel (task, TRUE);
+
+ if (id == NULL)
+ {
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_INVAL,
+ "Invalid breakpoint identifier");
+ return;
+ }
+
+ command = g_strdup_printf ("-break-delete %s", id);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command,
+ cancellable,
+ gbp_gdb_debugger_remove_breakpoint_cb,
+ g_steal_pointer (&task));
+}
+
+static gboolean
+gbp_gdb_debugger_remove_breakpoint_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_list_register_names_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ struct gdbwire_mi_output *output;
+ g_autoptr(GError) error = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_warning ("%s", error->message);
+ goto cleanup;
+ }
+
+ gbp_gdb_debugger_cache_register_names (self, output);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_move_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ struct gdbwire_mi_output *output;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_move_async (IdeDebugger *debugger,
+ IdeDebuggerMovement movement,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ const gchar *command = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_IS_DEBUGGER_MOVEMENT (movement));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_move_async);
+
+ switch (movement)
+ {
+ case IDE_DEBUGGER_MOVEMENT_START:
+ command = "-exec-run --all --start";
+ break;
+
+ case IDE_DEBUGGER_MOVEMENT_CONTINUE:
+ command = "-exec-continue";
+ break;
+
+ case IDE_DEBUGGER_MOVEMENT_STEP_IN:
+ command = "-exec-step";
+ break;
+
+ case IDE_DEBUGGER_MOVEMENT_STEP_OVER:
+ command = "-exec-next";
+ break;
+
+ default:
+ g_return_if_reached ();
+ }
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command,
+ cancellable,
+ gbp_gdb_debugger_move_cb,
+ g_steal_pointer (&task));
+
+ /*
+ * After we've started, we can cache accurate register names.
+ * Doing this before we've started gives incorrect information.
+ */
+ if (self->register_names == NULL)
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ "-data-list-register-names",
+ NULL,
+ gbp_gdb_debugger_list_register_names_cb,
+ NULL);
+}
+
+static gboolean
+gbp_gdb_debugger_move_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_list_frames_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GPtrArray) ar = NULL;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ goto cleanup;
+ }
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT &&
+ output->variant.result_record != NULL &&
+ output->variant.result_record->result != NULL)
+ {
+ const struct gdbwire_mi_result *res = output->variant.result_record->result;
+
+ if (res->kind == GDBWIRE_MI_LIST)
+ {
+ const struct gdbwire_mi_result *liter;
+
+ for (liter = res->variant.result; liter != NULL; liter = liter->next)
+ {
+ if (liter->kind == GDBWIRE_MI_TUPLE)
+ {
+ g_autoptr(IdeDebuggerFrame) frame = NULL;
+ G_GNUC_UNUSED const gchar *fullname = NULL;
+ G_GNUC_UNUSED const gchar *from = NULL;
+ const struct gdbwire_mi_result *iter;
+ const gchar *func = NULL;
+ const gchar *file = NULL;
+ IdeDebuggerAddress addr = 0;
+ guint level = 0;
+ guint line = 0;
+
+ for (iter = liter->variant.result; iter; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (iter->variable, "level") == 0)
+ level = g_ascii_strtoll (iter->variant.cstring, NULL, 10);
+ else if (g_strcmp0 (iter->variable, "addr") == 0)
+ addr = ide_debugger_address_parse (iter->variant.cstring);
+ else if (g_strcmp0 (iter->variable, "func") == 0)
+ func = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "file") == 0)
+ file = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "fullname") == 0)
+ fullname = iter->variant.cstring;
+ else if (g_strcmp0 (iter->variable, "line") == 0)
+ line = g_ascii_strtoll (iter->variant.cstring, NULL, 10);
+ else if (g_strcmp0 (iter->variable, "from") == 0)
+ from = iter->variant.cstring;
+ }
+ }
+
+ frame = ide_debugger_frame_new ();
+
+ ide_debugger_frame_set_address (frame, addr);
+ ide_debugger_frame_set_function (frame, func);
+ ide_debugger_frame_set_file (frame, file);
+ ide_debugger_frame_set_line (frame, line);
+ ide_debugger_frame_set_depth (frame, level);
+
+ g_ptr_array_add (ar, g_steal_pointer (&frame));
+ }
+ }
+
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_list_frames_async (IdeDebugger *debugger,
+ IdeDebuggerThread *thread,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_DEBUGGER_THREAD (thread));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_list_frames_async);
+
+ /* TODO: We are expected to be stopped here, but we should also make sure
+ * the appropriate thread is selected first.
+ */
+
+ gbp_gdb_debugger_exec_async (self,
+ thread,
+ "-stack-list-frames",
+ cancellable,
+ gbp_gdb_debugger_list_frames_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_list_frames_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_interrupt_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ struct gdbwire_mi_output *output;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_interrupt_async (IdeDebugger *debugger,
+ IdeDebuggerThreadGroup *thread_group,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (!thread_group || IDE_IS_DEBUGGER_THREAD_GROUP (thread_group));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_interrupt_async);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ "-exec-interrupt --all",
+ cancellable,
+ gbp_gdb_debugger_interrupt_cb,
+ g_steal_pointer (&task));
+}
+
+static gboolean
+gbp_gdb_debugger_interrupt_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_send_signal_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ struct gdbwire_mi_output *output;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ /* We expect a NULL output because this command cannot have a reply
+ * that we can reliably wait for (not command id can be prefaced).
+ */
+
+ if (error != NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+
+static void
+gbp_gdb_debugger_send_signal_async (IdeDebugger *debugger,
+ gint signum,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_send_signal_async);
+
+ command = g_strdup_printf ("signal %d", signum);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command,
+ cancellable,
+ gbp_gdb_debugger_send_signal_cb,
+ g_steal_pointer (&task));
+}
+
+static gboolean
+gbp_gdb_debugger_send_signal_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_modify_breakpoint_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GTask) task = user_data;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_task_return_error (task, g_steal_pointer (&error));
+ else
+ g_task_return_boolean (task, TRUE);
+
+ gbp_gdb_debugger_reload_breakpoints (self);
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_modify_breakpoint_async (IdeDebugger *debugger,
+ IdeDebuggerBreakpointChange change,
+ IdeDebuggerBreakpoint *breakpoint,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_IS_DEBUGGER_BREAKPOINT_CHANGE (change));
+ g_assert (IDE_IS_DEBUGGER_BREAKPOINT (breakpoint));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_source_tag (task, gbp_gdb_debugger_modify_breakpoint_async);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+
+ switch (change)
+ {
+ case IDE_DEBUGGER_BREAKPOINT_CHANGE_ENABLED:
+ if (ide_debugger_breakpoint_get_enabled (breakpoint))
+ command = g_strdup_printf ("-break-enable %s",
+ ide_debugger_breakpoint_get_id (breakpoint));
+ else
+ command = g_strdup_printf ("-break-disable %s",
+ ide_debugger_breakpoint_get_id (breakpoint));
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+
+ if (command == NULL)
+ {
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_NOT_SUPPORTED,
+ "Unsupported change requested");
+ return;
+ }
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command,
+ cancellable,
+ gbp_gdb_debugger_modify_breakpoint_cb,
+ g_steal_pointer (&task));
+}
+
+static gboolean
+gbp_gdb_debugger_modify_breakpoint_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_boolean (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_list_locals_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GPtrArray) ar = NULL;
+ g_autoptr(GTask) task = user_data;
+ struct gdbwire_mi_output *output;
+ struct gdbwire_mi_result *res;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ goto cleanup;
+ }
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ /* Decode variables */
+
+ res = output->variant.result_record->result;
+
+ if (res->kind == GDBWIRE_MI_LIST &&
+ g_strcmp0 (res->variable, "locals") == 0)
+ {
+ struct gdbwire_mi_result *iter;
+
+ for (iter = res->variant.result; iter; iter = iter->next)
+ {
+ if (iter->kind == GDBWIRE_MI_TUPLE)
+ {
+ struct gdbwire_mi_result *titer;
+ g_autoptr(IdeDebuggerVariable) var = NULL;
+ G_GNUC_UNUSED const gchar *value = NULL;
+ const gchar *type = NULL;
+ const gchar *name = NULL;
+
+ for (titer = iter->variant.result; titer; titer = titer->next)
+ {
+ if (titer->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (titer->variable, "name") == 0)
+ name = titer->variant.cstring;
+ else if (g_strcmp0 (titer->variable, "type") == 0)
+ type = titer->variant.cstring;
+ else if (g_strcmp0 (titer->variable, "value") == 0)
+ value = titer->variant.cstring;
+ }
+ }
+
+ if (name == NULL)
+ continue;
+
+ var = ide_debugger_variable_new (name);
+ ide_debugger_variable_set_type_name (var, type);
+ ide_debugger_variable_set_value (var, value);
+
+ /* TODO: We really need to create frozen variables for this
+ * so that we can get the updated value.
+ */
+
+ g_ptr_array_add (ar, g_steal_pointer (&var));
+ }
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_list_locals_async (IdeDebugger *debugger,
+ IdeDebuggerThread *thread,
+ IdeDebuggerFrame *frame,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+ guint depth;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_IS_DEBUGGER_THREAD (thread));
+ g_assert (IDE_IS_DEBUGGER_FRAME (frame));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_list_locals_async);
+
+ depth = ide_debugger_frame_get_depth (frame);
+ command = g_strdup_printf ("9999-stack-select-frame %u\n"
+ "@@@@-stack-list-locals --simple-values\n"
+ "9999-stack-select-frame",
+ depth);
+
+ gbp_gdb_debugger_exec_async (self,
+ thread,
+ command,
+ cancellable,
+ gbp_gdb_debugger_list_locals_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_list_locals_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_list_params_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GPtrArray) ar = NULL;
+ g_autoptr(GError) error = NULL;
+ struct gdbwire_mi_output *output;
+ struct gdbwire_mi_result *res;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ goto cleanup;
+ }
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ res = output->variant.result_record->result;
+
+ if (res->kind == GDBWIRE_MI_LIST &&
+ g_strcmp0 (res->variable, "stack-args") == 0 &&
+ res->variant.result->kind == GDBWIRE_MI_TUPLE &&
+ g_strcmp0 (res->variant.result->variable, "frame") == 0)
+ {
+ const struct gdbwire_mi_result *titer;
+
+ for (titer = res->variant.result->variant.result; titer; titer = titer->next)
+ {
+ if (titer->kind == GDBWIRE_MI_LIST && g_strcmp0 (titer->variable, "args") == 0)
+ {
+ const struct gdbwire_mi_result *args;
+
+ for (args = titer->variant.result; args; args = args->next)
+ {
+ if (args->kind == GDBWIRE_MI_TUPLE)
+ {
+ g_autoptr(IdeDebuggerVariable) var = NULL;
+ const struct gdbwire_mi_result *arginfo;
+ const gchar *name = NULL;
+ const gchar *type = NULL;
+ const gchar *value = NULL;
+
+ for (arginfo = args->variant.result; arginfo; arginfo = arginfo->next)
+ {
+ if (arginfo->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (arginfo->variable, "name") == 0)
+ name = arginfo->variant.cstring;
+ else if (g_strcmp0 (arginfo->variable, "type") == 0)
+ type = arginfo->variant.cstring;
+ else if (g_strcmp0 (arginfo->variable, "value") == 0)
+ value = arginfo->variant.cstring;
+ }
+ }
+
+ var = ide_debugger_variable_new (name);
+ ide_debugger_variable_set_type_name (var, type);
+ ide_debugger_variable_set_value (var, value);
+
+ g_ptr_array_add (ar, g_steal_pointer (&var));
+ }
+ }
+ }
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_list_params_async (IdeDebugger *debugger,
+ IdeDebuggerThread *thread,
+ IdeDebuggerFrame *frame,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+ guint depth;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_IS_DEBUGGER_THREAD (thread));
+ g_assert (IDE_IS_DEBUGGER_FRAME (frame));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_list_params_async);
+
+ depth = ide_debugger_frame_get_depth (frame);
+ command = g_strdup_printf ("-stack-list-arguments --simple-values %u %u", depth, depth);
+
+ gbp_gdb_debugger_exec_async (self,
+ thread,
+ command,
+ cancellable,
+ gbp_gdb_debugger_list_params_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_list_params_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_list_registers_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GPtrArray) ar = NULL;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GTask) task = user_data;
+ struct gdbwire_mi_output *output;
+ struct gdbwire_mi_result *res;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (task));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ goto cleanup;
+ }
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ res = output->variant.result_record->result;
+
+ if (res->kind == GDBWIRE_MI_LIST &&
+ g_strcmp0 (res->variable, "register-values") == 0)
+ {
+ const struct gdbwire_mi_result *liter;
+
+ for (liter = res->variant.result; liter; liter = liter->next)
+ {
+ if (liter->kind == GDBWIRE_MI_TUPLE)
+ {
+ g_autoptr(IdeDebuggerRegister) reg = NULL;
+ const struct gdbwire_mi_result *titer;
+ const gchar *name = NULL;
+ const gchar *number = NULL;
+ const gchar *value = NULL;
+
+ for (titer = liter->variant.result; titer; titer = titer->next)
+ {
+ if (titer->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (titer->variable, "number") == 0)
+ number = titer->variant.cstring;
+ else if (g_strcmp0 (titer->variable, "value") == 0)
+ value = titer->variant.cstring;
+ }
+ }
+
+ if (number != NULL && self->register_names != NULL)
+ name = g_hash_table_lookup (self->register_names, number);
+
+ reg = ide_debugger_register_new (number);
+ ide_debugger_register_set_name (reg, name);
+ ide_debugger_register_set_value (reg, value);
+
+ g_ptr_array_add (ar, g_steal_pointer (®));
+ }
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_list_registers_async (IdeDebugger *debugger,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_list_registers_async);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ "-data-list-register-values x",
+ cancellable,
+ gbp_gdb_debugger_list_registers_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_list_registers_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static void
+gbp_gdb_debugger_disassemble_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GTask) task = user_data;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GPtrArray) ar = NULL;
+ struct gdbwire_mi_output *output;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (G_IS_TASK (result));
+
+ output = gbp_gdb_debugger_exec_finish (self, result, &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ goto cleanup;
+ }
+
+ ar = g_ptr_array_new_with_free_func (g_object_unref);
+
+ if (output->kind == GDBWIRE_MI_OUTPUT_RESULT &&
+ output->variant.result_record != NULL &&
+ output->variant.result_record->result_class == GDBWIRE_MI_DONE &&
+ output->variant.result_record->result != NULL &&
+ output->variant.result_record->result->kind == GDBWIRE_MI_LIST &&
+ g_strcmp0 (output->variant.result_record->result->variable, "asm_insns") == 0)
+ {
+ const struct gdbwire_mi_result *res = output->variant.result_record->result;
+ const struct gdbwire_mi_result *liter;
+
+ for (liter = res->variant.result; liter; liter = liter->next)
+ {
+ if (liter->kind == GDBWIRE_MI_TUPLE)
+ {
+ g_autoptr(IdeDebuggerInstruction) inst = NULL;
+ const struct gdbwire_mi_result *titer;
+ IdeDebuggerAddress addr = 0;
+ const gchar *func = NULL;
+ const gchar *display = NULL;
+
+ for (titer = liter->variant.result; titer; titer = titer->next)
+ {
+ if (titer->kind == GDBWIRE_MI_CSTRING)
+ {
+ if (g_strcmp0 (titer->variable, "address") == 0)
+ addr = ide_debugger_address_parse (titer->variant.cstring);
+ else if (g_strcmp0 (titer->variable, "func-name") == 0)
+ func = titer->variant.cstring;
+ else if (g_strcmp0 (titer->variable, "inst") == 0)
+ display = titer->variant.cstring;
+ }
+ }
+
+ inst = ide_debugger_instruction_new (addr);
+ ide_debugger_instruction_set_function (inst, func);
+ ide_debugger_instruction_set_display (inst, display);
+
+ g_ptr_array_add (ar, g_steal_pointer (&inst));
+ }
+ }
+ }
+
+ g_task_return_pointer (task, g_steal_pointer (&ar), (GDestroyNotify)g_ptr_array_unref);
+
+cleanup:
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static void
+gbp_gdb_debugger_disassemble_async (IdeDebugger *debugger,
+ const IdeDebuggerAddressRange *range,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ g_autoptr(GTask) task = NULL;
+ g_autofree gchar *command = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (range != NULL);
+ g_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_disassemble_async);
+
+ command = g_strdup_printf ("-data-disassemble -s 0x%"G_GINT64_MODIFIER"x -e 0x%"G_GINT64_MODIFIER"x 0",
+ range->from, range->to);
+
+ gbp_gdb_debugger_exec_async (self,
+ NULL,
+ command,
+ cancellable,
+ gbp_gdb_debugger_disassemble_cb,
+ g_steal_pointer (&task));
+}
+
+static GPtrArray *
+gbp_gdb_debugger_disassemble_finish (IdeDebugger *debugger,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (G_IS_TASK (result));
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
+
+static gboolean
+gbp_gdb_debugger_supports_runner (IdeDebugger *debugger,
+ IdeRunner *runner,
+ gint *priority)
+{
+ IdeRuntime *runtime;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (debugger));
+ g_assert (IDE_IS_RUNNER (runner));
+ g_assert (priority != NULL);
+
+ runtime = ide_runner_get_runtime (runner);
+
+ if (ide_runtime_contains_program_in_path (runtime, "gdb", NULL))
+ {
+ *priority = G_MAXINT;
+ return TRUE;
+ }
+
+ g_debug ("Failed to locate gdb in runtime");
+
+ return FALSE;
+}
+
+static void
+gbp_gdb_debugger_prepare (IdeDebugger *debugger,
+ IdeRunner *runner)
+{
+ static gchar *prepend_argv[] = { "gdb", "--interpreter", "mi2", "--args" };
+ GbpGdbDebugger *self = (GbpGdbDebugger *)debugger;
+ int tty_fd;
+
+ IDE_ENTRY;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (IDE_IS_RUNNER (runner));
+
+ /* Prepend arguments in reverse to preserve ordering */
+ for (guint i = G_N_ELEMENTS (prepend_argv); i > 0; i--)
+ ide_runner_prepend_argv (runner, prepend_argv [i-1]);
+
+ /* Connect to all our important signals */
+ dzl_signal_group_set_target (self->runner_signals, runner);
+
+ /*
+ * We steal and remap the PTY fd into the process so that gdb does not get
+ * the controlling terminal, but instead allow us to ask gdb to setup the
+ * inferrior with that same PTY.
+ */
+ if (-1 != (tty_fd = ide_runner_steal_tty (runner)))
+ self->mapped_fd = ide_runner_take_fd (runner, tty_fd, -1);
+
+ /* We need access to stdin/stdout for communicating with gdb */
+ ide_runner_set_flags (runner, G_SUBPROCESS_FLAGS_STDIN_PIPE | G_SUBPROCESS_FLAGS_STDOUT_PIPE);
+
+ IDE_EXIT;
+}
+
+static void
+gbp_gdb_debugger_on_runner_spawned (GbpGdbDebugger *self,
+ const gchar *identifier,
+ IdeRunner *runner)
+{
+ g_autoptr(GIOStream) io_stream = NULL;
+ g_autofree gchar *tty_command = NULL;
+
+ IDE_ENTRY;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (identifier != NULL);
+ g_assert (IDE_IS_RUNNER (runner));
+
+ /* Create an IOStream to track pipe communication with gdb */
+ io_stream = g_simple_io_stream_new (ide_runner_get_stdout (runner),
+ ide_runner_get_stdin (runner));
+
+ /* Start communicating with gdb */
+ gbp_gdb_debugger_connect (self, io_stream, NULL);
+
+ /* Ask gdb to use our mapped in FD for the TTY when spawning the child */
+ tty_command = g_strdup_printf ("-gdb-set inferior-tty /proc/self/fd/%d", self->mapped_fd);
+ gbp_gdb_debugger_exec_async (self, NULL, tty_command, NULL, NULL, NULL);
+
+ IDE_EXIT;
+}
+
+static void
+gbp_gdb_debugger_dispose (GObject *object)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ g_autoptr(GList) list = NULL;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+
+ list = self->cmdqueue.head;
+
+ self->cmdqueue.head = NULL;
+ self->cmdqueue.tail = NULL;
+ self->cmdqueue.length = 0;
+
+ for (const GList *iter = list; iter != NULL; iter = iter->next)
+ {
+ g_autoptr(GTask) task = iter->data;
+
+ g_task_return_new_error (task,
+ G_IO_ERROR,
+ G_IO_ERROR_CANCELLED,
+ "The task was canceled");
+ }
+
+ if (!g_cancellable_is_cancelled (self->read_cancellable))
+ g_cancellable_cancel (self->read_cancellable);
+
+ if (self->io_stream != NULL)
+ {
+ if (!g_io_stream_is_closed (self->io_stream))
+ g_io_stream_close (self->io_stream, NULL, NULL);
+ }
+
+ g_queue_foreach (&self->writequeue, (GFunc)g_bytes_unref, NULL);
+ g_queue_clear (&self->writequeue);
+
+ G_OBJECT_CLASS (gbp_gdb_debugger_parent_class)->finalize (object);
+}
+
+static void
+gbp_gdb_debugger_finalize (GObject *object)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+
+ /* Ensure no tasks were queued after dispose call */
+ g_assert (self->cmdqueue.length == 0);
+
+ g_clear_object (&self->io_stream);
+ g_clear_object (&self->read_cancellable);
+ g_clear_pointer (&self->parser, gdbwire_mi_parser_destroy);
+ g_clear_pointer (&self->read_buffer, g_free);
+ g_clear_pointer (&self->register_names, g_hash_table_unref);
+ g_queue_clear (&self->cmdqueue);
+
+ G_OBJECT_CLASS (gbp_gdb_debugger_parent_class)->finalize (object);
+}
+
+static void
+gbp_gdb_debugger_class_init (GbpGdbDebuggerClass *klass)
+{
+ GObjectClass *object_class = G_OBJECT_CLASS (klass);
+ IdeDebuggerClass *debugger_class = IDE_DEBUGGER_CLASS (klass);
+
+ object_class->dispose = gbp_gdb_debugger_dispose;
+ object_class->finalize = gbp_gdb_debugger_finalize;
+
+ debugger_class->supports_runner = gbp_gdb_debugger_supports_runner;
+ debugger_class->disassemble_async = gbp_gdb_debugger_disassemble_async;
+ debugger_class->disassemble_finish = gbp_gdb_debugger_disassemble_finish;
+ debugger_class->insert_breakpoint_async = gbp_gdb_debugger_insert_breakpoint_async;
+ debugger_class->insert_breakpoint_finish = gbp_gdb_debugger_insert_breakpoint_finish;
+ debugger_class->interrupt_async = gbp_gdb_debugger_interrupt_async;
+ debugger_class->interrupt_finish = gbp_gdb_debugger_interrupt_finish;
+ debugger_class->list_breakpoints_async = gbp_gdb_debugger_list_breakpoints_async;
+ debugger_class->list_breakpoints_finish = gbp_gdb_debugger_list_breakpoints_finish;
+ debugger_class->list_frames_async = gbp_gdb_debugger_list_frames_async;
+ debugger_class->list_frames_finish = gbp_gdb_debugger_list_frames_finish;
+ debugger_class->list_locals_async = gbp_gdb_debugger_list_locals_async;
+ debugger_class->list_locals_finish = gbp_gdb_debugger_list_locals_finish;
+ debugger_class->list_params_async = gbp_gdb_debugger_list_params_async;
+ debugger_class->list_params_finish = gbp_gdb_debugger_list_params_finish;
+ debugger_class->list_registers_async = gbp_gdb_debugger_list_registers_async;
+ debugger_class->list_registers_finish = gbp_gdb_debugger_list_registers_finish;
+ debugger_class->modify_breakpoint_async = gbp_gdb_debugger_modify_breakpoint_async;
+ debugger_class->modify_breakpoint_finish = gbp_gdb_debugger_modify_breakpoint_finish;
+ debugger_class->move_async = gbp_gdb_debugger_move_async;
+ debugger_class->move_finish = gbp_gdb_debugger_move_finish;
+ debugger_class->remove_breakpoint_async = gbp_gdb_debugger_remove_breakpoint_async;
+ debugger_class->remove_breakpoint_finish = gbp_gdb_debugger_remove_breakpoint_finish;
+ debugger_class->send_signal_async = gbp_gdb_debugger_send_signal_async;
+ debugger_class->send_signal_finish = gbp_gdb_debugger_send_signal_finish;
+}
+
+static void
+gbp_gdb_debugger_init (GbpGdbDebugger *self)
+{
+ struct gdbwire_mi_parser_callbacks callbacks = {
+ self, gbp_gdb_debugger_output_callback
+ };
+
+ self->parser = gdbwire_mi_parser_create (callbacks);
+ self->read_cancellable = g_cancellable_new ();
+ self->read_buffer = g_malloc (READ_BUFFER_LEN);
+
+ g_queue_init (&self->cmdqueue);
+
+ self->runner_signals = dzl_signal_group_new (IDE_TYPE_RUNNER);
+
+ dzl_signal_group_connect_object (self->runner_signals,
+ "spawned",
+ G_CALLBACK (gbp_gdb_debugger_on_runner_spawned),
+ self,
+ G_CONNECT_SWAPPED);
+}
+
+GbpGdbDebugger *
+gbp_gdb_debugger_new (void)
+{
+ return g_object_new (GBP_TYPE_GDB_DEBUGGER, NULL);
+}
+
+static void
+gbp_gdb_debugger_read_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ g_autoptr(GbpGdbDebugger) self = user_data;
+ GInputStream *stream = (GInputStream *)object;
+ g_autoptr(GError) error = NULL;
+ enum gdbwire_result res;
+ GCancellable *read_cancellable;
+ gchar *read_buffer;
+ gssize n_read;
+
+ g_assert (G_IS_INPUT_STREAM (stream));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+
+ n_read = g_input_stream_read_finish (stream, result, &error);
+
+ if (error != NULL)
+ {
+ if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) &&
+ !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CLOSED))
+ g_warning ("gdb client read failed: %s", error->message);
+ return;
+ }
+
+ if (n_read <= 0)
+ {
+ g_debug ("empty read from peer, possibly closed?");
+ return;
+ }
+
+#if 0
+ self->read_buffer[n_read] = 0;
+ g_printerr (")))%s", self->read_buffer);
+#endif
+
+ res = gdbwire_mi_parser_push_data (self->parser, self->read_buffer, n_read);
+
+ if (res != GDBWIRE_OK)
+ {
+ g_warning ("Failed to push data into gdbwire parser: %d", res);
+ return;
+ }
+
+ /* We can't access these inline because we need to steal *
+ * the self pointer for proper ownership management. */
+ read_buffer = self->read_buffer;
+ read_cancellable = self->read_cancellable;
+
+ g_input_stream_read_async (stream,
+ read_buffer,
+ READ_BUFFER_LEN,
+ G_PRIORITY_LOW,
+ read_cancellable,
+ gbp_gdb_debugger_read_cb,
+ g_steal_pointer (&self));
+}
+
+void
+gbp_gdb_debugger_connect (GbpGdbDebugger *self,
+ GIOStream *io_stream,
+ GCancellable *cancellable)
+{
+ struct gdbwire_mi_output *output;
+ g_autoptr(GError) error = NULL;
+ GInputStream *stream;
+
+ g_return_if_fail (GBP_IS_GDB_DEBUGGER (self));
+ g_return_if_fail (G_IS_IO_STREAM (io_stream));
+ g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+ g_set_object (&self->io_stream, io_stream);
+
+ stream = g_io_stream_get_input_stream (self->io_stream);
+
+ g_return_if_fail (stream != NULL);
+ g_return_if_fail (G_IS_INPUT_STREAM (stream));
+
+ g_input_stream_read_async (stream,
+ self->read_buffer,
+ READ_BUFFER_LEN,
+ G_PRIORITY_LOW,
+ self->read_cancellable,
+ gbp_gdb_debugger_read_cb,
+ g_object_ref (self));
+
+ /* Setup Async Execution in GDB */
+
+ output = gbp_gdb_debugger_exec (self,
+ NULL,
+ "-gdb-set mi-async on",
+ cancellable,
+ &error);
+
+ if (output == NULL || gbp_gdb_debugger_unwrap (output, &error))
+ g_warning ("%s", error->message);
+ else
+ gbp_gdb_debugger_reload_breakpoints (self);
+
+ g_clear_pointer (&output, gdbwire_mi_output_free);
+}
+
+static gboolean
+gbp_gdb_debugger_check_ready (GbpGdbDebugger *self,
+ GError **error)
+{
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+
+ if (self->io_stream == NULL || g_io_stream_is_closed (self->io_stream))
+ {
+ g_set_error (error,
+ G_IO_ERROR,
+ G_IO_ERROR_CLOSED,
+ "The connection to gdb is closed or has not been set");
+ return FALSE;
+ }
+
+ return TRUE;
+}
+
+static void
+gbp_gdb_debugger_exec_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GbpGdbDebugger *self = (GbpGdbDebugger *)object;
+ SyncHandle *sync_handle = user_data;
+
+ g_assert (GBP_IS_GDB_DEBUGGER (self));
+ g_assert (G_IS_ASYNC_RESULT (result));
+ g_assert (sync_handle != NULL);
+
+ sync_handle->output = gbp_gdb_debugger_exec_finish (self, result, sync_handle->error);
+ sync_handle->completed = TRUE;
+
+ g_assert (sync_handle->output != NULL || *sync_handle->error != NULL);
+
+ g_main_context_wakeup (sync_handle->context);
+}
+
+struct gdbwire_mi_output *
+gbp_gdb_debugger_exec (GbpGdbDebugger *self,
+ IdeDebuggerThread *thread,
+ const gchar *command,
+ GCancellable *cancellable,
+ GError **error)
+{
+ SyncHandle sync_handle;
+
+ g_return_val_if_fail (GBP_IS_GDB_DEBUGGER (self), NULL);
+ g_return_val_if_fail (command != NULL, NULL);
+ g_return_val_if_fail (!thread || IDE_IS_DEBUGGER_THREAD (thread), NULL);
+ g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
+
+ sync_handle.context = g_main_context_ref_thread_default ();
+ sync_handle.error = error;
+ sync_handle.output = NULL;
+ sync_handle.completed = FALSE;
+
+ gbp_gdb_debugger_exec_async (self,
+ thread,
+ command,
+ cancellable,
+ gbp_gdb_debugger_exec_cb,
+ &sync_handle);
+
+ while (!sync_handle.completed)
+ g_main_context_iteration (sync_handle.context, TRUE);
+ g_main_context_unref (sync_handle.context);
+
+ g_assert (sync_handle.output != NULL || *sync_handle.error != NULL);
+
+ return sync_handle.output;
+}
+
+static void
+gbp_gdb_debugger_write_cb (GObject *object,
+ GAsyncResult *result,
+ gpointer user_data)
+{
+ GOutputStream *stream = (GOutputStream *)object;
+ g_autoptr(GbpGdbDebugger) self = user_data;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GBytes) bytes = NULL;
+
+ g_assert (G_IS_OUTPUT_STREAM (stream));
+ g_assert (G_IS_ASYNC_RESULT (result));
+
+ g_output_stream_write_bytes_finish (stream, result, &error);
+
+ if (error != NULL)
+ {
+ g_warning ("%s", error->message);
+ gbp_gdb_debugger_panic (self);
+ return;
+ }
+
+ bytes = g_queue_pop_head (&self->writequeue);
+
+ if (bytes != NULL)
+ {
+ GCancellable *cancellable = self->read_cancellable;
+
+ g_output_stream_write_bytes_async (stream,
+ bytes,
+ G_PRIORITY_LOW,
+ cancellable,
+ gbp_gdb_debugger_write_cb,
+ g_steal_pointer (&self));
+ }
+}
+
+/**
+ * gbp_gdb_debugger_exec_async:
+ * @self: An #GbpGdbDebugger
+ * @thread: (nullable): An #IdeDebuggerThread or %NULL
+ * @command: the command to be executed
+ * @cancellable: (nullable): A #GCancellable or %NULL
+ * @user_data: user data for @cancellable
+ *
+ * Submits a command to the gdb process to be executed by the debugger.
+ *
+ * For this function to succeed, you must have already called
+ * gbp_gdb_debugger_connect().
+ *
+ * This asynchronous function will complete when we have received a response
+ * from the debugger with the result, or the connection has closed. Whichever
+ * is first.
+ *
+ * Since: 3.26
+ */
+void
+gbp_gdb_debugger_exec_async (GbpGdbDebugger *self,
+ IdeDebuggerThread *thread,
+ const gchar *command,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
+{
+ g_autoptr(GTask) task = NULL;
+ g_autoptr(GError) error = NULL;
+ g_autoptr(GBytes) bytes = NULL;
+ IdeDebuggerThread *selected;
+ GOutputStream *stream;
+ GString *str;
+ guint id;
+
+ g_return_if_fail (GBP_IS_GDB_DEBUGGER (self));
+ g_return_if_fail (command != NULL);
+ g_return_if_fail (!thread || IDE_IS_DEBUGGER_THREAD (thread));
+ g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+#if 0
+ {
+ guint i = 0;
+
+ g_print ("Submitting command with depth of %d\n",
+ g_queue_get_length (&self->cmdqueue));
+
+ for (const GList *iter = self->cmdqueue.head; iter; iter = iter->next, i++)
+ {
+ GBytes *b = g_object_get_data (iter->data, "REQUEST_BYTES");
+ g_print ("Queued[%u]: %s", i, (gchar *)g_bytes_get_data (b, NULL));
+ }
+ }
+#endif
+
+ /* Wrap at 10,000, but steal 9999 to use for thread switching */
+ id = ++self->cmdseq;
+ if (id == 9999)
+ id = self->cmdseq = 1;
+
+ task = g_task_new (self, cancellable, callback, user_data);
+ g_task_set_priority (task, G_PRIORITY_LOW);
+ g_task_set_source_tag (task, gbp_gdb_debugger_exec_async);
+ g_task_set_task_data (task, g_strdup_printf ("%03u", id), g_free);
+
+ if (!gbp_gdb_debugger_check_ready (self, &error))
+ {
+ g_task_return_error (task, g_steal_pointer (&error));
+ return;
+ }
+
+ g_assert (self->io_stream != NULL);
+ g_assert (!g_io_stream_is_closed (self->io_stream));
+
+ stream = g_io_stream_get_output_stream (self->io_stream);
+
+ str = g_string_new (NULL);
+
+ selected = ide_debugger_get_selected_thread (IDE_DEBUGGER (self));
+
+ /* We might need to switch threads before we execute the command. */
+ if (thread != NULL)
+ {
+ if (selected == NULL || ide_debugger_thread_compare (selected, thread) != 0)
+ {
+ const gchar *tid = ide_debugger_thread_get_id (thread);
+
+ /* We ignore 9999 commands */
+ g_string_append_printf (str, "9999-thread-select %s\n", tid);
+ }
+ }
+
+ if (command[0] == '-' || strstr (command, "@@@@") != NULL)
+ {
+ const gchar *at = strstr (command, "@@@@");
+
+ if (at != NULL)
+ {
+ g_string_append_len (str, command, at - command);
+ g_string_append_printf (str, "%03u", id);
+ g_string_append_printf (str, "%s", at + 4);
+ if (str->str[str->len - 1] != '\n')
+ g_string_append_c (str, '\n');
+ }
+ else
+ g_string_append_printf (str, "%03u%s\n", id, command);
+
+ /*
+ * Stash the task to be completed when we have received the result
+ * on the GInputStream and decoded via gdbwire.
+ */
+ g_queue_push_tail (&self->cmdqueue, g_object_ref (task));
+ }
+ else
+ {
+ /* This command is not one that we can get a reply for because it does
+ * not start with "-". So we will just send the result immediately and
+ * synthesize a NULL response.
+ */
+ g_string_append_printf (str, "%s\n", command);
+ g_task_return_pointer (task, NULL, NULL);
+ }
+
+ bytes = g_string_free_to_bytes (str);
+ g_object_set_data_full (G_OBJECT (task), "REQUEST_BYTES",
+ g_bytes_ref (bytes), (GDestroyNotify)g_bytes_unref);
+
+ if (g_output_stream_has_pending (stream) || self->writequeue.length > 0)
+ g_queue_push_tail (&self->writequeue, g_steal_pointer (&bytes));
+ else
+ g_output_stream_write_bytes_async (stream,
+ bytes,
+ G_PRIORITY_LOW,
+ self->read_cancellable,
+ gbp_gdb_debugger_write_cb,
+ g_object_ref (self));
+}
+
+/**
+ * gbp_gdb_debugger_exec_finish:
+ * @self: A #GbpGdbDebugger
+ * @result: A result provided to the async callback
+ * @error: a location for a #GError, or %NULL
+ *
+ * Completes an asynchronous operation to gbp_gdb_debugger_exec_async().
+ *
+ * Returns: a gdbwire_mi_output which should be freed with
+ * gdbwire_mi_output_free() when no longer in use.
+ */
+struct gdbwire_mi_output *
+gbp_gdb_debugger_exec_finish (GbpGdbDebugger *self,
+ GAsyncResult *result,
+ GError **error)
+{
+ g_return_val_if_fail (GBP_IS_GDB_DEBUGGER (self), NULL);
+ g_return_val_if_fail (G_IS_TASK (result), NULL);
+
+ return g_task_propagate_pointer (G_TASK (result), error);
+}
diff --git a/plugins/gdb/gbp-gdb-debugger.h b/plugins/gdb/gbp-gdb-debugger.h
new file mode 100644
index 0000000..feadd41
--- /dev/null
+++ b/plugins/gdb/gbp-gdb-debugger.h
@@ -0,0 +1,52 @@
+/* gbp-gdb-debugger.h
+ *
+ * Copyright (C) 2017 Christian Hergert <chergert redhat com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include <ide.h>
+
+#include "gdbwire.h"
+
+G_BEGIN_DECLS
+
+#define GBP_TYPE_GDB_DEBUGGER (gbp_gdb_debugger_get_type())
+
+G_DECLARE_FINAL_TYPE (GbpGdbDebugger, gbp_gdb_debugger, GBP, GDB_DEBUGGER, IdeDebugger)
+
+GbpGdbDebugger *gbp_gdb_debugger_new (void);
+void gbp_gdb_debugger_connect (GbpGdbDebugger *self,
+ GIOStream *io_stream,
+ GCancellable *cancellable);
+struct gdbwire_mi_output *gbp_gdb_debugger_exec (GbpGdbDebugger *self,
+ IdeDebuggerThread *thread,
+ const gchar *command,
+ GCancellable *cancellable,
+ GError **error);
+void gbp_gdb_debugger_exec_async (GbpGdbDebugger *self,
+ IdeDebuggerThread *thread,
+ const gchar *command,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+struct gdbwire_mi_output *gbp_gdb_debugger_exec_finish (GbpGdbDebugger *self,
+ GAsyncResult *result,
+ GError **error);
+void gbp_gdb_debugger_reload_breakpoints (GbpGdbDebugger *self);
+
+
+G_END_DECLS
diff --git a/plugins/gdb/gbp-gdb-plugin.c b/plugins/gdb/gbp-gdb-plugin.c
new file mode 100644
index 0000000..ccf7c17
--- /dev/null
+++ b/plugins/gdb/gbp-gdb-plugin.c
@@ -0,0 +1,27 @@
+/* gbp-gdb-plugin.c
+ *
+ * Copyright (C) 2017 Christian Hergert <chergert redhat com>
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <libpeas/peas.h>
+
+#include "gbp-gdb-debugger.h"
+
+void
+peas_register_types (PeasObjectModule *module)
+{
+ peas_object_module_register_extension_type (module, IDE_TYPE_DEBUGGER, GBP_TYPE_GDB_DEBUGGER);
+}
diff --git a/plugins/gdb/gdb.plugin b/plugins/gdb/gdb.plugin
new file mode 100644
index 0000000..13a6588
--- /dev/null
+++ b/plugins/gdb/gdb.plugin
@@ -0,0 +1,9 @@
+[Plugin]
+Module=gdb-plugin
+Name=Gdb
+Description=Provides integration with the GNU Debugger
+Authors=Christian Hergert <chergert redhat com>
+Copyright=Copyright © 2017 Christian Hergert
+Depends=debugger;editor;terminal
+Builtin=true
+Hidden=true
diff --git a/plugins/gdb/gdbwire.c b/plugins/gdb/gdbwire.c
new file mode 100644
index 0000000..8a4845a
--- /dev/null
+++ b/plugins/gdb/gdbwire.c
@@ -0,0 +1,7895 @@
+/**
+ * Copyright (C) 2013 Robert Rossi <bob brasko net>
+ *
+ * This file is an amalgamation of the source files from GDBWIRE.
+ *
+ * It was created using gdbwire 1.0 and git revision b5ae67f.
+ *
+ * GDBWIRE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GDBWIRE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GDBWIRE. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/***** Begin file gdbwire_sys.c **********************************************/
+#include <stdlib.h>
+#include <string.h>
+
+/***** Include gdbwire_sys.h in the middle of gdbwire_sys.c ******************/
+/***** Begin file gdbwire_sys.h **********************************************/
+#ifndef __GDBWIRE_SYS_H__
+#define __GDBWIRE_SYS_H__
+
+/**
+ * Supporting system functions.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Duplicate a string.
+ *
+ * @param str
+ * The string to duplicate
+ *
+ * @return
+ * An allocated string that must be freed.
+ * Null if out of memory or str is NULL.
+ */
+char *gdbwire_strdup(const char *str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_sys.h **************************************************/
+/***** Continuing where we left off in gdbwire_sys.c *************************/
+
+char *gdbwire_strdup(const char *str)
+{
+ char *result = NULL;
+
+ if (str) {
+ size_t length_to_allocate = strlen(str) + 1;
+ result = malloc(length_to_allocate * sizeof(char));
+ if (result) {
+ strcpy(result, str);
+ }
+ }
+
+ return result;
+}
+/***** End of gdbwire_sys.c **************************************************/
+/***** Begin file gdbwire_string.c *******************************************/
+#include <string.h>
+#include <stdlib.h>
+/***** Include gdbwire_string.h in the middle of gdbwire_string.c ************/
+/***** Begin file gdbwire_string.h *******************************************/
+#ifndef __GDBWIRE_STRING_H__
+#define __GDBWIRE_STRING_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+/**
+ * A dynamic string representation.
+ *
+ * To create and destroy a string use gdbwire_string_create() and
+ * gdbwire_string_destroy() respectively.
+ *
+ * This string is an abstraction of a low level C string. It supports being
+ * used as a NULL terminated c string and also as an arbitrary array of
+ * bytes. You can append to this string in either of these modes using
+ * gdbwire_string_append_cstr() or gdbwire_string_append_data(). This string
+ * automatically grows as you append data to it. Please note, the size of
+ * the string will not include the NULL terminated character when using
+ * the gdbwire_string_append_cstr() function to append data.
+ *
+ * To get access to the underlying bytes associated with this string
+ * call gdbwire_string_data(). It is OK to modify the result as long as
+ * you are careful to stay in it's valid bounds.
+ *
+ * The size (or length) of the string can be accessed through the
+ * gdbwire_string_size() function. The character pointer returned from
+ * gdbwire_string_data() is valid from the index range of 0 to
+ * gdbwire_string_size() - 1.
+ */
+struct gdbwire_string;
+
+/**
+ * Create a string instance.
+ *
+ * @return
+ * A valid string instance or NULL on error.
+ */
+struct gdbwire_string *gdbwire_string_create(void);
+
+/**
+ * Destroy the string instance and it's resources.
+ *
+ * @param string
+ * The string to destroy.
+ */
+void gdbwire_string_destroy(struct gdbwire_string *string);
+
+/**
+ * Clear the contents of a string.
+ *
+ * Sets the string back to an empty string which also changes it's
+ * size back to zero.
+ *
+ * The capacity remains unchanged.
+ *
+ * @param string
+ * The string to clear
+ */
+void gdbwire_string_clear(struct gdbwire_string *string);
+
+/**
+ * Append a c string to the string instance.
+ *
+ * @param string
+ * The string instance to append the c string to.
+ *
+ * @param cstr
+ * The c string to append to the string instance.
+ *
+ * @return
+ * 0 on success or -1 on failure.
+ */
+int gdbwire_string_append_cstr(struct gdbwire_string *string, const char *cstr);
+
+/**
+ * Append a sequence of bytes to the string instance.
+ *
+ * @param string
+ * The string instance to append the sequence of bytes to.
+ *
+ * @param data
+ * The sequence of bytes to append to the string instance. This may
+ * contain NUL characters.
+ *
+ * @param size
+ * The number of bytes in data to append to the string instance.
+ *
+ * @return
+ * 0 on success or -1 on failure.
+ */
+int gdbwire_string_append_data(struct gdbwire_string *string,
+ const char *data, size_t size);
+
+/**
+ * Get the data associated with this string.
+ *
+ * The data could be formatted as a NULL terminated C string or
+ * as an arbitrary array of bytes. Use gdbwire_string_size() to
+ * determine the size (or length) of the result of this function.
+ *
+ * Modifying the return value of this function is acceptable as long as you
+ * stay in the string's valid bounds.
+ *
+ * @param string
+ * The string index to get the pointer data from.
+ *
+ * @return
+ * The data that has been added to this string instance or "" after
+ * creation or clear. The result is gdbwire_string_size() bytes long.
+ */
+char *gdbwire_string_data(struct gdbwire_string *string);
+
+/**
+ * Determine the size (the number of bytes) this string instance represents.
+ *
+ * Please note, the result of this function will not include the NULL
+ * terminated character when using the gdbwire_string_append_cstr() function
+ * to append data.
+ *
+ * @param string
+ * The string instance to get the size for.
+ *
+ * @return
+ * The number of bytes contained in this string instance. To access these
+ * bytes see gdbwire_string_data(). Will be 0 after creation or clear.
+ */
+size_t gdbwire_string_size(struct gdbwire_string *string);
+
+/**
+ * Determine the maximum capacity (number of bytes) this string may hold.
+ *
+ * The max capacity of the string is automatically increased when data
+ * is appended to this string through the gdbwire_string_append_*()
+ * family of functions.
+ *
+ * @param string
+ * The string to determine the capacity of.
+ *
+ * @return
+ * The max number of bytes this string may hold.
+ */
+size_t gdbwire_string_capacity(struct gdbwire_string *string);
+
+/**
+ * Search for the first character in chars occuring in this string.
+ *
+ * @param string
+ * The string to search for the characters in chars in.
+ *
+ * @param chars
+ * A null terminated string of characters. This string is not searched
+ * for directly but instead each individually character in the string
+ * is searched for.
+ *
+ * @return
+ * The index position of the first matched character in chars.
+ * Will return gdbwire_string_size() if not found.
+ */
+size_t gdbwire_string_find_first_of(struct gdbwire_string *string,
+ const char *chars);
+
+/**
+ * Erase characters from this string, reducing it's size.
+ *
+ * @param string
+ * The string to erase characters from.
+ *
+ * @param pos
+ * The index position of the first character to be erased.
+ *
+ * @param count
+ * The number of characters to erase starting at position pos.
+ * If count goes past the end of the string it is adjusted to erase
+ * until the end of the string. This allows the caller to pass in
+ * gdbwire_string_size() to erase the end of the string with out
+ * doing index arithmetic.
+ *
+ * @return
+ * On success 0 will be returned otherwise -1. The string will remain
+ * unmodified when an error occurs. Success can only occur if the entire
+ * requested range can be erased.
+ */
+int gdbwire_string_erase(struct gdbwire_string *string, size_t pos,
+ size_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_string.h ***********************************************/
+/***** Continuing where we left off in gdbwire_string.c **********************/
+
+struct gdbwire_string {
+ /* The bytes that make up the string. May contain NUL characters. */
+ char *data;
+ /* The number of bytes occuring in data at the moment. */
+ size_t size;
+ /* The max capacity of the string */
+ size_t capacity;
+};
+
+struct gdbwire_string *
+gdbwire_string_create(void)
+{
+ struct gdbwire_string *string;
+
+ string = calloc(1, sizeof (struct gdbwire_string));
+ if (string) {
+ if (gdbwire_string_append_cstr(string, "") == -1) {
+ gdbwire_string_destroy(string);
+ string = NULL;
+ }
+ }
+
+ return string;
+}
+
+void
+gdbwire_string_destroy(struct gdbwire_string *string)
+{
+ if (string) {
+ if (string->data) {
+ free(string->data);
+ string->data = NULL;
+ }
+ string->size = 0;
+ string->capacity = 0;
+ free(string);
+ }
+}
+
+void
+gdbwire_string_clear(struct gdbwire_string *string)
+{
+ if (string) {
+ string->size = 0;
+ string->data[0] = '\0';
+ }
+}
+
+/**
+ * Increase the size of the string capacity.
+ *
+ * @param string
+ * The string to increase the capacity.
+ *
+ * @return
+ * 0 on success or -1 on error.
+ */
+static int
+gdbwire_string_increase_capacity(struct gdbwire_string *string)
+{
+ /**
+ * The algorithm chosen to increase the capacity is arbitrary.
+ * It starts at 128 bytes. It then doubles it's size in bytes like this,
+ * 128, 256, 512, 1024, 2048, 4096
+ * After it reaches 4096 it then grows by 4096 bytes at a time.
+ */
+ if (string->capacity == 0) {
+ string->capacity = 128;
+ } else if (string->capacity < 4096) {
+ string->capacity *= 2;
+ } else {
+ string->capacity += 4096;
+ }
+
+ /* At this point string->capacity is set to the new size, so realloc */
+ string->data = (char*)realloc(string->data, string->capacity);
+
+ return (string->data) ? 0 : -1;
+}
+
+int
+gdbwire_string_append_cstr(struct gdbwire_string *string, const char *cstr)
+{
+ int result;
+
+ if (string && cstr) {
+ size_t length = strlen(cstr) + 1;
+ result = gdbwire_string_append_data(string, cstr, length);
+ /* Do not include the NUL character in the size for NULL terminated
+ * strings. This is documented in the interface. */
+ if (result == 0) {
+ string->size--;
+ }
+ } else {
+ result = -1;
+ }
+
+ return result;
+}
+
+int
+gdbwire_string_append_data(struct gdbwire_string *string, const char *data,
+ size_t size)
+{
+ int result = (string && data) ? 0 : -1;
+ size_t data_index = 0;
+
+ for (; string && data && data_index < size; ++data_index, ++string->size) {
+ if (string->size >= string->capacity) {
+ result = gdbwire_string_increase_capacity(string);
+ if (result == -1) {
+ break;
+ }
+ }
+
+ string->data[string->size] = data[data_index];
+ }
+
+ return result;
+}
+
+char *
+gdbwire_string_data(struct gdbwire_string *string)
+{
+ char *result = NULL;
+
+ if (string) {
+ result = string->data;
+ }
+
+ return result;
+}
+
+size_t
+gdbwire_string_size(struct gdbwire_string *string)
+{
+ return string->size;
+}
+
+size_t
+gdbwire_string_capacity(struct gdbwire_string *string)
+{
+ return string->capacity;
+}
+
+size_t
+gdbwire_string_find_first_of(struct gdbwire_string *string, const char *chars)
+{
+ size_t data_pos, data_size = 0;
+ char *data_cur;
+ const char *chars_cur;
+
+ if (string && chars) {
+ data_size = gdbwire_string_size(string);
+ data_cur = gdbwire_string_data(string);
+
+ for (data_pos = 0; data_pos < data_size; ++data_pos) {
+ char data_c = data_cur[data_pos];
+ for (chars_cur = chars; *chars_cur; ++chars_cur) {
+ if (data_c == *chars_cur) {
+ return data_pos;
+ }
+ }
+ }
+ }
+
+ return data_size;
+}
+
+int
+gdbwire_string_erase(struct gdbwire_string *string, size_t pos, size_t count)
+{
+ int result = -1;
+
+ if (string) {
+ size_t count_erased = count;
+ size_t data_size = gdbwire_string_size(string);
+ char *data = gdbwire_string_data(string);
+
+ /* The position index must be smaller than the data size to be valid */
+ if (pos < data_size) {
+ size_t from_pos = pos + count;
+
+ /**
+ * Check to see if anything needs to be copied.
+ * If not, just null terminate the position to be erased
+ * Null terminating the string ensures the c string and the data
+ * string approach are both safe. In the data mode, the nul
+ * character is unneeded.
+ */
+ if (from_pos >= data_size) {
+ data[pos] = 0;
+ count_erased = data_size - pos;
+ /* If so, move characters from the from position
+ to the to position */
+ } else {
+ char *to_cur = &data[pos], *from_cur = &data[from_pos];
+
+ /* shift everything after the erase request to the left */
+ for (; from_pos < data_size; ++from_pos, ++to_cur, ++from_cur) {
+ *to_cur = *from_cur;
+ }
+ }
+ string->size -= count_erased;
+ result = 0;
+ }
+ }
+
+ return result;
+}
+/***** End of gdbwire_string.c ***********************************************/
+/***** Begin file gdbwire_logger.c *******************************************/
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+/***** Include gdbwire_logger.h in the middle of gdbwire_logger.c ************/
+/***** Begin file gdbwire_logger.h *******************************************/
+#ifndef __GDBWIRE_LOGGER_H__
+#define __GDBWIRE_LOGGER_H__
+
+/***** Include gdbwire_result.h in the middle of gdbwire_logger.h ************/
+/***** Begin file gdbwire_result.h *******************************************/
+#ifndef GDBWIRE_RESULT_H
+#define GDBWIRE_RESULT_H
+
+enum gdbwire_result {
+ /* The result of the operation was successful */
+ GDBWIRE_OK,
+
+ /**
+ * An assertion failed in the calling code.
+ *
+ * Functions are encouraged to assert expressions they expect
+ * to be true. The macro GDBWIRE_ASSERT and GDBWIRE_ASSERT_ERRNO
+ * are useful for asserting expressions, and upon failure, to
+ * automatically log the assertion expression and return
+ * this result status.
+ */
+ GDBWIRE_ASSERT,
+
+ /**
+ * An internal logic error has occurred.
+ *
+ * In general, this should be used when a function can no
+ * longer carry out it's contract and must abort.
+ *
+ * This happens, for instance, when a called function returns
+ * an error status, or when invalid input was provided, etc.
+ */
+ GDBWIRE_LOGIC,
+
+ /**
+ * The system is out of memory.
+ *
+ * Will occur when malloc, strdup, calloc, etc fail to allocate memory.
+ */
+ GDBWIRE_NOMEM
+};
+
+#endif /* GDBWIRE_RESULT_H */
+/***** End of gdbwire_result.h ***********************************************/
+/***** Continuing where we left off in gdbwire_logger.h **********************/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum gdbwire_logger_level {
+ GDBWIRE_LOGGER_DEBUG,
+ GDBWIRE_LOGGER_INFO,
+ GDBWIRE_LOGGER_WARN,
+ GDBWIRE_LOGGER_ERROR
+};
+
+/**
+ * Log a statement to the logger.
+ *
+ * This is typically not called directly. Use the below macros instead.
+ * The macros automatically supply the file, line and level arguments.
+ *
+ * @param file
+ * The filename the logger was invoked from.
+ *
+ * @param line
+ * The line number the logger was invoked from.
+ *
+ * @param level
+ * The level associated with the log message.
+ *
+ * @param fmt
+ * The format string for the message (printf formatting).
+ *
+ * @param ...
+ * Any additional format arguments.
+ */
+void gdbwire_logger_log(const char *file, int line,
+ enum gdbwire_logger_level level, const char *fmt, ...);
+
+/* The macros intended to be used for logging */
+#define gdbwire_debug(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_DEBUG, fmt, ##__VA_ARGS__))
+#define gdbwire_info(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_INFO, fmt, ##__VA_ARGS__))
+#define gdbwire_warn(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_WARN, fmt, ##__VA_ARGS__))
+#define gdbwire_error(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_ERROR, fmt, ##__VA_ARGS__))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_logger.h ***********************************************/
+/***** Continuing where we left off in gdbwire_logger.c **********************/
+
+static const char *gdbwire_logger_level_str[GDBWIRE_LOGGER_ERROR+1] = {
+ "DEBUG",
+ "INFO",
+ "WARN",
+ "ERROR"
+};
+
+void
+gdbwire_logger_log(const char *file, int line, enum gdbwire_logger_level level,
+ const char *fmt, ...)
+{
+ static int checked_env = 0;
+ static int gdbwire_debug_to_stderr;
+ char *buf;
+ int size;
+
+ va_list ap;
+ va_start(ap, fmt);
+
+ size = vsnprintf(0, 0, fmt, ap);
+ buf = malloc(sizeof(char)*size + 1);
+
+ va_start(ap, fmt);
+ size = vsnprintf(buf, size + 1, fmt, ap);
+ va_end(ap);
+
+ if (checked_env == 0) {
+ checked_env = 1;
+ gdbwire_debug_to_stderr = getenv("GDBWIRE_DEBUG_TO_STDERR") != NULL;
+ }
+
+ if (gdbwire_debug_to_stderr) {
+ fprintf(stderr, "gdbwire_logger_log: [%s] %s:%d %s\n",
+ gdbwire_logger_level_str[level], file, line, buf);
+ }
+
+ free(buf);
+}
+/***** End of gdbwire_logger.c ***********************************************/
+/***** Begin file gdbwire_mi_parser.c ****************************************/
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+/* #include "gdbwire_sys.h" */
+/***** Include gdbwire_assert.h in the middle of gdbwire_mi_parser.c *********/
+/***** Begin file gdbwire_assert.h *******************************************/
+#ifndef GDBWIRE_ERROR_H
+#define GDBWIRE_ERROR_H
+
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_logger.h" */
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * If the expression does not evaluate to true, log the error and
+ * return a GDBWIRE_ASSERT status code.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ */
+#define GDBWIRE_ASSERT(expr) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s]", #expr); \
+ return GDBWIRE_ASSERT; \
+ } \
+ } while (0)
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * If the expression does not evaluate to true, log the error,
+ * set the variable provided to GDBWIRE_ASSERT and goto the label
+ * provided.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ *
+ * @param variable
+ * The result variable to assign the value GDBWIRE_ASSERT to.
+ *
+ * @param label
+ * The label to jump to if the expression evaluates to False.
+ */
+#define GDBWIRE_ASSERT_GOTO(expr, variable, label) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s], " \
+ "label[%s]", #expr, #label); \
+ variable = GDBWIRE_ASSERT; \
+ goto label; \
+ } \
+ } while (0)
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * This particular assertion macro is used when a system library
+ * call fails and that library call has an associated errno status
+ * to describe the failure reason.
+ *
+ * If the expression does not evaluate to true, log the error,
+ * along with the errno value and message and return a GDBWIRE_ASSERT
+ * status code.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ */
+#define GDBWIRE_ASSERT_ERRNO(expr) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s]," \
+ "errno[%d], strerror[%s]", \
+ #expr, errno, strerror(errno)); \
+ return GDBWIRE_ASSERT; \
+ } \
+ } while (0)
+
+#endif /* GDBWIRE_ERROR_H */
+/***** End of gdbwire_assert.h ***********************************************/
+/***** Continuing where we left off in gdbwire_mi_parser.c *******************/
+/***** Include gdbwire_mi_grammar.h in the middle of gdbwire_mi_parser.c *****/
+/***** Begin file gdbwire_mi_grammar.h ***************************************/
+/* A Bison parser, made by GNU Bison 3.0.4. */
+
+/* Bison interface for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+#ifndef YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+# define YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int gdbwire_mi_debug;
+#endif
+/* "%code requires" blocks. */
+
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void *yyscan_t;
+#endif
+
+ struct gdbwire_mi_output;
+
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ OPEN_BRACE = 258,
+ CLOSED_BRACE = 259,
+ OPEN_PAREN = 260,
+ CLOSED_PAREN = 261,
+ ADD_OP = 262,
+ MULT_OP = 263,
+ EQUAL_SIGN = 264,
+ TILDA = 265,
+ AT_SYMBOL = 266,
+ AMPERSAND = 267,
+ OPEN_BRACKET = 268,
+ CLOSED_BRACKET = 269,
+ NEWLINE = 270,
+ INTEGER_LITERAL = 271,
+ STRING_LITERAL = 272,
+ CSTRING = 273,
+ COMMA = 274,
+ CARROT = 275
+ };
+#endif
+/* Tokens. */
+#define OPEN_BRACE 258
+#define CLOSED_BRACE 259
+#define OPEN_PAREN 260
+#define CLOSED_PAREN 261
+#define ADD_OP 262
+#define MULT_OP 263
+#define EQUAL_SIGN 264
+#define TILDA 265
+#define AT_SYMBOL 266
+#define AMPERSAND 267
+#define OPEN_BRACKET 268
+#define CLOSED_BRACKET 269
+#define NEWLINE 270
+#define INTEGER_LITERAL 271
+#define STRING_LITERAL 272
+#define CSTRING 273
+#define COMMA 274
+#define CARROT 275
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+
+ struct gdbwire_mi_output *u_output;
+ struct gdbwire_mi_oob_record *u_oob_record;
+ struct gdbwire_mi_result_record *u_result_record;
+ int u_result_class;
+ int u_async_record_kind;
+ struct gdbwire_mi_result_list *u_result_list;
+ struct gdbwire_mi_result *u_result;
+ char *u_token;
+ struct gdbwire_mi_async_record *u_async_record;
+ struct gdbwire_mi_stream_record *u_stream_record;
+ int u_async_class;
+ char *u_variable;
+ char *u_cstring;
+ struct gdbwire_mi_result *u_tuple;
+ struct gdbwire_mi_result *u_list;
+ int u_stream_record_kind;
+
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#ifndef YYPUSH_MORE_DEFINED
+# define YYPUSH_MORE_DEFINED
+enum { YYPUSH_MORE = 4 };
+#endif
+
+typedef struct gdbwire_mi_pstate gdbwire_mi_pstate;
+
+int gdbwire_mi_push_parse (gdbwire_mi_pstate *ps, int pushed_char, YYSTYPE const *pushed_val, yyscan_t
yyscanner, struct gdbwire_mi_output **gdbwire_mi_output);
+
+gdbwire_mi_pstate * gdbwire_mi_pstate_new (void);
+void gdbwire_mi_pstate_delete (gdbwire_mi_pstate *ps);
+
+#endif /* !YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED */
+/***** End of gdbwire_mi_grammar.h *******************************************/
+/***** Continuing where we left off in gdbwire_mi_parser.c *******************/
+/***** Include gdbwire_mi_parser.h in the middle of gdbwire_mi_parser.c ******/
+/***** Begin file gdbwire_mi_parser.h ****************************************/
+#ifndef GDBWIRE_MI_PARSER_H
+#define GDBWIRE_MI_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #include "gdbwire_result.h" */
+/***** Include gdbwire_mi_pt.h in the middle of gdbwire_mi_parser.h **********/
+/***** Begin file gdbwire_mi_pt.h ********************************************/
+#ifndef GDBWIRE_MI_PT_H
+#define GDBWIRE_MI_PT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The position of a token in a GDB/MI line.
+ *
+ * Note that a string in C is zero based and the token column
+ * position is 1 based. For example,
+ * char *str = "hello world";
+ * The "hello" token would have a start_column as 1 and an end
+ * column as 5.
+ *
+ * The start_column and end_column will be the same column number for
+ * a token of size 1.
+ */
+struct gdbwire_mi_position {
+ /* The starting column position of the token */
+ int start_column;
+ /* The ending column position of the token */
+ int end_column;
+};
+
+/** The gdbwire_mi output kinds. */
+enum gdbwire_mi_output_kind {
+ /**
+ * The GDB/MI output contains an out of band record.
+ *
+ * The out of band record is not necessarily associated with any
+ * particular GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_OOB,
+
+ /**
+ * The GDB/MI output contains a gdbwire_mi result record.
+ *
+ * This record typically contains the result data from a request
+ * made by the client in a previous GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_RESULT,
+
+ /**
+ * The GDB/MI output represents a prompt. (ie. (gdb) )
+ *
+ * TODO: Document when GDB is ready to receive a command. Only if
+ * the prompt is received and at *stopped?
+ */
+ GDBWIRE_MI_OUTPUT_PROMPT,
+
+ /**
+ * A parse error occurred.
+ */
+ GDBWIRE_MI_OUTPUT_PARSE_ERROR
+};
+
+/**
+ * The GDB/MI output command.
+ *
+ * A GDB/MI output command is the main mechanism in which GDB
+ * corresponds with a front end.
+ */
+struct gdbwire_mi_output {
+ enum gdbwire_mi_output_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_OUTPUT_OOB, never NULL. */
+ struct gdbwire_mi_oob_record *oob_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_RESULT, never NULL. */
+ struct gdbwire_mi_result_record *result_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_PARSE_ERROR, never NULL. */
+ struct {
+ /** The token the error occurred on */
+ char *token;
+ /** The position of the token where the error occurred. */
+ struct gdbwire_mi_position pos;
+ } error;
+ } variant;
+
+ /**
+ * The GDB/MI output line that was used to create this output instance.
+ *
+ * Each gdbwire_mi output structure is created from exactly one line of
+ * MI output from GDB. This field represents the line that created
+ * this particular output structure.
+ *
+ * This field is always available and never NULL, even for a parse error.
+ */
+ char *line;
+
+ /** The next GDB/MI output command or NULL if none */
+ struct gdbwire_mi_output *next;
+};
+
+/**
+ * A GDB/MI token.
+ *
+ * A string made up of one or more digits.
+ * The regular expression [0-9]+ will match this types contents.
+ */
+typedef char *gdbwire_mi_token_t;
+
+/**
+ * A GDB/MI output command may contain one of the following result indications.
+ */
+enum gdbwire_mi_result_class {
+ /**
+ * The synchronous operation was successful (^done).
+ */
+ GDBWIRE_MI_DONE,
+
+ /**
+ * Equivalent to GDBWIRE_MI_DONE (^running).
+ *
+ * Historically, was output by GDB instead of ^done if the command
+ * resumed the target.
+ *
+ * Do not rely on or use this result class in the front end to determine
+ * the state of the target. Use the async *running output record to
+ * determine which threads have resumed running.
+ *
+ * TODO: Ensure that early versions of GDB can depend on the async
+ * *running or if front ends DO have to rely on ^running.
+ */
+ GDBWIRE_MI_RUNNING,
+
+ /**
+ * GDB has connected to a remote target (^connected).
+ *
+ * This is in response to the -target-select command.
+ *
+ * A comment in the GDB source code says,
+ * There's no particularly good reason why target-connect results
+ * in not ^done. Should kill ^connected for MI3.
+ *
+ * With this in mind, it makes sense to assume that GDBWIRE_MI_CONNECTED
+ * and GDBWIRE_MI_DONE are equivalent.
+ */
+ GDBWIRE_MI_CONNECTED,
+
+ /**
+ * An error has occurred (^error).
+ *
+ * This can occur if the user provides an improper command to GDB.
+ * In this case, the user will be provided the standard error output but
+ * the front end will also be provided this information independently.
+ */
+ GDBWIRE_MI_ERROR,
+
+ /**
+ * GDB has terminated (^exit).
+ *
+ * When GDB knows it is about to exit, it provides this notification
+ * in the GDB/MI output command. However, on all other circumstances,
+ * the front end should be prepared to have GDB exit and not provide
+ * this information.
+ */
+ GDBWIRE_MI_EXIT,
+
+ /* An unsupported result class */
+ GDBWIRE_MI_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI result record in an output command.
+ *
+ * The result record represents the result data in the GDB/MI output
+ * command sent by GDB. This typically contains the content the client
+ * was requesting when it sent a GDB/MI input command to GDB.
+ */
+struct gdbwire_mi_result_record {
+ /**
+ * The token associated with the corresponding GDB/MI input command.
+ *
+ * The client may provide a unique string of digits at the beginning of a
+ * GDB/MI input command. For example,
+ * 0000-foo
+ * When GDB finally gets around to responding to the GDB/MI input command,
+ * it takes the token provided in the input command and puts it into the
+ * result record of the corresponding GDB/MI output command. For
+ * example, the output commmand associated with the above input command is,
+ * 0000^error,msg="Undefined MI command: foo",code="undefined-command"
+ * and the result record would have the below token field set to "0000".
+ *
+ * This is intended to allow the front end to correlate the GDB/MI input
+ * command it sent with the GDB/MI output command GDB responded with.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The result records result class. */
+ enum gdbwire_mi_result_class result_class;
+
+ /**
+ * An optional list of results for this result record.
+ *
+ * Will be NULL if there is no results for this result record.
+ *
+ * This is typically where the result data is that the client
+ * is looking for.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The out of band record kinds. */
+enum gdbwire_mi_oob_record_kind {
+ /**
+ * An asyncronous out of band record.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ *
+ * For instance, if the inferior has stopped, or a new thread has
+ * started.
+ */
+ GDBWIRE_MI_ASYNC,
+
+ /**
+ * A stream out of band record.
+ *
+ * This is the result of normal output from the console, target or GDB.
+ */
+ GDBWIRE_MI_STREAM
+};
+
+/* This is an out of band record. */
+struct gdbwire_mi_oob_record {
+ /** The kind of out of band record. */
+ enum gdbwire_mi_oob_record_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_ASYNC. */
+ struct gdbwire_mi_async_record *async_record;
+ /** When kind == GDBWIRE_MI_STREAM. */
+ struct gdbwire_mi_stream_record *stream_record;
+ } variant;
+};
+
+/** The asynchronous out of band record kinds */
+enum gdbwire_mi_async_record_kind {
+ /**
+ * The asynchronous status record kind.
+ *
+ * Contains on-going status information about the progress of a slow
+ * operation. It can be discarded.
+ *
+ * This output is prepended by the + character.
+ */
+ GDBWIRE_MI_STATUS,
+
+ /**
+ * The asynchronous exec record kind.
+ *
+ * Contains asynchronous state change regarding the target:
+ * (stopped, started, disappeared).
+ *
+ * This output is prepended by the * character.
+ */
+ GDBWIRE_MI_EXEC,
+
+ /**
+ * The asyncronous notify record kind.
+ *
+ * Contains supplementary information that the client should handle
+ * (e.g., a new breakpoint information).
+ *
+ * This output is prepended by the = character.
+ */
+ GDBWIRE_MI_NOTIFY
+};
+
+/** The stream out of band record kinds */
+enum gdbwire_mi_stream_record_kind {
+ /**
+ * The console output.
+ *
+ * Output that should be displayed as is in the console.
+ * It is the textual response to a CLI command.
+ *
+ * This output is prepended by the ~ character.
+ */
+ GDBWIRE_MI_CONSOLE,
+
+ /**
+ * The target output.
+ *
+ * Output produced by the target program.
+ *
+ * This output is prepended by the @ character.
+ */
+ GDBWIRE_MI_TARGET,
+
+ /**
+ * The GDB log output.
+ *
+ * Output text coming from GDB's internals. For instance messages
+ * that should be displayed as part of an error log.
+ *
+ * This output is prepended by the & character.
+ */
+ GDBWIRE_MI_LOG
+};
+
+/**
+ * The GDB/MI asyncronous class.
+ *
+ *
+ */
+enum gdbwire_mi_async_class {
+ /**
+ * Loading the executable onto the remote target.
+ *
+ * This was undocumented in the GDB manual as far as GDB 7.7.
+ *
+ * This occurs if the async record is GDBWIRE_MI_STATUS as +download.
+ */
+ GDBWIRE_MI_ASYNC_DOWNLOAD,
+
+ /**
+ * The target has stopped.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *stopped.
+ */
+ GDBWIRE_MI_ASYNC_STOPPED,
+
+ /**
+ * The target is now running.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *running.
+ */
+ GDBWIRE_MI_ASYNC_RUNNING,
+
+ /**
+ * Reports that a thread group was added.
+ *
+ * When a thread group is added, it generally might not be associated
+ * with a running process.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-added.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED,
+
+ /**
+ * Reports that a thread group was removed.
+ *
+ * When a thread group is removed, its id becomes invalid and cannot be
+ * used in any way.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-removed.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED,
+
+ /**
+ * Reports that a thread group was started.
+ *
+ * A thread group became associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-started.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED,
+
+ /**
+ * Reports that a thread group was exited.
+ *
+ * A thread group is no longer associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED,
+
+ /**
+ * Reports that a thread was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-created.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_CREATED,
+
+ /**
+ * Reports that a thread was exited.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_EXITED,
+
+ /**
+ * Reports that a thread was selected.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-selected.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_SELECTED,
+
+ /**
+ * Reports that a new library was loaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =library-loaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_LOADED,
+
+ /**
+ * Reports that a new library was unloaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =library-unloaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED,
+
+ /**
+ * Reports that a trace frame was changed.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =traceframe-changed.
+ */
+ GDBWIRE_MI_ASYNC_TRACEFRAME_CHANGED,
+
+ /**
+ * Reports that a trace state variable was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-created.
+ */
+ GDBWIRE_MI_ASYNC_TSV_CREATED,
+
+ /**
+ * Reports that a trace state variable was modified.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-modified.
+ */
+ GDBWIRE_MI_ASYNC_TSV_MODIFIED,
+
+ /**
+ * Reports that a trace state variable was deleted.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-deleted.
+ */
+ GDBWIRE_MI_ASYNC_TSV_DELETED,
+
+ /**
+ * Reports that a breakpoint was created.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-created.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED,
+
+ /**
+ * Reports that a breakpoint was modified.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-modified.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED,
+
+ /**
+ * Reports that a breakpoint was deleted.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-deleted.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED,
+
+ /**
+ * Reports that execution log recording was started on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIF
+ * as =record-started.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STARTED,
+
+ /**
+ * Reports that execution log recording was stopped on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =record-stopped.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STOPPED,
+
+ /**
+ * Reports that a parameter of the command set param is changed to value.
+ *
+ * For example, when the user runs a command like 'set print pretty on',
+ * this async command will be invoked with the parameter reported as
+ * 'print pretty' and the value as 'on'.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =cmd-param-changed.
+ */
+ GDBWIRE_MI_ASYNC_CMD_PARAM_CHANGED,
+
+ /**
+ * Reports that bytes from addr to data + len were written in an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =memory-changed.
+ */
+ GDBWIRE_MI_ASYNC_MEMORY_CHANGED,
+
+ /* An unsupported async class */
+ GDBWIRE_MI_ASYNC_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI asyncronous record in an output command.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ */
+struct gdbwire_mi_async_record {
+ /**
+ * The result record token.
+ *
+ * Please note that the GDB/MI manual says that asyncronous records
+ * do not currently populate this token on output but reserve the right
+ * to do so. For that reason, token here should always be NULL.
+ *
+ * From the GDB documentation:
+ * Note that for all async output, while the token is allowed by the
+ * grammar and may be output by future versions of gdb for select async
+ * output messages, it is generally omitted. Frontends should treat all
+ * async output as reporting general changes in the state of the target
+ * and there should be no need to associate async output to any prior
+ * command.
+ *
+ * After further investigation, I determined that newer GDB's will no
+ * longer ever output this information. Older GDB's will. The commit
+ * that made this change in GDB is 721c02de on April 24th, 2008.
+ * The next GDB that was released was on October 6th, 2009, version 7.0.
+ *
+ * Before the above mentioned commit async *stopped commands would
+ * sometimes output the token associated with the last token provided in
+ * a GDB/MI input command. After that change, the token is never
+ * associated with an async output command, even though the
+ * documentation says it might be.
+ *
+ * Finally, even before that change when the token was output in the
+ * async *stopped command, the developers of GDB felt that it was not
+ * useful and should be avoided by front ends.
+ *
+ * With this information, I've determined that front ends should never
+ * use this value to determine logic. However, the value is parsed in
+ * order to accurately handle and represent the cases where this value
+ * occurs.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The kind of asynchronous record. */
+ enum gdbwire_mi_async_record_kind kind;
+
+ /** The asynchronous output class */
+ enum gdbwire_mi_async_class async_class;
+
+ /**
+ * An optional list of results for this async output.
+ *
+ * Will be NULL if there is no results.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The GDB/MI result kind */
+enum gdbwire_mi_result_kind {
+ /** The result is a cstring */
+ GDBWIRE_MI_CSTRING,
+ /** The result is a tuple */
+ GDBWIRE_MI_TUPLE,
+ /** The result is a list */
+ GDBWIRE_MI_LIST
+};
+
+/**
+ * A GDB/MI result list.
+ *
+ * This is one of the important GDB/MI data structures. GDB communicates many
+ * of it's values to the front end through this key/value data structure.
+ *
+ * It is basically a list of key/value pairs, where the key is a
+ * variable name and the value expands to a string, a tuple of results or
+ * a list of results.
+ *
+ * This can be thought of as a custom json object.
+ */
+struct gdbwire_mi_result {
+ /** The kind of result this represents. */
+ enum gdbwire_mi_result_kind kind;
+
+ /** The key being described by the result. */
+ char *variable;
+
+ union {
+ /** When kind is GDBWIRE_MI_CSTRING */
+ char *cstring;
+
+ /**
+ * When kind is GDBWIRE_MI_TUPLE or GDBWIRE_MI_LIST.
+ *
+ * If kind is GDBWIRE_MI_TUPLE, each result in the tuple should have a
+ * valid key according to the GDB/MI specification. That is, for
+ * each result, result->variable should not be NULL.
+ * Note: GDBWIRE currently relaxes the above rule. It allows tuple's
+ * with out a key in each member. For instance, {key="value"}
+ * is what the GDB/MI specification advocates for, but some
+ * variations of GDB emit {"value"} and so GDBWIRE allows it.
+ *
+ * If kind is GDBWIRE_MI_LIST, the GDB/MI specification allows
+ * results in this list to not have keys. That is, for each result,
+ * result->variable may be NULL.
+ *
+ * Will be NULL if the tuple or list is empty.
+ */
+ struct gdbwire_mi_result *result;
+ } variant;
+
+ /** The next result or NULL if none */
+ struct gdbwire_mi_result *next;
+};
+
+/**
+ * An out of band GDB/MI stream record.
+ *
+ * A stream record is intended to provide the front end with information
+ * from the console, the target or from GDB itself.
+ */
+struct gdbwire_mi_stream_record {
+ /** The kind of stream record. */
+ enum gdbwire_mi_stream_record_kind kind;
+ /** The buffer provided in this stream record. */
+ char *cstring;
+};
+
+void gdbwire_mi_output_free(struct gdbwire_mi_output *param);
+
+struct gdbwire_mi_output *append_gdbwire_mi_output(
+ struct gdbwire_mi_output *list, struct gdbwire_mi_output *item);
+
+struct gdbwire_mi_result *append_gdbwire_mi_result(
+ struct gdbwire_mi_result *list, struct gdbwire_mi_result *item);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_pt.h ************************************************/
+/***** Continuing where we left off in gdbwire_mi_parser.h *******************/
+
+/* The opaque GDB/MI parser context */
+struct gdbwire_mi_parser;
+
+/**
+ * The primary mechanism to alert users of GDB/MI notifications.
+ *
+ * The flow is like this:
+ * - create a parser context (gdbwire_mi_parser_create)
+ * - push onto the parser arbitrary amounts of data (gdbwire_mi_parser_push)
+ * - receive callbacks from inside gdbwire_mi_parser_push when
+ * it discovers callbacks the user will find interesting
+ * - destroy the parser (gdbwire_mi_parser_destroy)
+ */
+struct gdbwire_mi_parser_callbacks {
+ /**
+ * An arbitrary pointer to associate with the callbacks.
+ *
+ * If the calling api is C++ it is useful to make this an instance
+ * of an object you want to bind to the callback functions below.
+ */
+ void *context;
+
+ /**
+ * A GDB/MI output command is available.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param output
+ * The gdbwire_mi output command. This output command is now owned by the
+ * function being invoked and should be destroyed when necessary.
+ */
+ void (*gdbwire_mi_output_callback)(void *context,
+ struct gdbwire_mi_output *output);
+};
+
+/**
+ * Create a GDB/MI parser context.
+ *
+ * @param callbacks
+ * The callback functions to invoke upon discovery of parse data.
+ *
+ * @return
+ * A new GDB/MI parser instance or NULL on error.
+ */
+struct gdbwire_mi_parser *gdbwire_mi_parser_create(
+ struct gdbwire_mi_parser_callbacks callbacks);
+
+/**
+ * Destroy a gdbwire_mi_parser context.
+ *
+ * This function will do nothing if parser is NULL.
+ *
+ * @param parser
+ * The instance the parser to destroy
+ */
+void gdbwire_mi_parser_destroy(struct gdbwire_mi_parser *parser);
+
+/**
+ * Push a null terminated string onto the parser.
+ *
+ * During this function, if a gdbwire_mi output command is discovered by
+ * the parser (or any other useful GDB/MI notification), it will invoke
+ * the appropriate callbacks assigned during parser creation.
+ *
+ * @param parser
+ * The gdbwire_mi parser context to operate on.
+ *
+ * @param data
+ * The parse data to push onto the parser.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_mi_parser_push(struct gdbwire_mi_parser *parser,
+ const char *data);
+
+/**
+ * Push some parse data onto the parser.
+ *
+ * See gdbwire_mi_parser_push for details on function behavior.
+ *
+ * @param parser
+ * The gdbwire_mi parser context to operate on.
+ *
+ * @param data
+ * The parse data to push onto the parser.
+ *
+ * @param size
+ * The size of the data to push onto the parser.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_mi_parser_push_data(
+ struct gdbwire_mi_parser *parser, const char *data, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_parser.h ********************************************/
+/***** Continuing where we left off in gdbwire_mi_parser.c *******************/
+/* #include "gdbwire_string.h" */
+
+/* flex prototypes used in this unit */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void *yyscan_t;
+#endif
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+/* Lexer set/destroy buffer to parse */
+extern YY_BUFFER_STATE gdbwire_mi__scan_string(
+ const char *yy_str, yyscan_t yyscanner);
+extern void gdbwire_mi__delete_buffer(YY_BUFFER_STATE state,
+ yyscan_t yyscanner);
+
+/* Lexer get token function */
+extern int gdbwire_mi_lex(yyscan_t yyscanner);
+extern char *gdbwire_mi_get_text(yyscan_t yyscanner);
+extern void gdbwire_mi_set_column(int column_no, yyscan_t yyscanner);
+
+/* Lexer state create/destroy functions */
+extern int gdbwire_mi_lex_init(yyscan_t *scanner);
+extern int gdbwire_mi_lex_destroy(yyscan_t scanner);
+
+struct gdbwire_mi_parser {
+ /* The buffer pushed into the parser from the user */
+ struct gdbwire_string *buffer;
+ /* The GDB/MI lexer state */
+ yyscan_t mils;
+ /* The GDB/MI push parser state */
+ gdbwire_mi_pstate *mips;
+ /* The client parser callbacks */
+ struct gdbwire_mi_parser_callbacks callbacks;
+};
+
+struct gdbwire_mi_parser *
+gdbwire_mi_parser_create(struct gdbwire_mi_parser_callbacks callbacks)
+{
+ struct gdbwire_mi_parser *parser;
+
+ parser = (struct gdbwire_mi_parser *)calloc(1,
+ sizeof(struct gdbwire_mi_parser));
+ if (!parser) {
+ return NULL;
+ }
+
+ /* Create a new buffer for the user to push parse data into */
+ parser->buffer = gdbwire_string_create();
+ if (!parser->buffer) {
+ free(parser);
+ return NULL;
+ }
+
+ /* Create a new lexer state instance */
+ if (gdbwire_mi_lex_init(&parser->mils) != 0) {
+ gdbwire_string_destroy(parser->buffer);
+ free(parser);
+ return NULL;
+ }
+
+ /* Create a new push parser state instance */
+ parser->mips = gdbwire_mi_pstate_new();
+ if (!parser->mips) {
+ gdbwire_mi_lex_destroy(parser->mils);
+ gdbwire_string_destroy(parser->buffer);
+ free(parser);
+ return NULL;
+ }
+
+ /* Ensure that the callbacks are non null */
+ if (!callbacks.gdbwire_mi_output_callback) {
+ gdbwire_mi_pstate_delete(parser->mips);
+ gdbwire_mi_lex_destroy(parser->mils);
+ gdbwire_string_destroy(parser->buffer);
+ free(parser);
+ return NULL;
+ }
+
+ parser->callbacks = callbacks;
+
+ return parser;
+}
+
+void gdbwire_mi_parser_destroy(struct gdbwire_mi_parser *parser)
+{
+ if (parser) {
+ /* Free the parse buffer */
+ if (parser->buffer) {
+ gdbwire_string_destroy(parser->buffer);
+ parser->buffer = NULL;
+ }
+
+ /* Free the lexer instance */
+ if (parser->mils) {
+ gdbwire_mi_lex_destroy(parser->mils);
+ parser->mils = 0;
+ }
+
+ /* Free the push parser instance */
+ if (parser->mips) {
+ gdbwire_mi_pstate_delete(parser->mips);
+ parser->mips = NULL;
+ }
+
+ free(parser);
+ parser = NULL;
+ }
+}
+
+static struct gdbwire_mi_parser_callbacks
+gdbwire_mi_parser_get_callbacks(struct gdbwire_mi_parser *parser)
+{
+ return parser->callbacks;
+}
+
+/**
+ * Parse a single line of output in GDB/MI format.
+ *
+ * The normal usage of this function is to call it over and over again with
+ * more data lines and wait for it to return an mi output command.
+ *
+ * @param parser
+ * The parser context to operate on.
+ *
+ * @param line
+ * A line of output in GDB/MI format to be parsed.
+ *
+ * \return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+static enum gdbwire_result
+gdbwire_mi_parser_parse_line(struct gdbwire_mi_parser *parser,
+ const char *line)
+{
+ struct gdbwire_mi_parser_callbacks callbacks =
+ gdbwire_mi_parser_get_callbacks(parser);
+ struct gdbwire_mi_output *output = 0;
+ YY_BUFFER_STATE state = 0;
+ int pattern, mi_status;
+
+ GDBWIRE_ASSERT(parser && line);
+
+ /* Create a new input buffer for flex. */
+ state = gdbwire_mi__scan_string(line, parser->mils);
+ GDBWIRE_ASSERT(state);
+ gdbwire_mi_set_column(1, parser->mils);
+
+ /* Iterate over all the tokens found in the scanner buffer */
+ do {
+ pattern = gdbwire_mi_lex(parser->mils);
+ if (pattern == 0)
+ break;
+ mi_status = gdbwire_mi_push_parse(parser->mips, pattern, NULL,
+ parser->mils, &output);
+ } while (mi_status == YYPUSH_MORE);
+
+ /* Free the scanners buffer */
+ gdbwire_mi__delete_buffer(state, parser->mils);
+
+ /**
+ * The push parser will return,
+ * - 0 if parsing was successful (return is due to end-of-input).
+ * - 1 if parsing failed because of invalid input, i.e., input
+ * that contains a syntax error or that causes YYABORT to be invoked.
+ * - 2 if parsing failed due to memory exhaustion.
+ * - YYPUSH_MORE if more input is required to finish parsing the grammar.
+ * Anything besides this would be unexpected.
+ *
+ * The grammar is designed to accept an infinate list of GDB/MI
+ * output commands. For this reason, YYPUSH_MORE is the expected
+ * return value of all the calls to gdbwire_mi_push_parse. However,
+ * in reality, gdbwire only translates a line at a time from GDB.
+ * When the line is finished, gdbwire_mi_lex returns 0, and the parsing
+ * is done.
+ */
+
+ /* Check mi_status, will be 1 on parse error, and YYPUSH_MORE on success */
+ GDBWIRE_ASSERT(mi_status == 1 || mi_status == YYPUSH_MORE);
+
+ /* Each GDB/MI line should produce an output command */
+ GDBWIRE_ASSERT(output);
+ output->line = gdbwire_strdup(line);
+
+ callbacks.gdbwire_mi_output_callback(callbacks.context, output);
+
+ return GDBWIRE_OK;
+}
+
+/**
+ * Get the next line available in the buffer.
+ *
+ * @param buffer
+ * The entire buffer the user has pushed onto the gdbwire_mi parser
+ * through gdbwire_mi_parser_push. If a line is found, the returned line
+ * will be removed from this buffer.
+ *
+ * @param line
+ * Will return as an allocated line if a line is available or NULL
+ * otherwise. If this function does not return GDBWIRE_OK then ignore
+ * the output of this parameter. It is the callers responsibility to
+ * free the memory.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+static enum gdbwire_result
+gdbwire_mi_parser_get_next_line(struct gdbwire_string *buffer,
+ struct gdbwire_string **line)
+{
+ enum gdbwire_result result = GDBWIRE_OK;
+
+ GDBWIRE_ASSERT(buffer && line);
+
+ char *data = gdbwire_string_data(buffer);
+ size_t size = gdbwire_string_size(buffer);
+ size_t pos = gdbwire_string_find_first_of(buffer, "\r\n");
+
+ /**
+ * Search to see if a newline has been reached in gdb/mi.
+ * If a line of data has been recieved, process it.
+ */
+ if (pos != size) {
+ int status;
+
+ /**
+ * We have the position of the newline character from
+ * gdbwire_string_find_first_of. However, the length must be
+ * calculated to make a copy of the line.
+ *
+ * This is either pos + 1 (for \r or \n) or pos + 1 + 1 for (\r\n).
+ * Check for\r\n for the special case.
+ */
+ size_t line_length = (data[pos] == '\r' && (pos + 1 < size) &&
+ data[pos + 1] == '\n') ? pos + 2 : pos + 1;
+
+ /**
+ * - allocate the buffer
+ * - append the new line
+ * - append a null terminating character
+ * - if successful, delete the new line found from buffer
+ * - any failures cleanup and return an error
+ */
+ *line = gdbwire_string_create();
+ GDBWIRE_ASSERT(*line);
+
+ status = gdbwire_string_append_data(*line, data, line_length);
+ GDBWIRE_ASSERT_GOTO(status == 0, result, cleanup);
+
+ status = gdbwire_string_append_data(*line, "\0", 1);
+ GDBWIRE_ASSERT_GOTO(status == 0, result, cleanup);
+
+ status = gdbwire_string_erase(buffer, 0, line_length);
+ GDBWIRE_ASSERT_GOTO(status == 0, result, cleanup);
+ }
+
+ return result;
+
+cleanup:
+ gdbwire_string_destroy(*line);
+ *line = 0;
+ return result;
+
+}
+
+enum gdbwire_result
+gdbwire_mi_parser_push(struct gdbwire_mi_parser *parser, const char *data)
+{
+ return gdbwire_mi_parser_push_data(parser, data, strlen(data));
+}
+
+enum gdbwire_result
+gdbwire_mi_parser_push_data(struct gdbwire_mi_parser *parser, const char *data,
+ size_t size)
+{
+ struct gdbwire_string *line = 0;
+ enum gdbwire_result result = GDBWIRE_OK;
+ int has_newline = 0;
+ size_t index;
+
+ GDBWIRE_ASSERT(parser && data);
+
+ /**
+ * No need to parse an MI command until a newline occurs.
+ *
+ * A gdb/mi command may be a very long line. For this reason, it is
+ * better to check the data passed into this function once for a newline
+ * rather than checking all the data every time this function is called.
+ * This optimizes the case where this function is called one character
+ * at a time.
+ */
+ for (index = size; index > 0; --index) {
+ if (data[index-1] == '\n' || data[index-1] == '\r') {
+ has_newline = 1;
+ break;
+ }
+ }
+
+ GDBWIRE_ASSERT(gdbwire_string_append_data(parser->buffer, data, size) == 0);
+
+ if (has_newline) {
+ for (;;) {
+ result = gdbwire_mi_parser_get_next_line(parser->buffer, &line);
+ GDBWIRE_ASSERT_GOTO(result == GDBWIRE_OK, result, cleanup);
+
+ if (line) {
+ result = gdbwire_mi_parser_parse_line(parser,
+ gdbwire_string_data(line));
+ gdbwire_string_destroy(line);
+ line = 0;
+ GDBWIRE_ASSERT_GOTO(result == GDBWIRE_OK, result, cleanup);
+ } else {
+ break;
+ }
+ }
+ }
+
+cleanup:
+ return result;
+}
+/***** End of gdbwire_mi_parser.c ********************************************/
+/***** Begin file gdbwire_mi_pt_alloc.c **************************************/
+#include <stdlib.h>
+
+/* #include "gdbwire_mi_pt.h" */
+/***** Include gdbwire_mi_pt_alloc.h in the middle of gdbwire_mi_pt_alloc.c **/
+/***** Begin file gdbwire_mi_pt_alloc.h **************************************/
+#ifndef GDBWIRE_MI_PT_ALLOC_H
+#define GDBWIRE_MI_PT_ALLOC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Responsible for allocating and deallocating gdbwire_mi_pt objects.
+ */
+
+/* struct gdbwire_mi_output */
+struct gdbwire_mi_output *gdbwire_mi_output_alloc(void);
+void gdbwire_mi_output_free(struct gdbwire_mi_output *param);
+
+/* struct gdbwire_mi_result_record */
+struct gdbwire_mi_result_record *gdbwire_mi_result_record_alloc(void);
+void gdbwire_mi_result_record_free(struct gdbwire_mi_result_record *param);
+
+/* struct gdbwire_mi_result */
+struct gdbwire_mi_result *gdbwire_mi_result_alloc(void);
+void gdbwire_mi_result_free(struct gdbwire_mi_result *param);
+
+/* struct gdbwire_mi_oob_record */
+struct gdbwire_mi_oob_record *gdbwire_mi_oob_record_alloc(void);
+void gdbwire_mi_oob_record_free(struct gdbwire_mi_oob_record *param);
+
+/* struct gdbwire_mi_async_record */
+struct gdbwire_mi_async_record *gdbwire_mi_async_record_alloc(void);
+void gdbwire_mi_async_record_free(struct gdbwire_mi_async_record *param);
+
+/* struct gdbwire_mi_stream_record */
+struct gdbwire_mi_stream_record *gdbwire_mi_stream_record_alloc(void);
+void gdbwire_mi_stream_record_free(struct gdbwire_mi_stream_record *param);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GDBWIRE_MI_PT_ALLOC_H */
+/***** End of gdbwire_mi_pt_alloc.h ******************************************/
+/***** Continuing where we left off in gdbwire_mi_pt_alloc.c *****************/
+
+/* struct gdbwire_mi_output */
+struct gdbwire_mi_output *
+gdbwire_mi_output_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_output));
+}
+
+void
+gdbwire_mi_output_free(struct gdbwire_mi_output *param)
+{
+ if (param) {
+ switch (param->kind) {
+ case GDBWIRE_MI_OUTPUT_OOB:
+ gdbwire_mi_oob_record_free(param->variant.oob_record);
+ param->variant.oob_record = NULL;
+ break;
+ case GDBWIRE_MI_OUTPUT_RESULT:
+ gdbwire_mi_result_record_free(param->variant.result_record);
+ param->variant.result_record = NULL;
+ break;
+ case GDBWIRE_MI_OUTPUT_PROMPT:
+ break;
+ case GDBWIRE_MI_OUTPUT_PARSE_ERROR:
+ free(param->variant.error.token);
+ param->variant.error.token = NULL;
+ break;
+ }
+
+ free(param->line);
+ param->line = 0;
+
+ gdbwire_mi_output_free(param->next);
+ param->next = NULL;
+
+ free(param);
+ param = NULL;
+ }
+}
+
+/* struct gdbwire_mi_result_record */
+struct gdbwire_mi_result_record *
+gdbwire_mi_result_record_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_result_record));
+}
+
+void
+gdbwire_mi_result_record_free(struct gdbwire_mi_result_record *param)
+{
+ if (param) {
+ free(param->token);
+
+ gdbwire_mi_result_free(param->result);
+ param->result = NULL;
+
+ free(param);
+ param = NULL;
+ }
+}
+
+/* struct gdbwire_mi_result */
+struct gdbwire_mi_result *
+gdbwire_mi_result_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_result));
+}
+
+void
+gdbwire_mi_result_free(struct gdbwire_mi_result *param)
+{
+ if (param) {
+ if (param->variable) {
+ free(param->variable);
+ param->variable = NULL;
+ }
+
+ switch (param->kind) {
+ case GDBWIRE_MI_CSTRING:
+ if (param->variant.cstring) {
+ free(param->variant.cstring);
+ param->variant.cstring = NULL;
+ }
+ break;
+ case GDBWIRE_MI_TUPLE:
+ case GDBWIRE_MI_LIST:
+ gdbwire_mi_result_free(param->variant.result);
+ param->variant.result = NULL;
+ break;
+ }
+
+ gdbwire_mi_result_free(param->next);
+ param->next = NULL;
+
+ free(param);
+ param = NULL;
+ }
+}
+
+/* struct gdbwire_mi_oob_record */
+struct gdbwire_mi_oob_record *
+gdbwire_mi_oob_record_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_oob_record));
+}
+
+void
+gdbwire_mi_oob_record_free(struct gdbwire_mi_oob_record *param)
+{
+ if (param) {
+ switch(param->kind) {
+ case GDBWIRE_MI_ASYNC:
+ gdbwire_mi_async_record_free(param->variant.async_record);
+ param->variant.async_record = NULL;
+ break;
+ case GDBWIRE_MI_STREAM:
+ gdbwire_mi_stream_record_free(param->variant.stream_record);
+ param->variant.stream_record = NULL;
+ break;
+ }
+
+ free(param);
+ param = NULL;
+ }
+}
+
+/* struct gdbwire_mi_async_record */
+struct gdbwire_mi_async_record *
+gdbwire_mi_async_record_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_async_record));
+}
+
+void
+gdbwire_mi_async_record_free(struct gdbwire_mi_async_record *param)
+{
+ if (param) {
+ free(param->token);
+
+ gdbwire_mi_result_free(param->result);
+ param->result = NULL;
+
+ free(param);
+ param = NULL;
+ }
+}
+
+/* struct gdbwire_mi_stream_record */
+struct gdbwire_mi_stream_record *
+gdbwire_mi_stream_record_alloc(void)
+{
+ return calloc(1, sizeof (struct gdbwire_mi_stream_record));
+}
+
+void
+gdbwire_mi_stream_record_free(struct gdbwire_mi_stream_record *param)
+{
+ if (param) {
+ if (param->cstring) {
+ free(param->cstring);
+ param->cstring = NULL;
+ }
+
+ free(param);
+ param = NULL;
+ }
+}
+/***** End of gdbwire_mi_pt_alloc.c ******************************************/
+/***** Begin file gdbwire_mi_pt.c ********************************************/
+#include <stdio.h>
+#include <stdlib.h>
+
+/* #include "gdbwire_mi_pt.h" */
+
+struct gdbwire_mi_output *
+append_gdbwire_mi_output(struct gdbwire_mi_output *list,
+ struct gdbwire_mi_output *item)
+{
+ if (!item)
+ return NULL;
+
+ if (!list)
+ list = item;
+ else {
+ struct gdbwire_mi_output *cur = list;
+
+ while (cur->next)
+ cur = cur->next;
+
+ cur->next = item;
+ }
+
+ return list;
+}
+
+struct gdbwire_mi_result *
+append_gdbwire_mi_result(struct gdbwire_mi_result *list,
+ struct gdbwire_mi_result *item)
+{
+ if (!item)
+ return NULL;
+
+ if (!list)
+ list = item;
+ else {
+ struct gdbwire_mi_result *cur = list;
+
+ while (cur->next)
+ cur = cur->next;
+
+ cur->next = item;
+ }
+
+ return list;
+}
+/***** End of gdbwire_mi_pt.c ************************************************/
+/***** Begin file gdbwire_mi_command.c ***************************************/
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+
+/* #include "gdbwire_sys.h" */
+/* #include "gdbwire_assert.h" */
+/***** Include gdbwire_mi_command.h in the middle of gdbwire_mi_command.c ****/
+/***** Begin file gdbwire_mi_command.h ***************************************/
+#ifndef GDBWIRE_MI_COMMAND_H
+#define GDBWIRE_MI_COMMAND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_mi_pt.h" */
+
+/**
+ * An enumeration representing the supported GDB/MI commands.
+ */
+enum gdbwire_mi_command_kind {
+ /* -break-info */
+ GDBWIRE_MI_BREAK_INFO,
+
+ /* -stack-info-frame */
+ GDBWIRE_MI_STACK_INFO_FRAME,
+
+ /* -file-list-exec-source-file */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE,
+ /* -file-list-exec-source-files */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES
+};
+
+/** A linked list of source files. */
+struct gdbwire_mi_source_file {
+ /** A relative path to a file, never NULL */
+ char *file;
+ /**An absolute path to a file, NULL if unavailable */
+ char *fullname;
+ /** The next file name or NULL if no more. */
+ struct gdbwire_mi_source_file *next;
+};
+
+/** The disposition of a breakpoint. What to do after hitting it. */
+enum gdbwire_mi_breakpoint_disp_kind {
+ GDBWIRE_MI_BP_DISP_DELETE, /** Delete on next hit */
+ GDBWIRE_MI_BP_DISP_DELETE_NEXT_STOP, /** Delete on next stop, hit or not */
+ GDBWIRE_MI_BP_DISP_DISABLE, /** Disable on next hit */
+ GDBWIRE_MI_BP_DISP_KEEP, /** Leave the breakpoint in place */
+ GDBWIRE_MI_BP_DISP_UNKNOWN /** When GDB doesn't specify */
+};
+
+/**
+ * A linked list of breakpoints.
+ *
+ * A breakpoint is a breakpoint, a tracepoint, a watchpoing or a
+ * catchpoint. The GDB breakpoint model is quite sophisticated.
+ * This structure can be extended when necessary.
+ */
+struct gdbwire_mi_breakpoint {
+ /**
+ * The breakpoint number.
+ *
+ * An integer, however, for a breakpoint that represents one location of
+ * a multiple location breakpoint, this will be a dotted pair, like ‘1.2’.
+ *
+ * Never NULL.
+ */
+ char *number;
+
+ /**
+ * Determines if this is a multiple location breakpoint.
+ *
+ * True for a multi-location breakpoint, false otherwise.
+ *
+ * It is possible that a breakpoint corresponds to several locations in
+ * your program. For example, several functions may have the same name.
+ * For the following source code,
+ * int foo(int p) { return p; }
+ * double foo(double p) { return p; }
+ * int main() { int i = 1; double d = 2.3; return foo(i) + foo(d); }
+ * If the user sets a breakpoint at foo by typing,
+ * b foo
+ * Then gdb will create 3 breakpoints. The multiple location breakpoint,
+ * which is the parent of the two breakpoints created for each foo
+ * function. Here is the output of gdb from the CLI perspective,
+ * Num Type Disp Enb Address What
+ * 1 breakpoint keep y <MULTIPLE>
+ * 1.1 y 0x4004dd in foo(int) at main.cpp:1
+ * 1.2 y 0x4004eb in foo(double) at main.cpp:2
+ *
+ * However, if the user created a breakpoint for main by typing,
+ * b main
+ * Then gdb will only create a single breakpoint which would look like,
+ * 1 breakpoint keep y 0x4004fa in main() at main.cpp:3
+ *
+ * When this is true, the address field will be "<MULTIPLE>" and
+ * the field multi_breakpoints will represent the breakpoints that this
+ * multiple location breakpoint has created.
+ */
+ unsigned char multi:1;
+
+ /**
+ * True for breakpoints of a multi-location breakpoint, otherwise false.
+ *
+ * For the example above, 1.1 and 1.2 would have this field set true.
+ *
+ * When this is true, the field multi_breakpoint will represent
+ * the multiple location breakpoint that has created this breakpoint.
+ */
+ unsigned char from_multi:1;
+
+ /**
+ * The breakpoint type.
+ *
+ * Typically "breakpoint", "watchpoint" or "catchpoint", but can be
+ * a variety of different values. In gdb, see breakpoint.c:bptype_string
+ * to see all the different possibilities.
+ *
+ * This will be NULL for breakpoints of a multiple location breakpoint.
+ * In this circumstance, check the multi_breakpoint field for the
+ * multiple location breakpoint type field.
+ */
+ char *type;
+
+ /**
+ * The type of the catchpoint or NULL if not a catch point.
+ *
+ * This field is only valid when the breakpoint is a catchpoint.
+ * Unfortuntely, gdb says the "type" of the breakpoint in the type field
+ * is "breakpoint" not "catchpoint". So if this field is non-NULL, it is
+ * safe to assume that this breakpoint represents at catch point.
+ */
+ char *catch_type;
+
+ /**
+ * The breakpoint disposition.
+ *
+ * For multiple location breakpoints, this will be
+ * GDBWIRE_MI_BP_DISP_UNKNOWN. In this circumstance, check the
+ * multi_breakpoint field for the multiple location breakpoint
+ * disposition field.
+ */
+ enum gdbwire_mi_breakpoint_disp_kind disposition;
+
+ /** True if enabled or False if disabled. */
+ unsigned char enabled:1;
+
+ /**
+ * The address of the breakpoint.
+ *
+ * This may be
+ * - a hexidecimal number, representing the address
+ * - the string ‘<PENDING>’ for a pending breakpoint
+ * - the string ‘<MULTIPLE>’ for a breakpoint with multiple locations
+ *
+ * This field will be NULL if no address can be determined.
+ * For example, a watchpoint does not have an address.
+ */
+ char *address;
+
+ /**
+ * The name of the function or NULL if unknown.
+ */
+ char *func_name;
+
+ /**
+ * A relative path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * An absolute path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * The line number the breakpoint is at or 0 if unkonwn.
+ */
+ unsigned long line;
+
+ /**
+ * The number of times this breakpoint has been hit.
+ *
+ * For breakpoints of multi-location breakpoints, this will be 0.
+ * Look at the multi-location breakpoint field instead.
+ */
+ unsigned long times;
+
+ /**
+ * The location of the breakpoint as originally specified by the user.
+ *
+ * This may be NULL for instance, for breakpoints for multi-breakpoints.
+ */
+ char *original_location;
+
+ /**
+ * True for a pending breakpoint, otherwise false.
+ *
+ * When this is true, the address field will be "<PENDING>".
+ */
+ unsigned char pending:1;
+
+ /**
+ * The breakpoints for a multi-location breakpoint.
+ *
+ * If multi is true, this will be the breakpoints associated with the
+ * multiple location breakpoint. Otherwise will be NULL.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoints;
+
+ /**
+ * A pointer to the multi location breakpoint that created this breakpoint.
+ *
+ * When the field from_multi is true, this will be a pointer to the
+ * multi-location breakpoint that created this breakpoint. Otherwise NULL.
+ *
+ * For the example above in the multi field, breakpoints 1.1 and 1.2
+ * would have this field pointing to the breakpoint 1.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoint;
+
+
+ /** The next breakpoint or NULL if no more. */
+ struct gdbwire_mi_breakpoint *next;
+};
+
+struct gdbwire_mi_stack_frame {
+ /**
+ * The frame number.
+ *
+ * Where 0 is the topmost frame, i.e., the innermost function.
+ *
+ * Always present.
+ */
+ unsigned level;
+
+ /**
+ * The address ($pc value) of the frame.
+ *
+ * May be NULL if GDB can not determine the frame address.
+ */
+ char *address;
+
+ /**
+ * The function name for the frame. May be NULL if unknown.
+ */
+ char *func;
+
+ /**
+ * The file name for the frame. May be NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * The fullname name for the frame. May be NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * Line number corresponding to the $pc. Maybe be 0 if unknown.
+ */
+ int line;
+
+ /**
+ * The shared library where this function is defined.
+ *
+ * This is only given if the frame's function is not known.
+ * May be NULL if unknown.
+ */
+ char *from;
+};
+
+/**
+ * Represents a GDB/MI command.
+ */
+struct gdbwire_mi_command {
+ /**
+ * The kind of mi command this represents.
+ */
+ enum gdbwire_mi_command_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_BREAK_INFO */
+ struct {
+ /** The list of breakpoints, NULL if none exist. */
+ struct gdbwire_mi_breakpoint *breakpoints;
+ } break_info;
+
+ /** When kind == GDBWIRE_MI_STACK_INFO_FRAME */
+ struct {
+ struct gdbwire_mi_stack_frame *frame;
+ } stack_info_frame;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE */
+ struct {
+ /**
+ * The line number the inferior is currently executing at.
+ */
+ int line;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is usually a relative path.
+ */
+ char *file;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is an absolute path.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ char *fullname;
+
+ /**
+ * Determines if the file includes preprocessor macro information.
+ *
+ * This command was added in 2004. However, the macro-info
+ * field was added to the output in 2008 in git commit 17784837.
+ *
+ * Only check this field if macro_info_exists is true.
+ */
+ char macro_info:1;
+
+ /** True if macro-info field was in mi output, otherwise false */
+ char macro_info_exists:1;
+ } file_list_exec_source_file;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES */
+ struct {
+ /**
+ * A list of files that make up the inferior.
+ *
+ * When there are no files (if the gdb does not have an inferior
+ * loaded) than files will be NULL.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ struct gdbwire_mi_source_file *files;
+ } file_list_exec_source_files;
+
+ } variant;
+};
+
+/**
+ * Get a gdbwire MI command from the result record.
+ *
+ * @param kind
+ * The kind of command the result record is associated with.
+ *
+ * @param result_record
+ * The result record to turn into a command.
+ *
+ * @param out_mi_command
+ * Will return an allocated gdbwire mi command if GDBWIRE_OK is returned
+ * from this function. You should free this memory with
+ * gdbwire_mi_command_free when you are done with it.
+ *
+ * @return
+ * The result of this function.
+ */
+enum gdbwire_result gdbwire_get_mi_command(
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out_mi_command);
+
+/**
+ * Free the gdbwire mi command.
+ *
+ * @param mi_command
+ * The mi command to free.
+ */
+void gdbwire_mi_command_free(struct gdbwire_mi_command *mi_command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_command.h *******************************************/
+/***** Continuing where we left off in gdbwire_mi_command.c ******************/
+
+/**
+ * Free a source file list.
+ *
+ * @param files
+ * The source file list to free, OK to pass in NULL.
+ */
+static void
+gdbwire_mi_source_files_free(struct gdbwire_mi_source_file *files)
+{
+ struct gdbwire_mi_source_file *tmp, *cur = files;
+ while (cur) {
+ free(cur->file);
+ free(cur->fullname);
+ tmp = cur;
+ cur = cur->next;
+ free(tmp);
+ }
+}
+
+/**
+ * Free a breakpoint list.
+ *
+ * @param breakpoints
+ * The breakpoint list to free, OK to pass in NULL.
+ */
+static void
+gdbwire_mi_breakpoints_free(struct gdbwire_mi_breakpoint *breakpoints)
+{
+ struct gdbwire_mi_breakpoint *tmp, *cur = breakpoints;
+ while (cur) {
+ free(cur->original_location);
+ free(cur->fullname);
+ free(cur->file);
+ free(cur->func_name);
+ free(cur->address);
+ free(cur->catch_type);
+ free(cur->type);
+ free(cur->number);
+
+ gdbwire_mi_breakpoints_free(cur->multi_breakpoints);
+ cur->multi_breakpoint = 0;
+
+ tmp = cur;
+ cur = cur->next;
+ free(tmp);
+ }
+}
+
+/**
+ * Free a stack frame.
+ *
+ * @param frame
+ * The frame to free, OK to pass in NULL.
+ */
+static void
+gdbwire_mi_stack_frame_free(struct gdbwire_mi_stack_frame *frame)
+{
+ free(frame->address);
+ free(frame->func);
+ free(frame->file);
+ free(frame->fullname);
+ free(frame->from);
+ free(frame);
+}
+
+/**
+ * Convert a string to an unsigned long.
+ *
+ * @param str
+ * The string to convert.
+ *
+ * @param num
+ * If GDBWIRE_OK is returned, this will be returned as the number.
+ *
+ * @return
+ * GDBWIRE_OK on success, and num is valid, or GDBWIRE_LOGIC on failure.
+ */
+static enum gdbwire_result
+gdbwire_string_to_ulong(char *str, unsigned long *num)
+{
+ enum gdbwire_result result = GDBWIRE_LOGIC;
+ unsigned long int strtol_result;
+ char *end_ptr;
+
+ GDBWIRE_ASSERT(str);
+ GDBWIRE_ASSERT(num);
+
+ errno = 0;
+ strtol_result = strtoul(str, &end_ptr, 10);
+ if (errno == 0 && str != end_ptr && *end_ptr == '\0') {
+ *num = strtol_result;
+ result = GDBWIRE_OK;
+ }
+
+ return result;
+}
+
+/**
+ * Handle breakpoints from the -break-info command.
+ *
+ * @param mi_result
+ * The mi parse tree starting from bkpt={...}
+ *
+ * @param bkpt
+ * Allocated breakpoint on way out on success. Otherwise NULL on way out.
+ *
+ * @return
+ * GDBWIRE_OK on success and bkpt is an allocated breakpoint. Otherwise
+ * the appropriate error code and bkpt will be NULL.
+ */
+static enum gdbwire_result
+break_info_for_breakpoint(struct gdbwire_mi_result *mi_result,
+ struct gdbwire_mi_breakpoint **bkpt)
+{
+ enum gdbwire_result result = GDBWIRE_OK;
+
+ struct gdbwire_mi_breakpoint *breakpoint = 0;
+
+ char *number = 0;
+ int multi = 0;
+ int from_multi = 0;
+ char *catch_type = 0;
+ int pending = 0;
+ int enabled = 0;
+ char *address = 0;
+ char *type = 0;
+ enum gdbwire_mi_breakpoint_disp_kind disp_kind = GDBWIRE_MI_BP_DISP_UNKNOWN;
+ char *func_name = 0;
+ char *file = 0;
+ char *fullname = 0;
+ unsigned long line = 0;
+ unsigned long times = 0;
+ char *original_location = 0;
+
+ GDBWIRE_ASSERT(mi_result);
+ GDBWIRE_ASSERT(bkpt);
+
+ *bkpt = 0;
+
+ while (mi_result) {
+ if (mi_result->kind == GDBWIRE_MI_CSTRING) {
+ if (strcmp(mi_result->variable, "number") == 0) {
+ number = mi_result->variant.cstring;
+
+ if (strstr(number, ".") != NULL) {
+ from_multi = 1;
+ }
+ } else if (strcmp(mi_result->variable, "enabled") == 0) {
+ enabled = mi_result->variant.cstring[0] == 'y';
+ } else if (strcmp(mi_result->variable, "addr") == 0) {
+ multi = strcmp(mi_result->variant.cstring, "<MULTIPLE>") == 0;
+ pending = strcmp(mi_result->variant.cstring, "<PENDING>") == 0;
+ address = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "catch-type") == 0) {
+ catch_type = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "type") == 0) {
+ type = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "disp") == 0) {
+ if (strcmp(mi_result->variant.cstring, "del") == 0) {
+ disp_kind = GDBWIRE_MI_BP_DISP_DELETE;
+ } else if (strcmp(mi_result->variant.cstring, "dstp") == 0) {
+ disp_kind = GDBWIRE_MI_BP_DISP_DELETE_NEXT_STOP;
+ } else if (strcmp(mi_result->variant.cstring, "dis") == 0) {
+ disp_kind = GDBWIRE_MI_BP_DISP_DISABLE;
+ } else if (strcmp(mi_result->variant.cstring, "keep") == 0) {
+ disp_kind = GDBWIRE_MI_BP_DISP_KEEP;
+ } else {
+ return GDBWIRE_LOGIC;
+ }
+ } else if (strcmp(mi_result->variable, "func") == 0) {
+ func_name = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "file") == 0) {
+ file = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "fullname") == 0) {
+ fullname = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "line") == 0) {
+ GDBWIRE_ASSERT(gdbwire_string_to_ulong(
+ mi_result->variant.cstring, &line) == GDBWIRE_OK);
+ } else if (strcmp(mi_result->variable, "times") == 0) {
+ GDBWIRE_ASSERT(gdbwire_string_to_ulong(
+ mi_result->variant.cstring, ×) == GDBWIRE_OK);
+ } else if (strcmp(mi_result->variable, "original-location") == 0) {
+ original_location = mi_result->variant.cstring;
+ }
+ }
+
+ mi_result = mi_result->next;
+ }
+
+ /* Validate required fields before proceeding. */
+ GDBWIRE_ASSERT(number);
+
+ /* At this point, allocate a breakpoint */
+ breakpoint = calloc(1, sizeof(struct gdbwire_mi_breakpoint));
+ if (!breakpoint) {
+ return GDBWIRE_NOMEM;
+ }
+
+ breakpoint->multi = multi;
+ breakpoint->from_multi = from_multi;
+ breakpoint->number = gdbwire_strdup(number);
+ breakpoint->type = (type)?gdbwire_strdup(type):0;
+ breakpoint->catch_type = (catch_type)?gdbwire_strdup(catch_type):0;
+ breakpoint->disposition = disp_kind;
+ breakpoint->enabled = enabled;
+ breakpoint->address = (address)?gdbwire_strdup(address):0;
+ breakpoint->func_name = (func_name)?gdbwire_strdup(func_name):0;
+ breakpoint->file = (file)?gdbwire_strdup(file):0;
+ breakpoint->fullname = (fullname)?gdbwire_strdup(fullname):0;
+ breakpoint->line = line;
+ breakpoint->times = times;
+ breakpoint->original_location =
+ (original_location)?gdbwire_strdup(original_location):0;
+ breakpoint->pending = pending;
+
+ /* Handle the out of memory situation */
+ if (!breakpoint->number ||
+ (type && !breakpoint->type) ||
+ (catch_type && !breakpoint->catch_type) ||
+ (address && !breakpoint->address) ||
+ (func_name && !breakpoint->func_name) ||
+ (file && !breakpoint->file) ||
+ (fullname && !breakpoint->fullname) ||
+ (original_location && !breakpoint->original_location)) {
+ gdbwire_mi_breakpoints_free(breakpoint);
+ breakpoint = 0;
+ result = GDBWIRE_NOMEM;
+ }
+
+ *bkpt = breakpoint;
+
+ return result;
+}
+
+/**
+ * Handle the -break-info command.
+ *
+ * @param result_record
+ * The mi result record that makes up the command output from gdb.
+ *
+ * @param out
+ * The output command, null on error.
+ *
+ * @return
+ * GDBWIRE_OK on success, otherwise failure and out is NULL.
+ */
+static enum gdbwire_result
+break_info(
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out)
+{
+ enum gdbwire_result result = GDBWIRE_OK;
+ struct gdbwire_mi_result *mi_result;
+ struct gdbwire_mi_command *mi_command = 0;
+ struct gdbwire_mi_breakpoint *breakpoints = 0, *cur_bkpt;
+ int found_body = 0;
+
+ GDBWIRE_ASSERT(result_record);
+ GDBWIRE_ASSERT(out);
+
+ *out = 0;
+
+ GDBWIRE_ASSERT(result_record->result_class == GDBWIRE_MI_DONE);
+ GDBWIRE_ASSERT(result_record->result);
+
+ mi_result = result_record->result;
+
+ GDBWIRE_ASSERT(mi_result->kind == GDBWIRE_MI_TUPLE);
+ GDBWIRE_ASSERT(strcmp(mi_result->variable, "BreakpointTable") == 0);
+ GDBWIRE_ASSERT(mi_result->variant.result);
+ GDBWIRE_ASSERT(!mi_result->next);
+ mi_result = mi_result->variant.result;
+
+ /* Fast forward to the body */
+ while (mi_result) {
+ if (mi_result->kind == GDBWIRE_MI_LIST &&
+ strcmp(mi_result->variable, "body") == 0) {
+ found_body = 1;
+ break;
+ } else {
+ mi_result = mi_result->next;
+ }
+ }
+
+ GDBWIRE_ASSERT(found_body);
+ GDBWIRE_ASSERT(!mi_result->next);
+ mi_result = mi_result->variant.result;
+
+ while (mi_result) {
+ struct gdbwire_mi_breakpoint *bkpt;
+ GDBWIRE_ASSERT_GOTO(
+ mi_result->kind == GDBWIRE_MI_TUPLE, result, cleanup);
+
+ /**
+ * GDB emits non-compliant MI when sending breakpoint information.
+ * https://sourceware.org/bugzilla/show_bug.cgi?id=9659
+ * In particular, instead of saying
+ * bkpt={...},bkpt={...}
+ * it puts out,
+ * bkpt={...},{...}
+ * skipping the additional bkpt for subsequent breakpoints. I've seen
+ * this output for multiple location breakpoints as the bug points to.
+ *
+ * For this reason, only check bkpt for the first breakpoint and
+ * assume it is true for the remaining.
+ */
+ if (mi_result->variable) {
+ GDBWIRE_ASSERT_GOTO(
+ strcmp(mi_result->variable, "bkpt") == 0, result, cleanup);
+ }
+
+ result = break_info_for_breakpoint(mi_result->variant.result, &bkpt);
+ if (result != GDBWIRE_OK) {
+ goto cleanup;
+ }
+
+ if (bkpt->from_multi) {
+
+ bkpt->multi_breakpoint = cur_bkpt;
+
+ /* Append breakpoint to the multiple location breakpoints */
+ if (cur_bkpt->multi_breakpoints) {
+ struct gdbwire_mi_breakpoint *multi =
+ cur_bkpt->multi_breakpoints;
+ while (multi->next) {
+ multi = multi->next;
+ }
+ multi->next = bkpt;
+ } else {
+ cur_bkpt->multi_breakpoints = bkpt;
+ }
+ } else {
+ /* Append breakpoint to the list of breakpoints */
+ if (breakpoints) {
+ cur_bkpt->next = bkpt;
+ cur_bkpt = cur_bkpt->next;
+ } else {
+ breakpoints = cur_bkpt = bkpt;
+ }
+ }
+
+ mi_result = mi_result->next;
+ }
+
+ mi_command = calloc(1, sizeof(struct gdbwire_mi_command));
+ if (!mi_command) {
+ result = GDBWIRE_NOMEM;
+ goto cleanup;
+ }
+ mi_command->variant.break_info.breakpoints = breakpoints;
+
+ *out = mi_command;
+
+ return result;
+
+cleanup:
+ gdbwire_mi_breakpoints_free(breakpoints);
+ return result;
+}
+
+/**
+ * Handle the -stack-info-frame command.
+ *
+ * @param result_record
+ * The mi result record that makes up the command output from gdb.
+ *
+ * @param out
+ * The output command, null on error.
+ *
+ * @return
+ * GDBWIRE_OK on success, otherwise failure and out is NULL.
+ */
+static enum gdbwire_result
+stack_info_frame(
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out)
+{
+ struct gdbwire_mi_stack_frame *frame;
+ struct gdbwire_mi_result *mi_result;
+ struct gdbwire_mi_command *mi_command = 0;
+
+ char *level = 0, *address = 0;
+ char *func = 0, *file = 0, *fullname = 0, *line = 0, *from = 0;
+
+ *out = 0;
+
+ GDBWIRE_ASSERT(result_record->result_class == GDBWIRE_MI_DONE);
+ GDBWIRE_ASSERT(result_record->result);
+
+ mi_result = result_record->result;
+
+ GDBWIRE_ASSERT(mi_result->kind == GDBWIRE_MI_TUPLE);
+ GDBWIRE_ASSERT(strcmp(mi_result->variable, "frame") == 0);
+ GDBWIRE_ASSERT(mi_result->variant.result);
+ GDBWIRE_ASSERT(!mi_result->next);
+ mi_result = mi_result->variant.result;
+
+ while (mi_result) {
+ if (mi_result->kind == GDBWIRE_MI_CSTRING) {
+ if (strcmp(mi_result->variable, "level") == 0) {
+ level = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "addr") == 0) {
+ address = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "func") == 0) {
+ func = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "file") == 0) {
+ file = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "fullname") == 0) {
+ fullname = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "line") == 0) {
+ line = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "from") == 0) {
+ from = mi_result->variant.cstring;
+ }
+ }
+
+ mi_result = mi_result->next;
+ }
+
+ GDBWIRE_ASSERT(level && address);
+
+ if (strcmp(address, "<unavailable>") == 0) {
+ address = 0;
+ }
+
+ frame = calloc(1, sizeof(struct gdbwire_mi_stack_frame));
+ if (!frame) {
+ return GDBWIRE_NOMEM;
+ }
+
+ frame->level = atoi(level);
+ frame->address = (address)?gdbwire_strdup(address):0;
+ frame->func = (func)?gdbwire_strdup(func):0;
+ frame->file = (file)?gdbwire_strdup(file):0;
+ frame->fullname = (fullname)?gdbwire_strdup(fullname):0;
+ frame->line = (line)?atoi(line):0;
+ frame->from = (from)?gdbwire_strdup(from):0;
+
+ /* Handle the out of memory situation */
+ if ((address && !frame->address) ||
+ (func && !frame->func) ||
+ (file && !frame->file) ||
+ (fullname && !frame->fullname) ||
+ (from && !frame->from)) {
+ gdbwire_mi_stack_frame_free(frame);
+ return GDBWIRE_NOMEM;
+ }
+
+ mi_command = calloc(1, sizeof(struct gdbwire_mi_command));
+ if (!mi_command) {
+ gdbwire_mi_stack_frame_free(frame);
+ return GDBWIRE_NOMEM;
+ }
+ mi_command->kind = GDBWIRE_MI_STACK_INFO_FRAME;
+ mi_command->variant.stack_info_frame.frame = frame;
+
+ *out = mi_command;
+
+ return GDBWIRE_OK;
+}
+
+/**
+ * Handle the -file-list-exec-source-file command.
+ *
+ * @param result_record
+ * The mi result record that makes up the command output from gdb.
+ *
+ * @param out
+ * The output command, null on error.
+ *
+ * @return
+ * GDBWIRE_OK on success, otherwise failure and out is NULL.
+ */
+static enum gdbwire_result
+file_list_exec_source_file(
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out)
+{
+ struct gdbwire_mi_result *mi_result;
+ struct gdbwire_mi_command *mi_command = 0;
+
+ char *line = 0, *file = 0, *fullname = 0, *macro_info = 0;
+
+ *out = 0;
+
+ GDBWIRE_ASSERT(result_record->result_class == GDBWIRE_MI_DONE);
+ GDBWIRE_ASSERT(result_record->result);
+
+ mi_result = result_record->result;
+
+ while (mi_result) {
+ if (mi_result->kind == GDBWIRE_MI_CSTRING) {
+ if (strcmp(mi_result->variable, "line") == 0) {
+ line = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "file") == 0) {
+ file = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "fullname") == 0) {
+ fullname = mi_result->variant.cstring;
+ } else if (strcmp(mi_result->variable, "macro-info") == 0) {
+ macro_info = mi_result->variant.cstring;
+ GDBWIRE_ASSERT(strlen(macro_info) == 1);
+ GDBWIRE_ASSERT(macro_info[0] == '0' || macro_info[0] == '1');
+ }
+ }
+
+ mi_result = mi_result->next;
+ }
+
+ GDBWIRE_ASSERT(line && file);
+
+ mi_command = calloc(1, sizeof(struct gdbwire_mi_command));
+ if (!mi_command) {
+ return GDBWIRE_NOMEM;
+ }
+
+ mi_command->kind = GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE;
+ mi_command->variant.file_list_exec_source_file.line = atoi(line);
+ mi_command->variant.file_list_exec_source_file.file = gdbwire_strdup(file);
+ if (!mi_command->variant.file_list_exec_source_file.file) {
+ gdbwire_mi_command_free(mi_command);
+ return GDBWIRE_NOMEM;
+ }
+ mi_command->variant.file_list_exec_source_file.fullname =
+ (fullname)?gdbwire_strdup(fullname):0;
+ if (fullname &&
+ !mi_command->variant.file_list_exec_source_file.fullname) {
+ gdbwire_mi_command_free(mi_command);
+ return GDBWIRE_NOMEM;
+ }
+ mi_command->variant.file_list_exec_source_file.macro_info_exists =
+ macro_info != 0;
+ if (macro_info) {
+ mi_command->variant.file_list_exec_source_file.macro_info =
+ atoi(macro_info);
+ }
+
+ *out = mi_command;
+
+ return GDBWIRE_OK;
+}
+
+/**
+ * Handle the -file-list-exec-source-files command.
+ *
+ * @param result_record
+ * The mi result record that makes up the command output from gdb.
+ *
+ * @param out
+ * The output command, null on error.
+ *
+ * @return
+ * GDBWIRE_OK on success, otherwise failure and out is NULL.
+ */
+static enum gdbwire_result
+file_list_exec_source_files(
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out)
+{
+ enum gdbwire_result result = GDBWIRE_OK;
+ struct gdbwire_mi_result *mi_result;
+ struct gdbwire_mi_source_file *files = 0, *cur_node, *new_node;
+
+ GDBWIRE_ASSERT(result_record->result_class == GDBWIRE_MI_DONE);
+ GDBWIRE_ASSERT(result_record->result);
+
+ mi_result = result_record->result;
+
+ GDBWIRE_ASSERT(mi_result->kind == GDBWIRE_MI_LIST);
+ GDBWIRE_ASSERT(strcmp(mi_result->variable, "files") == 0);
+ GDBWIRE_ASSERT(!mi_result->next);
+
+ mi_result = mi_result->variant.result;
+
+ while (mi_result) {
+ struct gdbwire_mi_result *tuple;
+ char *file = 0, *fullname = 0;
+ GDBWIRE_ASSERT_GOTO(mi_result->kind == GDBWIRE_MI_TUPLE, result, err);
+ tuple = mi_result->variant.result;
+
+ /* file field */
+ GDBWIRE_ASSERT_GOTO(tuple->kind == GDBWIRE_MI_CSTRING, result, err);
+ GDBWIRE_ASSERT_GOTO(strcmp(tuple->variable, "file") == 0, result, err);
+ file = tuple->variant.cstring;
+
+ if (tuple->next) {
+ tuple = tuple->next;
+
+ /* fullname field */
+ GDBWIRE_ASSERT_GOTO(tuple->kind == GDBWIRE_MI_CSTRING, result, err);
+ GDBWIRE_ASSERT_GOTO(strcmp(tuple->variable, "fullname") == 0,
+ result, err);
+ fullname = tuple->variant.cstring;
+ }
+
+ GDBWIRE_ASSERT(!tuple->next);
+
+ /* Create the new */
+ new_node = calloc(1, sizeof(struct gdbwire_mi_source_file));
+ GDBWIRE_ASSERT_GOTO(new_node, result, err);
+
+ new_node->file = gdbwire_strdup(file);
+ new_node->fullname = (fullname)?gdbwire_strdup(fullname):0;
+ new_node->next = 0;
+
+ /* Append the node to the list */
+ if (files) {
+ cur_node->next = new_node;
+ cur_node = cur_node->next;
+ } else {
+ files = cur_node = new_node;
+ }
+
+ GDBWIRE_ASSERT_GOTO(new_node->file && (new_node->fullname || !fullname),
+ result, err);
+
+ mi_result = mi_result->next;
+ }
+
+ *out = calloc(1, sizeof(struct gdbwire_mi_command));
+ GDBWIRE_ASSERT_GOTO(*out, result, err);
+ (*out)->kind = GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES;
+ (*out)->variant.file_list_exec_source_files.files = files;
+
+ return result;
+
+err:
+ gdbwire_mi_source_files_free(files);
+
+ return result;
+}
+
+enum gdbwire_result
+gdbwire_get_mi_command(enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out)
+{
+ enum gdbwire_result result = GDBWIRE_OK;
+
+ GDBWIRE_ASSERT(result_record);
+ GDBWIRE_ASSERT(out);
+
+ *out = 0;
+
+ switch (kind) {
+ case GDBWIRE_MI_BREAK_INFO:
+ result = break_info(result_record, out);
+ break;
+ case GDBWIRE_MI_STACK_INFO_FRAME:
+ result = stack_info_frame(result_record, out);
+ break;
+ case GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE:
+ result = file_list_exec_source_file(result_record, out);
+ break;
+ case GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES:
+ result = file_list_exec_source_files(result_record, out);
+ break;
+ }
+
+ return result;
+}
+
+void gdbwire_mi_command_free(struct gdbwire_mi_command *mi_command)
+{
+ if (mi_command) {
+ switch (mi_command->kind) {
+ case GDBWIRE_MI_BREAK_INFO:
+ gdbwire_mi_breakpoints_free(
+ mi_command->variant.break_info.breakpoints);
+ break;
+ case GDBWIRE_MI_STACK_INFO_FRAME:
+ gdbwire_mi_stack_frame_free(
+ mi_command->variant.stack_info_frame.frame);
+ break;
+ case GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE:
+ free(mi_command->variant.file_list_exec_source_file.file);
+ free(mi_command->variant.file_list_exec_source_file.fullname);
+ break;
+ case GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES:
+ gdbwire_mi_source_files_free(
+ mi_command->variant.file_list_exec_source_files.files);
+ break;
+ }
+
+ free(mi_command);
+ }
+}
+/***** End of gdbwire_mi_command.c *******************************************/
+/***** Begin file gdbwire_mi_lexer.c *****************************************/
+
+
+#define YY_INT_ALIGNED short int
+
+/* A lexical scanner generated by flex */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 6
+#define YY_FLEX_SUBMINOR_VERSION 1
+#if YY_FLEX_SUBMINOR_VERSION > 0
+#define FLEX_BETA
+#endif
+
+/* First, we deal with platform-specific or compiler-specific issues. */
+
+/* begin standard C headers. */
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <stdlib.h>
+
+/* end standard C headers. */
+
+/* flex integer type definitions */
+
+#ifndef FLEXINT_H
+#define FLEXINT_H
+
+/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
+
+#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+
+/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
+ * if you want the limit (max/min) macros for int types.
+ */
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS 1
+#endif
+
+#include <inttypes.h>
+typedef int8_t flex_int8_t;
+typedef uint8_t flex_uint8_t;
+typedef int16_t flex_int16_t;
+typedef uint16_t flex_uint16_t;
+typedef int32_t flex_int32_t;
+typedef uint32_t flex_uint32_t;
+#else
+typedef signed char flex_int8_t;
+typedef short int flex_int16_t;
+typedef int flex_int32_t;
+typedef unsigned char flex_uint8_t;
+typedef unsigned short int flex_uint16_t;
+typedef unsigned int flex_uint32_t;
+
+/* Limits of integral types. */
+#ifndef INT8_MIN
+#define INT8_MIN (-128)
+#endif
+#ifndef INT16_MIN
+#define INT16_MIN (-32767-1)
+#endif
+#ifndef INT32_MIN
+#define INT32_MIN (-2147483647-1)
+#endif
+#ifndef INT8_MAX
+#define INT8_MAX (127)
+#endif
+#ifndef INT16_MAX
+#define INT16_MAX (32767)
+#endif
+#ifndef INT32_MAX
+#define INT32_MAX (2147483647)
+#endif
+#ifndef UINT8_MAX
+#define UINT8_MAX (255U)
+#endif
+#ifndef UINT16_MAX
+#define UINT16_MAX (65535U)
+#endif
+#ifndef UINT32_MAX
+#define UINT32_MAX (4294967295U)
+#endif
+
+#endif /* ! C99 */
+
+#endif /* ! FLEXINT_H */
+
+/* TODO: this is always defined, so inline it */
+#define yyconst const
+
+#if defined(__GNUC__) && __GNUC__ >= 3
+#define yynoreturn __attribute__((__noreturn__))
+#else
+#define yynoreturn
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index. If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void* yyscan_t;
+#endif
+
+/* For convenience, these vars (plus the bison vars far below)
+ are macros in the reentrant scanner. */
+#define yyin yyg->yyin_r
+#define yyout yyg->yyout_r
+#define yyextra yyg->yyextra_r
+#define yyleng yyg->yyleng_r
+#define yytext yyg->yytext_r
+#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
+#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
+#define yy_flex_debug yyg->yy_flex_debug_r
+
+/* Enter a start condition. This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yyg->yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state. The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yyg->yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE gdbwire_mi_restart(yyin ,yyscanner )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#ifndef YY_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k.
+ * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
+ * Ditto for the __ia64__ case accordingly.
+ */
+#define YY_BUF_SIZE 32768
+#else
+#define YY_BUF_SIZE 16384
+#endif /* __ia64__ */
+#endif
+
+/* The state buf must be large enough to hold one state per character in the main buffer.
+ */
+#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
+
+#ifndef YY_TYPEDEF_YY_BUFFER_STATE
+#define YY_TYPEDEF_YY_BUFFER_STATE
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+#endif
+
+#ifndef YY_TYPEDEF_YY_SIZE_T
+#define YY_TYPEDEF_YY_SIZE_T
+typedef size_t yy_size_t;
+#endif
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+ #define YY_LESS_LINENO(n)
+ #define YY_LINENO_REWIND_TO(ptr)
+
+/* Return all but the first "n" matched characters back to the input stream. */
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ yy_size_t yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ *yy_cp = yyg->yy_hold_char; \
+ YY_RESTORE_YY_MORE_OFFSET \
+ yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
+ YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+ } \
+ while ( 0 )
+
+#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
+
+#ifndef YY_STRUCT_YY_BUFFER_STATE
+#define YY_STRUCT_YY_BUFFER_STATE
+struct yy_buffer_state
+ {
+ FILE *yy_input_file;
+
+ char *yy_ch_buf; /* input buffer */
+ char *yy_buf_pos; /* current position in input buffer */
+
+ /* Size of input buffer in bytes, not including room for EOB
+ * characters.
+ */
+ int yy_buf_size;
+
+ /* Number of characters read into yy_ch_buf, not including EOB
+ * characters.
+ */
+ int yy_n_chars;
+
+ /* Whether we "own" the buffer - i.e., we know we created it,
+ * and can realloc() it to grow it, and should free() it to
+ * delete it.
+ */
+ int yy_is_our_buffer;
+
+ /* Whether this is an "interactive" input source; if so, and
+ * if we're using stdio for input, then we want to use getc()
+ * instead of fread(), to make sure we stop fetching input after
+ * each newline.
+ */
+ int yy_is_interactive;
+
+ /* Whether we're considered to be at the beginning of a line.
+ * If so, '^' rules will be active on the next match, otherwise
+ * not.
+ */
+ int yy_at_bol;
+
+ int yy_bs_lineno; /**< The line count. */
+ int yy_bs_column; /**< The column count. */
+
+ /* Whether to try to fill the input buffer when we reach the
+ * end of it.
+ */
+ int yy_fill_buffer;
+
+ int yy_buffer_status;
+
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+ /* When an EOF's been seen but there's still some text to process
+ * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+ * shouldn't try reading from the input source any more. We might
+ * still have a bunch of tokens to match, though, because of
+ * possible backing-up.
+ *
+ * When we actually see the EOF, we change the status to "new"
+ * (via gdbwire_mi_restart()), so that the user can continue scanning by
+ * just pointing yyin at a new input file.
+ */
+#define YY_BUFFER_EOF_PENDING 2
+
+ };
+#endif /* !YY_STRUCT_YY_BUFFER_STATE */
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ *
+ * Returns the top of the stack, or NULL.
+ */
+#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
+ ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
+ : NULL)
+
+/* Same as previous macro, but useful when we know that the buffer stack is not
+ * NULL or when we need an lvalue. For internal use only.
+ */
+#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
+
+void gdbwire_mi_restart (FILE *input_file ,yyscan_t yyscanner );
+void gdbwire_mi__switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+YY_BUFFER_STATE gdbwire_mi__create_buffer (FILE *file,int size ,yyscan_t yyscanner );
+void gdbwire_mi__delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void gdbwire_mi__flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
+void gdbwire_mi_push_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
+void gdbwire_mi_pop_buffer_state (yyscan_t yyscanner );
+
+static void gdbwire_mi_ensure_buffer_stack (yyscan_t yyscanner );
+static void gdbwire_mi__load_buffer_state (yyscan_t yyscanner );
+static void gdbwire_mi__init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
+
+#define YY_FLUSH_BUFFER gdbwire_mi__flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
+
+YY_BUFFER_STATE gdbwire_mi__scan_buffer (char *base,yy_size_t size ,yyscan_t yyscanner );
+YY_BUFFER_STATE gdbwire_mi__scan_string (yyconst char *yy_str ,yyscan_t yyscanner );
+YY_BUFFER_STATE gdbwire_mi__scan_bytes (yyconst char *bytes,int len ,yyscan_t yyscanner );
+
+void *gdbwire_mi_alloc (yy_size_t ,yyscan_t yyscanner );
+void *gdbwire_mi_realloc (void *,yy_size_t ,yyscan_t yyscanner );
+void gdbwire_mi_free (void * ,yyscan_t yyscanner );
+
+#define yy_new_buffer gdbwire_mi__create_buffer
+
+#define yy_set_interactive(is_interactive) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){ \
+ gdbwire_mi_ensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ gdbwire_mi__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
+ }
+
+#define yy_set_bol(at_bol) \
+ { \
+ if ( ! YY_CURRENT_BUFFER ){\
+ gdbwire_mi_ensure_buffer_stack (yyscanner); \
+ YY_CURRENT_BUFFER_LVALUE = \
+ gdbwire_mi__create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
+ } \
+ YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
+ }
+
+#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
+
+/* Begin user sect3 */
+
+#define gdbwire_mi_wrap(yyscanner) (/*CONSTCOND*/1)
+#define YY_SKIP_YYWRAP
+
+typedef unsigned char YY_CHAR;
+
+typedef int yy_state_type;
+
+#define yytext_ptr yytext_r
+
+static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
+static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
+static int yy_get_next_buffer (yyscan_t yyscanner );
+static void yynoreturn yy_fatal_error (yyconst char* msg ,yyscan_t yyscanner );
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+ yyg->yytext_ptr = yy_bp; \
+ yyleng = (int) (yy_cp - yy_bp); \
+ yyg->yy_hold_char = *yy_cp; \
+ *yy_cp = '\0'; \
+ yyg->yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 23
+#define YY_END_OF_BUFFER 24
+/* This struct is not used in this scanner,
+ but its presence is necessary. */
+struct yy_trans_info
+ {
+ flex_int32_t yy_verify;
+ flex_int32_t yy_nxt;
+ };
+static yyconst flex_int16_t yy_accept[33] =
+ { 0,
+ 0, 0, 24, 21, 19, 15, 17, 21, 8, 13,
+ 14, 4, 3, 2, 18, 5, 7, 20, 9, 10,
+ 1, 11, 12, 6, 16, 0, 22, 0, 18, 20,
+ 20, 0
+ } ;
+
+static yyconst YY_CHAR yy_ec[256] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
+ 2, 2, 4, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 2, 1, 5, 1, 1, 1, 6, 1, 7,
+ 8, 9, 10, 11, 12, 1, 1, 13, 13, 13,
+ 13, 13, 13, 13, 13, 13, 13, 1, 1, 1,
+ 14, 1, 1, 15, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 17, 18, 19, 20, 16, 1, 16, 16, 16, 16,
+
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,
+ 16, 16, 21, 1, 22, 23, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1
+ } ;
+
+static yyconst YY_CHAR yy_meta[24] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1
+ } ;
+
+static yyconst flex_uint16_t yy_base[34] =
+ { 0,
+ 0, 0, 42, 43, 43, 43, 38, 19, 43, 43,
+ 43, 43, 43, 43, 26, 43, 43, 13, 43, 43,
+ 43, 43, 43, 43, 43, 22, 43, 35, 22, 18,
+ 20, 43, 27
+ } ;
+
+static yyconst flex_int16_t yy_def[34] =
+ { 0,
+ 32, 1, 32, 32, 32, 32, 32, 33, 32, 32,
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 33, 32, 33, 32, 32,
+ 32, 0, 32
+ } ;
+
+static yyconst flex_uint16_t yy_nxt[67] =
+ { 0,
+ 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
+ 14, 4, 15, 16, 17, 18, 19, 4, 20, 21,
+ 22, 23, 24, 27, 30, 30, 27, 26, 31, 30,
+ 30, 30, 30, 30, 29, 31, 28, 32, 29, 28,
+ 25, 32, 3, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 32
+ } ;
+
+static yyconst flex_int16_t yy_chk[67] =
+ { 0,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+ 1, 1, 1, 8, 18, 18, 26, 33, 18, 30,
+ 30, 31, 31, 30, 29, 31, 8, 28, 15, 26,
+ 7, 3, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 32, 32, 32, 32, 32,
+ 32, 32, 32, 32, 32, 32
+ } ;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#define YY_NO_INPUT 1
+/* Avoids the use of fileno, which is POSIX and not compatible with c11 */
+
+/* flex 2.6.0 produces a sign-compare warning */
+#pragma GCC diagnostic ignored "-Wsign-compare"
+
+#include <stdio.h>
+/* #include "gdbwire_mi_grammar.h" */
+/* #include "gdbwire_mi_pt.h" */
+
+/**
+ * This macro sets the beginning and ending column position of each
+ * token in the pure lexer. No global state is used.
+ *
+ * The parser can then use this position to determine the location
+ * of any token it desires.
+ *
+ * Currently only the column is stored as the parser only uses
+ * the lexer on a line at a time. Currently, the caller of the
+ * lexer sets the column position back to 1 each time a new
+ * line is set to be parsed in the lexer.
+ */
+#define YY_USER_ACTION \
+ { \
+ struct gdbwire_mi_position pos = { yycolumn, yycolumn+yyleng-1 }; \
+ yyextra = pos; \
+ yycolumn += yyleng; \
+ }
+
+#define INITIAL 0
+
+#ifndef YY_NO_UNISTD_H
+/* Special case for "unistd.h", since it is non-ANSI. We include it way
+ * down here because we want the user's section 1 to have been scanned first.
+ * The user has a chance to override it with an option.
+ */
+#include <unistd.h>
+#endif
+
+#define YY_EXTRA_TYPE struct gdbwire_mi_position
+
+/* Holds the entire state of the reentrant scanner. */
+struct yyguts_t
+ {
+
+ /* User-defined. Not touched by flex. */
+ YY_EXTRA_TYPE yyextra_r;
+
+ /* The rest are the same as the globals declared in the non-reentrant scanner. */
+ FILE *yyin_r, *yyout_r;
+ size_t yy_buffer_stack_top; /**< index of top of stack. */
+ size_t yy_buffer_stack_max; /**< capacity of stack. */
+ YY_BUFFER_STATE * yy_buffer_stack; /**< Stack as an array. */
+ char yy_hold_char;
+ int yy_n_chars;
+ int yyleng_r;
+ char *yy_c_buf_p;
+ int yy_init;
+ int yy_start;
+ int yy_did_buffer_switch_on_eof;
+ int yy_start_stack_ptr;
+ int yy_start_stack_depth;
+ int *yy_start_stack;
+ yy_state_type yy_last_accepting_state;
+ char* yy_last_accepting_cpos;
+
+ int yylineno_r;
+ int yy_flex_debug_r;
+
+ char *yytext_r;
+ int yy_more_flag;
+ int yy_more_len;
+
+ }; /* end struct yyguts_t */
+
+static int yy_init_globals (yyscan_t yyscanner );
+
+int gdbwire_mi_lex_init (yyscan_t* scanner);
+
+int gdbwire_mi_lex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
+
+/* Accessor methods to globals.
+ These are made visible to non-reentrant scanners for convenience. */
+
+int gdbwire_mi_lex_destroy (yyscan_t yyscanner );
+
+int gdbwire_mi_get_debug (yyscan_t yyscanner );
+
+void gdbwire_mi_set_debug (int debug_flag ,yyscan_t yyscanner );
+
+YY_EXTRA_TYPE gdbwire_mi_get_extra (yyscan_t yyscanner );
+
+void gdbwire_mi_set_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
+
+FILE *gdbwire_mi_get_in (yyscan_t yyscanner );
+
+void gdbwire_mi_set_in (FILE * _in_str ,yyscan_t yyscanner );
+
+FILE *gdbwire_mi_get_out (yyscan_t yyscanner );
+
+void gdbwire_mi_set_out (FILE * _out_str ,yyscan_t yyscanner );
+
+ int gdbwire_mi_get_leng (yyscan_t yyscanner );
+
+char *gdbwire_mi_get_text (yyscan_t yyscanner );
+
+int gdbwire_mi_get_lineno (yyscan_t yyscanner );
+
+void gdbwire_mi_set_lineno (int _line_number ,yyscan_t yyscanner );
+
+int gdbwire_mi_get_column (yyscan_t yyscanner );
+
+void gdbwire_mi_set_column (int _column_no ,yyscan_t yyscanner );
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int gdbwire_mi_wrap (yyscan_t yyscanner );
+#else
+extern int gdbwire_mi_wrap (yyscan_t yyscanner );
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char *,yyconst char *,int ,yyscan_t yyscanner);
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * ,yyscan_t yyscanner);
+#endif
+
+#ifndef YY_NO_INPUT
+
+#ifdef __cplusplus
+static int yyinput (yyscan_t yyscanner );
+#else
+static int input (yyscan_t yyscanner );
+#endif
+
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#ifdef __ia64__
+/* On IA-64, the buffer size is 16k, not 8k */
+#define YY_READ_BUF_SIZE 16384
+#else
+#define YY_READ_BUF_SIZE 8192
+#endif /* __ia64__ */
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
+#endif
+
+/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
+ { \
+ int c = '*'; \
+ int n; \
+ for ( n = 0; n < max_size && \
+ (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+ buf[n] = (char) c; \
+ if ( c == '\n' ) \
+ buf[n++] = (char) c; \
+ if ( c == EOF && ferror( yyin ) ) \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ result = n; \
+ } \
+ else \
+ { \
+ errno=0; \
+ while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
+ { \
+ if( errno != EINTR) \
+ { \
+ YY_FATAL_ERROR( "input in flex scanner failed" ); \
+ break; \
+ } \
+ errno=0; \
+ clearerr(yyin); \
+ } \
+ }\
+\
+
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
+#endif
+
+/* end tables serialization structures and prototypes */
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL_IS_OURS 1
+
+extern int gdbwire_mi_lex (yyscan_t yyscanner);
+
+#define YY_DECL int gdbwire_mi_lex (yyscan_t yyscanner)
+#endif /* !YY_DECL */
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK /*LINTED*/break;
+#endif
+
+#define YY_RULE_SETUP \
+ YY_USER_ACTION
+
+/** The main scanner function which does all the work.
+ */
+YY_DECL
+{
+ yy_state_type yy_current_state;
+ char *yy_cp, *yy_bp;
+ int yy_act;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( !yyg->yy_init )
+ {
+ yyg->yy_init = 1;
+
+#ifdef YY_USER_INIT
+ YY_USER_INIT;
+#endif
+
+ if ( ! yyg->yy_start )
+ yyg->yy_start = 1; /* first start state */
+
+ if ( ! yyin )
+ yyin = stdin;
+
+ if ( ! yyout )
+ yyout = stdout;
+
+ if ( ! YY_CURRENT_BUFFER ) {
+ gdbwire_mi_ensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ gdbwire_mi__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+ }
+
+ gdbwire_mi__load_buffer_state(yyscanner );
+ }
+
+ {
+
+
+
+ while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
+ {
+ yy_cp = yyg->yy_c_buf_p;
+
+ /* Support of yytext. */
+ *yy_cp = yyg->yy_hold_char;
+
+ /* yy_bp points to the position in yy_ch_buf of the start of
+ * the current run.
+ */
+ yy_bp = yy_cp;
+
+ yy_current_state = yyg->yy_start;
+yy_match:
+ do
+ {
+ YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 33 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+ ++yy_cp;
+ }
+ while ( yy_current_state != 32 );
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+
+yy_find_action:
+ yy_act = yy_accept[yy_current_state];
+
+ YY_DO_BEFORE_ACTION;
+
+do_action: /* This label is used only to access EOF actions. */
+
+ switch ( yy_act )
+ { /* beginning of action switch */
+ case 0: /* must back up */
+ /* undo the effects of YY_DO_BEFORE_ACTION */
+ *yy_cp = yyg->yy_hold_char;
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+ goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+{ return CARROT; }
+ YY_BREAK
+case 2:
+YY_RULE_SETUP
+{ return COMMA; }
+ YY_BREAK
+case 3:
+YY_RULE_SETUP
+{ return ADD_OP; }
+ YY_BREAK
+case 4:
+YY_RULE_SETUP
+{ return MULT_OP; }
+ YY_BREAK
+case 5:
+YY_RULE_SETUP
+{ return EQUAL_SIGN; }
+ YY_BREAK
+case 6:
+YY_RULE_SETUP
+{ return TILDA; }
+ YY_BREAK
+case 7:
+YY_RULE_SETUP
+{ return AT_SYMBOL; }
+ YY_BREAK
+case 8:
+YY_RULE_SETUP
+{ return AMPERSAND; }
+ YY_BREAK
+case 9:
+YY_RULE_SETUP
+{ return OPEN_BRACKET; }
+ YY_BREAK
+case 10:
+YY_RULE_SETUP
+{ return CLOSED_BRACKET; }
+ YY_BREAK
+case 11:
+YY_RULE_SETUP
+{ return OPEN_BRACE; }
+ YY_BREAK
+case 12:
+YY_RULE_SETUP
+{ return CLOSED_BRACE; }
+ YY_BREAK
+case 13:
+YY_RULE_SETUP
+{ return OPEN_PAREN; }
+ YY_BREAK
+case 14:
+YY_RULE_SETUP
+{ return CLOSED_PAREN; }
+ YY_BREAK
+case 15:
+/* rule 15 can match eol */
+YY_RULE_SETUP
+{ return NEWLINE; }
+ YY_BREAK
+case 16:
+/* rule 16 can match eol */
+YY_RULE_SETUP
+{ return NEWLINE; }
+ YY_BREAK
+case 17:
+YY_RULE_SETUP
+{ return NEWLINE; }
+ YY_BREAK
+case 18:
+YY_RULE_SETUP
+{ return INTEGER_LITERAL; }
+ YY_BREAK
+case 19:
+YY_RULE_SETUP
+{}
+ YY_BREAK
+case 20:
+YY_RULE_SETUP
+{ return STRING_LITERAL; }
+ YY_BREAK
+case 21:
+YY_RULE_SETUP
+{ return STRING_LITERAL; }
+ YY_BREAK
+case 22:
+/* rule 22 can match eol */
+YY_RULE_SETUP
+{ return CSTRING; }
+ YY_BREAK
+case 23:
+YY_RULE_SETUP
+ECHO;
+ YY_BREAK
+case YY_STATE_EOF(INITIAL):
+ yyterminate();
+
+ case YY_END_OF_BUFFER:
+ {
+ /* Amount of text matched not including the EOB char. */
+ int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
+
+ /* Undo the effects of YY_DO_BEFORE_ACTION. */
+ *yy_cp = yyg->yy_hold_char;
+ YY_RESTORE_YY_MORE_OFFSET
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
+ {
+ /* We're scanning a new file or input source. It's
+ * possible that this happened because the user
+ * just pointed yyin at a new source and called
+ * gdbwire_mi_lex(). If so, then we have to assure
+ * consistency between YY_CURRENT_BUFFER and our
+ * globals. Here is the right place to do so, because
+ * this is the first action (other than possibly a
+ * back-up) that will match for the new input source.
+ */
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
+ }
+
+ /* Note that here we test for yy_c_buf_p "<=" to the position
+ * of the first EOB in the buffer, since yy_c_buf_p will
+ * already have been incremented past the NUL character
+ * (since all states make transitions on EOB to the
+ * end-of-buffer state). Contrast this with the test
+ * in input().
+ */
+ if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ { /* This was really a NUL. */
+ yy_state_type yy_next_state;
+
+ yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ /* Okay, we're now positioned to make the NUL
+ * transition. We couldn't have
+ * yy_get_previous_state() go ahead and do it
+ * for us because it doesn't know how to deal
+ * with the possibility of jamming (and we don't
+ * want to build jamming into it because then it
+ * will run more slowly).
+ */
+
+ yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
+
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ if ( yy_next_state )
+ {
+ /* Consume the NUL. */
+ yy_cp = ++yyg->yy_c_buf_p;
+ yy_current_state = yy_next_state;
+ goto yy_match;
+ }
+
+ else
+ {
+ yy_cp = yyg->yy_last_accepting_cpos;
+ yy_current_state = yyg->yy_last_accepting_state;
+ goto yy_find_action;
+ }
+ }
+
+ else switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ case EOB_ACT_END_OF_FILE:
+ {
+ yyg->yy_did_buffer_switch_on_eof = 0;
+
+ if ( gdbwire_mi_wrap(yyscanner ) )
+ {
+ /* Note: because we've taken care in
+ * yy_get_next_buffer() to have set up
+ * yytext, we can now set up
+ * yy_c_buf_p so that if some total
+ * hoser (like flex itself) wants to
+ * call the scanner after we return the
+ * YY_NULL, it'll still work - another
+ * YY_NULL will get returned.
+ */
+ yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
+
+ yy_act = YY_STATE_EOF(YY_START);
+ goto do_action;
+ }
+
+ else
+ {
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+ }
+ break;
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p =
+ yyg->yytext_ptr + yy_amount_of_matched_text;
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+ goto yy_match;
+
+ case EOB_ACT_LAST_MATCH:
+ yyg->yy_c_buf_p =
+ &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
+
+ yy_current_state = yy_get_previous_state( yyscanner );
+
+ yy_cp = yyg->yy_c_buf_p;
+ yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
+ goto yy_find_action;
+ }
+ break;
+ }
+
+ default:
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--no action found" );
+ } /* end of action switch */
+ } /* end of scanning one token */
+ } /* end of user's declarations */
+} /* end of gdbwire_mi_lex */
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+ * EOB_ACT_LAST_MATCH -
+ * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+ * EOB_ACT_END_OF_FILE - end of file
+ */
+static int yy_get_next_buffer (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
+ char *source = yyg->yytext_ptr;
+ yy_size_t number_to_move, i;
+ int ret_val;
+
+ if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
+ YY_FATAL_ERROR(
+ "fatal flex scanner internal error--end of buffer missed" );
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
+ { /* Don't try to fill the buffer, so this is an EOF. */
+ if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
+ {
+ /* We matched a single character, the EOB, so
+ * treat this as a final EOF.
+ */
+ return EOB_ACT_END_OF_FILE;
+ }
+
+ else
+ {
+ /* We matched some text prior to the EOB, first
+ * process it.
+ */
+ return EOB_ACT_LAST_MATCH;
+ }
+ }
+
+ /* Try to read more data. */
+
+ /* First move last chars to start of buffer. */
+ number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
+
+ for ( i = 0; i < number_to_move; ++i )
+ *(dest++) = *(source++);
+
+ if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+ /* don't do the read, it's not guaranteed to return an EOF,
+ * just force an EOF
+ */
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
+
+ else
+ {
+ int num_to_read =
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
+
+ while ( num_to_read <= 0 )
+ { /* Not enough room in the buffer - grow it. */
+
+ /* just a shorter name for the current buffer */
+ YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
+
+ int yy_c_buf_p_offset =
+ (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
+
+ if ( b->yy_is_our_buffer )
+ {
+ int new_size = b->yy_buf_size * 2;
+
+ if ( new_size <= 0 )
+ b->yy_buf_size += b->yy_buf_size / 8;
+ else
+ b->yy_buf_size *= 2;
+
+ b->yy_ch_buf = (char *)
+ /* Include room in for 2 EOB chars. */
+ gdbwire_mi_realloc((void *) b->yy_ch_buf,(yy_size_t) (b->yy_buf_size
+ 2) ,yyscanner );
+ }
+ else
+ /* Can't grow it, we don't own it. */
+ b->yy_ch_buf = NULL;
+
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR(
+ "fatal error - scanner input buffer overflow" );
+
+ yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+ num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
+ number_to_move - 1;
+
+ }
+
+ if ( num_to_read > YY_READ_BUF_SIZE )
+ num_to_read = YY_READ_BUF_SIZE;
+
+ /* Read in more data. */
+ YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
+ yyg->yy_n_chars, num_to_read );
+
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ if ( yyg->yy_n_chars == 0 )
+ {
+ if ( number_to_move == YY_MORE_ADJ )
+ {
+ ret_val = EOB_ACT_END_OF_FILE;
+ gdbwire_mi_restart(yyin ,yyscanner);
+ }
+
+ else
+ {
+ ret_val = EOB_ACT_LAST_MATCH;
+ YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
+ YY_BUFFER_EOF_PENDING;
+ }
+ }
+
+ else
+ ret_val = EOB_ACT_CONTINUE_SCAN;
+
+ if ((int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
+ /* Extend the array by 50%, plus the number we really need. */
+ int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) gdbwire_mi_realloc((void *)
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,(yy_size_t) new_size ,yyscanner );
+ if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
+ }
+
+ yyg->yy_n_chars += number_to_move;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+ YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+ yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
+
+ return ret_val;
+}
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+ static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
+{
+ yy_state_type yy_current_state;
+ char *yy_cp;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ yy_current_state = yyg->yy_start;
+
+ for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
+ {
+ YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 33 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+ }
+
+ return yy_current_state;
+}
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+ * next_state = yy_try_NUL_trans( current_state );
+ */
+ static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
+{
+ int yy_is_jam;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner; /* This var may be unused depending upon options. */
+ char *yy_cp = yyg->yy_c_buf_p;
+
+ YY_CHAR yy_c = 1;
+ if ( yy_accept[yy_current_state] )
+ {
+ yyg->yy_last_accepting_state = yy_current_state;
+ yyg->yy_last_accepting_cpos = yy_cp;
+ }
+ while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+ {
+ yy_current_state = (int) yy_def[yy_current_state];
+ if ( yy_current_state >= 33 )
+ yy_c = yy_meta[(unsigned int) yy_c];
+ }
+ yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
+ yy_is_jam = (yy_current_state == 32);
+
+ (void)yyg;
+ return yy_is_jam ? 0 : yy_current_state;
+}
+
+#ifndef YY_NO_UNPUT
+
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+ static int yyinput (yyscan_t yyscanner)
+#else
+ static int input (yyscan_t yyscanner)
+#endif
+
+{
+ int c;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+
+ if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+ {
+ /* yy_c_buf_p now points to the character we want to return.
+ * If this occurs *before* the EOB characters, then it's a
+ * valid NUL; if not, then we've hit the end of the buffer.
+ */
+ if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
+ /* This was really a NUL. */
+ *yyg->yy_c_buf_p = '\0';
+
+ else
+ { /* need more input */
+ int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
+ ++yyg->yy_c_buf_p;
+
+ switch ( yy_get_next_buffer( yyscanner ) )
+ {
+ case EOB_ACT_LAST_MATCH:
+ /* This happens because yy_g_n_b()
+ * sees that we've accumulated a
+ * token and flags that we need to
+ * try matching the token before
+ * proceeding. But for input(),
+ * there's no matching to consider.
+ * So convert the EOB_ACT_LAST_MATCH
+ * to EOB_ACT_END_OF_FILE.
+ */
+
+ /* Reset buffer status. */
+ gdbwire_mi_restart(yyin ,yyscanner);
+
+ /*FALLTHROUGH*/
+
+ case EOB_ACT_END_OF_FILE:
+ {
+ if ( gdbwire_mi_wrap(yyscanner ) )
+ return 0;
+
+ if ( ! yyg->yy_did_buffer_switch_on_eof )
+ YY_NEW_FILE;
+#ifdef __cplusplus
+ return yyinput(yyscanner);
+#else
+ return input(yyscanner);
+#endif
+ }
+
+ case EOB_ACT_CONTINUE_SCAN:
+ yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
+ break;
+ }
+ }
+ }
+
+ c = *(unsigned char *) yyg->yy_c_buf_p; /* cast for 8-bit char's */
+ *yyg->yy_c_buf_p = '\0'; /* preserve yytext */
+ yyg->yy_hold_char = *++yyg->yy_c_buf_p;
+
+ return c;
+}
+#endif /* ifndef YY_NO_INPUT */
+
+/** Immediately switch to a different input stream.
+ * @param input_file A readable stream.
+ * @param yyscanner The scanner object.
+ * @note This function does not reset the start condition to @c INITIAL .
+ */
+ void gdbwire_mi_restart (FILE * input_file , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( ! YY_CURRENT_BUFFER ){
+ gdbwire_mi_ensure_buffer_stack (yyscanner);
+ YY_CURRENT_BUFFER_LVALUE =
+ gdbwire_mi__create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
+ }
+
+ gdbwire_mi__init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
+ gdbwire_mi__load_buffer_state(yyscanner );
+}
+
+/** Switch to a different input buffer.
+ * @param new_buffer The new input buffer.
+ * @param yyscanner The scanner object.
+ */
+ void gdbwire_mi__switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* TODO. We should be able to replace this entire function body
+ * with
+ * gdbwire_mi_pop_buffer_state();
+ * gdbwire_mi_push_buffer_state(new_buffer);
+ */
+ gdbwire_mi_ensure_buffer_stack (yyscanner);
+ if ( YY_CURRENT_BUFFER == new_buffer )
+ return;
+
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+ gdbwire_mi__load_buffer_state(yyscanner );
+
+ /* We don't actually know whether we did this switch during
+ * EOF (gdbwire_mi_wrap()) processing, but the only time this flag
+ * is looked at is after gdbwire_mi_wrap() is called, so it's safe
+ * to go ahead and always set it.
+ */
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+static void gdbwire_mi__load_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
+ yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
+ yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
+ yyg->yy_hold_char = *yyg->yy_c_buf_p;
+}
+
+/** Allocate and initialize an input buffer state.
+ * @param file A readable stream.
+ * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
+ * @param yyscanner The scanner object.
+ * @return the allocated buffer state.
+ */
+ YY_BUFFER_STATE gdbwire_mi__create_buffer (FILE * file, int size , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+
+ b = (YY_BUFFER_STATE) gdbwire_mi_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi__create_buffer()" );
+
+ b->yy_buf_size = size;
+
+ /* yy_ch_buf has to be 2 characters longer than the size given because
+ * we need to put in 2 end-of-buffer characters.
+ */
+ b->yy_ch_buf = (char *) gdbwire_mi_alloc((yy_size_t) (b->yy_buf_size + 2) ,yyscanner );
+ if ( ! b->yy_ch_buf )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi__create_buffer()" );
+
+ b->yy_is_our_buffer = 1;
+
+ gdbwire_mi__init_buffer(b,file ,yyscanner);
+
+ return b;
+}
+
+/** Destroy the buffer.
+ * @param b a buffer created with gdbwire_mi__create_buffer()
+ * @param yyscanner The scanner object.
+ */
+ void gdbwire_mi__delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if ( ! b )
+ return;
+
+ if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
+ YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
+
+ if ( b->yy_is_our_buffer )
+ gdbwire_mi_free((void *) b->yy_ch_buf ,yyscanner );
+
+ gdbwire_mi_free((void *) b ,yyscanner );
+}
+
+/* Initializes or reinitializes a buffer.
+ * This function is sometimes called more than once on the same buffer,
+ * such as during a gdbwire_mi_restart() or at EOF.
+ */
+ static void gdbwire_mi__init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
+
+{
+ int oerrno = errno;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ gdbwire_mi__flush_buffer(b ,yyscanner);
+
+ b->yy_input_file = file;
+ b->yy_fill_buffer = 1;
+
+ /* If b is the current buffer, then gdbwire_mi__init_buffer was _probably_
+ * called from gdbwire_mi_restart() or through yy_get_next_buffer.
+ * In that case, we don't want to reset the lineno or column.
+ */
+ if (b != YY_CURRENT_BUFFER){
+ b->yy_bs_lineno = 1;
+ b->yy_bs_column = 0;
+ }
+
+ b->yy_is_interactive = 0;
+
+ errno = oerrno;
+}
+
+/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
+ * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
+ * @param yyscanner The scanner object.
+ */
+ void gdbwire_mi__flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if ( ! b )
+ return;
+
+ b->yy_n_chars = 0;
+
+ /* We always need two end-of-buffer characters. The first causes
+ * a transition to the end-of-buffer state. The second causes
+ * a jam in that state.
+ */
+ b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+ b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+ b->yy_buf_pos = &b->yy_ch_buf[0];
+
+ b->yy_at_bol = 1;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ if ( b == YY_CURRENT_BUFFER )
+ gdbwire_mi__load_buffer_state(yyscanner );
+}
+
+/** Pushes the new state onto the stack. The new state becomes
+ * the current state. This function will allocate the stack
+ * if necessary.
+ * @param new_buffer The new state.
+ * @param yyscanner The scanner object.
+ */
+void gdbwire_mi_push_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (new_buffer == NULL)
+ return;
+
+ gdbwire_mi_ensure_buffer_stack(yyscanner);
+
+ /* This block is copied from gdbwire_mi__switch_to_buffer. */
+ if ( YY_CURRENT_BUFFER )
+ {
+ /* Flush out information for old buffer. */
+ *yyg->yy_c_buf_p = yyg->yy_hold_char;
+ YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
+ YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
+ }
+
+ /* Only push if top exists. Otherwise, replace top. */
+ if (YY_CURRENT_BUFFER)
+ yyg->yy_buffer_stack_top++;
+ YY_CURRENT_BUFFER_LVALUE = new_buffer;
+
+ /* copied from gdbwire_mi__switch_to_buffer. */
+ gdbwire_mi__load_buffer_state(yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+}
+
+/** Removes and deletes the top of the stack, if present.
+ * The next element becomes the new top.
+ * @param yyscanner The scanner object.
+ */
+void gdbwire_mi_pop_buffer_state (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ if (!YY_CURRENT_BUFFER)
+ return;
+
+ gdbwire_mi__delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ if (yyg->yy_buffer_stack_top > 0)
+ --yyg->yy_buffer_stack_top;
+
+ if (YY_CURRENT_BUFFER) {
+ gdbwire_mi__load_buffer_state(yyscanner );
+ yyg->yy_did_buffer_switch_on_eof = 1;
+ }
+}
+
+/* Allocates the stack if it does not exist.
+ * Guarantees space for at least one push.
+ */
+static void gdbwire_mi_ensure_buffer_stack (yyscan_t yyscanner)
+{
+ int num_to_alloc;
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (!yyg->yy_buffer_stack) {
+
+ /* First allocation is just for 2 elements, since we don't know if this
+ * scanner will even need a stack. We use 2 instead of 1 to avoid an
+ * immediate realloc on the next call.
+ */
+ num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)gdbwire_mi_alloc
+ (num_to_alloc * sizeof(struct
yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi_ensure_buffer_stack()" );
+
+ memset(yyg->yy_buffer_stack, 0, num_to_alloc * sizeof(struct yy_buffer_state*));
+
+ yyg->yy_buffer_stack_max = num_to_alloc;
+ yyg->yy_buffer_stack_top = 0;
+ return;
+ }
+
+ if (yyg->yy_buffer_stack_top >= (yyg->yy_buffer_stack_max) - 1){
+
+ /* Increase the buffer to prepare for a possible push. */
+ yy_size_t grow_size = 8 /* arbitrary grow size */;
+
+ num_to_alloc = yyg->yy_buffer_stack_max + grow_size;
+ yyg->yy_buffer_stack = (struct yy_buffer_state**)gdbwire_mi_realloc
+ (yyg->yy_buffer_stack,
+ num_to_alloc * sizeof(struct yy_buffer_state*)
+ , yyscanner);
+ if ( ! yyg->yy_buffer_stack )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi_ensure_buffer_stack()" );
+
+ /* zero only the new slots.*/
+ memset(yyg->yy_buffer_stack + yyg->yy_buffer_stack_max, 0, grow_size * sizeof(struct
yy_buffer_state*));
+ yyg->yy_buffer_stack_max = num_to_alloc;
+ }
+}
+
+/** Setup the input buffer state to scan directly from a user-specified character buffer.
+ * @param base the character buffer
+ * @param size the size in bytes of the character buffer
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE gdbwire_mi__scan_buffer (char * base, yy_size_t size , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+
+ if ( size < 2 ||
+ base[size-2] != YY_END_OF_BUFFER_CHAR ||
+ base[size-1] != YY_END_OF_BUFFER_CHAR )
+ /* They forgot to leave room for the EOB's. */
+ return NULL;
+
+ b = (YY_BUFFER_STATE) gdbwire_mi_alloc(sizeof( struct yy_buffer_state ) ,yyscanner );
+ if ( ! b )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi__scan_buffer()" );
+
+ b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
+ b->yy_buf_pos = b->yy_ch_buf = base;
+ b->yy_is_our_buffer = 0;
+ b->yy_input_file = NULL;
+ b->yy_n_chars = b->yy_buf_size;
+ b->yy_is_interactive = 0;
+ b->yy_at_bol = 1;
+ b->yy_fill_buffer = 0;
+ b->yy_buffer_status = YY_BUFFER_NEW;
+
+ gdbwire_mi__switch_to_buffer(b ,yyscanner );
+
+ return b;
+}
+
+/** Setup the input buffer state to scan a string. The next call to gdbwire_mi_lex() will
+ * scan from a @e copy of @a str.
+ * @param yystr a NUL-terminated string to scan
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ * @note If you want to scan bytes that may contain NUL values, then use
+ * gdbwire_mi__scan_bytes() instead.
+ */
+YY_BUFFER_STATE gdbwire_mi__scan_string (yyconst char * yystr , yyscan_t yyscanner)
+{
+
+ return gdbwire_mi__scan_bytes(yystr,(int) strlen(yystr) ,yyscanner);
+}
+
+/** Setup the input buffer state to scan the given bytes. The next call to gdbwire_mi_lex() will
+ * scan from a @e copy of @a bytes.
+ * @param yybytes the byte buffer to scan
+ * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
+ * @param yyscanner The scanner object.
+ * @return the newly allocated buffer state object.
+ */
+YY_BUFFER_STATE gdbwire_mi__scan_bytes (yyconst char * yybytes, int _yybytes_len , yyscan_t yyscanner)
+{
+ YY_BUFFER_STATE b;
+ char *buf;
+ yy_size_t n;
+ yy_size_t i;
+
+ /* Get memory for full buffer, including space for trailing EOB's. */
+ n = (yy_size_t) _yybytes_len + 2;
+ buf = (char *) gdbwire_mi_alloc(n ,yyscanner );
+ if ( ! buf )
+ YY_FATAL_ERROR( "out of dynamic memory in gdbwire_mi__scan_bytes()" );
+
+ for ( i = 0; i < _yybytes_len; ++i )
+ buf[i] = yybytes[i];
+
+ buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
+
+ b = gdbwire_mi__scan_buffer(buf,n ,yyscanner);
+ if ( ! b )
+ YY_FATAL_ERROR( "bad buffer in gdbwire_mi__scan_bytes()" );
+
+ /* It's okay to grow etc. this buffer, and we should throw it
+ * away when we're done.
+ */
+ b->yy_is_our_buffer = 1;
+
+ return b;
+}
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+static void yynoreturn yy_fatal_error (yyconst char* msg , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ (void) fprintf( stderr, "%s\n", msg );
+ exit( YY_EXIT_FAILURE );
+}
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+ do \
+ { \
+ /* Undo effects of setting up yytext. */ \
+ yy_size_t yyless_macro_arg = (n); \
+ YY_LESS_LINENO(yyless_macro_arg);\
+ yytext[yyleng] = yyg->yy_hold_char; \
+ yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
+ yyg->yy_hold_char = *yyg->yy_c_buf_p; \
+ *yyg->yy_c_buf_p = '\0'; \
+ yyleng = yyless_macro_arg; \
+ } \
+ while ( 0 )
+
+/* Accessor methods (get/set functions) to struct members. */
+
+/** Get the user-defined data for this scanner.
+ * @param yyscanner The scanner object.
+ */
+YY_EXTRA_TYPE gdbwire_mi_get_extra (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyextra;
+}
+
+/** Get the current line number.
+ * @param yyscanner The scanner object.
+ */
+int gdbwire_mi_get_lineno (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yylineno;
+}
+
+/** Get the current column number.
+ * @param yyscanner The scanner object.
+ */
+int gdbwire_mi_get_column (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ if (! YY_CURRENT_BUFFER)
+ return 0;
+
+ return yycolumn;
+}
+
+/** Get the input stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *gdbwire_mi_get_in (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyin;
+}
+
+/** Get the output stream.
+ * @param yyscanner The scanner object.
+ */
+FILE *gdbwire_mi_get_out (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyout;
+}
+
+/** Get the length of the current token.
+ * @param yyscanner The scanner object.
+ */
+int gdbwire_mi_get_leng (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yyleng;
+}
+
+/** Get the current token.
+ * @param yyscanner The scanner object.
+ */
+
+char *gdbwire_mi_get_text (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yytext;
+}
+
+/** Set the user-defined data. This data is never touched by the scanner.
+ * @param user_defined The data to be associated with this scanner.
+ * @param yyscanner The scanner object.
+ */
+void gdbwire_mi_set_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyextra = user_defined ;
+}
+
+/** Set the current line number.
+ * @param _line_number line number
+ * @param yyscanner The scanner object.
+ */
+void gdbwire_mi_set_lineno (int _line_number , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* lineno is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "gdbwire_mi_set_lineno called with no buffer" );
+
+ yylineno = _line_number;
+}
+
+/** Set the current column.
+ * @param _column_no column number
+ * @param yyscanner The scanner object.
+ */
+void gdbwire_mi_set_column (int _column_no , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* column is only valid if an input buffer exists. */
+ if (! YY_CURRENT_BUFFER )
+ YY_FATAL_ERROR( "gdbwire_mi_set_column called with no buffer" );
+
+ yycolumn = _column_no;
+}
+
+/** Set the input stream. This does not discard the current
+ * input buffer.
+ * @param _in_str A readable stream.
+ * @param yyscanner The scanner object.
+ * @see gdbwire_mi__switch_to_buffer
+ */
+void gdbwire_mi_set_in (FILE * _in_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyin = _in_str ;
+}
+
+void gdbwire_mi_set_out (FILE * _out_str , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yyout = _out_str ;
+}
+
+int gdbwire_mi_get_debug (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ return yy_flex_debug;
+}
+
+void gdbwire_mi_set_debug (int _bdebug , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ yy_flex_debug = _bdebug ;
+}
+
+/* Accessor methods for yylval and yylloc */
+
+/* User-visible API */
+
+/* gdbwire_mi_lex_init is special because it creates the scanner itself, so it is
+ * the ONLY reentrant function that doesn't take the scanner as the last argument.
+ * That's why we explicitly handle the declaration, instead of using our macros.
+ */
+
+int gdbwire_mi_lex_init(yyscan_t* ptr_yy_globals)
+
+{
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) gdbwire_mi_alloc ( sizeof( struct yyguts_t ), NULL );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+/* gdbwire_mi_lex_init_extra has the same functionality as gdbwire_mi_lex_init, but follows the
+ * convention of taking the scanner as the last argument. Note however, that
+ * this is a *pointer* to a scanner, as it will be allocated by this call (and
+ * is the reason, too, why this function also must handle its own declaration).
+ * The user defined value in the first argument will be available to gdbwire_mi_alloc in
+ * the yyextra field.
+ */
+
+int gdbwire_mi_lex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
+
+{
+ struct yyguts_t dummy_yyguts;
+
+ gdbwire_mi_set_extra (yy_user_defined, &dummy_yyguts);
+
+ if (ptr_yy_globals == NULL){
+ errno = EINVAL;
+ return 1;
+ }
+
+ *ptr_yy_globals = (yyscan_t) gdbwire_mi_alloc ( sizeof( struct yyguts_t ), &dummy_yyguts );
+
+ if (*ptr_yy_globals == NULL){
+ errno = ENOMEM;
+ return 1;
+ }
+
+ /* By setting to 0xAA, we expose bugs in
+ yy_init_globals. Leave at 0x00 for releases. */
+ memset(*ptr_yy_globals,0x00,sizeof(struct yyguts_t));
+
+ gdbwire_mi_set_extra (yy_user_defined, *ptr_yy_globals);
+
+ return yy_init_globals ( *ptr_yy_globals );
+}
+
+static int yy_init_globals (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ /* Initialization is the same as for the non-reentrant scanner.
+ * This function is called from gdbwire_mi_lex_destroy(), so don't allocate here.
+ */
+
+ yyg->yy_buffer_stack = NULL;
+ yyg->yy_buffer_stack_top = 0;
+ yyg->yy_buffer_stack_max = 0;
+ yyg->yy_c_buf_p = NULL;
+ yyg->yy_init = 0;
+ yyg->yy_start = 0;
+
+ yyg->yy_start_stack_ptr = 0;
+ yyg->yy_start_stack_depth = 0;
+ yyg->yy_start_stack = NULL;
+
+/* Defined in main.c */
+#ifdef YY_STDINIT
+ yyin = stdin;
+ yyout = stdout;
+#else
+ yyin = NULL;
+ yyout = NULL;
+#endif
+
+ /* For future reference: Set errno on error, since we are called by
+ * gdbwire_mi_lex_init()
+ */
+ return 0;
+}
+
+/* gdbwire_mi_lex_destroy is for both reentrant and non-reentrant scanners. */
+int gdbwire_mi_lex_destroy (yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+
+ /* Pop the buffer stack, destroying each element. */
+ while(YY_CURRENT_BUFFER){
+ gdbwire_mi__delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
+ YY_CURRENT_BUFFER_LVALUE = NULL;
+ gdbwire_mi_pop_buffer_state(yyscanner);
+ }
+
+ /* Destroy the stack itself. */
+ gdbwire_mi_free(yyg->yy_buffer_stack ,yyscanner);
+ yyg->yy_buffer_stack = NULL;
+
+ /* Destroy the start condition stack. */
+ gdbwire_mi_free(yyg->yy_start_stack ,yyscanner );
+ yyg->yy_start_stack = NULL;
+
+ /* Reset the globals. This is important in a non-reentrant scanner so the next time
+ * gdbwire_mi_lex() is called, initialization will occur. */
+ yy_init_globals( yyscanner);
+
+ /* Destroy the main struct (reentrant only). */
+ gdbwire_mi_free ( yyscanner , yyscanner );
+ yyscanner = NULL;
+ return 0;
+}
+
+/*
+ * Internal utility routines.
+ */
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy (char* s1, yyconst char * s2, int n , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ int i;
+ for ( i = 0; i < n; ++i )
+ s1[i] = s2[i];
+}
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen (yyconst char * s , yyscan_t yyscanner)
+{
+ int n;
+ for ( n = 0; s[n]; ++n )
+ ;
+
+ return n;
+}
+#endif
+
+void *gdbwire_mi_alloc (yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ return malloc(size);
+}
+
+void *gdbwire_mi_realloc (void * ptr, yy_size_t size , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+
+ /* The cast to (char *) in the following accommodates both
+ * implementations that use char* generic pointers, and those
+ * that use void* generic pointers. It works with the latter
+ * because both ANSI C and C++ allow castless assignment from
+ * any pointer type to void*, and deal with argument conversions
+ * as though doing an assignment.
+ */
+ return realloc(ptr, size);
+}
+
+void gdbwire_mi_free (void * ptr , yyscan_t yyscanner)
+{
+ struct yyguts_t * yyg = (struct yyguts_t*)yyscanner;
+ (void)yyg;
+ free( (char *) ptr ); /* see gdbwire_mi_realloc() for (char *) cast */
+}
+
+#define YYTABLES_NAME "yytables"
+
+
+
+
+/***** End of gdbwire_mi_lexer.c *********************************************/
+/***** Begin file gdbwire_mi_grammar.c ***************************************/
+/* A Bison parser, made by GNU Bison 3.0.4. */
+
+/* Bison implementation for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+/* C LALR(1) parser skeleton written by Richard Stallman, by
+ simplifying the original so-called "semantic" parser. */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+ infringing on user name space. This should be done even for local
+ variables, as they might otherwise be expanded by user macros.
+ There are some unavoidable exceptions within include files to
+ define necessary library symbols; they are noted "INFRINGES ON
+ USER NAME SPACE" below. */
+
+/* Identify Bison output. */
+#define YYBISON 1
+
+/* Bison version. */
+#define YYBISON_VERSION "3.0.4"
+
+/* Skeleton name. */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers. */
+#define YYPURE 1
+
+/* Push parsers. */
+#define YYPUSH 1
+
+/* Pull parsers. */
+#define YYPULL 0
+
+
+/* Substitute the variable and function names. */
+#define yypush_parse gdbwire_mi_push_parse
+#define yypstate_new gdbwire_mi_pstate_new
+#define yypstate_delete gdbwire_mi_pstate_delete
+#define yypstate gdbwire_mi_pstate
+#define yylex gdbwire_mi_lex
+#define yyerror gdbwire_mi_error
+#define yydebug gdbwire_mi_debug
+#define yynerrs gdbwire_mi_nerrs
+
+
+/* Copy the first part of user declarations. */
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+/* #include "gdbwire_sys.h" */
+/* #include "gdbwire_mi_grammar.h" */
+/* #include "gdbwire_mi_pt.h" */
+/* #include "gdbwire_mi_pt_alloc.h" */
+
+char *gdbwire_mi_get_text(yyscan_t yyscanner);
+struct gdbwire_mi_position gdbwire_mi_get_extra(yyscan_t yyscanner);
+
+/**
+ * Used only in the parser to build a gdbwire_mi_result list.
+ *
+ * The grammar wants to build a list of gdbwire_mi_result pointers.
+ * However, the gdbwire_mi_result is a traditional linked list and
+ * standard append functionality (using next to get to end of list) is slow.
+ *
+ * This structure allows us to keep around the last result in the list
+ * for fast insertion.
+ */
+struct gdbwire_mi_result_list {
+ /** The gdbwire_mi_result list that is being built */
+ struct gdbwire_mi_result *head;
+ /** The pointer to the last result in the list for fast insertion. */
+ struct gdbwire_mi_result **tail;
+};
+
+/**
+ * Allocate a gdbwire_mi_result_list data structure.
+ *
+ * @return
+ * The gdbwire_mi_result_list. Use free() to release the memory.
+ */
+struct gdbwire_mi_result_list *gdbwire_mi_result_list_alloc(void)
+{
+ struct gdbwire_mi_result_list *result;
+ result = calloc(1, sizeof(struct gdbwire_mi_result_list));
+ result->tail = &result->head;
+ return result;
+}
+
+/**
+ * Append an item to this list.
+ *
+ * @param list
+ * The list to append to.
+ *
+ * @param result
+ * The result to append to the end of the list.
+ */
+void gdbwire_mi_result_list_push_back(struct gdbwire_mi_result_list *list,
+ struct gdbwire_mi_result *result)
+{
+ *list->tail = result;
+ list->tail = &result->next;
+}
+
+void gdbwire_mi_error(yyscan_t yyscanner,
+ struct gdbwire_mi_output **gdbwire_mi_output, const char *s)
+{
+ char *text = gdbwire_mi_get_text(yyscanner);
+ struct gdbwire_mi_position pos = gdbwire_mi_get_extra(yyscanner);
+
+ *gdbwire_mi_output = gdbwire_mi_output_alloc();
+ (*gdbwire_mi_output)->kind = GDBWIRE_MI_OUTPUT_PARSE_ERROR;
+ (*gdbwire_mi_output)->variant.error.token = gdbwire_strdup(text);
+ (*gdbwire_mi_output)->variant.error.pos = pos;
+}
+
+/**
+ * GDB/MI escapes characters in the c-string rule.
+ *
+ * The c-string starts and ends with a ".
+ * Each " in the c-string is escaped with a \. So GDB turns " into \".
+ * Each \ in the string is then escaped with a \. So GDB turns \ into \\.
+ *
+ * Remove the GDB/MI escape characters to provide back to the user the
+ * original characters that GDB was intending to transmit. So
+ * \" -> "
+ * \\ -> \
+ * \n -> new line
+ * \r -> carriage return
+ * \t -> tab
+ *
+ * See gdbwire_mi_grammar.txt (GDB/MI Clarifications) for more information.
+ *
+ * @param str
+ * The escaped GDB/MI c-string data.
+ *
+ * @return
+ * An allocated strng representing str with the escaping undone.
+ */
+static char *gdbwire_mi_unescape_cstring(char *str)
+{
+ char *result;
+ size_t r, s, length;
+
+ /*assert(str);*/
+
+ result = gdbwire_strdup(str);
+ length = strlen(str);
+
+ /* a CSTRING should start and end with a quote */
+ /*assert(result);*/
+ /*assert(length >= 2);*/
+
+ for (r = 0, s = 1; s < length - 1; ++s) {
+ if (str[s] == '\\') {
+ switch (str[s+1]) {
+ case 'n':
+ result[r++] = '\n';
+ ++s;
+ break;
+ case 'r':
+ result[r++] = '\r';
+ ++s;
+ break;
+ case 't':
+ result[r++] = '\t';
+ ++s;
+ break;
+ case '"':
+ result[r++] = '\"';
+ ++s;
+ break;
+ case '\\':
+ result[r++] = '\\';
+ ++s;
+ break;
+ default:
+ result[r++] = str[s];
+ break;
+ }
+ } else {
+ result[r++] = str[s];
+ }
+ }
+
+ result[r] = 0;
+
+ return result;
+}
+
+
+
+# ifndef YY_NULLPTR
+# if defined __cplusplus && 201103L <= __cplusplus
+# define YY_NULLPTR nullptr
+# else
+# define YY_NULLPTR 0
+# endif
+# endif
+
+/* Enabling verbose error messages. */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+/* In a future release of Bison, this section will be replaced
+ by #include "y.tab.h". */
+#ifndef YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+# define YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int gdbwire_mi_debug;
+#endif
+/* "%code requires" blocks. */
+
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void *yyscan_t;
+#endif
+
+ struct gdbwire_mi_output;
+
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ OPEN_BRACE = 258,
+ CLOSED_BRACE = 259,
+ OPEN_PAREN = 260,
+ CLOSED_PAREN = 261,
+ ADD_OP = 262,
+ MULT_OP = 263,
+ EQUAL_SIGN = 264,
+ TILDA = 265,
+ AT_SYMBOL = 266,
+ AMPERSAND = 267,
+ OPEN_BRACKET = 268,
+ CLOSED_BRACKET = 269,
+ NEWLINE = 270,
+ INTEGER_LITERAL = 271,
+ STRING_LITERAL = 272,
+ CSTRING = 273,
+ COMMA = 274,
+ CARROT = 275
+ };
+#endif
+/* Tokens. */
+#define OPEN_BRACE 258
+#define CLOSED_BRACE 259
+#define OPEN_PAREN 260
+#define CLOSED_PAREN 261
+#define ADD_OP 262
+#define MULT_OP 263
+#define EQUAL_SIGN 264
+#define TILDA 265
+#define AT_SYMBOL 266
+#define AMPERSAND 267
+#define OPEN_BRACKET 268
+#define CLOSED_BRACKET 269
+#define NEWLINE 270
+#define INTEGER_LITERAL 271
+#define STRING_LITERAL 272
+#define CSTRING 273
+#define COMMA 274
+#define CARROT 275
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+
+ struct gdbwire_mi_output *u_output;
+ struct gdbwire_mi_oob_record *u_oob_record;
+ struct gdbwire_mi_result_record *u_result_record;
+ int u_result_class;
+ int u_async_record_kind;
+ struct gdbwire_mi_result_list *u_result_list;
+ struct gdbwire_mi_result *u_result;
+ char *u_token;
+ struct gdbwire_mi_async_record *u_async_record;
+ struct gdbwire_mi_stream_record *u_stream_record;
+ int u_async_class;
+ char *u_variable;
+ char *u_cstring;
+ struct gdbwire_mi_result *u_tuple;
+ struct gdbwire_mi_result *u_list;
+ int u_stream_record_kind;
+
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#ifndef YYPUSH_MORE_DEFINED
+# define YYPUSH_MORE_DEFINED
+enum { YYPUSH_MORE = 4 };
+#endif
+
+typedef struct gdbwire_mi_pstate gdbwire_mi_pstate;
+
+int gdbwire_mi_push_parse (gdbwire_mi_pstate *ps, int pushed_char, YYSTYPE const *pushed_val, yyscan_t
yyscanner, struct gdbwire_mi_output **gdbwire_mi_output);
+
+gdbwire_mi_pstate * gdbwire_mi_pstate_new (void);
+void gdbwire_mi_pstate_delete (gdbwire_mi_pstate *ps);
+
+#endif /* !YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED */
+
+/* Copy the second part of user declarations. */
+
+
+#ifdef short
+# undef short
+#endif
+
+#ifdef YYTYPE_UINT8
+typedef YYTYPE_UINT8 yytype_uint8;
+#else
+typedef unsigned char yytype_uint8;
+#endif
+
+#ifdef YYTYPE_INT8
+typedef YYTYPE_INT8 yytype_int8;
+#else
+typedef signed char yytype_int8;
+#endif
+
+#ifdef YYTYPE_UINT16
+typedef YYTYPE_UINT16 yytype_uint16;
+#else
+typedef unsigned short int yytype_uint16;
+#endif
+
+#ifdef YYTYPE_INT16
+typedef YYTYPE_INT16 yytype_int16;
+#else
+typedef short int yytype_int16;
+#endif
+
+#ifndef YYSIZE_T
+# ifdef __SIZE_TYPE__
+# define YYSIZE_T __SIZE_TYPE__
+# elif defined size_t
+# define YYSIZE_T size_t
+# elif ! defined YYSIZE_T
+# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+# define YYSIZE_T size_t
+# else
+# define YYSIZE_T unsigned int
+# endif
+#endif
+
+#define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
+
+#ifndef YY_
+# if defined YYENABLE_NLS && YYENABLE_NLS
+# if ENABLE_NLS
+# include <libintl.h> /* INFRINGES ON USER NAME SPACE */
+# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
+# endif
+# endif
+# ifndef YY_
+# define YY_(Msgid) Msgid
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE
+# if (defined __GNUC__ \
+ && (2 < __GNUC__ || (__GNUC__ == 2 && 96 <= __GNUC_MINOR__))) \
+ || defined __SUNPRO_C && 0x5110 <= __SUNPRO_C
+# define YY_ATTRIBUTE(Spec) __attribute__(Spec)
+# else
+# define YY_ATTRIBUTE(Spec) /* empty */
+# endif
+#endif
+
+#ifndef YY_ATTRIBUTE_PURE
+# define YY_ATTRIBUTE_PURE YY_ATTRIBUTE ((__pure__))
+#endif
+
+#ifndef YY_ATTRIBUTE_UNUSED
+# define YY_ATTRIBUTE_UNUSED YY_ATTRIBUTE ((__unused__))
+#endif
+
+#if !defined _Noreturn \
+ && (!defined __STDC_VERSION__ || __STDC_VERSION__ < 201112)
+# if defined _MSC_VER && 1200 <= _MSC_VER
+# define _Noreturn __declspec (noreturn)
+# else
+# define _Noreturn YY_ATTRIBUTE ((__noreturn__))
+# endif
+#endif
+
+/* Suppress unused-variable warnings by "using" E. */
+#if ! defined lint || defined __GNUC__
+# define YYUSE(E) ((void) (E))
+#else
+# define YYUSE(E) /* empty */
+#endif
+
+#if defined __GNUC__ && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
+/* Suppress an incorrect diagnostic about yylval being uninitialized. */
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
+ _Pragma ("GCC diagnostic push") \
+ _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")\
+ _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
+ _Pragma ("GCC diagnostic pop")
+#else
+# define YY_INITIAL_VALUE(Value) Value
+#endif
+#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+# define YY_IGNORE_MAYBE_UNINITIALIZED_END
+#endif
+#ifndef YY_INITIAL_VALUE
+# define YY_INITIAL_VALUE(Value) /* Nothing. */
+#endif
+
+
+#if ! defined yyoverflow || YYERROR_VERBOSE
+
+/* The parser invokes alloca or malloc; define the necessary symbols. */
+
+# ifdef YYSTACK_ALLOC
+ /* Pacify GCC's 'empty if-body' warning. */
+# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# ifndef YYSTACK_ALLOC_MAXIMUM
+ /* The OS might guarantee only one guard page at the bottom of the stack,
+ and a page size can be as small as 4096 bytes. So we cannot safely
+ invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
+ to allow for a few compiler-allocated temporary stack slots. */
+# define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
+# endif
+# else
+# define YYSTACK_ALLOC YYMALLOC
+# define YYSTACK_FREE YYFREE
+# ifndef YYSTACK_ALLOC_MAXIMUM
+# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
+# endif
+# if (defined __cplusplus && ! defined EXIT_SUCCESS \
+ && ! ((defined YYMALLOC || defined malloc) \
+ && (defined YYFREE || defined free)))
+# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+# ifndef EXIT_SUCCESS
+# define EXIT_SUCCESS 0
+# endif
+# endif
+# ifndef YYMALLOC
+# define YYMALLOC malloc
+# if ! defined malloc && ! defined EXIT_SUCCESS
+void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# ifndef YYFREE
+# define YYFREE free
+# if ! defined free && ! defined EXIT_SUCCESS
+void free (void *); /* INFRINGES ON USER NAME SPACE */
+# endif
+# endif
+# endif
+#endif /* ! defined yyoverflow || YYERROR_VERBOSE */
+
+
+#if (! defined yyoverflow \
+ && (! defined __cplusplus \
+ || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member. */
+union yyalloc
+{
+ yytype_int16 yyss_alloc;
+ YYSTYPE yyvs_alloc;
+};
+
+/* The size of the maximum gap between one aligned stack and the next. */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+ N elements. */
+# define YYSTACK_BYTES(N) \
+ ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
+ + YYSTACK_GAP_MAXIMUM)
+
+# define YYCOPY_NEEDED 1
+
+/* Relocate STACK from its old location to the new one. The
+ local variables YYSIZE and YYSTACKSIZE give the old and new number of
+ elements in the stack, and YYPTR gives the new location of the
+ stack. Advance YYPTR to a properly aligned location for the next
+ stack. */
+# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
+ do \
+ { \
+ YYSIZE_T yynewbytes; \
+ YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
+ Stack = &yyptr->Stack_alloc; \
+ yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+ yyptr += yynewbytes / sizeof (*yyptr); \
+ } \
+ while (0)
+
+#endif
+
+#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
+/* Copy COUNT objects from SRC to DST. The source and destination do
+ not overlap. */
+# ifndef YYCOPY
+# if defined __GNUC__ && 1 < __GNUC__
+# define YYCOPY(Dst, Src, Count) \
+ __builtin_memcpy (Dst, Src, (Count) * sizeof (*(Src)))
+# else
+# define YYCOPY(Dst, Src, Count) \
+ do \
+ { \
+ YYSIZE_T yyi; \
+ for (yyi = 0; yyi < (Count); yyi++) \
+ (Dst)[yyi] = (Src)[yyi]; \
+ } \
+ while (0)
+# endif
+# endif
+#endif /* !YYCOPY_NEEDED */
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL 2
+/* YYLAST -- Last index in YYTABLE. */
+#define YYLAST 42
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS 21
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS 22
+/* YYNRULES -- Number of rules. */
+#define YYNRULES 40
+/* YYNSTATES -- Number of states. */
+#define YYNSTATES 56
+
+/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
+ by yylex, with out-of-bounds checking. */
+#define YYUNDEFTOK 2
+#define YYMAXUTOK 275
+
+#define YYTRANSLATE(YYX) \
+ ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
+ as returned by yylex, without out-of-bounds checking. */
+static const yytype_uint8 yytranslate[] =
+{
+ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
+ 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
+ 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+ 15, 16, 17, 18, 19, 20
+};
+
+#if YYDEBUG
+ /* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
+static const yytype_uint16 yyrline[] =
+{
+ 0, 248, 248, 251, 254, 258, 262, 268, 274, 274,
+ 286, 293, 301, 307, 313, 321, 330, 334, 338, 342,
+ 359, 412, 416, 420, 425, 430, 437, 444, 451, 456,
+ 461, 465, 470, 474, 479, 485, 489, 493, 497, 501,
+ 505
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE || 0
+/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+ First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+ "$end", "error", "$undefined", "OPEN_BRACE", "CLOSED_BRACE",
+ "OPEN_PAREN", "CLOSED_PAREN", "ADD_OP", "MULT_OP", "EQUAL_SIGN", "TILDA",
+ "AT_SYMBOL", "AMPERSAND", "OPEN_BRACKET", "CLOSED_BRACKET", "NEWLINE",
+ "INTEGER_LITERAL", "STRING_LITERAL", "CSTRING", "COMMA", "CARROT",
+ "$accept", "output_list", "output", "output_variant", "$@1",
+ "result_record", "oob_record", "async_record", "async_record_class",
+ "result_class", "async_class", "opt_variable", "result_list", "result",
+ "variable", "cstring", "tuple", "list", "stream_record",
+ "stream_record_class", "opt_token", "token", YY_NULLPTR
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[NUM] -- (External) token number corresponding to the
+ (internal) symbol number NUM (which must be that of a token). */
+static const yytype_uint16 yytoknum[] =
+{
+ 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
+ 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
+ 275
+};
+# endif
+
+#define YYPACT_NINF -19
+
+#define yypact_value_is_default(Yystate) \
+ (!!((Yystate) == (-19)))
+
+#define YYTABLE_NINF -39
+
+#define yytable_value_is_error(Yytable_value) \
+ 0
+
+ /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+ STATE-NUM. */
+static const yytype_int8 yypact[] =
+{
+ -19, 0, -19, 15, 11, -19, -19, -19, -19, -19,
+ 16, -19, -19, -19, -19, -3, 14, -19, -19, -19,
+ -19, -19, -19, -19, -19, -19, -19, 12, 18, 27,
+ -19, 17, -19, 19, -19, 11, 11, 1, 20, -19,
+ 28, 20, 9, -11, -19, -19, -19, 11, -19, -19,
+ -2, -19, 13, -19, -19, -19
+};
+
+ /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
+ Performed when YYTABLE does not specify something else to do. Zero
+ means the default is an error. */
+static const yytype_uint8 yydefact[] =
+{
+ 2, 0, 1, 0, 0, 35, 36, 37, 40, 3,
+ 0, 7, 6, 12, 13, 0, 0, 39, 5, 28,
+ 8, 4, 29, 34, 17, 16, 18, 0, 0, 0,
+ 19, 10, 20, 14, 9, 21, 21, 0, 11, 23,
+ 0, 15, 21, 21, 25, 26, 27, 21, 22, 30,
+ 0, 32, 0, 24, 31, 33
+};
+
+ /* YYPGOTO[NTERM-NUM]. */
+static const yytype_int8 yypgoto[] =
+{
+ -19, -19, -19, -19, -19, -19, -19, -19, -19, -19,
+ -19, -19, -18, -7, 37, 5, -19, -19, -19, -19,
+ -19, -19
+};
+
+ /* YYDEFGOTO[NTERM-NUM]. */
+static const yytype_int8 yydefgoto[] =
+{
+ -1, 1, 9, 10, 29, 11, 12, 13, 28, 31,
+ 33, 37, 38, 39, 40, 23, 45, 46, 14, 15,
+ 16, 17
+};
+
+ /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
+ positive, shift that token. If negative, reduce the rule whose
+ number is the opposite. If YYTABLE_NINF, syntax error. */
+static const yytype_int8 yytable[] =
+{
+ 2, 3, 54, 51, 42, 4, 19, -38, -38, -38,
+ 5, 6, 7, 49, 43, 22, 8, 47, 41, 22,
+ -38, 24, 25, 26, 50, 52, 19, 55, 19, 30,
+ 18, 21, 47, 34, 27, 32, 35, 48, 36, 47,
+ 53, 20, 44
+};
+
+static const yytype_uint8 yycheck[] =
+{
+ 0, 1, 4, 14, 3, 5, 17, 7, 8, 9,
+ 10, 11, 12, 4, 13, 18, 16, 19, 36, 18,
+ 20, 7, 8, 9, 42, 43, 17, 14, 17, 17,
+ 15, 15, 19, 6, 20, 17, 19, 9, 19, 19,
+ 47, 4, 37
+};
+
+ /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+ symbol of state STATE-NUM. */
+static const yytype_uint8 yystos[] =
+{
+ 0, 22, 0, 1, 5, 10, 11, 12, 16, 23,
+ 24, 26, 27, 28, 39, 40, 41, 42, 15, 17,
+ 35, 15, 18, 36, 7, 8, 9, 20, 29, 25,
+ 17, 30, 17, 31, 6, 19, 19, 32, 33, 34,
+ 35, 33, 3, 13, 36, 37, 38, 19, 9, 4,
+ 33, 14, 33, 34, 4, 14
+};
+
+ /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const yytype_uint8 yyr1[] =
+{
+ 0, 21, 22, 22, 23, 23, 24, 24, 25, 24,
+ 26, 26, 27, 27, 28, 28, 29, 29, 29, 30,
+ 31, 32, 32, 33, 33, 34, 34, 34, 35, 36,
+ 37, 37, 38, 38, 39, 40, 40, 40, 41, 41,
+ 42
+};
+
+ /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
+static const yytype_uint8 yyr2[] =
+{
+ 0, 2, 0, 2, 2, 2, 1, 1, 0, 4,
+ 3, 5, 1, 1, 3, 5, 1, 1, 1, 1,
+ 1, 0, 2, 1, 3, 2, 2, 2, 1, 1,
+ 2, 3, 2, 3, 2, 1, 1, 1, 0, 1,
+ 1
+};
+
+
+#define yyerrok (yyerrstatus = 0)
+#define yyclearin (yychar = YYEMPTY)
+#define YYEMPTY (-2)
+#define YYEOF 0
+
+#define YYACCEPT goto yyacceptlab
+#define YYABORT goto yyabortlab
+#define YYERROR goto yyerrorlab
+
+
+#define YYRECOVERING() (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value) \
+do \
+ if (yychar == YYEMPTY) \
+ { \
+ yychar = (Token); \
+ yylval = (Value); \
+ YYPOPSTACK (yylen); \
+ yystate = *yyssp; \
+ goto yybackup; \
+ } \
+ else \
+ { \
+ yyerror (yyscanner, gdbwire_mi_output, YY_("syntax error: cannot back up")); \
+ YYERROR; \
+ } \
+while (0)
+
+/* Error token number */
+#define YYTERROR 1
+#define YYERRCODE 256
+
+
+
+/* Enable debugging if requested. */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+# define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args) \
+do { \
+ if (yydebug) \
+ YYFPRINTF Args; \
+} while (0)
+
+/* This macro is provided for backward compatibility. */
+#ifndef YY_LOCATION_PRINT
+# define YY_LOCATION_PRINT(File, Loc) ((void) 0)
+#endif
+
+
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
+do { \
+ if (yydebug) \
+ { \
+ YYFPRINTF (stderr, "%s ", Title); \
+ yy_symbol_print (stderr, \
+ Type, Value, yyscanner, gdbwire_mi_output); \
+ YYFPRINTF (stderr, "\n"); \
+ } \
+} while (0)
+
+
+/*----------------------------------------.
+| Print this symbol's value on YYOUTPUT. |
+`----------------------------------------*/
+
+static void
+yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner,
struct gdbwire_mi_output **gdbwire_mi_output)
+{
+ FILE *yyo = yyoutput;
+ YYUSE (yyo);
+ YYUSE (yyscanner);
+ YYUSE (gdbwire_mi_output);
+ if (!yyvaluep)
+ return;
+# ifdef YYPRINT
+ if (yytype < YYNTOKENS)
+ YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+ YYUSE (yytype);
+}
+
+
+/*--------------------------------.
+| Print this symbol on YYOUTPUT. |
+`--------------------------------*/
+
+static void
+yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, yyscan_t yyscanner, struct
gdbwire_mi_output **gdbwire_mi_output)
+{
+ YYFPRINTF (yyoutput, "%s %s (",
+ yytype < YYNTOKENS ? "token" : "nterm", yytname[yytype]);
+
+ yy_symbol_value_print (yyoutput, yytype, yyvaluep, yyscanner, gdbwire_mi_output);
+ YYFPRINTF (yyoutput, ")");
+}
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included). |
+`------------------------------------------------------------------*/
+
+static void
+yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
+{
+ YYFPRINTF (stderr, "Stack now");
+ for (; yybottom <= yytop; yybottom++)
+ {
+ int yybot = *yybottom;
+ YYFPRINTF (stderr, " %d", yybot);
+ }
+ YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top) \
+do { \
+ if (yydebug) \
+ yy_stack_print ((Bottom), (Top)); \
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced. |
+`------------------------------------------------*/
+
+static void
+yy_reduce_print (yytype_int16 *yyssp, YYSTYPE *yyvsp, int yyrule, yyscan_t yyscanner, struct
gdbwire_mi_output **gdbwire_mi_output)
+{
+ unsigned long int yylno = yyrline[yyrule];
+ int yynrhs = yyr2[yyrule];
+ int yyi;
+ YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
+ yyrule - 1, yylno);
+ /* The symbols being reduced. */
+ for (yyi = 0; yyi < yynrhs; yyi++)
+ {
+ YYFPRINTF (stderr, " $%d = ", yyi + 1);
+ yy_symbol_print (stderr,
+ yystos[yyssp[yyi + 1 - yynrhs]],
+ &(yyvsp[(yyi + 1) - (yynrhs)])
+ , yyscanner, gdbwire_mi_output);
+ YYFPRINTF (stderr, "\n");
+ }
+}
+
+# define YY_REDUCE_PRINT(Rule) \
+do { \
+ if (yydebug) \
+ yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, gdbwire_mi_output); \
+} while (0)
+
+/* Nonzero means print parse trace. It is left uninitialized so that
+ multiple parsers can coexist. */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YY_SYMBOL_PRINT(Title, Type, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks. */
+#ifndef YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+ if the built-in stack extension method is used).
+
+ Do not make this value too large; the results are undefined if
+ YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
+ evaluated with infinite-precision integer arithmetic. */
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+# if defined __GLIBC__ && defined _STRING_H
+# define yystrlen strlen
+# else
+/* Return the length of YYSTR. */
+static YYSIZE_T
+yystrlen (const char *yystr)
+{
+ YYSIZE_T yylen;
+ for (yylen = 0; yystr[yylen]; yylen++)
+ continue;
+ return yylen;
+}
+# endif
+# endif
+
+# ifndef yystpcpy
+# if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
+# define yystpcpy stpcpy
+# else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+ YYDEST. */
+static char *
+yystpcpy (char *yydest, const char *yysrc)
+{
+ char *yyd = yydest;
+ const char *yys = yysrc;
+
+ while ((*yyd++ = *yys++) != '\0')
+ continue;
+
+ return yyd - 1;
+}
+# endif
+# endif
+
+# ifndef yytnamerr
+/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
+ quotes and backslashes, so that it's suitable for yyerror. The
+ heuristic is that double-quoting is unnecessary unless the string
+ contains an apostrophe, a comma, or backslash (other than
+ backslash-backslash). YYSTR is taken from yytname. If YYRES is
+ null, do not copy; instead, return the length of what the result
+ would have been. */
+static YYSIZE_T
+yytnamerr (char *yyres, const char *yystr)
+{
+ if (*yystr == '"')
+ {
+ YYSIZE_T yyn = 0;
+ char const *yyp = yystr;
+
+ for (;;)
+ switch (*++yyp)
+ {
+ case '\'':
+ case ',':
+ goto do_not_strip_quotes;
+
+ case '\\':
+ if (*++yyp != '\\')
+ goto do_not_strip_quotes;
+ /* Fall through. */
+ default:
+ if (yyres)
+ yyres[yyn] = *yyp;
+ yyn++;
+ break;
+
+ case '"':
+ if (yyres)
+ yyres[yyn] = '\0';
+ return yyn;
+ }
+ do_not_strip_quotes: ;
+ }
+
+ if (! yyres)
+ return yystrlen (yystr);
+
+ return yystpcpy (yyres, yystr) - yyres;
+}
+# endif
+
+/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
+ about the unexpected token YYTOKEN for the state stack whose top is
+ YYSSP.
+
+ Return 0 if *YYMSG was successfully written. Return 1 if *YYMSG is
+ not large enough to hold the message. In that case, also set
+ *YYMSG_ALLOC to the required number of bytes. Return 2 if the
+ required number of bytes is too large to store. */
+static int
+yysyntax_error (YYSIZE_T *yymsg_alloc, char **yymsg,
+ yytype_int16 *yyssp, int yytoken)
+{
+ YYSIZE_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
+ YYSIZE_T yysize = yysize0;
+ enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
+ /* Internationalized format string. */
+ const char *yyformat = YY_NULLPTR;
+ /* Arguments of yyformat. */
+ char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
+ /* Number of reported tokens (one for the "unexpected", one per
+ "expected"). */
+ int yycount = 0;
+
+ /* There are many possibilities here to consider:
+ - If this state is a consistent state with a default action, then
+ the only way this function was invoked is if the default action
+ is an error action. In that case, don't check for expected
+ tokens because there are none.
+ - The only way there can be no lookahead present (in yychar) is if
+ this state is a consistent state with a default action. Thus,
+ detecting the absence of a lookahead is sufficient to determine
+ that there is no unexpected or expected token to report. In that
+ case, just report a simple "syntax error".
+ - Don't assume there isn't a lookahead just because this state is a
+ consistent state with a default action. There might have been a
+ previous inconsistent state, consistent state with a non-default
+ action, or user semantic action that manipulated yychar.
+ - Of course, the expected token list depends on states to have
+ correct lookahead information, and it depends on the parser not
+ to perform extra reductions after fetching a lookahead from the
+ scanner and before detecting a syntax error. Thus, state merging
+ (from LALR or IELR) and default reductions corrupt the expected
+ token list. However, the list is correct for canonical LR with
+ one exception: it will still contain any token that will not be
+ accepted due to an error action in a later state.
+ */
+ if (yytoken != YYEMPTY)
+ {
+ int yyn = yypact[*yyssp];
+ yyarg[yycount++] = yytname[yytoken];
+ if (!yypact_value_is_default (yyn))
+ {
+ /* Start YYX at -YYN if negative to avoid negative indexes in
+ YYCHECK. In other words, skip the first -YYN actions for
+ this state because they are default actions. */
+ int yyxbegin = yyn < 0 ? -yyn : 0;
+ /* Stay within bounds of both yycheck and yytname. */
+ int yychecklim = YYLAST - yyn + 1;
+ int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+ int yyx;
+
+ for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+ if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
+ && !yytable_value_is_error (yytable[yyx + yyn]))
+ {
+ if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
+ {
+ yycount = 1;
+ yysize = yysize0;
+ break;
+ }
+ yyarg[yycount++] = yytname[yyx];
+ {
+ YYSIZE_T yysize1 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
+ if (! (yysize <= yysize1
+ && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+ }
+ }
+ }
+
+ switch (yycount)
+ {
+# define YYCASE_(N, S) \
+ case N: \
+ yyformat = S; \
+ break
+ YYCASE_(0, YY_("syntax error"));
+ YYCASE_(1, YY_("syntax error, unexpected %s"));
+ YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
+ YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
+ YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
+ YYCASE_(5, YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
+# undef YYCASE_
+ }
+
+ {
+ YYSIZE_T yysize1 = yysize + yystrlen (yyformat);
+ if (! (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM))
+ return 2;
+ yysize = yysize1;
+ }
+
+ if (*yymsg_alloc < yysize)
+ {
+ *yymsg_alloc = 2 * yysize;
+ if (! (yysize <= *yymsg_alloc
+ && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
+ *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
+ return 1;
+ }
+
+ /* Avoid sprintf, as that infringes on the user's name space.
+ Don't have undefined behavior even if the translation
+ produced a string with the wrong number of "%s"s. */
+ {
+ char *yyp = *yymsg;
+ int yyi = 0;
+ while ((*yyp = *yyformat) != '\0')
+ if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount)
+ {
+ yyp += yytnamerr (yyp, yyarg[yyi++]);
+ yyformat += 2;
+ }
+ else
+ {
+ yyp++;
+ yyformat++;
+ }
+ }
+ return 0;
+}
+#endif /* YYERROR_VERBOSE */
+
+/*-----------------------------------------------.
+| Release the memory associated to this symbol. |
+`-----------------------------------------------*/
+
+static void
+yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, yyscan_t yyscanner, struct gdbwire_mi_output
**gdbwire_mi_output)
+{
+ YYUSE (yyvaluep);
+ YYUSE (yyscanner);
+ YYUSE (gdbwire_mi_output);
+ if (!yymsg)
+ yymsg = "Deleting";
+ YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ switch (yytype)
+ {
+ case 24: /* output_variant */
+ { gdbwire_mi_output_free(((*yyvaluep).u_output)); }
+ break;
+
+ case 32: /* opt_variable */
+ { free(((*yyvaluep).u_variable)); }
+ break;
+
+ case 33: /* result_list */
+ { gdbwire_mi_result_free(((*yyvaluep).u_result_list)->head); free(((*yyvaluep).u_result_list)); }
+ break;
+
+ case 34: /* result */
+ { gdbwire_mi_result_free(((*yyvaluep).u_result)); }
+ break;
+
+ case 35: /* variable */
+ { free(((*yyvaluep).u_variable)); }
+ break;
+
+ case 41: /* opt_token */
+ { free(((*yyvaluep).u_token)); }
+ break;
+
+
+ default:
+ break;
+ }
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+
+
+struct yypstate
+ {
+ /* Number of syntax errors so far. */
+ int yynerrs;
+
+ int yystate;
+ /* Number of tokens to shift before error messages enabled. */
+ int yyerrstatus;
+
+ /* The stacks and their tools:
+ 'yyss': related to states.
+ 'yyvs': related to semantic values.
+
+ Refer to the stacks through separate pointers, to allow yyoverflow
+ to reallocate them elsewhere. */
+
+ /* The state stack. */
+ yytype_int16 yyssa[YYINITDEPTH];
+ yytype_int16 *yyss;
+ yytype_int16 *yyssp;
+
+ /* The semantic value stack. */
+ YYSTYPE yyvsa[YYINITDEPTH];
+ YYSTYPE *yyvs;
+ YYSTYPE *yyvsp;
+
+ YYSIZE_T yystacksize;
+ /* Used to determine if this is the first time this instance has
+ been used. */
+ int yynew;
+ };
+
+/* Initialize the parser data structure. */
+yypstate *
+yypstate_new (void)
+{
+ yypstate *yyps;
+ yyps = (yypstate *) malloc (sizeof *yyps);
+ if (!yyps)
+ return YY_NULLPTR;
+ yyps->yynew = 1;
+ return yyps;
+}
+
+void
+yypstate_delete (yypstate *yyps)
+{
+#ifndef yyoverflow
+ /* If the stack was reallocated but the parse did not complete, then the
+ stack still needs to be freed. */
+ if (!yyps->yynew && yyps->yyss != yyps->yyssa)
+ YYSTACK_FREE (yyps->yyss);
+#endif
+ free (yyps);
+}
+
+#define gdbwire_mi_nerrs yyps->gdbwire_mi_nerrs
+#define yystate yyps->yystate
+#define yyerrstatus yyps->yyerrstatus
+#define yyssa yyps->yyssa
+#define yyss yyps->yyss
+#define yyssp yyps->yyssp
+#define yyvsa yyps->yyvsa
+#define yyvs yyps->yyvs
+#define yyvsp yyps->yyvsp
+#define yystacksize yyps->yystacksize
+
+
+/*---------------.
+| yypush_parse. |
+`---------------*/
+
+int
+yypush_parse (yypstate *yyps, int yypushed_char, YYSTYPE const *yypushed_val, yyscan_t yyscanner, struct
gdbwire_mi_output **gdbwire_mi_output)
+{
+/* The lookahead symbol. */
+int yychar;
+
+
+/* The semantic value of the lookahead symbol. */
+/* Default value used for initialization, for pacifying older GCCs
+ or non-GCC compilers. */
+YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
+
+ int yyn;
+ int yyresult;
+ /* Lookahead token as an internal (translated) token number. */
+ int yytoken = 0;
+ /* The variables used to return semantic value and location from the
+ action routines. */
+ YYSTYPE yyval;
+
+#if YYERROR_VERBOSE
+ /* Buffer for error messages, and its allocated size. */
+ char yymsgbuf[128];
+ char *yymsg = yymsgbuf;
+ YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
+#endif
+
+#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
+
+ /* The number of symbols on the RHS of the reduced rule.
+ Keep to zero when no symbol should be popped. */
+ int yylen = 0;
+
+ if (!yyps->yynew)
+ {
+ yyn = yypact[yystate];
+ goto yyread_pushed_token;
+ }
+
+ yyssp = yyss = yyssa;
+ yyvsp = yyvs = yyvsa;
+ yystacksize = YYINITDEPTH;
+
+ YYDPRINTF ((stderr, "Starting parse\n"));
+
+ yystate = 0;
+ yyerrstatus = 0;
+ yynerrs = 0;
+ yychar = YYEMPTY; /* Cause a token to be read. */
+ goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate. |
+`------------------------------------------------------------*/
+ yynewstate:
+ /* In all cases, when you get here, the value and location stacks
+ have just been pushed. So pushing a state here evens the stacks. */
+ yyssp++;
+
+ yysetstate:
+ *yyssp = yystate;
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ {
+ /* Get the current used size of the three stacks, in elements. */
+ YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+ {
+ /* Give user a chance to reallocate the stack. Use copies of
+ these so that the &'s don't force the real ones into
+ memory. */
+ YYSTYPE *yyvs1 = yyvs;
+ yytype_int16 *yyss1 = yyss;
+
+ /* Each stack pointer address is followed by the size of the
+ data in use in that stack, in bytes. This used to be a
+ conditional around just the two extra args, but that might
+ be undefined if yyoverflow is a macro. */
+ yyoverflow (YY_("memory exhausted"),
+ &yyss1, yysize * sizeof (*yyssp),
+ &yyvs1, yysize * sizeof (*yyvsp),
+ &yystacksize);
+
+ yyss = yyss1;
+ yyvs = yyvs1;
+ }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+ goto yyexhaustedlab;
+# else
+ /* Extend the stack our own way. */
+ if (YYMAXDEPTH <= yystacksize)
+ goto yyexhaustedlab;
+ yystacksize *= 2;
+ if (YYMAXDEPTH < yystacksize)
+ yystacksize = YYMAXDEPTH;
+
+ {
+ yytype_int16 *yyss1 = yyss;
+ union yyalloc *yyptr =
+ (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+ if (! yyptr)
+ goto yyexhaustedlab;
+ YYSTACK_RELOCATE (yyss_alloc, yyss);
+ YYSTACK_RELOCATE (yyvs_alloc, yyvs);
+# undef YYSTACK_RELOCATE
+ if (yyss1 != yyssa)
+ YYSTACK_FREE (yyss1);
+ }
+# endif
+#endif /* no yyoverflow */
+
+ yyssp = yyss + yysize - 1;
+ yyvsp = yyvs + yysize - 1;
+
+ YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+ (unsigned long int) yystacksize));
+
+ if (yyss + yystacksize - 1 <= yyssp)
+ YYABORT;
+ }
+
+ YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+ if (yystate == YYFINAL)
+ YYACCEPT;
+
+ goto yybackup;
+
+/*-----------.
+| yybackup. |
+`-----------*/
+yybackup:
+
+ /* Do appropriate processing given the current state. Read a
+ lookahead token if we need one and don't already have one. */
+
+ /* First try to decide what to do without reference to lookahead token. */
+ yyn = yypact[yystate];
+ if (yypact_value_is_default (yyn))
+ goto yydefault;
+
+ /* Not known => get a lookahead token if don't already have one. */
+
+ /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
+ if (yychar == YYEMPTY)
+ {
+ if (!yyps->yynew)
+ {
+ YYDPRINTF ((stderr, "Return for a new token:\n"));
+ yyresult = YYPUSH_MORE;
+ goto yypushreturn;
+ }
+ yyps->yynew = 0;
+yyread_pushed_token:
+ YYDPRINTF ((stderr, "Reading a token: "));
+ yychar = yypushed_char;
+ if (yypushed_val)
+ yylval = *yypushed_val;
+ }
+
+ if (yychar <= YYEOF)
+ {
+ yychar = yytoken = YYEOF;
+ YYDPRINTF ((stderr, "Now at end of input.\n"));
+ }
+ else
+ {
+ yytoken = YYTRANSLATE (yychar);
+ YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+ }
+
+ /* If the proper action on seeing token YYTOKEN is to reduce or to
+ detect an error, take that action. */
+ yyn += yytoken;
+ if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+ goto yydefault;
+ yyn = yytable[yyn];
+ if (yyn <= 0)
+ {
+ if (yytable_value_is_error (yyn))
+ goto yyerrlab;
+ yyn = -yyn;
+ goto yyreduce;
+ }
+
+ /* Count tokens shifted since error; after three, turn off error
+ status. */
+ if (yyerrstatus)
+ yyerrstatus--;
+
+ /* Shift the lookahead token. */
+ YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+
+ /* Discard the shifted token. */
+ yychar = YYEMPTY;
+
+ yystate = yyn;
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+ goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state. |
+`-----------------------------------------------------------*/
+yydefault:
+ yyn = yydefact[yystate];
+ if (yyn == 0)
+ goto yyerrlab;
+ goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction. |
+`-----------------------------*/
+yyreduce:
+ /* yyn is the number of a rule to reduce with. */
+ yylen = yyr2[yyn];
+
+ /* If YYLEN is nonzero, implement the default value of the action:
+ '$$ = $1'.
+
+ Otherwise, the following line sets YYVAL to garbage.
+ This behavior is undocumented and Bison
+ users should not rely upon it. Assigning to YYVAL
+ unconditionally makes the parser a bit smaller, and it avoids a
+ GCC warning that YYVAL may be used uninitialized. */
+ yyval = yyvsp[1-yylen];
+
+
+ YY_REDUCE_PRINT (yyn);
+ switch (yyn)
+ {
+ case 2:
+ {
+}
+ break;
+
+ case 3:
+ {
+}
+ break;
+
+ case 4:
+ {
+ *gdbwire_mi_output = (yyvsp[-1].u_output);
+}
+ break;
+
+ case 5:
+ {
+ yyerrok;
+}
+ break;
+
+ case 6:
+ {
+ (yyval.u_output) = gdbwire_mi_output_alloc();
+ (yyval.u_output)->kind = GDBWIRE_MI_OUTPUT_OOB;
+ (yyval.u_output)->variant.oob_record = (yyvsp[0].u_oob_record);
+}
+ break;
+
+ case 7:
+ {
+ (yyval.u_output) = gdbwire_mi_output_alloc();
+ (yyval.u_output)->kind = GDBWIRE_MI_OUTPUT_RESULT;
+ (yyval.u_output)->variant.result_record = (yyvsp[0].u_result_record);
+}
+ break;
+
+ case 8:
+ {
+ if (strcmp("gdb", (yyvsp[0].u_variable)) != 0) {
+ /* Destructor will be called to free $2 on error */
+ yyerror(yyscanner, gdbwire_mi_output, "");
+ YYERROR;
+ }
+ }
+ break;
+
+ case 9:
+ {
+ (yyval.u_output) = gdbwire_mi_output_alloc();
+ (yyval.u_output)->kind = GDBWIRE_MI_OUTPUT_PROMPT;
+ free((yyvsp[-2].u_variable));
+ }
+ break;
+
+ case 10:
+ {
+ (yyval.u_result_record) = gdbwire_mi_result_record_alloc();
+ (yyval.u_result_record)->token = (yyvsp[-2].u_token);
+ (yyval.u_result_record)->result_class = (yyvsp[0].u_result_class);
+ (yyval.u_result_record)->result = NULL;
+}
+ break;
+
+ case 11:
+ {
+ (yyval.u_result_record) = gdbwire_mi_result_record_alloc();
+ (yyval.u_result_record)->token = (yyvsp[-4].u_token);
+ (yyval.u_result_record)->result_class = (yyvsp[-2].u_result_class);
+ (yyval.u_result_record)->result = (yyvsp[0].u_result_list)->head;
+ free((yyvsp[0].u_result_list));
+}
+ break;
+
+ case 12:
+ {
+ (yyval.u_oob_record) = gdbwire_mi_oob_record_alloc();
+ (yyval.u_oob_record)->kind = GDBWIRE_MI_ASYNC;
+ (yyval.u_oob_record)->variant.async_record = (yyvsp[0].u_async_record);
+}
+ break;
+
+ case 13:
+ {
+ (yyval.u_oob_record) = gdbwire_mi_oob_record_alloc();
+ (yyval.u_oob_record)->kind = GDBWIRE_MI_STREAM;
+ (yyval.u_oob_record)->variant.stream_record = (yyvsp[0].u_stream_record);
+}
+ break;
+
+ case 14:
+ {
+ (yyval.u_async_record) = gdbwire_mi_async_record_alloc();
+ (yyval.u_async_record)->token = (yyvsp[-2].u_token);
+ (yyval.u_async_record)->kind = (yyvsp[-1].u_async_record_kind);
+ (yyval.u_async_record)->async_class = (yyvsp[0].u_async_class);
+ (yyval.u_async_record)->result = NULL;
+}
+ break;
+
+ case 15:
+ {
+ (yyval.u_async_record) = gdbwire_mi_async_record_alloc();
+ (yyval.u_async_record)->token = (yyvsp[-4].u_token);
+ (yyval.u_async_record)->kind = (yyvsp[-3].u_async_record_kind);
+ (yyval.u_async_record)->async_class = (yyvsp[-2].u_async_class);
+ (yyval.u_async_record)->result = (yyvsp[0].u_result_list)->head;
+ free((yyvsp[0].u_result_list));
+}
+ break;
+
+ case 16:
+ {
+ (yyval.u_async_record_kind) = GDBWIRE_MI_EXEC;
+}
+ break;
+
+ case 17:
+ {
+ (yyval.u_async_record_kind) = GDBWIRE_MI_STATUS;
+}
+ break;
+
+ case 18:
+ {
+ (yyval.u_async_record_kind) = GDBWIRE_MI_NOTIFY;
+}
+ break;
+
+ case 19:
+ {
+ char *text = gdbwire_mi_get_text(yyscanner);
+ if (strcmp("done", text) == 0) {
+ (yyval.u_result_class) = GDBWIRE_MI_DONE;
+ } else if (strcmp("running", text) == 0) {
+ (yyval.u_result_class) = GDBWIRE_MI_RUNNING;
+ } else if (strcmp("connected", text) == 0) {
+ (yyval.u_result_class) = GDBWIRE_MI_CONNECTED;
+ } else if (strcmp("error", text) == 0) {
+ (yyval.u_result_class) = GDBWIRE_MI_ERROR;
+ } else if (strcmp("exit", text) == 0) {
+ (yyval.u_result_class) = GDBWIRE_MI_EXIT;
+ } else {
+ (yyval.u_result_class) = GDBWIRE_MI_UNSUPPORTED;
+ }
+}
+ break;
+
+ case 20:
+ {
+ char *text = gdbwire_mi_get_text(yyscanner);
+ if (strcmp("download", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_DOWNLOAD;
+ } else if (strcmp("stopped", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_STOPPED;
+ } else if (strcmp("running", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_RUNNING;
+ } else if (strcmp("thread-group-added", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED;
+ } else if (strcmp("thread-group-removed", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED;
+ } else if (strcmp("thread-group-started", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED;
+ } else if (strcmp("thread-group-exited", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED;
+ } else if (strcmp("thread-created", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_CREATED;
+ } else if (strcmp("thread-exited", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_EXITED;
+ } else if (strcmp("thread-selected", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_THREAD_SELECTED;
+ } else if (strcmp("library-loaded", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_LIBRARY_LOADED;
+ } else if (strcmp("library-unloaded", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED;
+ } else if (strcmp("traceframe-changed", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_TRACEFRAME_CHANGED;
+ } else if (strcmp("tsv-created", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_TSV_CREATED;
+ } else if (strcmp("tsv-modified", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_TSV_MODIFIED;
+ } else if (strcmp("tsv-deleted", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_TSV_DELETED;
+ } else if (strcmp("breakpoint-created", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED;
+ } else if (strcmp("breakpoint-modified", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED;
+ } else if (strcmp("breakpoint-deleted", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED;
+ } else if (strcmp("record-started", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_RECORD_STARTED;
+ } else if (strcmp("record-stopped", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_RECORD_STOPPED;
+ } else if (strcmp("cmd-param-changed", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_CMD_PARAM_CHANGED;
+ } else if (strcmp("memory-changed", text) == 0) {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_MEMORY_CHANGED;
+ } else {
+ (yyval.u_async_class) = GDBWIRE_MI_ASYNC_UNSUPPORTED;
+ }
+}
+ break;
+
+ case 21:
+ {
+ (yyval.u_variable) = 0;
+}
+ break;
+
+ case 22:
+ {
+ (yyval.u_variable) = (yyvsp[-1].u_variable);
+}
+ break;
+
+ case 23:
+ {
+ (yyval.u_result_list) = gdbwire_mi_result_list_alloc();
+ gdbwire_mi_result_list_push_back((yyval.u_result_list), (yyvsp[0].u_result));
+}
+ break;
+
+ case 24:
+ {
+ gdbwire_mi_result_list_push_back((yyvsp[-2].u_result_list), (yyvsp[0].u_result));
+ (yyval.u_result_list) = (yyvsp[-2].u_result_list);
+}
+ break;
+
+ case 25:
+ {
+ (yyval.u_result) = gdbwire_mi_result_alloc();
+ (yyval.u_result)->variable = (yyvsp[-1].u_variable);
+ (yyval.u_result)->kind = GDBWIRE_MI_CSTRING;
+ (yyval.u_result)->variant.cstring = (yyvsp[0].u_cstring);
+}
+ break;
+
+ case 26:
+ {
+ (yyval.u_result) = gdbwire_mi_result_alloc();
+ (yyval.u_result)->variable = (yyvsp[-1].u_variable);
+ (yyval.u_result)->kind = GDBWIRE_MI_TUPLE;
+ (yyval.u_result)->variant.result = (yyvsp[0].u_tuple);
+}
+ break;
+
+ case 27:
+ {
+ (yyval.u_result) = gdbwire_mi_result_alloc();
+ (yyval.u_result)->variable = (yyvsp[-1].u_variable);
+ (yyval.u_result)->kind = GDBWIRE_MI_LIST;
+ (yyval.u_result)->variant.result = (yyvsp[0].u_list);
+}
+ break;
+
+ case 28:
+ {
+ char *text = gdbwire_mi_get_text(yyscanner);
+ (yyval.u_variable) = gdbwire_strdup(text);
+}
+ break;
+
+ case 29:
+ {
+ char *text = gdbwire_mi_get_text(yyscanner);
+ (yyval.u_cstring) = gdbwire_mi_unescape_cstring(text);
+}
+ break;
+
+ case 30:
+ {
+ (yyval.u_tuple) = NULL;
+}
+ break;
+
+ case 31:
+ {
+ (yyval.u_tuple) = (yyvsp[-1].u_result_list)->head;
+ free((yyvsp[-1].u_result_list));
+}
+ break;
+
+ case 32:
+ {
+ (yyval.u_list) = NULL;
+}
+ break;
+
+ case 33:
+ {
+ (yyval.u_list) = (yyvsp[-1].u_result_list)->head;
+ free((yyvsp[-1].u_result_list));
+}
+ break;
+
+ case 34:
+ {
+ (yyval.u_stream_record) = gdbwire_mi_stream_record_alloc();
+ (yyval.u_stream_record)->kind = (yyvsp[-1].u_stream_record_kind);
+ (yyval.u_stream_record)->cstring = (yyvsp[0].u_cstring);
+}
+ break;
+
+ case 35:
+ {
+ (yyval.u_stream_record_kind) = GDBWIRE_MI_CONSOLE;
+}
+ break;
+
+ case 36:
+ {
+ (yyval.u_stream_record_kind) = GDBWIRE_MI_TARGET;
+}
+ break;
+
+ case 37:
+ {
+ (yyval.u_stream_record_kind) = GDBWIRE_MI_LOG;
+}
+ break;
+
+ case 38:
+ {
+ (yyval.u_token) = NULL;
+}
+ break;
+
+ case 39:
+ {
+ (yyval.u_token) = (yyvsp[0].u_token);
+}
+ break;
+
+ case 40:
+ {
+ char *text = gdbwire_mi_get_text(yyscanner);
+ (yyval.u_token) = gdbwire_strdup(text);
+}
+ break;
+
+
+ default: break;
+ }
+ /* User semantic actions sometimes alter yychar, and that requires
+ that yytoken be updated with the new translation. We take the
+ approach of translating immediately before every use of yytoken.
+ One alternative is translating here after every semantic action,
+ but that translation would be missed if the semantic action invokes
+ YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
+ if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
+ incorrect destructor might then be invoked immediately. In the
+ case of YYERROR or YYBACKUP, subsequent parser actions might lead
+ to an incorrect destructor call or verbose syntax error message
+ before the lookahead is translated. */
+ YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
+
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+
+ *++yyvsp = yyval;
+
+ /* Now 'shift' the result of the reduction. Determine what state
+ that goes to, based on the state we popped back to and the rule
+ number reduced by. */
+
+ yyn = yyr1[yyn];
+
+ yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+ if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+ yystate = yytable[yystate];
+ else
+ yystate = yydefgoto[yyn - YYNTOKENS];
+
+ goto yynewstate;
+
+
+/*--------------------------------------.
+| yyerrlab -- here on detecting error. |
+`--------------------------------------*/
+yyerrlab:
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
+
+ /* If not already recovering from an error, report this error. */
+ if (!yyerrstatus)
+ {
+ ++yynerrs;
+#if ! YYERROR_VERBOSE
+ yyerror (yyscanner, gdbwire_mi_output, YY_("syntax error"));
+#else
+# define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
+ yyssp, yytoken)
+ {
+ char const *yymsgp = YY_("syntax error");
+ int yysyntax_error_status;
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ if (yysyntax_error_status == 0)
+ yymsgp = yymsg;
+ else if (yysyntax_error_status == 1)
+ {
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+ yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
+ if (!yymsg)
+ {
+ yymsg = yymsgbuf;
+ yymsg_alloc = sizeof yymsgbuf;
+ yysyntax_error_status = 2;
+ }
+ else
+ {
+ yysyntax_error_status = YYSYNTAX_ERROR;
+ yymsgp = yymsg;
+ }
+ }
+ yyerror (yyscanner, gdbwire_mi_output, yymsgp);
+ if (yysyntax_error_status == 2)
+ goto yyexhaustedlab;
+ }
+# undef YYSYNTAX_ERROR
+#endif
+ }
+
+
+
+ if (yyerrstatus == 3)
+ {
+ /* If just tried and failed to reuse lookahead token after an
+ error, discard it. */
+
+ if (yychar <= YYEOF)
+ {
+ /* Return failure if at end of input. */
+ if (yychar == YYEOF)
+ YYABORT;
+ }
+ else
+ {
+ yydestruct ("Error: discarding",
+ yytoken, &yylval, yyscanner, gdbwire_mi_output);
+ yychar = YYEMPTY;
+ }
+ }
+
+ /* Else will try to reuse lookahead token after shifting the error
+ token. */
+ goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR. |
+`---------------------------------------------------*/
+yyerrorlab:
+
+ /* Pacify compilers like GCC when the user code never invokes
+ YYERROR and the label yyerrorlab therefore never appears in user
+ code. */
+ if (/*CONSTCOND*/ 0)
+ goto yyerrorlab;
+
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYERROR. */
+ YYPOPSTACK (yylen);
+ yylen = 0;
+ YY_STACK_PRINT (yyss, yyssp);
+ yystate = *yyssp;
+ goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR. |
+`-------------------------------------------------------------*/
+yyerrlab1:
+ yyerrstatus = 3; /* Each real token shifted decrements this. */
+
+ for (;;)
+ {
+ yyn = yypact[yystate];
+ if (!yypact_value_is_default (yyn))
+ {
+ yyn += YYTERROR;
+ if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+ {
+ yyn = yytable[yyn];
+ if (0 < yyn)
+ break;
+ }
+ }
+
+ /* Pop the current state because it cannot handle the error token. */
+ if (yyssp == yyss)
+ YYABORT;
+
+
+ yydestruct ("Error: popping",
+ yystos[yystate], yyvsp, yyscanner, gdbwire_mi_output);
+ YYPOPSTACK (1);
+ yystate = *yyssp;
+ YY_STACK_PRINT (yyss, yyssp);
+ }
+
+ YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+ *++yyvsp = yylval;
+ YY_IGNORE_MAYBE_UNINITIALIZED_END
+
+
+ /* Shift the error token. */
+ YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
+
+ yystate = yyn;
+ goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here. |
+`-------------------------------------*/
+yyacceptlab:
+ yyresult = 0;
+ goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here. |
+`-----------------------------------*/
+yyabortlab:
+ yyresult = 1;
+ goto yyreturn;
+
+#if !defined yyoverflow || YYERROR_VERBOSE
+/*-------------------------------------------------.
+| yyexhaustedlab -- memory exhaustion comes here. |
+`-------------------------------------------------*/
+yyexhaustedlab:
+ yyerror (yyscanner, gdbwire_mi_output, YY_("memory exhausted"));
+ yyresult = 2;
+ /* Fall through. */
+#endif
+
+yyreturn:
+ if (yychar != YYEMPTY)
+ {
+ /* Make sure we have latest lookahead translation. See comments at
+ user semantic actions for why this is necessary. */
+ yytoken = YYTRANSLATE (yychar);
+ yydestruct ("Cleanup: discarding lookahead",
+ yytoken, &yylval, yyscanner, gdbwire_mi_output);
+ }
+ /* Do not reclaim the symbols of the rule whose action triggered
+ this YYABORT or YYACCEPT. */
+ YYPOPSTACK (yylen);
+ YY_STACK_PRINT (yyss, yyssp);
+ while (yyssp != yyss)
+ {
+ yydestruct ("Cleanup: popping",
+ yystos[*yyssp], yyvsp, yyscanner, gdbwire_mi_output);
+ YYPOPSTACK (1);
+ }
+#ifndef yyoverflow
+ if (yyss != yyssa)
+ YYSTACK_FREE (yyss);
+#endif
+ yyps->yynew = 1;
+
+yypushreturn:
+#if YYERROR_VERBOSE
+ if (yymsg != yymsgbuf)
+ YYSTACK_FREE (yymsg);
+#endif
+ return yyresult;
+}
+/***** End of gdbwire_mi_grammar.c *******************************************/
+/***** Begin file gdbwire.c **************************************************/
+/**
+ * Copyright (C) 2013 Robert Rossi <bob brasko net>
+ *
+ * This file is part of GDBWIRE.
+ *
+ * GDBWIRE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GDBWIRE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GDBWIRE. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdlib.h>
+#include <string.h>
+
+/* #include "gdbwire_assert.h" */
+/***** Include gdbwire.h in the middle of gdbwire.c **************************/
+/***** Begin file gdbwire.h **************************************************/
+/**
+ * Copyright (C) 2013 Robert Rossi <bob brasko net>
+ *
+ * This file is part of GDBWIRE.
+ *
+ * GDBWIRE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GDBWIRE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GDBWIRE. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GDBWIRE_H
+#define GDBWIRE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_mi_pt.h" */
+/* #include "gdbwire_mi_command.h" */
+
+/* The opaque gdbwire context */
+struct gdbwire;
+
+/**
+ * The primary mechanism for gdbwire to send events to the caller.
+ *
+ * The flow is like this:
+ * - create a gdbwire instance
+ * - loop:
+ * - call gdbwire functions to send commands to gdb
+ * - receive callback events with results when they become available
+ * - destroy the instance
+ */
+struct gdbwire_callbacks {
+ /**
+ * An arbitrary pointer to associate with the events.
+ *
+ * This pointer will be passed back to the caller in each event.
+ */
+ void *context;
+
+ /**
+ * A console, target or log output event has occured.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param stream_record
+ * The stream record to display to the user.
+ */
+ void (*gdbwire_stream_record_fn)(void *context,
+ struct gdbwire_mi_stream_record *stream_record);
+
+ /**
+ * An asynchronous output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param async_record
+ * The asychronous record output by GDB.
+ */
+ void (*gdbwire_async_record_fn)(void *context,
+ struct gdbwire_mi_async_record *async_record);
+
+ /**
+ * A result output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param result_record
+ * The result record output by GDB.
+ */
+ void (*gdbwire_result_record_fn)(void *context,
+ struct gdbwire_mi_result_record *result_record);
+
+ /**
+ * A prompt output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param prompt
+ * The prompt output to display to the user.
+ */
+ void (*gdbwire_prompt_fn)(void *context, const char *prompt);
+
+ /**
+ * A gdbwire parse error occurred.
+ *
+ * If you receive this callback, that means the gdbwire parser
+ * failed to parse some gdb/mi coming out of gdb.
+ * Please send the parameters received in this callback to the
+ * gdbwire develpment team.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param mi
+ * The mi string that gdbwire could not parse.
+ *
+ * @param token
+ * The token the error occurred on.
+ *
+ * @param position
+ * The position of the token the error occurred on.
+ */
+ void (*gdbwire_parse_error_fn)(void *context, const char *mi,
+ const char *token, struct gdbwire_mi_position position);
+};
+
+/**
+ * Create a gdbwire context.
+ *
+ * Each gdbwire structure is capable of talking to a single gdb instance.
+ *
+ * @param callbacks
+ * The callback functions for when events should be sent. Be sure to
+ * initialize all of the callback functions. If a callback event is
+ * initialized to NULL, it will not be called.
+ *
+ * @return
+ * A new gdbwire instance or NULL on error.
+ */
+struct gdbwire *gdbwire_create(struct gdbwire_callbacks callbacks);
+
+/**
+ * Destroy a gdbwire context.
+ *
+ * This function will do nothing if the instance is NULL.
+ *
+ * @param gdbwire
+ * The instance of gdbwire to destroy
+ */
+void gdbwire_destroy(struct gdbwire *wire);
+
+/**
+ * Push some GDB output characters to gdbwire for processing.
+ *
+ * Currently, the calling application is responsible for reading the
+ * output of GDB and sending it to gdbwire. This may change in the future.
+ * Call this function with output from GDB when it is available.
+ *
+ * During this function, callback events may be invoked to alert the
+ * caller of useful gdbwire_mi events.
+ *
+ * @param wire
+ * The gdbwire context to operate on.
+ *
+ * @param data
+ * The data to push to gdbwire for interpretation.
+ *
+ * @param size
+ * The size of the data to push to gdbwire.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_push_data(struct gdbwire *wire, const char *data,
+ size_t size);
+
+/**
+ * Handle an interpreter-exec command.
+ *
+ * Typically, a front end would start gdb with the MI interface and create
+ * a corresponding gdbwire instance. The front end would feed the gdbwire
+ * instance all of the MI output. In this scenario, gdbwire triggers
+ * callbacks when interesting events occur.
+ *
+ * Some GDB front ends use the annotate interface with gdb, and will
+ * transition to using MI through the use of the interpreter-exec command.
+ * In this scenario, the front end will send GDB a single interpreter-exec
+ * command and will want to interpret the output of only that command.
+ * For this use case, a gdbwire instance is not necessary for the front end,
+ * nor any of the callbacks associated with that instance.
+ *
+ * This function provides a way for a front end to interpret the output
+ * of a single interpreter-exec command with out the need for creating
+ * a gdbwire instance or any gdbwire callbacks.
+ *
+ * @param interpreter_exec_output
+ * The MI output from GDB for the interpreter exec command.
+ *
+ * @param kind
+ * The interpreter-exec command kind.
+ *
+ * @param out_mi_command
+ * Will return an allocated gdbwire mi command if GDBWIRE_OK is returned
+ * from this function. You should free this memory with
+ * gdbwire_mi_command_free when you are done with it.
+ *
+ * @return
+ * The result of this function.
+ */
+enum gdbwire_result gdbwire_interpreter_exec(
+ const char *interpreter_exec_output,
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_command **out_mi_command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire.h ******************************************************/
+/***** Continuing where we left off in gdbwire.c *****************************/
+/* #include "gdbwire_mi_parser.h" */
+
+struct gdbwire
+{
+ /* The gdbwire_mi parser. */
+ struct gdbwire_mi_parser *parser;
+
+ /* The client callback functions */
+ struct gdbwire_callbacks callbacks;
+};
+
+static void
+gdbwire_mi_output_callback(void *context, struct gdbwire_mi_output *output) {
+ struct gdbwire *wire = (struct gdbwire *)context;
+
+ struct gdbwire_mi_output *cur = output;
+
+ while (cur) {
+ switch (cur->kind) {
+ case GDBWIRE_MI_OUTPUT_OOB: {
+ struct gdbwire_mi_oob_record *oob_record =
+ cur->variant.oob_record;
+ switch (oob_record->kind) {
+ case GDBWIRE_MI_ASYNC:
+ if (wire->callbacks.gdbwire_async_record_fn) {
+ wire->callbacks.gdbwire_async_record_fn(
+ wire->callbacks.context,
+ oob_record->variant.async_record);
+ }
+ break;
+ case GDBWIRE_MI_STREAM:
+ if (wire->callbacks.gdbwire_stream_record_fn) {
+ wire->callbacks.gdbwire_stream_record_fn(
+ wire->callbacks.context,
+ oob_record->variant.stream_record);
+ }
+ break;
+ }
+ break;
+ }
+ case GDBWIRE_MI_OUTPUT_RESULT:
+ if (wire->callbacks.gdbwire_result_record_fn) {
+ wire->callbacks.gdbwire_result_record_fn(
+ wire->callbacks.context, cur->variant.result_record);
+ }
+ break;
+ case GDBWIRE_MI_OUTPUT_PROMPT:
+ if (wire->callbacks.gdbwire_prompt_fn) {
+ wire->callbacks.gdbwire_prompt_fn(
+ wire->callbacks.context, cur->line);
+ }
+ break;
+ case GDBWIRE_MI_OUTPUT_PARSE_ERROR:
+ if (wire->callbacks.gdbwire_parse_error_fn) {
+ wire->callbacks.gdbwire_parse_error_fn(
+ wire->callbacks.context, cur->line,
+ cur->variant.error.token,
+ cur->variant.error.pos);
+ }
+ break;
+ }
+
+ cur = cur->next;
+ }
+
+ gdbwire_mi_output_free(output);
+}
+
+struct gdbwire *
+gdbwire_create(struct gdbwire_callbacks callbacks)
+{
+ struct gdbwire *result = 0;
+
+ result = malloc(sizeof(struct gdbwire));
+ if (result) {
+ struct gdbwire_mi_parser_callbacks parser_callbacks =
+ { result,gdbwire_mi_output_callback };
+ result->callbacks = callbacks;
+ result->parser = gdbwire_mi_parser_create(parser_callbacks);
+ if (!result->parser) {
+ free(result);
+ result = 0;
+ }
+ }
+
+ return result;
+}
+
+void
+gdbwire_destroy(struct gdbwire *gdbwire)
+{
+ if (gdbwire) {
+ gdbwire_mi_parser_destroy(gdbwire->parser);
+ free(gdbwire);
+ }
+}
+
+enum gdbwire_result
+gdbwire_push_data(struct gdbwire *wire, const char *data, size_t size)
+{
+ enum gdbwire_result result;
+ GDBWIRE_ASSERT(wire);
+ result = gdbwire_mi_parser_push_data(wire->parser, data, size);
+ return result;
+}
+
+struct gdbwire_interpreter_exec_context {
+ enum gdbwire_result result;
+ enum gdbwire_mi_command_kind kind;
+ struct gdbwire_mi_command *mi_command;
+};
+
+static void gdbwire_interpreter_exec_stream_record(void *context,
+ struct gdbwire_mi_stream_record *stream_record)
+{
+ struct gdbwire_interpreter_exec_context *ctx =
+ (struct gdbwire_interpreter_exec_context*)context;
+ ctx->result = GDBWIRE_LOGIC;
+}
+
+static void gdbwire_interpreter_exec_async_record(void *context,
+ struct gdbwire_mi_async_record *async_record)
+{
+ struct gdbwire_interpreter_exec_context *ctx =
+ (struct gdbwire_interpreter_exec_context*)context;
+ ctx->result = GDBWIRE_LOGIC;
+}
+
+static void gdbwire_interpreter_exec_result_record(void *context,
+ struct gdbwire_mi_result_record *result_record)
+{
+ struct gdbwire_interpreter_exec_context *ctx =
+ (struct gdbwire_interpreter_exec_context*)context;
+
+ if (ctx->result == GDBWIRE_OK) {
+ ctx->result = gdbwire_get_mi_command(
+ ctx->kind, result_record, &ctx->mi_command);
+ }
+}
+
+static void gdbwire_interpreter_exec_prompt(void *context, const char *prompt)
+{
+ struct gdbwire_interpreter_exec_context *ctx =
+ (struct gdbwire_interpreter_exec_context*)context;
+ ctx->result = GDBWIRE_LOGIC;
+}
+
+static void gdbwire_interpreter_exec_parse_error(void *context,
+ const char *mi, const char *token, struct gdbwire_mi_position
+ position)
+{
+ struct gdbwire_interpreter_exec_context *ctx =
+ (struct gdbwire_interpreter_exec_context*)context;
+ ctx->result = GDBWIRE_LOGIC;
+}
+
+
+enum gdbwire_result
+gdbwire_interpreter_exec(
+ const char *interpreter_exec_output,
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_command **out_mi_command)
+{
+ struct gdbwire_interpreter_exec_context context = {
+ GDBWIRE_OK, kind, 0 };
+ size_t len;
+ enum gdbwire_result result = GDBWIRE_OK;
+ struct gdbwire_callbacks callbacks = {
+ &context,
+ gdbwire_interpreter_exec_stream_record,
+ gdbwire_interpreter_exec_async_record,
+ gdbwire_interpreter_exec_result_record,
+ gdbwire_interpreter_exec_prompt,
+ gdbwire_interpreter_exec_parse_error
+ };
+ struct gdbwire *wire;
+
+ GDBWIRE_ASSERT(interpreter_exec_output);
+ GDBWIRE_ASSERT(out_mi_command);
+
+ len = strlen(interpreter_exec_output);
+
+ wire = gdbwire_create(callbacks);
+ GDBWIRE_ASSERT(wire);
+
+ result = gdbwire_push_data(wire, interpreter_exec_output, len);
+ if (result == GDBWIRE_OK) {
+ /* Honor function documentation,
+ * When it returns GDBWIRE_OK - the command will exist.
+ * Otherwise it will not. */
+ if (context.result == GDBWIRE_OK && !context.mi_command) {
+ result = GDBWIRE_LOGIC;
+ } else if (context.result != GDBWIRE_OK && context.mi_command) {
+ result = context.result;
+ gdbwire_mi_command_free(context.mi_command);
+ } else {
+ result = context.result;
+ *out_mi_command = context.mi_command;
+ }
+ }
+
+ gdbwire_destroy(wire);
+ return result;
+}
+/***** End of gdbwire.c ******************************************************/
diff --git a/plugins/gdb/gdbwire.h b/plugins/gdb/gdbwire.h
new file mode 100644
index 0000000..4e96082
--- /dev/null
+++ b/plugins/gdb/gdbwire.h
@@ -0,0 +1,3149 @@
+/**
+ * Copyright (C) 2013 Robert Rossi <bob brasko net>
+ *
+ * This file is an amalgamation of the source files from GDBWIRE.
+ *
+ * It was created using gdbwire 1.0 and git revision b5ae67f.
+ *
+ * GDBWIRE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GDBWIRE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GDBWIRE. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+/***** Begin file gdbwire_sys.h **********************************************/
+#ifndef __GDBWIRE_SYS_H__
+#define __GDBWIRE_SYS_H__
+
+/**
+ * Supporting system functions.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Duplicate a string.
+ *
+ * @param str
+ * The string to duplicate
+ *
+ * @return
+ * An allocated string that must be freed.
+ * Null if out of memory or str is NULL.
+ */
+char *gdbwire_strdup(const char *str);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_sys.h **************************************************/
+/***** Begin file gdbwire_string.h *******************************************/
+#ifndef __GDBWIRE_STRING_H__
+#define __GDBWIRE_STRING_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+
+/**
+ * A dynamic string representation.
+ *
+ * To create and destroy a string use gdbwire_string_create() and
+ * gdbwire_string_destroy() respectively.
+ *
+ * This string is an abstraction of a low level C string. It supports being
+ * used as a NULL terminated c string and also as an arbitrary array of
+ * bytes. You can append to this string in either of these modes using
+ * gdbwire_string_append_cstr() or gdbwire_string_append_data(). This string
+ * automatically grows as you append data to it. Please note, the size of
+ * the string will not include the NULL terminated character when using
+ * the gdbwire_string_append_cstr() function to append data.
+ *
+ * To get access to the underlying bytes associated with this string
+ * call gdbwire_string_data(). It is OK to modify the result as long as
+ * you are careful to stay in it's valid bounds.
+ *
+ * The size (or length) of the string can be accessed through the
+ * gdbwire_string_size() function. The character pointer returned from
+ * gdbwire_string_data() is valid from the index range of 0 to
+ * gdbwire_string_size() - 1.
+ */
+struct gdbwire_string;
+
+/**
+ * Create a string instance.
+ *
+ * @return
+ * A valid string instance or NULL on error.
+ */
+struct gdbwire_string *gdbwire_string_create(void);
+
+/**
+ * Destroy the string instance and it's resources.
+ *
+ * @param string
+ * The string to destroy.
+ */
+void gdbwire_string_destroy(struct gdbwire_string *string);
+
+/**
+ * Clear the contents of a string.
+ *
+ * Sets the string back to an empty string which also changes it's
+ * size back to zero.
+ *
+ * The capacity remains unchanged.
+ *
+ * @param string
+ * The string to clear
+ */
+void gdbwire_string_clear(struct gdbwire_string *string);
+
+/**
+ * Append a c string to the string instance.
+ *
+ * @param string
+ * The string instance to append the c string to.
+ *
+ * @param cstr
+ * The c string to append to the string instance.
+ *
+ * @return
+ * 0 on success or -1 on failure.
+ */
+int gdbwire_string_append_cstr(struct gdbwire_string *string, const char *cstr);
+
+/**
+ * Append a sequence of bytes to the string instance.
+ *
+ * @param string
+ * The string instance to append the sequence of bytes to.
+ *
+ * @param data
+ * The sequence of bytes to append to the string instance. This may
+ * contain NUL characters.
+ *
+ * @param size
+ * The number of bytes in data to append to the string instance.
+ *
+ * @return
+ * 0 on success or -1 on failure.
+ */
+int gdbwire_string_append_data(struct gdbwire_string *string,
+ const char *data, size_t size);
+
+/**
+ * Get the data associated with this string.
+ *
+ * The data could be formatted as a NULL terminated C string or
+ * as an arbitrary array of bytes. Use gdbwire_string_size() to
+ * determine the size (or length) of the result of this function.
+ *
+ * Modifying the return value of this function is acceptable as long as you
+ * stay in the string's valid bounds.
+ *
+ * @param string
+ * The string index to get the pointer data from.
+ *
+ * @return
+ * The data that has been added to this string instance or "" after
+ * creation or clear. The result is gdbwire_string_size() bytes long.
+ */
+char *gdbwire_string_data(struct gdbwire_string *string);
+
+/**
+ * Determine the size (the number of bytes) this string instance represents.
+ *
+ * Please note, the result of this function will not include the NULL
+ * terminated character when using the gdbwire_string_append_cstr() function
+ * to append data.
+ *
+ * @param string
+ * The string instance to get the size for.
+ *
+ * @return
+ * The number of bytes contained in this string instance. To access these
+ * bytes see gdbwire_string_data(). Will be 0 after creation or clear.
+ */
+size_t gdbwire_string_size(struct gdbwire_string *string);
+
+/**
+ * Determine the maximum capacity (number of bytes) this string may hold.
+ *
+ * The max capacity of the string is automatically increased when data
+ * is appended to this string through the gdbwire_string_append_*()
+ * family of functions.
+ *
+ * @param string
+ * The string to determine the capacity of.
+ *
+ * @return
+ * The max number of bytes this string may hold.
+ */
+size_t gdbwire_string_capacity(struct gdbwire_string *string);
+
+/**
+ * Search for the first character in chars occuring in this string.
+ *
+ * @param string
+ * The string to search for the characters in chars in.
+ *
+ * @param chars
+ * A null terminated string of characters. This string is not searched
+ * for directly but instead each individually character in the string
+ * is searched for.
+ *
+ * @return
+ * The index position of the first matched character in chars.
+ * Will return gdbwire_string_size() if not found.
+ */
+size_t gdbwire_string_find_first_of(struct gdbwire_string *string,
+ const char *chars);
+
+/**
+ * Erase characters from this string, reducing it's size.
+ *
+ * @param string
+ * The string to erase characters from.
+ *
+ * @param pos
+ * The index position of the first character to be erased.
+ *
+ * @param count
+ * The number of characters to erase starting at position pos.
+ * If count goes past the end of the string it is adjusted to erase
+ * until the end of the string. This allows the caller to pass in
+ * gdbwire_string_size() to erase the end of the string with out
+ * doing index arithmetic.
+ *
+ * @return
+ * On success 0 will be returned otherwise -1. The string will remain
+ * unmodified when an error occurs. Success can only occur if the entire
+ * requested range can be erased.
+ */
+int gdbwire_string_erase(struct gdbwire_string *string, size_t pos,
+ size_t count);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_string.h ***********************************************/
+/***** Begin file gdbwire_assert.h *******************************************/
+#ifndef GDBWIRE_ERROR_H
+#define GDBWIRE_ERROR_H
+
+/***** Include gdbwire_result.h in the middle of gdbwire_assert.h ************/
+/***** Begin file gdbwire_result.h *******************************************/
+#ifndef GDBWIRE_RESULT_H
+#define GDBWIRE_RESULT_H
+
+enum gdbwire_result {
+ /* The result of the operation was successful */
+ GDBWIRE_OK,
+
+ /**
+ * An assertion failed in the calling code.
+ *
+ * Functions are encouraged to assert expressions they expect
+ * to be true. The macro GDBWIRE_ASSERT and GDBWIRE_ASSERT_ERRNO
+ * are useful for asserting expressions, and upon failure, to
+ * automatically log the assertion expression and return
+ * this result status.
+ */
+ GDBWIRE_ASSERT,
+
+ /**
+ * An internal logic error has occurred.
+ *
+ * In general, this should be used when a function can no
+ * longer carry out it's contract and must abort.
+ *
+ * This happens, for instance, when a called function returns
+ * an error status, or when invalid input was provided, etc.
+ */
+ GDBWIRE_LOGIC,
+
+ /**
+ * The system is out of memory.
+ *
+ * Will occur when malloc, strdup, calloc, etc fail to allocate memory.
+ */
+ GDBWIRE_NOMEM
+};
+
+#endif /* GDBWIRE_RESULT_H */
+/***** End of gdbwire_result.h ***********************************************/
+/***** Continuing where we left off in gdbwire_assert.h **********************/
+/***** Include gdbwire_logger.h in the middle of gdbwire_assert.h ************/
+/***** Begin file gdbwire_logger.h *******************************************/
+#ifndef __GDBWIRE_LOGGER_H__
+#define __GDBWIRE_LOGGER_H__
+
+/* #include "gdbwire_result.h" */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum gdbwire_logger_level {
+ GDBWIRE_LOGGER_DEBUG,
+ GDBWIRE_LOGGER_INFO,
+ GDBWIRE_LOGGER_WARN,
+ GDBWIRE_LOGGER_ERROR
+};
+
+/**
+ * Log a statement to the logger.
+ *
+ * This is typically not called directly. Use the below macros instead.
+ * The macros automatically supply the file, line and level arguments.
+ *
+ * @param file
+ * The filename the logger was invoked from.
+ *
+ * @param line
+ * The line number the logger was invoked from.
+ *
+ * @param level
+ * The level associated with the log message.
+ *
+ * @param fmt
+ * The format string for the message (printf formatting).
+ *
+ * @param ...
+ * Any additional format arguments.
+ */
+void gdbwire_logger_log(const char *file, int line,
+ enum gdbwire_logger_level level, const char *fmt, ...);
+
+/* The macros intended to be used for logging */
+#define gdbwire_debug(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_DEBUG, fmt, ##__VA_ARGS__))
+#define gdbwire_info(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_INFO, fmt, ##__VA_ARGS__))
+#define gdbwire_warn(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_WARN, fmt, ##__VA_ARGS__))
+#define gdbwire_error(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_ERROR, fmt, ##__VA_ARGS__))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_logger.h ***********************************************/
+/***** Continuing where we left off in gdbwire_assert.h **********************/
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * If the expression does not evaluate to true, log the error and
+ * return a GDBWIRE_ASSERT status code.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ */
+#define GDBWIRE_ASSERT(expr) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s]", #expr); \
+ return GDBWIRE_ASSERT; \
+ } \
+ } while (0)
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * If the expression does not evaluate to true, log the error,
+ * set the variable provided to GDBWIRE_ASSERT and goto the label
+ * provided.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ *
+ * @param variable
+ * The result variable to assign the value GDBWIRE_ASSERT to.
+ *
+ * @param label
+ * The label to jump to if the expression evaluates to False.
+ */
+#define GDBWIRE_ASSERT_GOTO(expr, variable, label) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s], " \
+ "label[%s]", #expr, #label); \
+ variable = GDBWIRE_ASSERT; \
+ goto label; \
+ } \
+ } while (0)
+
+/**
+ * Validate that the expression evaluates to true.
+ *
+ * This particular assertion macro is used when a system library
+ * call fails and that library call has an associated errno status
+ * to describe the failure reason.
+ *
+ * If the expression does not evaluate to true, log the error,
+ * along with the errno value and message and return a GDBWIRE_ASSERT
+ * status code.
+ *
+ * Otherwise, if the expression does evaluate to true, do nothing.
+ *
+ * @param expr
+ * The expression to evaluate.
+ */
+#define GDBWIRE_ASSERT_ERRNO(expr) \
+ do { \
+ if (!(expr)) { \
+ gdbwire_error("Assertion failure, expr[%s]," \
+ "errno[%d], strerror[%s]", \
+ #expr, errno, strerror(errno)); \
+ return GDBWIRE_ASSERT; \
+ } \
+ } while (0)
+
+#endif /* GDBWIRE_ERROR_H */
+/***** End of gdbwire_assert.h ***********************************************/
+/***** Begin file gdbwire_result.h *******************************************/
+#ifndef GDBWIRE_RESULT_H
+#define GDBWIRE_RESULT_H
+
+enum gdbwire_result {
+ /* The result of the operation was successful */
+ GDBWIRE_OK,
+
+ /**
+ * An assertion failed in the calling code.
+ *
+ * Functions are encouraged to assert expressions they expect
+ * to be true. The macro GDBWIRE_ASSERT and GDBWIRE_ASSERT_ERRNO
+ * are useful for asserting expressions, and upon failure, to
+ * automatically log the assertion expression and return
+ * this result status.
+ */
+ GDBWIRE_ASSERT,
+
+ /**
+ * An internal logic error has occurred.
+ *
+ * In general, this should be used when a function can no
+ * longer carry out it's contract and must abort.
+ *
+ * This happens, for instance, when a called function returns
+ * an error status, or when invalid input was provided, etc.
+ */
+ GDBWIRE_LOGIC,
+
+ /**
+ * The system is out of memory.
+ *
+ * Will occur when malloc, strdup, calloc, etc fail to allocate memory.
+ */
+ GDBWIRE_NOMEM
+};
+
+#endif /* GDBWIRE_RESULT_H */
+/***** End of gdbwire_result.h ***********************************************/
+/***** Begin file gdbwire_logger.h *******************************************/
+#ifndef __GDBWIRE_LOGGER_H__
+#define __GDBWIRE_LOGGER_H__
+
+/* #include "gdbwire_result.h" */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+enum gdbwire_logger_level {
+ GDBWIRE_LOGGER_DEBUG,
+ GDBWIRE_LOGGER_INFO,
+ GDBWIRE_LOGGER_WARN,
+ GDBWIRE_LOGGER_ERROR
+};
+
+/**
+ * Log a statement to the logger.
+ *
+ * This is typically not called directly. Use the below macros instead.
+ * The macros automatically supply the file, line and level arguments.
+ *
+ * @param file
+ * The filename the logger was invoked from.
+ *
+ * @param line
+ * The line number the logger was invoked from.
+ *
+ * @param level
+ * The level associated with the log message.
+ *
+ * @param fmt
+ * The format string for the message (printf formatting).
+ *
+ * @param ...
+ * Any additional format arguments.
+ */
+void gdbwire_logger_log(const char *file, int line,
+ enum gdbwire_logger_level level, const char *fmt, ...);
+
+/* The macros intended to be used for logging */
+#define gdbwire_debug(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_DEBUG, fmt, ##__VA_ARGS__))
+#define gdbwire_info(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_INFO, fmt, ##__VA_ARGS__))
+#define gdbwire_warn(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_WARN, fmt, ##__VA_ARGS__))
+#define gdbwire_error(fmt, ...)(gdbwire_logger_log(__FILE__, __LINE__, \
+ GDBWIRE_LOGGER_ERROR, fmt, ##__VA_ARGS__))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_logger.h ***********************************************/
+/***** Begin file gdbwire_mi_pt.h ********************************************/
+#ifndef GDBWIRE_MI_PT_H
+#define GDBWIRE_MI_PT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The position of a token in a GDB/MI line.
+ *
+ * Note that a string in C is zero based and the token column
+ * position is 1 based. For example,
+ * char *str = "hello world";
+ * The "hello" token would have a start_column as 1 and an end
+ * column as 5.
+ *
+ * The start_column and end_column will be the same column number for
+ * a token of size 1.
+ */
+struct gdbwire_mi_position {
+ /* The starting column position of the token */
+ int start_column;
+ /* The ending column position of the token */
+ int end_column;
+};
+
+/** The gdbwire_mi output kinds. */
+enum gdbwire_mi_output_kind {
+ /**
+ * The GDB/MI output contains an out of band record.
+ *
+ * The out of band record is not necessarily associated with any
+ * particular GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_OOB,
+
+ /**
+ * The GDB/MI output contains a gdbwire_mi result record.
+ *
+ * This record typically contains the result data from a request
+ * made by the client in a previous GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_RESULT,
+
+ /**
+ * The GDB/MI output represents a prompt. (ie. (gdb) )
+ *
+ * TODO: Document when GDB is ready to receive a command. Only if
+ * the prompt is received and at *stopped?
+ */
+ GDBWIRE_MI_OUTPUT_PROMPT,
+
+ /**
+ * A parse error occurred.
+ */
+ GDBWIRE_MI_OUTPUT_PARSE_ERROR
+};
+
+/**
+ * The GDB/MI output command.
+ *
+ * A GDB/MI output command is the main mechanism in which GDB
+ * corresponds with a front end.
+ */
+struct gdbwire_mi_output {
+ enum gdbwire_mi_output_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_OUTPUT_OOB, never NULL. */
+ struct gdbwire_mi_oob_record *oob_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_RESULT, never NULL. */
+ struct gdbwire_mi_result_record *result_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_PARSE_ERROR, never NULL. */
+ struct {
+ /** The token the error occurred on */
+ char *token;
+ /** The position of the token where the error occurred. */
+ struct gdbwire_mi_position pos;
+ } error;
+ } variant;
+
+ /**
+ * The GDB/MI output line that was used to create this output instance.
+ *
+ * Each gdbwire_mi output structure is created from exactly one line of
+ * MI output from GDB. This field represents the line that created
+ * this particular output structure.
+ *
+ * This field is always available and never NULL, even for a parse error.
+ */
+ char *line;
+
+ /** The next GDB/MI output command or NULL if none */
+ struct gdbwire_mi_output *next;
+};
+
+/**
+ * A GDB/MI token.
+ *
+ * A string made up of one or more digits.
+ * The regular expression [0-9]+ will match this types contents.
+ */
+typedef char *gdbwire_mi_token_t;
+
+/**
+ * A GDB/MI output command may contain one of the following result indications.
+ */
+enum gdbwire_mi_result_class {
+ /**
+ * The synchronous operation was successful (^done).
+ */
+ GDBWIRE_MI_DONE,
+
+ /**
+ * Equivalent to GDBWIRE_MI_DONE (^running).
+ *
+ * Historically, was output by GDB instead of ^done if the command
+ * resumed the target.
+ *
+ * Do not rely on or use this result class in the front end to determine
+ * the state of the target. Use the async *running output record to
+ * determine which threads have resumed running.
+ *
+ * TODO: Ensure that early versions of GDB can depend on the async
+ * *running or if front ends DO have to rely on ^running.
+ */
+ GDBWIRE_MI_RUNNING,
+
+ /**
+ * GDB has connected to a remote target (^connected).
+ *
+ * This is in response to the -target-select command.
+ *
+ * A comment in the GDB source code says,
+ * There's no particularly good reason why target-connect results
+ * in not ^done. Should kill ^connected for MI3.
+ *
+ * With this in mind, it makes sense to assume that GDBWIRE_MI_CONNECTED
+ * and GDBWIRE_MI_DONE are equivalent.
+ */
+ GDBWIRE_MI_CONNECTED,
+
+ /**
+ * An error has occurred (^error).
+ *
+ * This can occur if the user provides an improper command to GDB.
+ * In this case, the user will be provided the standard error output but
+ * the front end will also be provided this information independently.
+ */
+ GDBWIRE_MI_ERROR,
+
+ /**
+ * GDB has terminated (^exit).
+ *
+ * When GDB knows it is about to exit, it provides this notification
+ * in the GDB/MI output command. However, on all other circumstances,
+ * the front end should be prepared to have GDB exit and not provide
+ * this information.
+ */
+ GDBWIRE_MI_EXIT,
+
+ /* An unsupported result class */
+ GDBWIRE_MI_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI result record in an output command.
+ *
+ * The result record represents the result data in the GDB/MI output
+ * command sent by GDB. This typically contains the content the client
+ * was requesting when it sent a GDB/MI input command to GDB.
+ */
+struct gdbwire_mi_result_record {
+ /**
+ * The token associated with the corresponding GDB/MI input command.
+ *
+ * The client may provide a unique string of digits at the beginning of a
+ * GDB/MI input command. For example,
+ * 0000-foo
+ * When GDB finally gets around to responding to the GDB/MI input command,
+ * it takes the token provided in the input command and puts it into the
+ * result record of the corresponding GDB/MI output command. For
+ * example, the output commmand associated with the above input command is,
+ * 0000^error,msg="Undefined MI command: foo",code="undefined-command"
+ * and the result record would have the below token field set to "0000".
+ *
+ * This is intended to allow the front end to correlate the GDB/MI input
+ * command it sent with the GDB/MI output command GDB responded with.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The result records result class. */
+ enum gdbwire_mi_result_class result_class;
+
+ /**
+ * An optional list of results for this result record.
+ *
+ * Will be NULL if there is no results for this result record.
+ *
+ * This is typically where the result data is that the client
+ * is looking for.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The out of band record kinds. */
+enum gdbwire_mi_oob_record_kind {
+ /**
+ * An asyncronous out of band record.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ *
+ * For instance, if the inferior has stopped, or a new thread has
+ * started.
+ */
+ GDBWIRE_MI_ASYNC,
+
+ /**
+ * A stream out of band record.
+ *
+ * This is the result of normal output from the console, target or GDB.
+ */
+ GDBWIRE_MI_STREAM
+};
+
+/* This is an out of band record. */
+struct gdbwire_mi_oob_record {
+ /** The kind of out of band record. */
+ enum gdbwire_mi_oob_record_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_ASYNC. */
+ struct gdbwire_mi_async_record *async_record;
+ /** When kind == GDBWIRE_MI_STREAM. */
+ struct gdbwire_mi_stream_record *stream_record;
+ } variant;
+};
+
+/** The asynchronous out of band record kinds */
+enum gdbwire_mi_async_record_kind {
+ /**
+ * The asynchronous status record kind.
+ *
+ * Contains on-going status information about the progress of a slow
+ * operation. It can be discarded.
+ *
+ * This output is prepended by the + character.
+ */
+ GDBWIRE_MI_STATUS,
+
+ /**
+ * The asynchronous exec record kind.
+ *
+ * Contains asynchronous state change regarding the target:
+ * (stopped, started, disappeared).
+ *
+ * This output is prepended by the * character.
+ */
+ GDBWIRE_MI_EXEC,
+
+ /**
+ * The asyncronous notify record kind.
+ *
+ * Contains supplementary information that the client should handle
+ * (e.g., a new breakpoint information).
+ *
+ * This output is prepended by the = character.
+ */
+ GDBWIRE_MI_NOTIFY
+};
+
+/** The stream out of band record kinds */
+enum gdbwire_mi_stream_record_kind {
+ /**
+ * The console output.
+ *
+ * Output that should be displayed as is in the console.
+ * It is the textual response to a CLI command.
+ *
+ * This output is prepended by the ~ character.
+ */
+ GDBWIRE_MI_CONSOLE,
+
+ /**
+ * The target output.
+ *
+ * Output produced by the target program.
+ *
+ * This output is prepended by the @ character.
+ */
+ GDBWIRE_MI_TARGET,
+
+ /**
+ * The GDB log output.
+ *
+ * Output text coming from GDB's internals. For instance messages
+ * that should be displayed as part of an error log.
+ *
+ * This output is prepended by the & character.
+ */
+ GDBWIRE_MI_LOG
+};
+
+/**
+ * The GDB/MI asyncronous class.
+ *
+ *
+ */
+enum gdbwire_mi_async_class {
+ /**
+ * Loading the executable onto the remote target.
+ *
+ * This was undocumented in the GDB manual as far as GDB 7.7.
+ *
+ * This occurs if the async record is GDBWIRE_MI_STATUS as +download.
+ */
+ GDBWIRE_MI_ASYNC_DOWNLOAD,
+
+ /**
+ * The target has stopped.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *stopped.
+ */
+ GDBWIRE_MI_ASYNC_STOPPED,
+
+ /**
+ * The target is now running.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *running.
+ */
+ GDBWIRE_MI_ASYNC_RUNNING,
+
+ /**
+ * Reports that a thread group was added.
+ *
+ * When a thread group is added, it generally might not be associated
+ * with a running process.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-added.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED,
+
+ /**
+ * Reports that a thread group was removed.
+ *
+ * When a thread group is removed, its id becomes invalid and cannot be
+ * used in any way.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-removed.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED,
+
+ /**
+ * Reports that a thread group was started.
+ *
+ * A thread group became associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-started.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED,
+
+ /**
+ * Reports that a thread group was exited.
+ *
+ * A thread group is no longer associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED,
+
+ /**
+ * Reports that a thread was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-created.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_CREATED,
+
+ /**
+ * Reports that a thread was exited.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_EXITED,
+
+ /**
+ * Reports that a thread was selected.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-selected.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_SELECTED,
+
+ /**
+ * Reports that a new library was loaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =library-loaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_LOADED,
+
+ /**
+ * Reports that a new library was unloaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =library-unloaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED,
+
+ /**
+ * Reports that a trace frame was changed.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =traceframe-changed.
+ */
+ GDBWIRE_MI_ASYNC_TRACEFRAME_CHANGED,
+
+ /**
+ * Reports that a trace state variable was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-created.
+ */
+ GDBWIRE_MI_ASYNC_TSV_CREATED,
+
+ /**
+ * Reports that a trace state variable was modified.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-modified.
+ */
+ GDBWIRE_MI_ASYNC_TSV_MODIFIED,
+
+ /**
+ * Reports that a trace state variable was deleted.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-deleted.
+ */
+ GDBWIRE_MI_ASYNC_TSV_DELETED,
+
+ /**
+ * Reports that a breakpoint was created.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-created.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED,
+
+ /**
+ * Reports that a breakpoint was modified.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-modified.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED,
+
+ /**
+ * Reports that a breakpoint was deleted.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-deleted.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED,
+
+ /**
+ * Reports that execution log recording was started on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIF
+ * as =record-started.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STARTED,
+
+ /**
+ * Reports that execution log recording was stopped on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =record-stopped.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STOPPED,
+
+ /**
+ * Reports that a parameter of the command set param is changed to value.
+ *
+ * For example, when the user runs a command like 'set print pretty on',
+ * this async command will be invoked with the parameter reported as
+ * 'print pretty' and the value as 'on'.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =cmd-param-changed.
+ */
+ GDBWIRE_MI_ASYNC_CMD_PARAM_CHANGED,
+
+ /**
+ * Reports that bytes from addr to data + len were written in an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =memory-changed.
+ */
+ GDBWIRE_MI_ASYNC_MEMORY_CHANGED,
+
+ /* An unsupported async class */
+ GDBWIRE_MI_ASYNC_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI asyncronous record in an output command.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ */
+struct gdbwire_mi_async_record {
+ /**
+ * The result record token.
+ *
+ * Please note that the GDB/MI manual says that asyncronous records
+ * do not currently populate this token on output but reserve the right
+ * to do so. For that reason, token here should always be NULL.
+ *
+ * From the GDB documentation:
+ * Note that for all async output, while the token is allowed by the
+ * grammar and may be output by future versions of gdb for select async
+ * output messages, it is generally omitted. Frontends should treat all
+ * async output as reporting general changes in the state of the target
+ * and there should be no need to associate async output to any prior
+ * command.
+ *
+ * After further investigation, I determined that newer GDB's will no
+ * longer ever output this information. Older GDB's will. The commit
+ * that made this change in GDB is 721c02de on April 24th, 2008.
+ * The next GDB that was released was on October 6th, 2009, version 7.0.
+ *
+ * Before the above mentioned commit async *stopped commands would
+ * sometimes output the token associated with the last token provided in
+ * a GDB/MI input command. After that change, the token is never
+ * associated with an async output command, even though the
+ * documentation says it might be.
+ *
+ * Finally, even before that change when the token was output in the
+ * async *stopped command, the developers of GDB felt that it was not
+ * useful and should be avoided by front ends.
+ *
+ * With this information, I've determined that front ends should never
+ * use this value to determine logic. However, the value is parsed in
+ * order to accurately handle and represent the cases where this value
+ * occurs.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The kind of asynchronous record. */
+ enum gdbwire_mi_async_record_kind kind;
+
+ /** The asynchronous output class */
+ enum gdbwire_mi_async_class async_class;
+
+ /**
+ * An optional list of results for this async output.
+ *
+ * Will be NULL if there is no results.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The GDB/MI result kind */
+enum gdbwire_mi_result_kind {
+ /** The result is a cstring */
+ GDBWIRE_MI_CSTRING,
+ /** The result is a tuple */
+ GDBWIRE_MI_TUPLE,
+ /** The result is a list */
+ GDBWIRE_MI_LIST
+};
+
+/**
+ * A GDB/MI result list.
+ *
+ * This is one of the important GDB/MI data structures. GDB communicates many
+ * of it's values to the front end through this key/value data structure.
+ *
+ * It is basically a list of key/value pairs, where the key is a
+ * variable name and the value expands to a string, a tuple of results or
+ * a list of results.
+ *
+ * This can be thought of as a custom json object.
+ */
+struct gdbwire_mi_result {
+ /** The kind of result this represents. */
+ enum gdbwire_mi_result_kind kind;
+
+ /** The key being described by the result. */
+ char *variable;
+
+ union {
+ /** When kind is GDBWIRE_MI_CSTRING */
+ char *cstring;
+
+ /**
+ * When kind is GDBWIRE_MI_TUPLE or GDBWIRE_MI_LIST.
+ *
+ * If kind is GDBWIRE_MI_TUPLE, each result in the tuple should have a
+ * valid key according to the GDB/MI specification. That is, for
+ * each result, result->variable should not be NULL.
+ * Note: GDBWIRE currently relaxes the above rule. It allows tuple's
+ * with out a key in each member. For instance, {key="value"}
+ * is what the GDB/MI specification advocates for, but some
+ * variations of GDB emit {"value"} and so GDBWIRE allows it.
+ *
+ * If kind is GDBWIRE_MI_LIST, the GDB/MI specification allows
+ * results in this list to not have keys. That is, for each result,
+ * result->variable may be NULL.
+ *
+ * Will be NULL if the tuple or list is empty.
+ */
+ struct gdbwire_mi_result *result;
+ } variant;
+
+ /** The next result or NULL if none */
+ struct gdbwire_mi_result *next;
+};
+
+/**
+ * An out of band GDB/MI stream record.
+ *
+ * A stream record is intended to provide the front end with information
+ * from the console, the target or from GDB itself.
+ */
+struct gdbwire_mi_stream_record {
+ /** The kind of stream record. */
+ enum gdbwire_mi_stream_record_kind kind;
+ /** The buffer provided in this stream record. */
+ char *cstring;
+};
+
+void gdbwire_mi_output_free(struct gdbwire_mi_output *param);
+
+struct gdbwire_mi_output *append_gdbwire_mi_output(
+ struct gdbwire_mi_output *list, struct gdbwire_mi_output *item);
+
+struct gdbwire_mi_result *append_gdbwire_mi_result(
+ struct gdbwire_mi_result *list, struct gdbwire_mi_result *item);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_pt.h ************************************************/
+/***** Begin file gdbwire_mi_pt_alloc.h **************************************/
+#ifndef GDBWIRE_MI_PT_ALLOC_H
+#define GDBWIRE_MI_PT_ALLOC_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * Responsible for allocating and deallocating gdbwire_mi_pt objects.
+ */
+
+/* struct gdbwire_mi_output */
+struct gdbwire_mi_output *gdbwire_mi_output_alloc(void);
+void gdbwire_mi_output_free(struct gdbwire_mi_output *param);
+
+/* struct gdbwire_mi_result_record */
+struct gdbwire_mi_result_record *gdbwire_mi_result_record_alloc(void);
+void gdbwire_mi_result_record_free(struct gdbwire_mi_result_record *param);
+
+/* struct gdbwire_mi_result */
+struct gdbwire_mi_result *gdbwire_mi_result_alloc(void);
+void gdbwire_mi_result_free(struct gdbwire_mi_result *param);
+
+/* struct gdbwire_mi_oob_record */
+struct gdbwire_mi_oob_record *gdbwire_mi_oob_record_alloc(void);
+void gdbwire_mi_oob_record_free(struct gdbwire_mi_oob_record *param);
+
+/* struct gdbwire_mi_async_record */
+struct gdbwire_mi_async_record *gdbwire_mi_async_record_alloc(void);
+void gdbwire_mi_async_record_free(struct gdbwire_mi_async_record *param);
+
+/* struct gdbwire_mi_stream_record */
+struct gdbwire_mi_stream_record *gdbwire_mi_stream_record_alloc(void);
+void gdbwire_mi_stream_record_free(struct gdbwire_mi_stream_record *param);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GDBWIRE_MI_PT_ALLOC_H */
+/***** End of gdbwire_mi_pt_alloc.h ******************************************/
+/***** Begin file gdbwire_mi_parser.h ****************************************/
+#ifndef GDBWIRE_MI_PARSER_H
+#define GDBWIRE_MI_PARSER_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #include "gdbwire_result.h" */
+/***** Include gdbwire_mi_pt.h in the middle of gdbwire_mi_parser.h **********/
+/***** Begin file gdbwire_mi_pt.h ********************************************/
+#ifndef GDBWIRE_MI_PT_H
+#define GDBWIRE_MI_PT_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * The position of a token in a GDB/MI line.
+ *
+ * Note that a string in C is zero based and the token column
+ * position is 1 based. For example,
+ * char *str = "hello world";
+ * The "hello" token would have a start_column as 1 and an end
+ * column as 5.
+ *
+ * The start_column and end_column will be the same column number for
+ * a token of size 1.
+ */
+struct gdbwire_mi_position {
+ /* The starting column position of the token */
+ int start_column;
+ /* The ending column position of the token */
+ int end_column;
+};
+
+/** The gdbwire_mi output kinds. */
+enum gdbwire_mi_output_kind {
+ /**
+ * The GDB/MI output contains an out of band record.
+ *
+ * The out of band record is not necessarily associated with any
+ * particular GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_OOB,
+
+ /**
+ * The GDB/MI output contains a gdbwire_mi result record.
+ *
+ * This record typically contains the result data from a request
+ * made by the client in a previous GDB/MI input command.
+ */
+ GDBWIRE_MI_OUTPUT_RESULT,
+
+ /**
+ * The GDB/MI output represents a prompt. (ie. (gdb) )
+ *
+ * TODO: Document when GDB is ready to receive a command. Only if
+ * the prompt is received and at *stopped?
+ */
+ GDBWIRE_MI_OUTPUT_PROMPT,
+
+ /**
+ * A parse error occurred.
+ */
+ GDBWIRE_MI_OUTPUT_PARSE_ERROR
+};
+
+/**
+ * The GDB/MI output command.
+ *
+ * A GDB/MI output command is the main mechanism in which GDB
+ * corresponds with a front end.
+ */
+struct gdbwire_mi_output {
+ enum gdbwire_mi_output_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_OUTPUT_OOB, never NULL. */
+ struct gdbwire_mi_oob_record *oob_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_RESULT, never NULL. */
+ struct gdbwire_mi_result_record *result_record;
+ /** When kind == GDBWIRE_MI_OUTPUT_PARSE_ERROR, never NULL. */
+ struct {
+ /** The token the error occurred on */
+ char *token;
+ /** The position of the token where the error occurred. */
+ struct gdbwire_mi_position pos;
+ } error;
+ } variant;
+
+ /**
+ * The GDB/MI output line that was used to create this output instance.
+ *
+ * Each gdbwire_mi output structure is created from exactly one line of
+ * MI output from GDB. This field represents the line that created
+ * this particular output structure.
+ *
+ * This field is always available and never NULL, even for a parse error.
+ */
+ char *line;
+
+ /** The next GDB/MI output command or NULL if none */
+ struct gdbwire_mi_output *next;
+};
+
+/**
+ * A GDB/MI token.
+ *
+ * A string made up of one or more digits.
+ * The regular expression [0-9]+ will match this types contents.
+ */
+typedef char *gdbwire_mi_token_t;
+
+/**
+ * A GDB/MI output command may contain one of the following result indications.
+ */
+enum gdbwire_mi_result_class {
+ /**
+ * The synchronous operation was successful (^done).
+ */
+ GDBWIRE_MI_DONE,
+
+ /**
+ * Equivalent to GDBWIRE_MI_DONE (^running).
+ *
+ * Historically, was output by GDB instead of ^done if the command
+ * resumed the target.
+ *
+ * Do not rely on or use this result class in the front end to determine
+ * the state of the target. Use the async *running output record to
+ * determine which threads have resumed running.
+ *
+ * TODO: Ensure that early versions of GDB can depend on the async
+ * *running or if front ends DO have to rely on ^running.
+ */
+ GDBWIRE_MI_RUNNING,
+
+ /**
+ * GDB has connected to a remote target (^connected).
+ *
+ * This is in response to the -target-select command.
+ *
+ * A comment in the GDB source code says,
+ * There's no particularly good reason why target-connect results
+ * in not ^done. Should kill ^connected for MI3.
+ *
+ * With this in mind, it makes sense to assume that GDBWIRE_MI_CONNECTED
+ * and GDBWIRE_MI_DONE are equivalent.
+ */
+ GDBWIRE_MI_CONNECTED,
+
+ /**
+ * An error has occurred (^error).
+ *
+ * This can occur if the user provides an improper command to GDB.
+ * In this case, the user will be provided the standard error output but
+ * the front end will also be provided this information independently.
+ */
+ GDBWIRE_MI_ERROR,
+
+ /**
+ * GDB has terminated (^exit).
+ *
+ * When GDB knows it is about to exit, it provides this notification
+ * in the GDB/MI output command. However, on all other circumstances,
+ * the front end should be prepared to have GDB exit and not provide
+ * this information.
+ */
+ GDBWIRE_MI_EXIT,
+
+ /* An unsupported result class */
+ GDBWIRE_MI_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI result record in an output command.
+ *
+ * The result record represents the result data in the GDB/MI output
+ * command sent by GDB. This typically contains the content the client
+ * was requesting when it sent a GDB/MI input command to GDB.
+ */
+struct gdbwire_mi_result_record {
+ /**
+ * The token associated with the corresponding GDB/MI input command.
+ *
+ * The client may provide a unique string of digits at the beginning of a
+ * GDB/MI input command. For example,
+ * 0000-foo
+ * When GDB finally gets around to responding to the GDB/MI input command,
+ * it takes the token provided in the input command and puts it into the
+ * result record of the corresponding GDB/MI output command. For
+ * example, the output commmand associated with the above input command is,
+ * 0000^error,msg="Undefined MI command: foo",code="undefined-command"
+ * and the result record would have the below token field set to "0000".
+ *
+ * This is intended to allow the front end to correlate the GDB/MI input
+ * command it sent with the GDB/MI output command GDB responded with.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The result records result class. */
+ enum gdbwire_mi_result_class result_class;
+
+ /**
+ * An optional list of results for this result record.
+ *
+ * Will be NULL if there is no results for this result record.
+ *
+ * This is typically where the result data is that the client
+ * is looking for.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The out of band record kinds. */
+enum gdbwire_mi_oob_record_kind {
+ /**
+ * An asyncronous out of band record.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ *
+ * For instance, if the inferior has stopped, or a new thread has
+ * started.
+ */
+ GDBWIRE_MI_ASYNC,
+
+ /**
+ * A stream out of band record.
+ *
+ * This is the result of normal output from the console, target or GDB.
+ */
+ GDBWIRE_MI_STREAM
+};
+
+/* This is an out of band record. */
+struct gdbwire_mi_oob_record {
+ /** The kind of out of band record. */
+ enum gdbwire_mi_oob_record_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_ASYNC. */
+ struct gdbwire_mi_async_record *async_record;
+ /** When kind == GDBWIRE_MI_STREAM. */
+ struct gdbwire_mi_stream_record *stream_record;
+ } variant;
+};
+
+/** The asynchronous out of band record kinds */
+enum gdbwire_mi_async_record_kind {
+ /**
+ * The asynchronous status record kind.
+ *
+ * Contains on-going status information about the progress of a slow
+ * operation. It can be discarded.
+ *
+ * This output is prepended by the + character.
+ */
+ GDBWIRE_MI_STATUS,
+
+ /**
+ * The asynchronous exec record kind.
+ *
+ * Contains asynchronous state change regarding the target:
+ * (stopped, started, disappeared).
+ *
+ * This output is prepended by the * character.
+ */
+ GDBWIRE_MI_EXEC,
+
+ /**
+ * The asyncronous notify record kind.
+ *
+ * Contains supplementary information that the client should handle
+ * (e.g., a new breakpoint information).
+ *
+ * This output is prepended by the = character.
+ */
+ GDBWIRE_MI_NOTIFY
+};
+
+/** The stream out of band record kinds */
+enum gdbwire_mi_stream_record_kind {
+ /**
+ * The console output.
+ *
+ * Output that should be displayed as is in the console.
+ * It is the textual response to a CLI command.
+ *
+ * This output is prepended by the ~ character.
+ */
+ GDBWIRE_MI_CONSOLE,
+
+ /**
+ * The target output.
+ *
+ * Output produced by the target program.
+ *
+ * This output is prepended by the @ character.
+ */
+ GDBWIRE_MI_TARGET,
+
+ /**
+ * The GDB log output.
+ *
+ * Output text coming from GDB's internals. For instance messages
+ * that should be displayed as part of an error log.
+ *
+ * This output is prepended by the & character.
+ */
+ GDBWIRE_MI_LOG
+};
+
+/**
+ * The GDB/MI asyncronous class.
+ *
+ *
+ */
+enum gdbwire_mi_async_class {
+ /**
+ * Loading the executable onto the remote target.
+ *
+ * This was undocumented in the GDB manual as far as GDB 7.7.
+ *
+ * This occurs if the async record is GDBWIRE_MI_STATUS as +download.
+ */
+ GDBWIRE_MI_ASYNC_DOWNLOAD,
+
+ /**
+ * The target has stopped.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *stopped.
+ */
+ GDBWIRE_MI_ASYNC_STOPPED,
+
+ /**
+ * The target is now running.
+ *
+ * This occurs if the async record is GDBWIRE_MI_EXEC as *running.
+ */
+ GDBWIRE_MI_ASYNC_RUNNING,
+
+ /**
+ * Reports that a thread group was added.
+ *
+ * When a thread group is added, it generally might not be associated
+ * with a running process.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-added.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_ADDED,
+
+ /**
+ * Reports that a thread group was removed.
+ *
+ * When a thread group is removed, its id becomes invalid and cannot be
+ * used in any way.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-removed.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_REMOVED,
+
+ /**
+ * Reports that a thread group was started.
+ *
+ * A thread group became associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-started.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_STARTED,
+
+ /**
+ * Reports that a thread group was exited.
+ *
+ * A thread group is no longer associated with a running program.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-group-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_GROUP_EXITED,
+
+ /**
+ * Reports that a thread was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =thread-created.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_CREATED,
+
+ /**
+ * Reports that a thread was exited.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-exited.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_EXITED,
+
+ /**
+ * Reports that a thread was selected.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =thread-selected.
+ */
+ GDBWIRE_MI_ASYNC_THREAD_SELECTED,
+
+ /**
+ * Reports that a new library was loaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =library-loaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_LOADED,
+
+ /**
+ * Reports that a new library was unloaded.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =library-unloaded.
+ */
+ GDBWIRE_MI_ASYNC_LIBRARY_UNLOADED,
+
+ /**
+ * Reports that a trace frame was changed.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =traceframe-changed.
+ */
+ GDBWIRE_MI_ASYNC_TRACEFRAME_CHANGED,
+
+ /**
+ * Reports that a trace state variable was created.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-created.
+ */
+ GDBWIRE_MI_ASYNC_TSV_CREATED,
+
+ /**
+ * Reports that a trace state variable was modified.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-modified.
+ */
+ GDBWIRE_MI_ASYNC_TSV_MODIFIED,
+
+ /**
+ * Reports that a trace state variable was deleted.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY as =tsv-deleted.
+ */
+ GDBWIRE_MI_ASYNC_TSV_DELETED,
+
+ /**
+ * Reports that a breakpoint was created.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-created.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_CREATED,
+
+ /**
+ * Reports that a breakpoint was modified.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-modified.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_MODIFIED,
+
+ /**
+ * Reports that a breakpoint was deleted.
+ *
+ * Only user-visible breakpoints are reported to the MI user.
+ *
+ * If a breakpoint is emitted in the result record of a
+ * command, then it will not also be emitted in an async record.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =breakpoint-deleted.
+ */
+ GDBWIRE_MI_ASYNC_BREAKPOINT_DELETED,
+
+ /**
+ * Reports that execution log recording was started on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIF
+ * as =record-started.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STARTED,
+
+ /**
+ * Reports that execution log recording was stopped on an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =record-stopped.
+ */
+ GDBWIRE_MI_ASYNC_RECORD_STOPPED,
+
+ /**
+ * Reports that a parameter of the command set param is changed to value.
+ *
+ * For example, when the user runs a command like 'set print pretty on',
+ * this async command will be invoked with the parameter reported as
+ * 'print pretty' and the value as 'on'.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =cmd-param-changed.
+ */
+ GDBWIRE_MI_ASYNC_CMD_PARAM_CHANGED,
+
+ /**
+ * Reports that bytes from addr to data + len were written in an inferior.
+ *
+ * This occurs if the async record is GDBWIRE_MI_NOTIFY
+ * as =memory-changed.
+ */
+ GDBWIRE_MI_ASYNC_MEMORY_CHANGED,
+
+ /* An unsupported async class */
+ GDBWIRE_MI_ASYNC_UNSUPPORTED
+};
+
+/**
+ * The GDB/MI asyncronous record in an output command.
+ *
+ * An asyncronous record occurs when GDB would like to update the
+ * client with information that it has not asked for.
+ */
+struct gdbwire_mi_async_record {
+ /**
+ * The result record token.
+ *
+ * Please note that the GDB/MI manual says that asyncronous records
+ * do not currently populate this token on output but reserve the right
+ * to do so. For that reason, token here should always be NULL.
+ *
+ * From the GDB documentation:
+ * Note that for all async output, while the token is allowed by the
+ * grammar and may be output by future versions of gdb for select async
+ * output messages, it is generally omitted. Frontends should treat all
+ * async output as reporting general changes in the state of the target
+ * and there should be no need to associate async output to any prior
+ * command.
+ *
+ * After further investigation, I determined that newer GDB's will no
+ * longer ever output this information. Older GDB's will. The commit
+ * that made this change in GDB is 721c02de on April 24th, 2008.
+ * The next GDB that was released was on October 6th, 2009, version 7.0.
+ *
+ * Before the above mentioned commit async *stopped commands would
+ * sometimes output the token associated with the last token provided in
+ * a GDB/MI input command. After that change, the token is never
+ * associated with an async output command, even though the
+ * documentation says it might be.
+ *
+ * Finally, even before that change when the token was output in the
+ * async *stopped command, the developers of GDB felt that it was not
+ * useful and should be avoided by front ends.
+ *
+ * With this information, I've determined that front ends should never
+ * use this value to determine logic. However, the value is parsed in
+ * order to accurately handle and represent the cases where this value
+ * occurs.
+ *
+ * This represents the token value the front end provided to the
+ * corresponding GDB/MI input command or NULL if no token was provided.
+ */
+ gdbwire_mi_token_t token;
+
+ /** The kind of asynchronous record. */
+ enum gdbwire_mi_async_record_kind kind;
+
+ /** The asynchronous output class */
+ enum gdbwire_mi_async_class async_class;
+
+ /**
+ * An optional list of results for this async output.
+ *
+ * Will be NULL if there is no results.
+ */
+ struct gdbwire_mi_result *result;
+};
+
+/** The GDB/MI result kind */
+enum gdbwire_mi_result_kind {
+ /** The result is a cstring */
+ GDBWIRE_MI_CSTRING,
+ /** The result is a tuple */
+ GDBWIRE_MI_TUPLE,
+ /** The result is a list */
+ GDBWIRE_MI_LIST
+};
+
+/**
+ * A GDB/MI result list.
+ *
+ * This is one of the important GDB/MI data structures. GDB communicates many
+ * of it's values to the front end through this key/value data structure.
+ *
+ * It is basically a list of key/value pairs, where the key is a
+ * variable name and the value expands to a string, a tuple of results or
+ * a list of results.
+ *
+ * This can be thought of as a custom json object.
+ */
+struct gdbwire_mi_result {
+ /** The kind of result this represents. */
+ enum gdbwire_mi_result_kind kind;
+
+ /** The key being described by the result. */
+ char *variable;
+
+ union {
+ /** When kind is GDBWIRE_MI_CSTRING */
+ char *cstring;
+
+ /**
+ * When kind is GDBWIRE_MI_TUPLE or GDBWIRE_MI_LIST.
+ *
+ * If kind is GDBWIRE_MI_TUPLE, each result in the tuple should have a
+ * valid key according to the GDB/MI specification. That is, for
+ * each result, result->variable should not be NULL.
+ * Note: GDBWIRE currently relaxes the above rule. It allows tuple's
+ * with out a key in each member. For instance, {key="value"}
+ * is what the GDB/MI specification advocates for, but some
+ * variations of GDB emit {"value"} and so GDBWIRE allows it.
+ *
+ * If kind is GDBWIRE_MI_LIST, the GDB/MI specification allows
+ * results in this list to not have keys. That is, for each result,
+ * result->variable may be NULL.
+ *
+ * Will be NULL if the tuple or list is empty.
+ */
+ struct gdbwire_mi_result *result;
+ } variant;
+
+ /** The next result or NULL if none */
+ struct gdbwire_mi_result *next;
+};
+
+/**
+ * An out of band GDB/MI stream record.
+ *
+ * A stream record is intended to provide the front end with information
+ * from the console, the target or from GDB itself.
+ */
+struct gdbwire_mi_stream_record {
+ /** The kind of stream record. */
+ enum gdbwire_mi_stream_record_kind kind;
+ /** The buffer provided in this stream record. */
+ char *cstring;
+};
+
+void gdbwire_mi_output_free(struct gdbwire_mi_output *param);
+
+struct gdbwire_mi_output *append_gdbwire_mi_output(
+ struct gdbwire_mi_output *list, struct gdbwire_mi_output *item);
+
+struct gdbwire_mi_result *append_gdbwire_mi_result(
+ struct gdbwire_mi_result *list, struct gdbwire_mi_result *item);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_pt.h ************************************************/
+/***** Continuing where we left off in gdbwire_mi_parser.h *******************/
+
+/* The opaque GDB/MI parser context */
+struct gdbwire_mi_parser;
+
+/**
+ * The primary mechanism to alert users of GDB/MI notifications.
+ *
+ * The flow is like this:
+ * - create a parser context (gdbwire_mi_parser_create)
+ * - push onto the parser arbitrary amounts of data (gdbwire_mi_parser_push)
+ * - receive callbacks from inside gdbwire_mi_parser_push when
+ * it discovers callbacks the user will find interesting
+ * - destroy the parser (gdbwire_mi_parser_destroy)
+ */
+struct gdbwire_mi_parser_callbacks {
+ /**
+ * An arbitrary pointer to associate with the callbacks.
+ *
+ * If the calling api is C++ it is useful to make this an instance
+ * of an object you want to bind to the callback functions below.
+ */
+ void *context;
+
+ /**
+ * A GDB/MI output command is available.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param output
+ * The gdbwire_mi output command. This output command is now owned by the
+ * function being invoked and should be destroyed when necessary.
+ */
+ void (*gdbwire_mi_output_callback)(void *context,
+ struct gdbwire_mi_output *output);
+};
+
+/**
+ * Create a GDB/MI parser context.
+ *
+ * @param callbacks
+ * The callback functions to invoke upon discovery of parse data.
+ *
+ * @return
+ * A new GDB/MI parser instance or NULL on error.
+ */
+struct gdbwire_mi_parser *gdbwire_mi_parser_create(
+ struct gdbwire_mi_parser_callbacks callbacks);
+
+/**
+ * Destroy a gdbwire_mi_parser context.
+ *
+ * This function will do nothing if parser is NULL.
+ *
+ * @param parser
+ * The instance the parser to destroy
+ */
+void gdbwire_mi_parser_destroy(struct gdbwire_mi_parser *parser);
+
+/**
+ * Push a null terminated string onto the parser.
+ *
+ * During this function, if a gdbwire_mi output command is discovered by
+ * the parser (or any other useful GDB/MI notification), it will invoke
+ * the appropriate callbacks assigned during parser creation.
+ *
+ * @param parser
+ * The gdbwire_mi parser context to operate on.
+ *
+ * @param data
+ * The parse data to push onto the parser.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_mi_parser_push(struct gdbwire_mi_parser *parser,
+ const char *data);
+
+/**
+ * Push some parse data onto the parser.
+ *
+ * See gdbwire_mi_parser_push for details on function behavior.
+ *
+ * @param parser
+ * The gdbwire_mi parser context to operate on.
+ *
+ * @param data
+ * The parse data to push onto the parser.
+ *
+ * @param size
+ * The size of the data to push onto the parser.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_mi_parser_push_data(
+ struct gdbwire_mi_parser *parser, const char *data, size_t size);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_parser.h ********************************************/
+/***** Begin file gdbwire_mi_command.h ***************************************/
+#ifndef GDBWIRE_MI_COMMAND_H
+#define GDBWIRE_MI_COMMAND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_mi_pt.h" */
+
+/**
+ * An enumeration representing the supported GDB/MI commands.
+ */
+enum gdbwire_mi_command_kind {
+ /* -break-info */
+ GDBWIRE_MI_BREAK_INFO,
+
+ /* -stack-info-frame */
+ GDBWIRE_MI_STACK_INFO_FRAME,
+
+ /* -file-list-exec-source-file */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE,
+ /* -file-list-exec-source-files */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES
+};
+
+/** A linked list of source files. */
+struct gdbwire_mi_source_file {
+ /** A relative path to a file, never NULL */
+ char *file;
+ /**An absolute path to a file, NULL if unavailable */
+ char *fullname;
+ /** The next file name or NULL if no more. */
+ struct gdbwire_mi_source_file *next;
+};
+
+/** The disposition of a breakpoint. What to do after hitting it. */
+enum gdbwire_mi_breakpoint_disp_kind {
+ GDBWIRE_MI_BP_DISP_DELETE, /** Delete on next hit */
+ GDBWIRE_MI_BP_DISP_DELETE_NEXT_STOP, /** Delete on next stop, hit or not */
+ GDBWIRE_MI_BP_DISP_DISABLE, /** Disable on next hit */
+ GDBWIRE_MI_BP_DISP_KEEP, /** Leave the breakpoint in place */
+ GDBWIRE_MI_BP_DISP_UNKNOWN /** When GDB doesn't specify */
+};
+
+/**
+ * A linked list of breakpoints.
+ *
+ * A breakpoint is a breakpoint, a tracepoint, a watchpoing or a
+ * catchpoint. The GDB breakpoint model is quite sophisticated.
+ * This structure can be extended when necessary.
+ */
+struct gdbwire_mi_breakpoint {
+ /**
+ * The breakpoint number.
+ *
+ * An integer, however, for a breakpoint that represents one location of
+ * a multiple location breakpoint, this will be a dotted pair, like ‘1.2’.
+ *
+ * Never NULL.
+ */
+ char *number;
+
+ /**
+ * Determines if this is a multiple location breakpoint.
+ *
+ * True for a multi-location breakpoint, false otherwise.
+ *
+ * It is possible that a breakpoint corresponds to several locations in
+ * your program. For example, several functions may have the same name.
+ * For the following source code,
+ * int foo(int p) { return p; }
+ * double foo(double p) { return p; }
+ * int main() { int i = 1; double d = 2.3; return foo(i) + foo(d); }
+ * If the user sets a breakpoint at foo by typing,
+ * b foo
+ * Then gdb will create 3 breakpoints. The multiple location breakpoint,
+ * which is the parent of the two breakpoints created for each foo
+ * function. Here is the output of gdb from the CLI perspective,
+ * Num Type Disp Enb Address What
+ * 1 breakpoint keep y <MULTIPLE>
+ * 1.1 y 0x4004dd in foo(int) at main.cpp:1
+ * 1.2 y 0x4004eb in foo(double) at main.cpp:2
+ *
+ * However, if the user created a breakpoint for main by typing,
+ * b main
+ * Then gdb will only create a single breakpoint which would look like,
+ * 1 breakpoint keep y 0x4004fa in main() at main.cpp:3
+ *
+ * When this is true, the address field will be "<MULTIPLE>" and
+ * the field multi_breakpoints will represent the breakpoints that this
+ * multiple location breakpoint has created.
+ */
+ unsigned char multi:1;
+
+ /**
+ * True for breakpoints of a multi-location breakpoint, otherwise false.
+ *
+ * For the example above, 1.1 and 1.2 would have this field set true.
+ *
+ * When this is true, the field multi_breakpoint will represent
+ * the multiple location breakpoint that has created this breakpoint.
+ */
+ unsigned char from_multi:1;
+
+ /**
+ * The breakpoint type.
+ *
+ * Typically "breakpoint", "watchpoint" or "catchpoint", but can be
+ * a variety of different values. In gdb, see breakpoint.c:bptype_string
+ * to see all the different possibilities.
+ *
+ * This will be NULL for breakpoints of a multiple location breakpoint.
+ * In this circumstance, check the multi_breakpoint field for the
+ * multiple location breakpoint type field.
+ */
+ char *type;
+
+ /**
+ * The type of the catchpoint or NULL if not a catch point.
+ *
+ * This field is only valid when the breakpoint is a catchpoint.
+ * Unfortuntely, gdb says the "type" of the breakpoint in the type field
+ * is "breakpoint" not "catchpoint". So if this field is non-NULL, it is
+ * safe to assume that this breakpoint represents at catch point.
+ */
+ char *catch_type;
+
+ /**
+ * The breakpoint disposition.
+ *
+ * For multiple location breakpoints, this will be
+ * GDBWIRE_MI_BP_DISP_UNKNOWN. In this circumstance, check the
+ * multi_breakpoint field for the multiple location breakpoint
+ * disposition field.
+ */
+ enum gdbwire_mi_breakpoint_disp_kind disposition;
+
+ /** True if enabled or False if disabled. */
+ unsigned char enabled:1;
+
+ /**
+ * The address of the breakpoint.
+ *
+ * This may be
+ * - a hexidecimal number, representing the address
+ * - the string ‘<PENDING>’ for a pending breakpoint
+ * - the string ‘<MULTIPLE>’ for a breakpoint with multiple locations
+ *
+ * This field will be NULL if no address can be determined.
+ * For example, a watchpoint does not have an address.
+ */
+ char *address;
+
+ /**
+ * The name of the function or NULL if unknown.
+ */
+ char *func_name;
+
+ /**
+ * A relative path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * An absolute path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * The line number the breakpoint is at or 0 if unkonwn.
+ */
+ unsigned long line;
+
+ /**
+ * The number of times this breakpoint has been hit.
+ *
+ * For breakpoints of multi-location breakpoints, this will be 0.
+ * Look at the multi-location breakpoint field instead.
+ */
+ unsigned long times;
+
+ /**
+ * The location of the breakpoint as originally specified by the user.
+ *
+ * This may be NULL for instance, for breakpoints for multi-breakpoints.
+ */
+ char *original_location;
+
+ /**
+ * True for a pending breakpoint, otherwise false.
+ *
+ * When this is true, the address field will be "<PENDING>".
+ */
+ unsigned char pending:1;
+
+ /**
+ * The breakpoints for a multi-location breakpoint.
+ *
+ * If multi is true, this will be the breakpoints associated with the
+ * multiple location breakpoint. Otherwise will be NULL.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoints;
+
+ /**
+ * A pointer to the multi location breakpoint that created this breakpoint.
+ *
+ * When the field from_multi is true, this will be a pointer to the
+ * multi-location breakpoint that created this breakpoint. Otherwise NULL.
+ *
+ * For the example above in the multi field, breakpoints 1.1 and 1.2
+ * would have this field pointing to the breakpoint 1.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoint;
+
+
+ /** The next breakpoint or NULL if no more. */
+ struct gdbwire_mi_breakpoint *next;
+};
+
+struct gdbwire_mi_stack_frame {
+ /**
+ * The frame number.
+ *
+ * Where 0 is the topmost frame, i.e., the innermost function.
+ *
+ * Always present.
+ */
+ unsigned level;
+
+ /**
+ * The address ($pc value) of the frame.
+ *
+ * May be NULL if GDB can not determine the frame address.
+ */
+ char *address;
+
+ /**
+ * The function name for the frame. May be NULL if unknown.
+ */
+ char *func;
+
+ /**
+ * The file name for the frame. May be NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * The fullname name for the frame. May be NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * Line number corresponding to the $pc. Maybe be 0 if unknown.
+ */
+ int line;
+
+ /**
+ * The shared library where this function is defined.
+ *
+ * This is only given if the frame's function is not known.
+ * May be NULL if unknown.
+ */
+ char *from;
+};
+
+/**
+ * Represents a GDB/MI command.
+ */
+struct gdbwire_mi_command {
+ /**
+ * The kind of mi command this represents.
+ */
+ enum gdbwire_mi_command_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_BREAK_INFO */
+ struct {
+ /** The list of breakpoints, NULL if none exist. */
+ struct gdbwire_mi_breakpoint *breakpoints;
+ } break_info;
+
+ /** When kind == GDBWIRE_MI_STACK_INFO_FRAME */
+ struct {
+ struct gdbwire_mi_stack_frame *frame;
+ } stack_info_frame;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE */
+ struct {
+ /**
+ * The line number the inferior is currently executing at.
+ */
+ int line;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is usually a relative path.
+ */
+ char *file;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is an absolute path.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ char *fullname;
+
+ /**
+ * Determines if the file includes preprocessor macro information.
+ *
+ * This command was added in 2004. However, the macro-info
+ * field was added to the output in 2008 in git commit 17784837.
+ *
+ * Only check this field if macro_info_exists is true.
+ */
+ char macro_info:1;
+
+ /** True if macro-info field was in mi output, otherwise false */
+ char macro_info_exists:1;
+ } file_list_exec_source_file;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES */
+ struct {
+ /**
+ * A list of files that make up the inferior.
+ *
+ * When there are no files (if the gdb does not have an inferior
+ * loaded) than files will be NULL.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ struct gdbwire_mi_source_file *files;
+ } file_list_exec_source_files;
+
+ } variant;
+};
+
+/**
+ * Get a gdbwire MI command from the result record.
+ *
+ * @param kind
+ * The kind of command the result record is associated with.
+ *
+ * @param result_record
+ * The result record to turn into a command.
+ *
+ * @param out_mi_command
+ * Will return an allocated gdbwire mi command if GDBWIRE_OK is returned
+ * from this function. You should free this memory with
+ * gdbwire_mi_command_free when you are done with it.
+ *
+ * @return
+ * The result of this function.
+ */
+enum gdbwire_result gdbwire_get_mi_command(
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out_mi_command);
+
+/**
+ * Free the gdbwire mi command.
+ *
+ * @param mi_command
+ * The mi command to free.
+ */
+void gdbwire_mi_command_free(struct gdbwire_mi_command *mi_command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_command.h *******************************************/
+/***** Begin file gdbwire_mi_grammar.h ***************************************/
+/* A Bison parser, made by GNU Bison 3.0.4. */
+
+/* Bison interface for Yacc-like parsers in C
+
+ Copyright (C) 1984, 1989-1990, 2000-2015 Free Software Foundation, Inc.
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>. */
+
+/* As a special exception, you may create a larger work that contains
+ part or all of the Bison parser skeleton and distribute that work
+ under terms of your choice, so long as that work isn't itself a
+ parser generator using the skeleton or a modified version thereof
+ as a parser skeleton. Alternatively, if you modify or redistribute
+ the parser skeleton itself, you may (at your option) remove this
+ special exception, which will cause the skeleton and the resulting
+ Bison output files to be licensed under the GNU General Public
+ License without this special exception.
+
+ This special exception was added by the Free Software Foundation in
+ version 2.2 of Bison. */
+
+#ifndef YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+# define YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED
+/* Debug traces. */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+#if YYDEBUG
+extern int gdbwire_mi_debug;
+#endif
+/* "%code requires" blocks. */
+
+
+/* An opaque pointer. */
+#ifndef YY_TYPEDEF_YY_SCANNER_T
+#define YY_TYPEDEF_YY_SCANNER_T
+typedef void *yyscan_t;
+#endif
+
+ struct gdbwire_mi_output;
+
+
+/* Token type. */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+ enum yytokentype
+ {
+ OPEN_BRACE = 258,
+ CLOSED_BRACE = 259,
+ OPEN_PAREN = 260,
+ CLOSED_PAREN = 261,
+ ADD_OP = 262,
+ MULT_OP = 263,
+ EQUAL_SIGN = 264,
+ TILDA = 265,
+ AT_SYMBOL = 266,
+ AMPERSAND = 267,
+ OPEN_BRACKET = 268,
+ CLOSED_BRACKET = 269,
+ NEWLINE = 270,
+ INTEGER_LITERAL = 271,
+ STRING_LITERAL = 272,
+ CSTRING = 273,
+ COMMA = 274,
+ CARROT = 275
+ };
+#endif
+/* Tokens. */
+#define OPEN_BRACE 258
+#define CLOSED_BRACE 259
+#define OPEN_PAREN 260
+#define CLOSED_PAREN 261
+#define ADD_OP 262
+#define MULT_OP 263
+#define EQUAL_SIGN 264
+#define TILDA 265
+#define AT_SYMBOL 266
+#define AMPERSAND 267
+#define OPEN_BRACKET 268
+#define CLOSED_BRACKET 269
+#define NEWLINE 270
+#define INTEGER_LITERAL 271
+#define STRING_LITERAL 272
+#define CSTRING 273
+#define COMMA 274
+#define CARROT 275
+
+/* Value type. */
+#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
+
+union YYSTYPE
+{
+
+ struct gdbwire_mi_output *u_output;
+ struct gdbwire_mi_oob_record *u_oob_record;
+ struct gdbwire_mi_result_record *u_result_record;
+ int u_result_class;
+ int u_async_record_kind;
+ struct gdbwire_mi_result_list *u_result_list;
+ struct gdbwire_mi_result *u_result;
+ char *u_token;
+ struct gdbwire_mi_async_record *u_async_record;
+ struct gdbwire_mi_stream_record *u_stream_record;
+ int u_async_class;
+ char *u_variable;
+ char *u_cstring;
+ struct gdbwire_mi_result *u_tuple;
+ struct gdbwire_mi_result *u_list;
+ int u_stream_record_kind;
+
+};
+
+typedef union YYSTYPE YYSTYPE;
+# define YYSTYPE_IS_TRIVIAL 1
+# define YYSTYPE_IS_DECLARED 1
+#endif
+
+
+
+#ifndef YYPUSH_MORE_DEFINED
+# define YYPUSH_MORE_DEFINED
+enum { YYPUSH_MORE = 4 };
+#endif
+
+typedef struct gdbwire_mi_pstate gdbwire_mi_pstate;
+
+int gdbwire_mi_push_parse (gdbwire_mi_pstate *ps, int pushed_char, YYSTYPE const *pushed_val, yyscan_t
yyscanner, struct gdbwire_mi_output **gdbwire_mi_output);
+
+gdbwire_mi_pstate * gdbwire_mi_pstate_new (void);
+void gdbwire_mi_pstate_delete (gdbwire_mi_pstate *ps);
+
+#endif /* !YY_GDBWIRE_MI_SRC_GDBWIRE_MI_GRAMMAR_H_INCLUDED */
+/***** End of gdbwire_mi_grammar.h *******************************************/
+/***** Begin file gdbwire.h **************************************************/
+/**
+ * Copyright (C) 2013 Robert Rossi <bob brasko net>
+ *
+ * This file is part of GDBWIRE.
+ *
+ * GDBWIRE is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * GDBWIRE is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with GDBWIRE. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef GDBWIRE_H
+#define GDBWIRE_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdlib.h>
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_mi_pt.h" */
+/***** Include gdbwire_mi_command.h in the middle of gdbwire.h ***************/
+/***** Begin file gdbwire_mi_command.h ***************************************/
+#ifndef GDBWIRE_MI_COMMAND_H
+#define GDBWIRE_MI_COMMAND_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* #include "gdbwire_result.h" */
+/* #include "gdbwire_mi_pt.h" */
+
+/**
+ * An enumeration representing the supported GDB/MI commands.
+ */
+enum gdbwire_mi_command_kind {
+ /* -break-info */
+ GDBWIRE_MI_BREAK_INFO,
+
+ /* -stack-info-frame */
+ GDBWIRE_MI_STACK_INFO_FRAME,
+
+ /* -file-list-exec-source-file */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE,
+ /* -file-list-exec-source-files */
+ GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES
+};
+
+/** A linked list of source files. */
+struct gdbwire_mi_source_file {
+ /** A relative path to a file, never NULL */
+ char *file;
+ /**An absolute path to a file, NULL if unavailable */
+ char *fullname;
+ /** The next file name or NULL if no more. */
+ struct gdbwire_mi_source_file *next;
+};
+
+/** The disposition of a breakpoint. What to do after hitting it. */
+enum gdbwire_mi_breakpoint_disp_kind {
+ GDBWIRE_MI_BP_DISP_DELETE, /** Delete on next hit */
+ GDBWIRE_MI_BP_DISP_DELETE_NEXT_STOP, /** Delete on next stop, hit or not */
+ GDBWIRE_MI_BP_DISP_DISABLE, /** Disable on next hit */
+ GDBWIRE_MI_BP_DISP_KEEP, /** Leave the breakpoint in place */
+ GDBWIRE_MI_BP_DISP_UNKNOWN /** When GDB doesn't specify */
+};
+
+/**
+ * A linked list of breakpoints.
+ *
+ * A breakpoint is a breakpoint, a tracepoint, a watchpoing or a
+ * catchpoint. The GDB breakpoint model is quite sophisticated.
+ * This structure can be extended when necessary.
+ */
+struct gdbwire_mi_breakpoint {
+ /**
+ * The breakpoint number.
+ *
+ * An integer, however, for a breakpoint that represents one location of
+ * a multiple location breakpoint, this will be a dotted pair, like ‘1.2’.
+ *
+ * Never NULL.
+ */
+ char *number;
+
+ /**
+ * Determines if this is a multiple location breakpoint.
+ *
+ * True for a multi-location breakpoint, false otherwise.
+ *
+ * It is possible that a breakpoint corresponds to several locations in
+ * your program. For example, several functions may have the same name.
+ * For the following source code,
+ * int foo(int p) { return p; }
+ * double foo(double p) { return p; }
+ * int main() { int i = 1; double d = 2.3; return foo(i) + foo(d); }
+ * If the user sets a breakpoint at foo by typing,
+ * b foo
+ * Then gdb will create 3 breakpoints. The multiple location breakpoint,
+ * which is the parent of the two breakpoints created for each foo
+ * function. Here is the output of gdb from the CLI perspective,
+ * Num Type Disp Enb Address What
+ * 1 breakpoint keep y <MULTIPLE>
+ * 1.1 y 0x4004dd in foo(int) at main.cpp:1
+ * 1.2 y 0x4004eb in foo(double) at main.cpp:2
+ *
+ * However, if the user created a breakpoint for main by typing,
+ * b main
+ * Then gdb will only create a single breakpoint which would look like,
+ * 1 breakpoint keep y 0x4004fa in main() at main.cpp:3
+ *
+ * When this is true, the address field will be "<MULTIPLE>" and
+ * the field multi_breakpoints will represent the breakpoints that this
+ * multiple location breakpoint has created.
+ */
+ unsigned char multi:1;
+
+ /**
+ * True for breakpoints of a multi-location breakpoint, otherwise false.
+ *
+ * For the example above, 1.1 and 1.2 would have this field set true.
+ *
+ * When this is true, the field multi_breakpoint will represent
+ * the multiple location breakpoint that has created this breakpoint.
+ */
+ unsigned char from_multi:1;
+
+ /**
+ * The breakpoint type.
+ *
+ * Typically "breakpoint", "watchpoint" or "catchpoint", but can be
+ * a variety of different values. In gdb, see breakpoint.c:bptype_string
+ * to see all the different possibilities.
+ *
+ * This will be NULL for breakpoints of a multiple location breakpoint.
+ * In this circumstance, check the multi_breakpoint field for the
+ * multiple location breakpoint type field.
+ */
+ char *type;
+
+ /**
+ * The type of the catchpoint or NULL if not a catch point.
+ *
+ * This field is only valid when the breakpoint is a catchpoint.
+ * Unfortuntely, gdb says the "type" of the breakpoint in the type field
+ * is "breakpoint" not "catchpoint". So if this field is non-NULL, it is
+ * safe to assume that this breakpoint represents at catch point.
+ */
+ char *catch_type;
+
+ /**
+ * The breakpoint disposition.
+ *
+ * For multiple location breakpoints, this will be
+ * GDBWIRE_MI_BP_DISP_UNKNOWN. In this circumstance, check the
+ * multi_breakpoint field for the multiple location breakpoint
+ * disposition field.
+ */
+ enum gdbwire_mi_breakpoint_disp_kind disposition;
+
+ /** True if enabled or False if disabled. */
+ unsigned char enabled:1;
+
+ /**
+ * The address of the breakpoint.
+ *
+ * This may be
+ * - a hexidecimal number, representing the address
+ * - the string ‘<PENDING>’ for a pending breakpoint
+ * - the string ‘<MULTIPLE>’ for a breakpoint with multiple locations
+ *
+ * This field will be NULL if no address can be determined.
+ * For example, a watchpoint does not have an address.
+ */
+ char *address;
+
+ /**
+ * The name of the function or NULL if unknown.
+ */
+ char *func_name;
+
+ /**
+ * A relative path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * An absolute path to the file the breakpoint is in or NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * The line number the breakpoint is at or 0 if unkonwn.
+ */
+ unsigned long line;
+
+ /**
+ * The number of times this breakpoint has been hit.
+ *
+ * For breakpoints of multi-location breakpoints, this will be 0.
+ * Look at the multi-location breakpoint field instead.
+ */
+ unsigned long times;
+
+ /**
+ * The location of the breakpoint as originally specified by the user.
+ *
+ * This may be NULL for instance, for breakpoints for multi-breakpoints.
+ */
+ char *original_location;
+
+ /**
+ * True for a pending breakpoint, otherwise false.
+ *
+ * When this is true, the address field will be "<PENDING>".
+ */
+ unsigned char pending:1;
+
+ /**
+ * The breakpoints for a multi-location breakpoint.
+ *
+ * If multi is true, this will be the breakpoints associated with the
+ * multiple location breakpoint. Otherwise will be NULL.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoints;
+
+ /**
+ * A pointer to the multi location breakpoint that created this breakpoint.
+ *
+ * When the field from_multi is true, this will be a pointer to the
+ * multi-location breakpoint that created this breakpoint. Otherwise NULL.
+ *
+ * For the example above in the multi field, breakpoints 1.1 and 1.2
+ * would have this field pointing to the breakpoint 1.
+ */
+ struct gdbwire_mi_breakpoint *multi_breakpoint;
+
+
+ /** The next breakpoint or NULL if no more. */
+ struct gdbwire_mi_breakpoint *next;
+};
+
+struct gdbwire_mi_stack_frame {
+ /**
+ * The frame number.
+ *
+ * Where 0 is the topmost frame, i.e., the innermost function.
+ *
+ * Always present.
+ */
+ unsigned level;
+
+ /**
+ * The address ($pc value) of the frame.
+ *
+ * May be NULL if GDB can not determine the frame address.
+ */
+ char *address;
+
+ /**
+ * The function name for the frame. May be NULL if unknown.
+ */
+ char *func;
+
+ /**
+ * The file name for the frame. May be NULL if unknown.
+ */
+ char *file;
+
+ /**
+ * The fullname name for the frame. May be NULL if unknown.
+ */
+ char *fullname;
+
+ /**
+ * Line number corresponding to the $pc. Maybe be 0 if unknown.
+ */
+ int line;
+
+ /**
+ * The shared library where this function is defined.
+ *
+ * This is only given if the frame's function is not known.
+ * May be NULL if unknown.
+ */
+ char *from;
+};
+
+/**
+ * Represents a GDB/MI command.
+ */
+struct gdbwire_mi_command {
+ /**
+ * The kind of mi command this represents.
+ */
+ enum gdbwire_mi_command_kind kind;
+
+ union {
+ /** When kind == GDBWIRE_MI_BREAK_INFO */
+ struct {
+ /** The list of breakpoints, NULL if none exist. */
+ struct gdbwire_mi_breakpoint *breakpoints;
+ } break_info;
+
+ /** When kind == GDBWIRE_MI_STACK_INFO_FRAME */
+ struct {
+ struct gdbwire_mi_stack_frame *frame;
+ } stack_info_frame;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILE */
+ struct {
+ /**
+ * The line number the inferior is currently executing at.
+ */
+ int line;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is usually a relative path.
+ */
+ char *file;
+
+ /**
+ * The filename the inferior is currently executing at.
+ *
+ * This is an absolute path.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ char *fullname;
+
+ /**
+ * Determines if the file includes preprocessor macro information.
+ *
+ * This command was added in 2004. However, the macro-info
+ * field was added to the output in 2008 in git commit 17784837.
+ *
+ * Only check this field if macro_info_exists is true.
+ */
+ char macro_info:1;
+
+ /** True if macro-info field was in mi output, otherwise false */
+ char macro_info_exists:1;
+ } file_list_exec_source_file;
+
+ /** When kind == GDBWIRE_MI_FILE_LIST_EXEC_SOURCE_FILES */
+ struct {
+ /**
+ * A list of files that make up the inferior.
+ *
+ * When there are no files (if the gdb does not have an inferior
+ * loaded) than files will be NULL.
+ *
+ * This command was addd in 2004, however, it was possible
+ * at the time that only the "file" field would be put out and
+ * the "fullname" field would be omitted. In 2012, in git commit,
+ * f35a17b5, gdb was changed to always omit the "fullname" field.
+ */
+ struct gdbwire_mi_source_file *files;
+ } file_list_exec_source_files;
+
+ } variant;
+};
+
+/**
+ * Get a gdbwire MI command from the result record.
+ *
+ * @param kind
+ * The kind of command the result record is associated with.
+ *
+ * @param result_record
+ * The result record to turn into a command.
+ *
+ * @param out_mi_command
+ * Will return an allocated gdbwire mi command if GDBWIRE_OK is returned
+ * from this function. You should free this memory with
+ * gdbwire_mi_command_free when you are done with it.
+ *
+ * @return
+ * The result of this function.
+ */
+enum gdbwire_result gdbwire_get_mi_command(
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_result_record *result_record,
+ struct gdbwire_mi_command **out_mi_command);
+
+/**
+ * Free the gdbwire mi command.
+ *
+ * @param mi_command
+ * The mi command to free.
+ */
+void gdbwire_mi_command_free(struct gdbwire_mi_command *mi_command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire_mi_command.h *******************************************/
+/***** Continuing where we left off in gdbwire.h *****************************/
+
+/* The opaque gdbwire context */
+struct gdbwire;
+
+/**
+ * The primary mechanism for gdbwire to send events to the caller.
+ *
+ * The flow is like this:
+ * - create a gdbwire instance
+ * - loop:
+ * - call gdbwire functions to send commands to gdb
+ * - receive callback events with results when they become available
+ * - destroy the instance
+ */
+struct gdbwire_callbacks {
+ /**
+ * An arbitrary pointer to associate with the events.
+ *
+ * This pointer will be passed back to the caller in each event.
+ */
+ void *context;
+
+ /**
+ * A console, target or log output event has occured.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param stream_record
+ * The stream record to display to the user.
+ */
+ void (*gdbwire_stream_record_fn)(void *context,
+ struct gdbwire_mi_stream_record *stream_record);
+
+ /**
+ * An asynchronous output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param async_record
+ * The asychronous record output by GDB.
+ */
+ void (*gdbwire_async_record_fn)(void *context,
+ struct gdbwire_mi_async_record *async_record);
+
+ /**
+ * A result output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param result_record
+ * The result record output by GDB.
+ */
+ void (*gdbwire_result_record_fn)(void *context,
+ struct gdbwire_mi_result_record *result_record);
+
+ /**
+ * A prompt output event.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param prompt
+ * The prompt output to display to the user.
+ */
+ void (*gdbwire_prompt_fn)(void *context, const char *prompt);
+
+ /**
+ * A gdbwire parse error occurred.
+ *
+ * If you receive this callback, that means the gdbwire parser
+ * failed to parse some gdb/mi coming out of gdb.
+ * Please send the parameters received in this callback to the
+ * gdbwire develpment team.
+ *
+ * @param context
+ * The context pointer above.
+ *
+ * @param mi
+ * The mi string that gdbwire could not parse.
+ *
+ * @param token
+ * The token the error occurred on.
+ *
+ * @param position
+ * The position of the token the error occurred on.
+ */
+ void (*gdbwire_parse_error_fn)(void *context, const char *mi,
+ const char *token, struct gdbwire_mi_position position);
+};
+
+/**
+ * Create a gdbwire context.
+ *
+ * Each gdbwire structure is capable of talking to a single gdb instance.
+ *
+ * @param callbacks
+ * The callback functions for when events should be sent. Be sure to
+ * initialize all of the callback functions. If a callback event is
+ * initialized to NULL, it will not be called.
+ *
+ * @return
+ * A new gdbwire instance or NULL on error.
+ */
+struct gdbwire *gdbwire_create(struct gdbwire_callbacks callbacks);
+
+/**
+ * Destroy a gdbwire context.
+ *
+ * This function will do nothing if the instance is NULL.
+ *
+ * @param gdbwire
+ * The instance of gdbwire to destroy
+ */
+void gdbwire_destroy(struct gdbwire *wire);
+
+/**
+ * Push some GDB output characters to gdbwire for processing.
+ *
+ * Currently, the calling application is responsible for reading the
+ * output of GDB and sending it to gdbwire. This may change in the future.
+ * Call this function with output from GDB when it is available.
+ *
+ * During this function, callback events may be invoked to alert the
+ * caller of useful gdbwire_mi events.
+ *
+ * @param wire
+ * The gdbwire context to operate on.
+ *
+ * @param data
+ * The data to push to gdbwire for interpretation.
+ *
+ * @param size
+ * The size of the data to push to gdbwire.
+ *
+ * @return
+ * GDBWIRE_OK on success or appropriate error result on failure.
+ */
+enum gdbwire_result gdbwire_push_data(struct gdbwire *wire, const char *data,
+ size_t size);
+
+/**
+ * Handle an interpreter-exec command.
+ *
+ * Typically, a front end would start gdb with the MI interface and create
+ * a corresponding gdbwire instance. The front end would feed the gdbwire
+ * instance all of the MI output. In this scenario, gdbwire triggers
+ * callbacks when interesting events occur.
+ *
+ * Some GDB front ends use the annotate interface with gdb, and will
+ * transition to using MI through the use of the interpreter-exec command.
+ * In this scenario, the front end will send GDB a single interpreter-exec
+ * command and will want to interpret the output of only that command.
+ * For this use case, a gdbwire instance is not necessary for the front end,
+ * nor any of the callbacks associated with that instance.
+ *
+ * This function provides a way for a front end to interpret the output
+ * of a single interpreter-exec command with out the need for creating
+ * a gdbwire instance or any gdbwire callbacks.
+ *
+ * @param interpreter_exec_output
+ * The MI output from GDB for the interpreter exec command.
+ *
+ * @param kind
+ * The interpreter-exec command kind.
+ *
+ * @param out_mi_command
+ * Will return an allocated gdbwire mi command if GDBWIRE_OK is returned
+ * from this function. You should free this memory with
+ * gdbwire_mi_command_free when you are done with it.
+ *
+ * @return
+ * The result of this function.
+ */
+enum gdbwire_result gdbwire_interpreter_exec(
+ const char *interpreter_exec_output,
+ enum gdbwire_mi_command_kind kind,
+ struct gdbwire_mi_command **out_mi_command);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
+/***** End of gdbwire.h ******************************************************/
diff --git a/plugins/gdb/meson.build b/plugins/gdb/meson.build
new file mode 100644
index 0000000..8a363c7
--- /dev/null
+++ b/plugins/gdb/meson.build
@@ -0,0 +1,21 @@
+if get_option('with_gdb')
+
+gdb_sources = [
+ 'gbp-gdb-debugger.c',
+ 'gbp-gdb-debugger.h',
+ 'gbp-gdb-plugin.c',
+ 'gdbwire.c',
+ 'gdbwire.h',
+]
+
+shared_module('gdb-plugin', gdb_sources,
+ dependencies: plugin_deps,
+ link_args: plugin_link_args,
+ link_depends: plugin_link_deps,
+ install: true,
+ install_dir: plugindir,
+)
+
+install_data('gdb.plugin', install_dir: plugindir)
+
+endif
diff --git a/plugins/meson.build b/plugins/meson.build
index c16c521..5a44745 100644
--- a/plugins/meson.build
+++ b/plugins/meson.build
@@ -30,6 +30,7 @@ subdir('find-other-file')
subdir('flatpak')
subdir('fpaste')
subdir('gcc')
+subdir('gdb')
subdir('gettext')
subdir('git')
subdir('gnome-code-assistance')
@@ -84,6 +85,7 @@ status += [
'Flatpak ............... : @0@'.format(get_option('with_flatpak')),
'Fpaste ................ : @0@'.format(get_option('with_fpaste')),
'GCC ................... : @0@'.format(get_option('with_gcc')),
+ 'GDB ................... : @0@'.format(get_option('with_gdb')),
'Gettext ............... : @0@'.format(get_option('with_gettext')),
'Git ................... : @0@'.format(get_option('with_git')),
'GNOME Code Assistance . : @0@'.format(get_option('with_gnome_code_assistance')),
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
