static gboolean is_commented_multiline (IAnjutaEditor *editor, IAnjutaIterable *start, IAnjutaIterable *end) { gchar *text; gboolean is_commented = TRUE; text = ianjuta_editor_get_text (editor, start, end, NULL); while (is_commented && !g_str_has_prefix (text, "/*")) { if (!ianjuta_iterable_previous (start, NULL)) is_commented = FALSE; g_free (text); text = ianjuta_editor_get_text (editor, start, end, NULL); if (g_str_has_prefix (text, "*/")) is_commented = FALSE; } while (is_commented && !g_str_has_suffix (text, "*/")) { if (!ianjuta_iterable_next (end, NULL)) is_commented = FALSE; g_free (text); text = ianjuta_editor_get_text (editor, start, end, NULL); if (g_str_has_suffix (text, "/*")) is_commented = FALSE; } g_free (text); return is_commented; }
/* Returns TRUE if the line is continuation of previous line (that is, it is * part of the same logical line). */ static gboolean line_is_continuation (IAnjutaEditor *editor, IAnjutaIterable *iter) { int is_continuation = FALSE; IAnjutaIterable *new_iter = ianjuta_iterable_clone (iter, NULL); if (skip_iter_to_previous_line (editor, new_iter)) { while (ianjuta_iterable_previous (new_iter, NULL)) { gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (ch == ' ' || ch == '\t') continue; if (ch == '\\') { is_continuation = TRUE; break; } if (iter_is_newline (new_iter, ch)) break; } } g_object_unref (new_iter); return is_continuation; }
/* Check if iter is inside string. Begining of string * is not counted as inside. */ static gboolean is_iter_inside_string (IAnjutaIterable *iter) { IAnjutaEditorAttribute attrib; attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); /* Check if we are *inside* string. Begining * of string does not count as inside. */ if (attrib == IANJUTA_EDITOR_STRING) { /* Peek previous attrib and see what it was */ if (ianjuta_iterable_previous (iter, NULL)) { attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); if (attrib == IANJUTA_EDITOR_STRING) { /* We are inside string */ return TRUE; } else { /* The string just began, not inside. * Restore iter from the peek */ ianjuta_iterable_next (iter, NULL); } } /* else, there is no previous and so we can't be inside string */ } return FALSE; }
/* Sets the iter to line end of previous line and TRUE is returned. * If there is no previous line, iter is set to first character in the * buffer and FALSE is returned. */ static gboolean skip_iter_to_previous_line (IAnjutaEditor *editor, IAnjutaIterable *iter) { gboolean found = FALSE; gchar ch; while (ianjuta_iterable_previous (iter, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); if (iter_is_newline (iter, ch)) { skip_iter_to_newline_head (iter, ch); found = TRUE; break; } } return found; }
/* Returns TRUE if iter was moved */ static gboolean skip_iter_to_newline_tail (IAnjutaIterable *iter, gchar ch) { gboolean ret_val = FALSE; if (ch == '\r') { /* Possibly at head */ if (ianjuta_iterable_previous (iter, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); if (ch != '\n') /* Already at tail, undo iter */ ianjuta_iterable_next (iter, NULL); else /* Correctly at tail */ ret_val = TRUE; } } return ret_val; }
/** * parser_cxx_assist_parse_expression: * @assist: self, * @iter: current cursor position * @start_iter: return location for the start of the completion * * Returns: An iter of a list of IAnjutaSymbols or NULL */ static IAnjutaIterable* parser_cxx_assist_parse_expression (ParserCxxAssist* assist, IAnjutaIterable* iter, IAnjutaIterable** start_iter) { IAnjutaEditor* editor = IANJUTA_EDITOR (assist->priv->iassist); IAnjutaIterable* res = NULL; IAnjutaIterable* cur_pos = ianjuta_iterable_clone (iter, NULL); gboolean op_start = FALSE; gboolean ref_start = FALSE; gchar* stmt = NULL; /* Cursor points after the current characters, move back */ ianjuta_iterable_previous (cur_pos, NULL); /* Search for a operator in the current line */ do { gchar ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL(cur_pos), 0, NULL); if (parser_cxx_assist_is_expression_separator(ch, FALSE, iter)) { break; } if (ch == '.' || (op_start && ch == '-') || (ref_start && ch == ':')) { /* Found an operator, get the statement and the pre_word */ IAnjutaIterable* pre_word_start = ianjuta_iterable_clone (cur_pos, NULL); IAnjutaIterable* pre_word_end = ianjuta_iterable_clone (iter, NULL); IAnjutaIterable* stmt_end = ianjuta_iterable_clone (pre_word_start, NULL); /* we need to pass to the parser all the statement included the last * operator, being it "." or "->" or "::" * Increase the end bound of the statement. */ ianjuta_iterable_next (stmt_end, NULL); if (op_start == TRUE || ref_start == TRUE) ianjuta_iterable_next (stmt_end, NULL); /* Move one character forward so we have the start of the pre_word * and not the last operator */ ianjuta_iterable_next (pre_word_start, NULL); /* If this is a two character operator, skip the second character */ if (op_start) { ianjuta_iterable_next (pre_word_start, NULL); } parser_cxx_assist_update_pre_word (assist, ianjuta_editor_get_text ( editor, pre_word_start, pre_word_end, NULL)); /* Try to get the name of the variable */ while (ianjuta_iterable_previous (cur_pos, NULL)) { gchar word_ch = ianjuta_editor_cell_get_char ( IANJUTA_EDITOR_CELL(cur_pos), 0, NULL); if (parser_cxx_assist_is_expression_separator(word_ch, FALSE, cur_pos)) break; } ianjuta_iterable_next (cur_pos, NULL); stmt = ianjuta_editor_get_text (editor, cur_pos, stmt_end, NULL); *start_iter = pre_word_start; g_object_unref (stmt_end); g_object_unref (pre_word_end); break; } else if (ch == '>') op_start = TRUE; else if (ch == ':') ref_start = TRUE; else { op_start = FALSE; ref_start = FALSE; } } while (ianjuta_iterable_previous (cur_pos, NULL)); if (stmt) { gint lineno; gchar *above_text; IAnjutaIterable* start; if (!assist->priv->editor_filename) { g_free (stmt); return NULL; } start = ianjuta_editor_get_start_position (editor, NULL); above_text = ianjuta_editor_get_text (editor, start, iter, NULL); g_object_unref (start); lineno = ianjuta_editor_get_lineno (editor, NULL); /* the parser works even for the "Gtk::" like expressions, so it * shouldn't be created a specific case to handle this. */ res = engine_parser_process_expression (stmt, above_text, assist->priv->editor_filename, lineno); g_free (stmt); } g_object_unref (cur_pos); return res; }
/* incomplete_statement: * 1 == COMPLETE STATEMENT * 0 == INCOMPLETE STATEMENT * -1 == UNKNOWN */ static gint get_line_indentation_base (IndentCPlugin *plugin, IAnjutaEditor *editor, gint line_num, gint *incomplete_statement, gint *parenthesis_indentation, gboolean *colon_indent) { IAnjutaIterable *iter; gchar point_ch; gint line_indent = 0; gint extra_indent = 0; gboolean looking_at_just_next_line = TRUE; gboolean current_line_is_preprocessor = FALSE; gboolean current_line_is_continuation = FALSE; gboolean line_checked_for_comment = FALSE; /* Determine whether or not to add multi-line comment asterisks */ const gchar *comment_continued = " * "; IAnjutaIterable *line_begin = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); IAnjutaIterable *line_end = ianjuta_editor_get_line_end_position (editor, line_num, NULL); *incomplete_statement = -1; *parenthesis_indentation = 0; if (line_num <= 1) return 0; /* DEBUG_PRINT ("In %s()", __FUNCTION__); */ iter = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); current_line_is_preprocessor = line_is_preprocessor (editor, iter); current_line_is_continuation = line_is_continuation (editor, iter); /* DEBUG_PRINT ("Current line is preprocessor = %d", current_line_is_preprocessor); DEBUG_PRINT ("Current line is continuation = %d", current_line_is_continuation); */ /* line_indent = get_line_indentation (editor, line_num - 1); */ if (current_line_is_preprocessor && current_line_is_continuation) { /* Continuation of preprocessor line -- just maintain indentation */ g_object_unref (iter); return get_line_indentation (editor, line_num - 1); } else if (current_line_is_preprocessor) { /* Preprocessor line -- indentation should be 0 */ g_object_unref (iter); return 0; } while (ianjuta_iterable_previous (iter, NULL)) { /* Skip strings */ IAnjutaEditorAttribute attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); if (attrib == IANJUTA_EDITOR_STRING) continue; point_ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); /* DEBUG_PRINT("point_ch = %c", point_ch); */ /* Check for line comment comment */ if (!line_checked_for_comment && !isspace(point_ch)) { gboolean comment = FALSE; IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); do { gchar c; /* Skip strings */ if (ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (new_iter), NULL) == IANJUTA_EDITOR_STRING) continue; c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (iter_is_newline (new_iter, c)) { line_checked_for_comment = TRUE; break; } if (c == '/') { IAnjutaIterable* tmp_iter = ianjuta_iterable_clone (new_iter, NULL); if (!ianjuta_iterable_previous (tmp_iter, NULL)) { g_object_unref (tmp_iter); break; } c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (tmp_iter), 0, NULL); if (c == '/') { /* is a line comment, skip until begin of comment */ comment = TRUE; g_object_unref (tmp_iter); break; } g_object_unref (tmp_iter); } } while (ianjuta_iterable_previous (new_iter, NULL)); if (comment) { ianjuta_iterable_assign (iter, new_iter, NULL); ianjuta_iterable_previous (iter, NULL); g_object_unref (new_iter); continue; } g_object_unref (new_iter); } /* Check if we are inside a comment */ if (point_ch == '/' || point_ch == '*') { gboolean comment = FALSE; gboolean comment_end = FALSE; IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); do { gchar c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL(new_iter), 0, NULL); if (!comment_end && iter_is_newline (new_iter, c)) { break; } if (c == '*') { IAnjutaIterable* prev = ianjuta_iterable_clone (new_iter, NULL); IAnjutaIterable* next = ianjuta_iterable_clone (new_iter, NULL); ianjuta_iterable_previous (prev, NULL); ianjuta_iterable_next (next, NULL); gchar prev_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (prev), 0, NULL); gchar next_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (next), 0, NULL); if (prev_c == '/') { /* starts comment */ comment = TRUE; if (!comment_end) { extra_indent++; /* If a multiline comment is continuing, check the next line and insert " * " * only if it does not already exist there. The purpose of this fix is to avoid * extra " * " on auto-indent. */ if ((g_settings_get_boolean (plugin->settings, PREF_COMMENT_LEADING_ASTERISK)) && (ianjuta_iterable_compare (line_end, line_begin, NULL)) == 0) { ianjuta_editor_insert (editor, line_begin, comment_continued, -1, NULL); } /* In the middle of a comment we can't know * if the statement is incomplete */ *incomplete_statement = -1; /* ":" have to be ignored inside comments */ if (*colon_indent) { *colon_indent = FALSE; extra_indent -= INDENT_SIZE; } } g_object_unref (prev); g_object_unref (next); break; } else if (next_c == '/') { /* ends comment: */ comment_end = TRUE; g_object_unref (prev); g_object_unref (next); continue; } /* Possibly continued comment */ else if (isspace(prev_c)) { gboolean possible_comment = FALSE; while (ianjuta_iterable_previous (prev, NULL)) { prev_c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (prev), 0, NULL); if (!isspace(prev_c)) break; if (iter_is_newline (prev, prev_c)) { possible_comment = TRUE; break; } } if (possible_comment) { ianjuta_iterable_assign (new_iter, prev, NULL); g_object_unref (prev); g_object_unref (next); continue; } } g_object_unref (prev); g_object_unref (next); } } while (ianjuta_iterable_previous (new_iter, NULL)); if (comment) { ianjuta_iterable_assign (iter, new_iter, NULL); ianjuta_iterable_previous (iter, NULL); g_object_unref (new_iter); continue; } g_object_unref (new_iter); } if (point_ch == ')' || point_ch == ']' || point_ch == '}') { gint line_saved; line_saved = ianjuta_editor_get_line_from_position (editor, iter, NULL); /* If we encounter a block-end before anything else, the * statement could hardly be incomplte. */ if (point_ch == '}' && *incomplete_statement == -1) *incomplete_statement = 0; /* If at level 0 indentation, encoutered a * block end, don't bother going further */ if (point_ch == '}' && get_line_indentation (editor, line_saved) <= 0) { line_indent = 0; line_indent += extra_indent; break; } /* Find matching brace and continue */ if (!anjuta_util_jump_to_matching_brace (iter, point_ch, -1)) { line_indent = get_line_indentation (editor, line_saved); line_indent += extra_indent; break; } } else if (point_ch == '{') { gint line_for_indent = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line_for_indent); /* Increase line indentation */ line_indent += INDENT_SIZE; line_indent += extra_indent; /* If we encounter a block-start before anything else, the * statement could hardly be incomplte. */ if (point_ch == '{' && *incomplete_statement == -1) *incomplete_statement = 0; break; } else if (point_ch == '(' || point_ch == '[') { line_indent = 0; if (g_settings_get_boolean (plugin->settings, PREF_INDENT_PARENTHESIS_LINEUP)) { while (ianjuta_iterable_previous (iter, NULL)) { gchar dummy_ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); if (iter_is_newline (iter, dummy_ch)) { skip_iter_to_newline_head (iter, dummy_ch); break; } if (dummy_ch == '\t') line_indent += TAB_SIZE; else (*parenthesis_indentation)++; } (*parenthesis_indentation)++; line_indent += extra_indent; } else { gint line_for_indent = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line_for_indent); line_indent += extra_indent; (*parenthesis_indentation) += g_settings_get_int (plugin->settings, PREF_INDENT_PARENTHESIS_SIZE); } /* Although statement is incomplete at this point, we don't * set it to incomplete and just leave it to unknown to avaoid * increating indentation for it, because incomplete braces, * overrides any existing indentation */ *incomplete_statement = -1; break; } else if (point_ch == ';' || point_ch == ',') { /* If we encounter statement-end before any non-whitespace * char, the statement is complete. */ if (*incomplete_statement == -1) *incomplete_statement = 0; } else if (point_ch == ':' && *colon_indent == FALSE) { /* This is a forward reference, all lines below should have * increased indentation until the next statement has * a ':' * If current line indentation is zero, that we don't indent */ IAnjutaIterable* new_iter = ianjuta_iterable_clone (iter, NULL); IAnjutaIterable* line_begin; gboolean indent = FALSE; gchar c; /* Is the last non-whitespace in line */ while (ianjuta_iterable_next (new_iter, NULL)) { c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (new_iter), 0, NULL); if (!isspace(c)) break; if (iter_is_newline (new_iter, c)) { indent = TRUE; break; } } line_begin = ianjuta_editor_get_line_begin_position(editor, ianjuta_editor_get_line_from_position(editor, iter, NULL), NULL); c = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (line_begin), 0, NULL); if (indent) { *colon_indent = TRUE; if (*incomplete_statement == -1) *incomplete_statement = 0; } if (indent && isspace(c)) { extra_indent += INDENT_SIZE; } g_object_unref (new_iter); g_object_unref (line_begin); } else if (iter_is_newline (iter, point_ch)) { skip_iter_to_newline_head (iter, point_ch); /* We just crossed a line boundary. Skip any preprocessor lines, * and ensure that line_indent is updated with correct real * previous non-preprocessor line. */ if (skip_preprocessor_lines (editor, iter) && looking_at_just_next_line) { /* gint line = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line); */ } looking_at_just_next_line = FALSE; line_checked_for_comment = FALSE; } else if (!isspace (point_ch)) { /* If we encounter any non-whitespace char before any of the * statement-complete indicators, the statement is basically * incomplete */ if (*incomplete_statement == -1) *incomplete_statement = 1; } } if (!line_indent && extra_indent) { line_indent += extra_indent; } g_object_unref (iter); return line_indent; }
static gint get_line_indentation (IAnjutaEditor *editor, gint line_num) { IAnjutaIterable *line_begin, *line_end; gchar *line_string, *idx; gint line_indent = 0, left_braces = 0, right_braces = 0; gchar ch; line_end = ianjuta_editor_get_line_end_position (editor, line_num, NULL); /* Find first right brace going backwards from end of current line that is before a closing bracket */ while (ianjuta_iterable_previous (line_end, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (line_end), 0, NULL); if (ch == ')') { right_braces++; break; } else if (ch =='}') break; } /* Find the line which contains the left brace matching the right brace we found */ if (right_braces > 0) { while (ianjuta_iterable_previous (line_end, NULL) && right_braces > left_braces) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (line_end), 0, NULL); if (ch == ')') right_braces++; else if (ch == '(') left_braces++; } line_num = ianjuta_editor_get_line_from_position (editor, line_end, NULL); } g_object_unref (line_end); line_begin = ianjuta_editor_get_line_begin_position (editor, line_num, NULL); line_end = ianjuta_editor_get_line_end_position (editor, line_num, NULL); /* DEBUG_PRINT ("%s: line begin = %d, line end = %d", __FUNCTION__, line_begin, line_end); */ if (ianjuta_iterable_compare (line_begin, line_end, NULL) == 0) { g_object_unref (line_begin); g_object_unref (line_end); return 0; } line_string = ianjuta_editor_get_text (editor, line_begin, line_end, NULL); g_object_unref (line_begin); g_object_unref (line_end); /* DEBUG_PRINT ("line_string = '%s'", line_string); */ if (!line_string) return 0; idx = line_string; /* Find first non-white space */ while (*idx != '\0' && isspace (*idx)) { if (*idx == '\t') line_indent += TAB_SIZE; else line_indent++; idx++; /* Since we are looking for first non-space char, simple * increment of the utf8 chars would do */ } g_free (line_string); return line_indent; }
void cpp_java_indentation_char_added (IAnjutaEditor *editor, IAnjutaIterable *insert_pos, gchar ch, IndentCPlugin *plugin) { IAnjutaEditorAttribute attrib; IAnjutaIterable *iter; gboolean should_auto_indent = FALSE; iter = ianjuta_iterable_clone (insert_pos, NULL); /* If autoindent is enabled*/ if (plugin->smart_indentation) { /* DEBUG_PRINT ("Char added at position %d: '%c'", insert_pos, ch); */ if (iter_is_newline (iter, ch)) { skip_iter_to_newline_head (iter, ch); /* All newline entries means enable indenting */ should_auto_indent = TRUE; } else if (ch == '{' || ch == '}' || ch == '#') { /* Indent only when it's the first non-white space char in the line */ /* Don't bother if we are inside string */ attrib = ianjuta_editor_cell_get_attribute (IANJUTA_EDITOR_CELL (iter), NULL); if (attrib != IANJUTA_EDITOR_STRING) { /* Iterate backwards till the begining of the line and disable * indenting if any non-white space char is encountered */ /* Begin by assuming it should be indented */ should_auto_indent = TRUE; while (ianjuta_iterable_previous (iter, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); //DEBUG_PRINT ("Looking at char '%c'", ch); /* Break on begining of line (== end of previous line) */ if (iter_is_newline (iter, ch)) { skip_iter_to_newline_head (iter, ch); break; } /* If a non-white space char is encountered, disabled indenting */ if (!isspace (ch)) { should_auto_indent = FALSE; break; } } } } if (should_auto_indent) { gint insert_line; gint line_indent; gint parenthesis_indentation; ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT(editor), NULL); insert_line = ianjuta_editor_get_lineno (editor, NULL); line_indent = get_line_auto_indentation (plugin, editor, insert_line, &parenthesis_indentation); set_line_indentation (plugin, editor, insert_line, line_indent, parenthesis_indentation); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT(editor), NULL); } } if (g_settings_get_boolean (plugin->settings, PREF_BRACE_AUTOCOMPLETION)) { if (ch == '[' || ch == '(') { gchar *prev_char, *next_char; IAnjutaIterable *previous, *next, *next_end; previous = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_previous (previous, NULL); prev_char = ianjuta_editor_get_text (editor, previous, iter, NULL); next = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_next (next, NULL); next_end = ianjuta_iterable_clone (next, NULL); ianjuta_iterable_next (next_end, NULL); next_char = ianjuta_editor_get_text (editor, next, next_end, NULL); /* If the previous char is a ' we don't have to autocomplete, also we only autocomplete if the next character is white-space a closing bracket, "," or ";" */ if (*prev_char != '\'' && (g_ascii_isspace(*next_char) || is_closing_bracket (*next_char) || *next_char == ',' || *next_char == ';'|| *next_char == '\0')) { ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT (editor), NULL); ianjuta_iterable_next (iter, NULL); switch (ch) { case '[': insert_editor_blocked (editor, iter, "]", plugin); break; case '(': insert_editor_blocked (editor, iter, ")", plugin); break; default: break; } ianjuta_editor_goto_position (editor, iter, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT (editor), NULL); } g_object_unref (previous); } else if (ch == '"' || ch == '\'') { gchar *prev_char; IAnjutaIterable *previous; previous = ianjuta_iterable_clone (iter, NULL); ianjuta_iterable_previous (previous, NULL); prev_char = ianjuta_editor_get_text (editor, previous, iter, NULL); /* First iter*/ ianjuta_iterable_next (iter, NULL); /* * If the character is " we have to decide if we need insert * another " or we have to skip the character */ if (ch == '"' || ch == '\'') { /* * Now we have to detect if we want to manage " as a char */ if (*prev_char != '\'' && *prev_char != '\\') { gchar *c; if (ch == '"') c = g_strdup ("\""); else c = g_strdup ("'"); ianjuta_document_begin_undo_action (IANJUTA_DOCUMENT (editor), NULL); insert_editor_blocked (editor, iter, c, plugin); ianjuta_editor_goto_position (editor, iter, NULL); ianjuta_document_end_undo_action (IANJUTA_DOCUMENT (editor), NULL); g_free (c); } g_object_unref (previous); g_object_unref (iter); return; } g_object_unref (previous); } } g_object_unref (iter); }
static gint get_line_auto_indentation (IndentCPlugin *plugin, IAnjutaEditor *editor, gint line, gint *parenthesis_indentation) { IAnjutaIterable *iter; IAnjutaIterable *end_iter; gint line_indent = 0; gint incomplete_statement = -1; gboolean colon_indent = FALSE; g_return_val_if_fail (line > 0, 0); /* be sure to set a default if we're in the first line otherwise * the pointer'll be left hanging with no value. */ *parenthesis_indentation = 0; if (line == 1) /* First line */ { return 0; } else { IAnjutaIterable* begin = ianjuta_editor_get_line_begin_position (editor, line -1 , NULL); IAnjutaIterable* end = ianjuta_editor_get_line_end_position (editor, line -1 , NULL); if (spaces_only (editor, begin, end)) { set_line_indentation (plugin, editor, line -1, 0, 0); } g_object_unref (begin); g_object_unref (end); } iter = ianjuta_editor_get_line_begin_position (editor, line, NULL); if (is_iter_inside_string (iter)) { line_indent = get_line_indentation (editor, line - 1); } else { line_indent = get_line_indentation_base (plugin, editor, line, &incomplete_statement, parenthesis_indentation, &colon_indent); } if (colon_indent) { /* If the last non-whitespace character in the line is ":" then * we remove the extra colon_indent */ end_iter = ianjuta_editor_get_line_end_position (editor, line, NULL); gchar ch; while (ianjuta_iterable_previous (end_iter, NULL)) { ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (end_iter), 0, NULL); if (ch == ':') { line_indent -= INDENT_SIZE; break; } if (!isspace(ch) || iter_is_newline (end_iter, ch)) break; } g_object_unref (end_iter); } /* Determine what the first non-white char in the line is */ do { gchar ch; /* Check if we are *inside* comment or string. Begining of comment * or string does not count as inside. If inside, just align with * previous indentation. */ if (is_iter_inside_string (iter)) { line_indent = get_line_indentation (editor, line - 1); break; } ch = ianjuta_editor_cell_get_char (IANJUTA_EDITOR_CELL (iter), 0, NULL); if (iter_is_newline (iter, ch)) { skip_iter_to_newline_tail (iter, ch); /* First levels are excused from incomplete statement indent */ if (incomplete_statement == 1 && line_indent > 0) line_indent += INDENT_SIZE; break; } if (ch == '{') { if (line_indent > 0) { /* The first level braces are excused from brace indentation */ /* DEBUG_PRINT ("Increasing indent level from %d to %d", line_indent, line_indent + BRACE_INDENT); */ line_indent += BRACE_INDENT; /* It looks ugly to add extra indent after case: so remove that */ if (colon_indent) line_indent -= INDENT_SIZE; } break; } else if (ch == '}') { ianjuta_iterable_previous (iter, NULL); if (anjuta_util_jump_to_matching_brace (iter, ch, -1)) { gint line = ianjuta_editor_get_line_from_position (editor, iter, NULL); line_indent = get_line_indentation (editor, line); } break; } else if (ch == '#') { line_indent = 0; *parenthesis_indentation = 0; } else if (!isspace (ch)) { /* First levels are excused from incomplete statement indent */ if (incomplete_statement == 1 && line_indent > 0) line_indent += INDENT_SIZE; break; } } while (ianjuta_iterable_next (iter, NULL)); g_object_unref (iter); return line_indent; }
static void iprovider_populate (IAnjutaProvider *obj, IAnjutaIterable* iter, GError **err) { static GList *trash = NULL; JSLang *plugin = (JSLang*)obj; if (plugin->last) { g_object_unref (plugin->last); } plugin->last = ianjuta_iterable_clone(iter, NULL); if (!plugin->current_editor) return; gint depth; GList *suggestions = NULL; gchar *str = code_completion_get_str (IANJUTA_EDITOR (plugin->current_editor), FALSE); if (trash) { g_list_foreach (trash, (GFunc)g_free, NULL); g_list_free (trash); trash = NULL; } if (!str) return; g_assert (plugin->prefs); if (strlen (str) < g_settings_get_int (plugin->prefs, MIN_CODECOMPLETE)) { ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, NULL, TRUE, NULL); return; } gchar *file = file_completion (IANJUTA_EDITOR (plugin->current_editor), &depth); gint i; DEBUG_PRINT ("JSLang: Auto complete for %s (TMFILE=%s)", str, file); for (i = strlen (str) - 1; i; i--) { if (str[i] == '.') break; } if (i > 0) { suggestions = code_completion_get_list (plugin, file, g_strndup (str, i), depth); } else suggestions = code_completion_get_list (plugin, file, NULL, depth); if (suggestions) { GList *nsuggest = NULL; gint k; if (i > 0) { suggestions = filter_list (suggestions, str + i + 1); k = strlen (str + i + 1); } else { suggestions = filter_list (suggestions, str); k = strlen (str); } GList *i; for (; k > 0; k--) ianjuta_iterable_previous (plugin->last, NULL); for (i = suggestions; i; i = g_list_next(i)) { IAnjutaEditorAssistProposal* proposal = g_new0(IAnjutaEditorAssistProposal, 1); if (!i->data) continue; proposal->label = i->data; proposal->data = i->data; nsuggest = g_list_prepend (nsuggest, proposal); } ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, nsuggest, TRUE, NULL); g_list_free (nsuggest); trash = suggestions; return; } ianjuta_editor_assist_proposals ( IANJUTA_EDITOR_ASSIST (plugin->current_editor), obj, NULL, TRUE, NULL); }