void gb_beautifier_process_launch_async (GbBeautifierWorkbenchAddin *self, IdeSourceView *source_view, GtkTextIter *begin, GtkTextIter *end, GbBeautifierConfigEntry *entry, GAsyncReadyCallback callback, GCancellable *cancellable, gpointer user_data) { GtkTextBuffer *buffer; ProcessState *state; g_autoptr(GTask) task = NULL; const gchar *lang_id; g_assert (GB_IS_BEAUTIFIER_WORKBENCH_ADDIN (self)); g_assert (IDE_IS_SOURCE_VIEW (source_view)); g_assert (!cancellable || G_IS_CANCELLABLE (cancellable)); g_assert (entry != NULL); g_assert (callback != NULL); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); lang_id = gb_beautifier_helper_get_lang_id (self, source_view); if (begin == NULL) gtk_text_buffer_get_start_iter (buffer, begin); if (end == NULL) gtk_text_buffer_get_end_iter (buffer, begin); g_assert (gtk_text_iter_get_buffer (begin) == buffer); g_assert (gtk_text_iter_get_buffer (end) == buffer); state = g_slice_new0 (ProcessState); state->self = self; state->source_view = source_view; gtk_text_iter_order (begin, end); state->text = gtk_text_buffer_get_text (buffer, begin, end, FALSE); state->begin_mark = gtk_text_buffer_create_mark (buffer, NULL, begin, TRUE); state->end_mark = gtk_text_buffer_create_mark (buffer, NULL, end, FALSE); state->command = entry->command; state->lang_id = g_strdup (lang_id); if (G_IS_FILE (entry->config_file)) state->config_file = g_file_dup (entry->config_file); if (entry->command_args != NULL) state->command_args = command_args_copy (entry->command_args); task = g_task_new (self, cancellable, callback, user_data); g_task_set_source_tag (task, gb_beautifier_process_launch_async); g_task_set_task_data (task, state, process_state_free); gb_beautifier_helper_create_tmp_file_async (self, state->text, create_tmp_file_cb, cancellable, g_steal_pointer (&task)); }
/** * gstyle_palette_new_from_buffer: * @buffer: a #GtkTextBUffer * @begin: (nullable): a begin #GtkTextIter * @end: (nullable): a end #GtkTextIter * @cancellable: A #GCancellable * @error: (nullable): a #GError location or %NULL * * Create a new #GstylePalette from a text buffer. * if @begin is %NULL, the buffer start iter is used. * if @end is %NULL, the buffer end is used. * * Returns: A #GstylePalette or %NULL if an error occur. */ GstylePalette * gstyle_palette_new_from_buffer (GtkTextBuffer *buffer, GtkTextIter *begin, GtkTextIter *end, GCancellable *cancellable, GError **error) { g_autofree gchar *text = NULL; GstylePalette *palette = NULL; g_autofree gchar *name = NULL; GtkTextIter real_begin, real_end; GtkTextIter buffer_begin, buffer_end; GstyleColorItem *item; GstyleColor *color; GPtrArray *items; GError *tmp_error = NULL; g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL); g_return_val_if_fail (begin == NULL || gtk_text_iter_get_buffer (begin) == buffer, NULL); g_return_val_if_fail (end == NULL || gtk_text_iter_get_buffer (end) == buffer, NULL); gtk_text_buffer_get_bounds (buffer, &buffer_begin, &buffer_end); real_begin = (begin == NULL) ? buffer_begin : *begin; real_end = (end == NULL) ? buffer_end : *end; text = gtk_text_buffer_get_slice (buffer, &real_begin, &real_end, FALSE); items = gstyle_color_parse (text); if (items == NULL) { g_set_error (error, GSTYLE_PALETTE_ERROR, GSTYLE_PALETTE_ERROR_PARSE, _("failed to parse\n")); return NULL; } if (items->len > 0) { /* To translators: always in singular form like in: generated palette number <generated_count> */ name = g_strdup_printf ("%s %i", _("Generated"), ++generated_count); palette = g_object_new (GSTYLE_TYPE_PALETTE, "id", NULL, "name", name, "file", NULL, NULL); for (gint i = 0; i < items->len; ++i) { item = g_ptr_array_index (items, i); color = (GstyleColor *)gstyle_color_item_get_color (item); gstyle_palette_add (palette, color, &tmp_error); } } g_ptr_array_free (items, TRUE); return palette; }
static gchar * get_word_at_iter (GscProviderDevhelp *devhelp, GtkTextIter *iter) { GtkTextIter start = *iter; gint line = gtk_text_iter_get_line (iter); gboolean went_back = TRUE; GtkTextMark *mark; if (!gtk_text_iter_backward_char (&start)) { return NULL; } while (went_back && line == gtk_text_iter_get_line (&start) && is_word_char (gtk_text_iter_get_char (&start))) { went_back = gtk_text_iter_backward_char (&start); } if (went_back) { gtk_text_iter_forward_char (&start); } if (gtk_text_iter_equal (iter, &start)) { return NULL; } mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter), MARK_NAME); if (mark) { gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter), mark, &start); } else { mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter), MARK_NAME, &start, TRUE); } return gtk_text_iter_get_text (&start, iter); }
void dma_sparse_iter_insert_lines (DmaSparseIter *src, GtkTextIter *dst, guint count) { DmaSparseIter iter; guint line = 0; GtkTextBuffer *buffer; buffer = gtk_text_iter_get_buffer (dst); /* It is possible to get an iterator that doesn't point to any node * if it has been move to a fixed address without rounding it to * the nearest line */ dma_sparse_iter_copy (&iter, src); dma_sparse_iter_refresh (&iter); /* Fill with data */ for (; line < count; line++) { dma_sparse_iter_insert_line (&iter, dst); if (!dma_sparse_iter_forward_line (&iter)) { /* no more data */ break; } if (line != count - 1) gtk_text_buffer_insert (buffer, dst, "\n", 1); } }
/** * ide_highlight_engine_invalidate: * @self: An #IdeHighlightEngine. * @begin: the beginning of the range to invalidate * @end: the end of the range to invalidate * * This function will extend the invalidated range of the buffer to include * the range of @begin to @end. * * The highlighter will be queued to interactively update the invalidated * region. * * Updating the invalidated region of the buffer may take some time, as it is * important that the highlighter does not block for more than 1-2 milliseconds * to avoid dropping frames. */ void ide_highlight_engine_invalidate (IdeHighlightEngine *self, const GtkTextIter *begin, const GtkTextIter *end) { GtkTextBuffer *buffer; GtkTextIter mark_begin; GtkTextIter mark_end; IDE_ENTRY; g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self)); g_return_if_fail (begin != NULL); g_return_if_fail (end != NULL); g_return_if_fail (gtk_text_iter_get_buffer (begin) == GTK_TEXT_BUFFER (self->buffer)); g_return_if_fail (gtk_text_iter_get_buffer (end) == GTK_TEXT_BUFFER (self->buffer)); buffer = GTK_TEXT_BUFFER (self->buffer); gtk_text_buffer_get_iter_at_mark (buffer, &mark_begin, self->invalid_begin); gtk_text_buffer_get_iter_at_mark (buffer, &mark_end, self->invalid_end); if (gtk_text_iter_equal (&mark_begin, &mark_end)) { gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin); gtk_text_buffer_move_mark (buffer, self->invalid_end, end); } else { if (gtk_text_iter_compare (begin, &mark_begin) < 0) gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin); if (gtk_text_iter_compare (end, &mark_end) > 0) gtk_text_buffer_move_mark (buffer, self->invalid_end, end); } ide_highlight_engine_queue_work (self); IDE_EXIT; }
/** * gb_color_picker_document_monitor_queue_colorize: * @self: a #GbColorPickerDocumentMonitor * * This queues a region to be recolorized but does so after returning * to the main loop. This can be useful for situations where you do not * know if you are in a path that must retain a valid GtkTextIter. * * Since: 3.26 */ static void gb_color_picker_document_monitor_queue_oper (GbColorPickerDocumentMonitor *self, const GtkTextIter *begin, const GtkTextIter *end, gboolean uncolorize) { QueuedColorize queued = { 0 }; GtkTextBuffer *buffer; GtkTextIter real_begin; GtkTextIter real_end; g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self)); g_return_if_fail (self->buffer != NULL); g_return_if_fail (begin == NULL || GTK_TEXT_BUFFER (self->buffer) == gtk_text_iter_get_buffer (begin)); g_return_if_fail (end == NULL || GTK_TEXT_BUFFER (self->buffer) == gtk_text_iter_get_buffer (end)); buffer = GTK_TEXT_BUFFER (self->buffer); gtk_text_buffer_get_bounds (buffer, &real_begin, &real_end); if (begin) real_begin = *begin; if (end) real_end = *end; queued.self = g_object_ref (self); queued.buffer = g_object_ref (buffer); queued.begin = g_object_ref (gtk_text_buffer_create_mark (buffer, NULL, &real_begin, TRUE)); queued.end = g_object_ref (gtk_text_buffer_create_mark (buffer, NULL, &real_end, FALSE)); queued.uncolorize = !!uncolorize; gdk_threads_add_idle_full (G_PRIORITY_LOW, gb_color_picker_document_monitor_queue_oper_cb, g_slice_dup (QueuedColorize, &queued), queued_colorize_free); }
static IdeHighlightResult ide_highlight_engine_apply_style (const GtkTextIter *begin, const GtkTextIter *end, const gchar *style_name) { IdeHighlightEngine *self; GtkTextBuffer *buffer; GtkTextTag *tag; buffer = gtk_text_iter_get_buffer (begin); self = g_object_get_qdata (G_OBJECT (buffer), gEngineQuark); tag = get_tag_from_style (self, style_name, TRUE); gtk_text_buffer_apply_tag (buffer, tag, begin, end); if (g_get_monotonic_time () >= self->quanta_expiration) return IDE_HIGHLIGHT_STOP; return IDE_HIGHLIGHT_CONTINUE; }
gboolean xed_spell_utils_skip_no_spell_check (GtkTextIter *start, GtkTextIter *end) { GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (start)); while (gtk_source_buffer_iter_has_context_class (buffer, start, "no-spell-check")) { GtkTextIter last = *start; if (!gtk_source_buffer_iter_forward_to_context_class_toggle (buffer, start, "no-spell-check")) { return FALSE; } if (gtk_text_iter_compare (start, &last) <= 0) { return FALSE; } gtk_text_iter_forward_word_end (start); gtk_text_iter_backward_word_start (start); if (gtk_text_iter_compare (start, &last) <= 0) { return FALSE; } if (gtk_text_iter_compare (start, end) >= 0) { return FALSE; } } return TRUE; }
static gboolean gsc_provider_devhelp_get_start_iter (GtkSourceCompletionProvider *provider, GtkSourceCompletionContext *context, GtkSourceCompletionProposal *proposal, GtkTextIter *iter) { GscProviderDevhelp *devhelp = GSC_PROVIDER_DEVHELP (provider); GtkTextBuffer *buf; GtkTextMark *mark; GtkTextIter context_iter; gtk_source_completion_context_get_iter (context, &context_iter); buf = gtk_text_iter_get_buffer (&context_iter); mark = gtk_text_buffer_get_mark (buf, MARK_NAME); if (!mark) { return FALSE; } gtk_text_buffer_get_iter_at_mark (buf, iter, mark); return TRUE; }
static void build_indent (IdeXmlIndenter *xml, guint line_offset, GtkTextIter *matching_line, GString *str) { GtkTextIter iter; gunichar ch; if (!line_offset) return; gtk_text_buffer_get_iter_at_line (gtk_text_iter_get_buffer (matching_line), &iter, gtk_text_iter_get_line (matching_line)); do { ch = gtk_text_iter_get_char (&iter); switch (ch) { case '\t': case ' ': g_string_append_unichar (str, ch); break; default: g_string_append_c (str, ' '); break; } } while (gtk_text_iter_forward_char (&iter) && (gtk_text_iter_compare (&iter, matching_line) <= 0) && (str->len < line_offset)); while (str->len < line_offset) g_string_append_c (str, ' '); if (xml->use_tabs) { GString *translated = g_string_new (NULL); const gchar *pos = str->str; const gchar *tab; gchar *needle; needle = g_malloc (xml->tab_width + 1); memset (needle, ' ', xml->tab_width); needle [xml->tab_width] = '\0'; while (NULL != (tab = strstr (pos, needle))) { g_string_append_len (translated, pos, tab - pos); g_string_append_c (translated, '\t'); pos = tab + xml->tab_width; } if (*pos) g_string_append (translated, pos); g_string_truncate (str, 0); g_string_append_len (str, translated->str, translated->len); g_string_free (translated, TRUE); g_free (needle); } }
static void ide_langserv_completion_provider_populate (GtkSourceCompletionProvider *provider, GtkSourceCompletionContext *context) { IdeLangservCompletionProvider *self = (IdeLangservCompletionProvider *)provider; IdeLangservCompletionProviderPrivate *priv = ide_langserv_completion_provider_get_instance_private (self); g_autoptr(GVariant) params = NULL; g_autoptr(GCancellable) cancellable = NULL; g_autoptr(CompletionState) state = NULL; g_autofree gchar *uri = NULL; GtkTextIter iter; IdeBuffer *buffer; gint line; gint column; IDE_ENTRY; g_assert (IDE_IS_LANGSERV_COMPLETION_PROVIDER (self)); g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context)); if (priv->client == NULL) { IDE_TRACE_MSG ("No client set, cannot provide proposals"); gtk_source_completion_context_add_proposals (context, provider, NULL, TRUE); IDE_EXIT; } gtk_source_completion_context_get_iter (context, &iter); buffer = IDE_BUFFER (gtk_text_iter_get_buffer (&iter)); uri = ide_buffer_get_uri (buffer); line = gtk_text_iter_get_line (&iter); column = gtk_text_iter_get_line_offset (&iter); params = JSONRPC_MESSAGE_NEW ( "textDocument", "{", "uri", JSONRPC_MESSAGE_PUT_STRING (uri), "}", "position", "{", "line", JSONRPC_MESSAGE_PUT_INT32 (line), "character", JSONRPC_MESSAGE_PUT_INT32 (column), "}" ); cancellable = g_cancellable_new (); g_signal_connect_data (context, "cancelled", G_CALLBACK (g_cancellable_cancel), g_object_ref (cancellable), (GClosureNotify)g_object_unref, G_CONNECT_SWAPPED); state = completion_state_new (self, context); ide_langserv_client_call_async (priv->client, "textDocument/completion", g_steal_pointer (¶ms), g_steal_pointer (&cancellable), ide_langserv_completion_provider_complete_cb, g_steal_pointer (&state)); IDE_EXIT; }
static VALUE rg_buffer(VALUE self) { return GOBJ2RVAL(gtk_text_iter_get_buffer(_SELF(self))); }
/* * This bad boy was taken from https://bugzilla.gnome.org/show_bug.cgi?id=59390 */ static void gtk_text_buffer_real_insert_markup (GtkTextBuffer *buffer, GtkTextIter *textiter, const gchar *markup, GtkTextTag *extratag) { PangoAttrIterator *paiter; PangoAttrList *attrlist; GtkTextMark *mark; GError *error = NULL; gchar *text; g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer)); g_return_if_fail (textiter != NULL); g_return_if_fail (markup != NULL); g_return_if_fail (gtk_text_iter_get_buffer (textiter) == buffer); if (*markup == '\000') return; if (!pango_parse_markup(markup, -1, 0, &attrlist, &text, NULL, &error)) { g_warning("Invalid markup string: %s", error->message); g_error_free(error); return; } if (attrlist == NULL) { gtk_text_buffer_insert(buffer, textiter, text, -1); g_free(text); return; } /* create mark with right gravity */ mark = gtk_text_buffer_create_mark(buffer, NULL, textiter, FALSE); paiter = pango_attr_list_get_iterator(attrlist); do { PangoAttribute *attr; GtkTextTag *tag; gint start, end; pango_attr_iterator_range(paiter, &start, &end); if (end == G_MAXINT) /* last chunk */ end = start-1; /* resulting in -1 to be passed to _insert */ tag = gtk_text_tag_new(NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_LANGUAGE))) g_object_set(tag, "language", pango_language_to_string(((PangoAttrLanguage*)attr)->value), NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FAMILY))) g_object_set(tag, "family", ((PangoAttrString*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STYLE))) g_object_set(tag, "style", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_WEIGHT))) g_object_set(tag, "weight", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_VARIANT))) g_object_set(tag, "variant", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRETCH))) g_object_set(tag, "stretch", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SIZE))) g_object_set(tag, "size", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FONT_DESC))) g_object_set(tag, "font-desc", ((PangoAttrFontDesc*)attr)->desc, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_FOREGROUND))) { GdkColor col = { 0, ((PangoAttrColor*)attr)->color.red, ((PangoAttrColor*)attr)->color.green, ((PangoAttrColor*)attr)->color.blue }; g_object_set(tag, "foreground-gdk", &col, NULL); } if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_BACKGROUND))) { GdkColor col = { 0, ((PangoAttrColor*)attr)->color.red, ((PangoAttrColor*)attr)->color.green, ((PangoAttrColor*)attr)->color.blue }; g_object_set(tag, "background-gdk", &col, NULL); } if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_UNDERLINE))) g_object_set(tag, "underline", ((PangoAttrInt*)attr)->value, NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_STRIKETHROUGH))) g_object_set(tag, "strikethrough", (gboolean)(((PangoAttrInt*)attr)->value != 0), NULL); if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_RISE))) g_object_set(tag, "rise", ((PangoAttrInt*)attr)->value, NULL); /* PANGO_ATTR_SHAPE cannot be defined via markup text */ if ((attr = pango_attr_iterator_get(paiter, PANGO_ATTR_SCALE))) g_object_set(tag, "scale", ((PangoAttrFloat*)attr)->value, NULL); gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(buffer), tag); if (extratag) { gtk_text_buffer_insert_with_tags(buffer, textiter, text+start, end - start, tag, extratag, NULL); } else { gtk_text_buffer_insert_with_tags(buffer, textiter, text+start, end - start, tag, NULL); } /* mark had right gravity, so it should be * at the end of the inserted text now */ gtk_text_buffer_get_iter_at_mark(buffer, textiter, mark); } while (pango_attr_iterator_next(paiter)); gtk_text_buffer_delete_mark(buffer, mark); pango_attr_iterator_destroy(paiter); pango_attr_list_unref(attrlist); g_free(text); }
static void ide_ctags_completion_provider_populate (GtkSourceCompletionProvider *provider, GtkSourceCompletionContext *context) { IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider; g_autofree gchar *word = NULL; const IdeCtagsIndexEntry *entries; const gchar * const *allowed; g_autoptr(GPtrArray) ar = NULL; IdeCtagsIndexEntry *last = NULL; GtkSourceBuffer *buffer; gsize n_entries; GtkTextIter iter; GList *list = NULL; gsize i; gsize j; IDE_ENTRY; g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self)); g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context)); if (self->indexes->len == 0) IDE_GOTO (failure); if (!g_settings_get_boolean (self->settings, "ctags-autocompletion")) IDE_GOTO (failure); if (!gtk_source_completion_context_get_iter (context, &iter)) IDE_GOTO (failure); buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (&iter)); allowed = get_allowed_suffixes (buffer); word = get_word_to_cursor (&iter); if (ide_str_empty0 (word) || strlen (word) < self->minimum_word_size) IDE_GOTO (failure); if (strlen (word) < 3) IDE_GOTO (failure); ar = g_ptr_array_new (); IDE_TRACE_MSG ("Searching for %s", word); for (j = 0; j < self->indexes->len; j++) { IdeCtagsIndex *index = g_ptr_array_index (self->indexes, j); entries = ide_ctags_index_lookup_prefix (index, word, &n_entries); if ((entries == NULL) || (n_entries == 0)) continue; for (i = 0; i < n_entries; i++) { const IdeCtagsIndexEntry *entry = &entries [i]; if (is_allowed (entry, allowed)) g_ptr_array_add (ar, (gpointer)entry); } } g_ptr_array_sort (ar, sort_wrapper); for (i = ar->len; i > 0; i--) { GtkSourceCompletionProposal *item; IdeCtagsIndexEntry *entry = g_ptr_array_index (ar, i - 1); /* * NOTE: * * We walk backwards in this ptrarray so that we can use g_list_prepend() for O(1) access. * I think everyone agrees that using GList for passing completion data around was not * a great choice, but it is what we have to work with. */ /* * Ignore this item if the previous one looks really similar. * We take the first item instead of the last since the first item (when walking backwards) * tends to be more likely to be the one we care about (based on lexicographical * ordering. For example, something in "gtk-2.0" is less useful than "gtk-3.0". * * This is done here instead of during our initial object creation so that * we can merge items between different indexes. It often happens that the * same headers are included in multiple tags files. */ if ((last != NULL) && too_similar (entry, last)) continue; /* * NOTE: * * Autocompletion is very performance sensitive code. The smallest amount of * extra work has a very negative impact on interactivity. We are trying to * avoid a couple things here based on how completion works. * * 1) Avoiding referencing or copying things. * Since the provider will always outlive the completion item, we use * borrowed references for as much as we can. * 2) We delay the work of looking up icons until they are requested. * No sense in doing that work before hand. */ item = ide_ctags_completion_item_new (entry, self, context); list = g_list_prepend (list, item); last = entry; } failure: gtk_source_completion_context_add_proposals (context, provider, list, TRUE); g_list_free_full (list, g_object_unref); IDE_EXIT; }
static void dma_disassembly_buffer_insert_line (DmaSparseIter *iter, GtkTextIter *dst) { DmaDisassemblyBuffer * dis = (DmaDisassemblyBuffer *)iter->buffer; GtkTextBuffer *buffer = gtk_text_iter_get_buffer (dst); if (dis->debugger != NULL) { dma_sparse_iter_refresh (iter); if (iter->line < DMA_DISASSEMBLY_VALID_ADDRESS) { if (iter->buffer->pending == NULL) { DmaSparseIter end; DmaSparseBufferTransport *trans; gint i, j; gulong start_adr; gulong end_adr; gint margin; /* If following line is define, get a block stopping here */ dma_sparse_iter_copy (&end, iter); margin = 0; for (j = 0; j < DMA_DISASSEMBLY_BUFFER_BLOCK_SIZE / DMA_DISASSEMBLY_DEFAULT_LINE_LENGTH; j++) { if (!dma_disassembly_iter_forward_line (&end)) { end.offset = 0; end.base = dma_sparse_buffer_get_upper (end.buffer); break; } if (margin > DMA_DISASSEMBLY_SKIP_BEGINNING_LINE) break; if ((margin != 0) || (end.line >= DMA_DISASSEMBLY_VALID_ADDRESS)) margin++; } i = j; if (iter->line == DMA_DISASSEMBLY_UNKNOWN_ADDRESS) { for (i = j; i < DMA_DISASSEMBLY_BUFFER_BLOCK_SIZE / DMA_DISASSEMBLY_DEFAULT_LINE_LENGTH; i++) { if (!dma_disassembly_iter_backward_line (iter)) break; if (iter->line >= DMA_DISASSEMBLY_VALID_ADDRESS) break; } } start_adr = dma_sparse_iter_get_address (iter); end_adr = dma_sparse_iter_get_address (&end); trans = dma_sparse_buffer_alloc_transport (DMA_SPARSE_BUFFER (dis), i, 0); trans->tag = i != j ? DMA_DISASSEMBLY_SKIP_BEGINNING : DMA_DISASSEMBLY_KEEP_ALL; trans->start = start_adr; trans->length = end_adr - start_adr; if (end_adr == dma_sparse_buffer_get_upper (DMA_SPARSE_BUFFER (dis))) { trans->length++; } DEBUG_PRINT("get disassemble %lx %lx %ld trans %p buffer %p", start_adr, end_adr, trans->length, trans, trans->buffer); dma_queue_disassemble (dis->debugger, start_adr, end_adr + 1 - start_adr, (IAnjutaDebuggerCallback)on_disassemble, trans); } } else { /* Fill with known data */ gtk_text_buffer_insert (buffer, dst, ((DmaDisassemblyBufferNode *)(iter->node))->data[iter->line].text, -1); return; } } /* Fill with unknow data */ gtk_text_buffer_insert (buffer, dst, "??", 2); }