--- /dev/null
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved by Bram Moolenaar
+ *
+ * Do ":help uganda" in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * cindent.c: C indentation related functions
+ *
+ * Many of C-indenting functions originally come from Eric Fischer.
+ *
+ * Below "XXX" means that this function may unlock the current line.
+ */
+
+#include "vim.h"
+
+// values for the "lookfor" state
+#define LOOKFOR_INITIAL 0
+#define LOOKFOR_IF 1
+#define LOOKFOR_DO 2
+#define LOOKFOR_CASE 3
+#define LOOKFOR_ANY 4
+#define LOOKFOR_TERM 5
+#define LOOKFOR_UNTERM 6
+#define LOOKFOR_SCOPEDECL 7
+#define LOOKFOR_NOBREAK 8
+#define LOOKFOR_CPP_BASECLASS 9
+#define LOOKFOR_ENUM_OR_INIT 10
+#define LOOKFOR_JS_KEY 11
+#define LOOKFOR_COMMA 12
+
+#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT)
+/*
+ * Return TRUE if the string "line" starts with a word from 'cinwords'.
+ */
+ int
+cin_is_cinword(char_u *line)
+{
+ char_u *cinw;
+ char_u *cinw_buf;
+ int cinw_len;
+ int retval = FALSE;
+ int len;
+
+ cinw_len = (int)STRLEN(curbuf->b_p_cinw) + 1;
+ cinw_buf = alloc(cinw_len);
+ if (cinw_buf != NULL)
+ {
+ line = skipwhite(line);
+ for (cinw = curbuf->b_p_cinw; *cinw; )
+ {
+ len = copy_option_part(&cinw, cinw_buf, cinw_len, ",");
+ if (STRNCMP(line, cinw_buf, len) == 0
+ && (!vim_iswordc(line[len]) || !vim_iswordc(line[len - 1])))
+ {
+ retval = TRUE;
+ break;
+ }
+ }
+ vim_free(cinw_buf);
+ }
+ return retval;
+}
+#endif
+
+#if defined(FEAT_CINDENT) || defined(FEAT_SYN_HL)
+
+/*
+ * Skip to the end of a "string" and a 'c' character.
+ * If there is no string or character, return argument unmodified.
+ */
+ static char_u *
+skip_string(char_u *p)
+{
+ int i;
+
+ // We loop, because strings may be concatenated: "date""time".
+ for ( ; ; ++p)
+ {
+ if (p[0] == '\'') // 'c' or '\n' or '\000'
+ {
+ if (!p[1]) // ' at end of line
+ break;
+ i = 2;
+ if (p[1] == '\\') // '\n' or '\000'
+ {
+ ++i;
+ while (vim_isdigit(p[i - 1])) // '\000'
+ ++i;
+ }
+ if (p[i] == '\'') // check for trailing '
+ {
+ p += i;
+ continue;
+ }
+ }
+ else if (p[0] == '"') // start of string
+ {
+ for (++p; p[0]; ++p)
+ {
+ if (p[0] == '\\' && p[1] != NUL)
+ ++p;
+ else if (p[0] == '"') // end of string
+ break;
+ }
+ if (p[0] == '"')
+ continue; // continue for another string
+ }
+ else if (p[0] == 'R' && p[1] == '"')
+ {
+ // Raw string: R"[delim](...)[delim]"
+ char_u *delim = p + 2;
+ char_u *paren = vim_strchr(delim, '(');
+
+ if (paren != NULL)
+ {
+ size_t delim_len = paren - delim;
+
+ for (p += 3; *p; ++p)
+ if (p[0] == ')' && STRNCMP(p + 1, delim, delim_len) == 0
+ && p[delim_len + 1] == '"')
+ {
+ p += delim_len + 1;
+ break;
+ }
+ if (p[0] == '"')
+ continue; // continue for another string
+ }
+ }
+ break; // no string found
+ }
+ if (!*p)
+ --p; // backup from NUL
+ return p;
+}
+
+/*
+ * Find the start of a comment, not knowing if we are in a comment right now.
+ * Search starts at w_cursor.lnum and goes backwards.
+ * Return NULL when not inside a comment.
+ */
+ static pos_T *
+ind_find_start_comment(void) // XXX
+{
+ return find_start_comment(curbuf->b_ind_maxcomment);
+}
+
+ pos_T *
+find_start_comment(int ind_maxcomment) // XXX
+{
+ pos_T *pos;
+ char_u *line;
+ char_u *p;
+ int cur_maxcomment = ind_maxcomment;
+
+ for (;;)
+ {
+ pos = findmatchlimit(NULL, '*', FM_BACKWARD, cur_maxcomment);
+ if (pos == NULL)
+ break;
+
+ // Check if the comment start we found is inside a string.
+ // If it is then restrict the search to below this line and try again.
+ line = ml_get(pos->lnum);
+ for (p = line; *p && (colnr_T)(p - line) < pos->col; ++p)
+ p = skip_string(p);
+ if ((colnr_T)(p - line) <= pos->col)
+ break;
+ cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
+ if (cur_maxcomment <= 0)
+ {
+ pos = NULL;
+ break;
+ }
+ }
+ return pos;
+}
+
+/*
+ * Find the start of a raw string, not knowing if we are in one right now.
+ * Search starts at w_cursor.lnum and goes backwards.
+ * Return NULL when not inside a raw string.
+ */
+ static pos_T *
+find_start_rawstring(int ind_maxcomment) // XXX
+{
+ pos_T *pos;
+ char_u *line;
+ char_u *p;
+ int cur_maxcomment = ind_maxcomment;
+
+ for (;;)
+ {
+ pos = findmatchlimit(NULL, 'R', FM_BACKWARD, cur_maxcomment);
+ if (pos == NULL)
+ break;
+
+ // Check if the raw string start we found is inside a string.
+ // If it is then restrict the search to below this line and try again.
+ line = ml_get(pos->lnum);
+ for (p = line; *p && (colnr_T)(p - line) < pos->col; ++p)
+ p = skip_string(p);
+ if ((colnr_T)(p - line) <= pos->col)
+ break;
+ cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
+ if (cur_maxcomment <= 0)
+ {
+ pos = NULL;
+ break;
+ }
+ }
+ return pos;
+}
+
+/*
+ * Find the start of a comment or raw string, not knowing if we are in a
+ * comment or raw string right now.
+ * Search starts at w_cursor.lnum and goes backwards.
+ * If is_raw is given and returns start of raw_string, sets it to true.
+ * Return NULL when not inside a comment or raw string.
+ * "CORS" -> Comment Or Raw String
+ */
+ static pos_T *
+ind_find_start_CORS(linenr_T *is_raw) // XXX
+{
+ static pos_T comment_pos_copy;
+ pos_T *comment_pos;
+ pos_T *rs_pos;
+
+ comment_pos = find_start_comment(curbuf->b_ind_maxcomment);
+ if (comment_pos != NULL)
+ {
+ // Need to make a copy of the static pos in findmatchlimit(),
+ // calling find_start_rawstring() may change it.
+ comment_pos_copy = *comment_pos;
+ comment_pos = &comment_pos_copy;
+ }
+ rs_pos = find_start_rawstring(curbuf->b_ind_maxcomment);
+
+ // If comment_pos is before rs_pos the raw string is inside the comment.
+ // If rs_pos is before comment_pos the comment is inside the raw string.
+ if (comment_pos == NULL || (rs_pos != NULL
+ && LT_POS(*rs_pos, *comment_pos)))
+ {
+ if (is_raw != NULL && rs_pos != NULL)
+ *is_raw = rs_pos->lnum;
+ return rs_pos;
+ }
+ return comment_pos;
+}
+#endif // FEAT_CINDENT || FEAT_SYN_HL
+
+#if defined(FEAT_CINDENT) || defined(PROTO)
+
+/*
+ * Return TRUE if C-indenting is on.
+ */
+ int
+cindent_on(void)
+{
+ return (!p_paste && (curbuf->b_p_cin
+# ifdef FEAT_EVAL
+ || *curbuf->b_p_inde != NUL
+# endif
+ ));
+}
+
+// Find result cache for cpp_baseclass
+typedef struct {
+ int found;
+ lpos_T lpos;
+} cpp_baseclass_cache_T;
+
+/*
+ * Skip over white space and C comments within the line.
+ * Also skip over Perl/shell comments if desired.
+ */
+ static char_u *
+cin_skipcomment(char_u *s)
+{
+ while (*s)
+ {
+ char_u *prev_s = s;
+
+ s = skipwhite(s);
+
+ // Perl/shell # comment comment continues until eol. Require a space
+ // before # to avoid recognizing $#array.
+ if (curbuf->b_ind_hash_comment != 0 && s != prev_s && *s == '#')
+ {
+ s += STRLEN(s);
+ break;
+ }
+ if (*s != '/')
+ break;
+ ++s;
+ if (*s == '/') // slash-slash comment continues till eol
+ {
+ s += STRLEN(s);
+ break;
+ }
+ if (*s != '*')
+ break;
+ for (++s; *s; ++s) // skip slash-star comment
+ if (s[0] == '*' && s[1] == '/')
+ {
+ s += 2;
+ break;
+ }
+ }
+ return s;
+}
+
+/*
+ * Return TRUE if there is no code at *s. White space and comments are
+ * not considered code.
+ */
+ static int
+cin_nocode(char_u *s)
+{
+ return *cin_skipcomment(s) == NUL;
+}
+
+/*
+ * Recognize the start of a C or C++ comment.
+ */
+ static int
+cin_iscomment(char_u *p)
+{
+ return (p[0] == '/' && (p[1] == '*' || p[1] == '/'));
+}
+
+/*
+ * Recognize the start of a "//" comment.
+ */
+ static int
+cin_islinecomment(char_u *p)
+{
+ return (p[0] == '/' && p[1] == '/');
+}
+
+/*
+ * Check previous lines for a "//" line comment, skipping over blank lines.
+ */
+ static pos_T *
+find_line_comment(void) // XXX
+{
+ static pos_T pos;
+ char_u *line;
+ char_u *p;
+
+ pos = curwin->w_cursor;
+ while (--pos.lnum > 0)
+ {
+ line = ml_get(pos.lnum);
+ p = skipwhite(line);
+ if (cin_islinecomment(p))
+ {
+ pos.col = (int)(p - line);
+ return &pos;
+ }
+ if (*p != NUL)
+ break;
+ }
+ return NULL;
+}
+
+/*
+ * Return TRUE if "text" starts with "key:".
+ */
+ static int
+cin_has_js_key(char_u *text)
+{
+ char_u *s = skipwhite(text);
+ int quote = -1;
+
+ if (*s == '\'' || *s == '"')
+ {
+ // can be 'key': or "key":
+ quote = *s;
+ ++s;
+ }
+ if (!vim_isIDc(*s)) // need at least one ID character
+ return FALSE;
+
+ while (vim_isIDc(*s))
+ ++s;
+ if (*s == quote)
+ ++s;
+
+ s = cin_skipcomment(s);
+
+ // "::" is not a label, it's C++
+ return (*s == ':' && s[1] != ':');
+}
+
+/*
+ * Check if string matches "label:"; move to character after ':' if true.
+ * "*s" must point to the start of the label, if there is one.
+ */
+ static int
+cin_islabel_skip(char_u **s)
+{
+ if (!vim_isIDc(**s)) // need at least one ID character
+ return FALSE;
+
+ while (vim_isIDc(**s))
+ (*s)++;
+
+ *s = cin_skipcomment(*s);
+
+ // "::" is not a label, it's C++
+ return (**s == ':' && *++*s != ':');
+}
+
+/*
+ * Recognize a "public/private/protected" scope declaration label.
+ */
+ static int
+cin_isscopedecl(char_u *s)
+{
+ int i;
+
+ s = cin_skipcomment(s);
+ if (STRNCMP(s, "public", 6) == 0)
+ i = 6;
+ else if (STRNCMP(s, "protected", 9) == 0)
+ i = 9;
+ else if (STRNCMP(s, "private", 7) == 0)
+ i = 7;
+ else
+ return FALSE;
+ return (*(s = cin_skipcomment(s + i)) == ':' && s[1] != ':');
+}
+
+/*
+ * Recognize a preprocessor statement: Any line that starts with '#'.
+ */
+ static int
+cin_ispreproc(char_u *s)
+{
+ if (*skipwhite(s) == '#')
+ return TRUE;
+ return FALSE;
+}
+
+/*
+ * Return TRUE if line "*pp" at "*lnump" is a preprocessor statement or a
+ * continuation line of a preprocessor statement. Decrease "*lnump" to the
+ * start and return the line in "*pp".
+ * Put the amount of indent in "*amount".
+ */
+ static int
+cin_ispreproc_cont(char_u **pp, linenr_T *lnump, int *amount)
+{
+ char_u *line = *pp;
+ linenr_T lnum = *lnump;
+ int retval = FALSE;
+ int candidate_amount = *amount;
+
+ if (*line != NUL && line[STRLEN(line) - 1] == '\\')
+ candidate_amount = get_indent_lnum(lnum);
+
+ for (;;)
+ {
+ if (cin_ispreproc(line))
+ {
+ retval = TRUE;
+ *lnump = lnum;
+ break;
+ }
+ if (lnum == 1)
+ break;
+ line = ml_get(--lnum);
+ if (*line == NUL || line[STRLEN(line) - 1] != '\\')
+ break;
+ }
+
+ if (lnum != *lnump)
+ *pp = ml_get(*lnump);
+ if (retval)
+ *amount = candidate_amount;
+ return retval;
+}
+
+ static int
+cin_iselse(
+ char_u *p)
+{
+ if (*p == '}') // accept "} else"
+ p = cin_skipcomment(p + 1);
+ return (STRNCMP(p, "else", 4) == 0 && !vim_isIDc(p[4]));
+}
+
+/*
+ * Recognize a line that starts with '{' or '}', or ends with ';', ',', '{' or
+ * '}'.
+ * Don't consider "} else" a terminated line.
+ * If a line begins with an "else", only consider it terminated if no unmatched
+ * opening braces follow (handle "else { foo();" correctly).
+ * Return the character terminating the line (ending char's have precedence if
+ * both apply in order to determine initializations).
+ */
+ static int
+cin_isterminated(
+ char_u *s,
+ int incl_open, // include '{' at the end as terminator
+ int incl_comma) // recognize a trailing comma
+{
+ char_u found_start = 0;
+ unsigned n_open = 0;
+ int is_else = FALSE;
+
+ s = cin_skipcomment(s);
+
+ if (*s == '{' || (*s == '}' && !cin_iselse(s)))
+ found_start = *s;
+
+ if (!found_start)
+ is_else = cin_iselse(s);
+
+ while (*s)
+ {
+ // skip over comments, "" strings and 'c'haracters
+ s = skip_string(cin_skipcomment(s));
+ if (*s == '}' && n_open > 0)
+ --n_open;
+ if ((!is_else || n_open == 0)
+ && (*s == ';' || *s == '}' || (incl_comma && *s == ','))
+ && cin_nocode(s + 1))
+ return *s;
+ else if (*s == '{')
+ {
+ if (incl_open && cin_nocode(s + 1))
+ return *s;
+ else
+ ++n_open;
+ }
+
+ if (*s)
+ s++;
+ }
+ return found_start;
+}
+
+/*
+ * Return TRUE when "s" starts with "word" and then a non-ID character.
+ */
+ static int
+cin_starts_with(char_u *s, char *word)
+{
+ int l = (int)STRLEN(word);
+
+ return (STRNCMP(s, word, l) == 0 && !vim_isIDc(s[l]));
+}
+
+/*
+ * Recognize a "default" switch label.
+ */
+ static int
+cin_isdefault(char_u *s)
+{
+ return (STRNCMP(s, "default", 7) == 0
+ && *(s = cin_skipcomment(s + 7)) == ':'
+ && s[1] != ':');
+}
+
+/*
+ * Recognize a switch label: "case .*:" or "default:".
+ */
+ static int
+cin_iscase(
+ char_u *s,
+ int strict) // Allow relaxed check of case statement for JS
+{
+ s = cin_skipcomment(s);
+ if (cin_starts_with(s, "case"))
+ {
+ for (s += 4; *s; ++s)
+ {
+ s = cin_skipcomment(s);
+ if (*s == ':')
+ {
+ if (s[1] == ':') // skip over "::" for C++
+ ++s;
+ else
+ return TRUE;
+ }
+ if (*s == '\'' && s[1] && s[2] == '\'')
+ s += 2; // skip over ':'
+ else if (*s == '/' && (s[1] == '*' || s[1] == '/'))
+ return FALSE; // stop at comment
+ else if (*s == '"')
+ {
+ // JS etc.
+ if (strict)
+ return FALSE; // stop at string
+ else
+ return TRUE;
+ }
+ }
+ return FALSE;
+ }
+
+ if (cin_isdefault(s))
+ return TRUE;
+ return FALSE;
+}
+
+/*
+ * Recognize a label: "label:".
+ * Note: curwin->w_cursor must be where we are looking for the label.
+ */
+ static int
+cin_islabel(void) // XXX
+{
+ char_u *s;
+
+ s = cin_skipcomment(ml_get_curline());
+
+ // Exclude "default" from labels, since it should be indented
+ // like a switch label. Same for C++ scope declarations.
+ if (cin_isdefault(s))
+ return FALSE;
+ if (cin_isscopedecl(s))
+ return FALSE;
+
+ if (cin_islabel_skip(&s))
+ {
+ // Only accept a label if the previous line is terminated or is a case
+ // label.
+ pos_T cursor_save;
+ pos_T *trypos;
+ char_u *line;
+
+ cursor_save = curwin->w_cursor;
+ while (curwin->w_cursor.lnum > 1)
+ {
+ --curwin->w_cursor.lnum;
+
+ // If we're in a comment or raw string now, skip to the start of
+ // it.
+ curwin->w_cursor.col = 0;
+ if ((trypos = ind_find_start_CORS(NULL)) != NULL) // XXX
+ curwin->w_cursor = *trypos;
+
+ line = ml_get_curline();
+ if (cin_ispreproc(line)) // ignore #defines, #if, etc.
+ continue;
+ if (*(line = cin_skipcomment(line)) == NUL)
+ continue;
+
+ curwin->w_cursor = cursor_save;
+ if (cin_isterminated(line, TRUE, FALSE)
+ || cin_isscopedecl(line)
+ || cin_iscase(line, TRUE)
+ || (cin_islabel_skip(&line) && cin_nocode(line)))
+ return TRUE;
+ return FALSE;
+ }
+ curwin->w_cursor = cursor_save;
+ return TRUE; // label at start of file???
+ }
+ return FALSE;
+}
+
+/*
+ * Return TRUE if string "s" ends with the string "find", possibly followed by
+ * white space and comments. Skip strings and comments.
+ * Ignore "ignore" after "find" if it's not NULL.
+ */
+ static int
+cin_ends_in(char_u *s, char_u *find, char_u *ignore)
+{
+ char_u *p = s;
+ char_u *r;
+ int len = (int)STRLEN(find);
+
+ while (*p != NUL)
+ {
+ p = cin_skipcomment(p);
+ if (STRNCMP(p, find, len) == 0)
+ {
+ r = skipwhite(p + len);
+ if (ignore != NULL && STRNCMP(r, ignore, STRLEN(ignore)) == 0)
+ r = skipwhite(r + STRLEN(ignore));
+ if (cin_nocode(r))
+ return TRUE;
+ }
+ if (*p != NUL)
+ ++p;
+ }
+ return FALSE;
+}
+
+/*
+ * Recognize structure initialization and enumerations:
+ * "[typedef] [static|public|protected|private] enum"
+ * "[typedef] [static|public|protected|private] = {"
+ */
+ static int
+cin_isinit(void)
+{
+ char_u *s;
+ static char *skip[] = {"static", "public", "protected", "private"};
+
+ s = cin_skipcomment(ml_get_curline());
+
+ if (cin_starts_with(s, "typedef"))
+ s = cin_skipcomment(s + 7);
+
+ for (;;)
+ {
+ int i, l;
+
+ for (i = 0; i < (int)(sizeof(skip) / sizeof(char *)); ++i)
+ {
+ l = (int)strlen(skip[i]);
+ if (cin_starts_with(s, skip[i]))
+ {
+ s = cin_skipcomment(s + l);
+ l = 0;
+ break;
+ }
+ }
+ if (l != 0)
+ break;
+ }
+
+ if (cin_starts_with(s, "enum"))
+ return TRUE;
+
+ if (cin_ends_in(s, (char_u *)"=", (char_u *)"{"))
+ return TRUE;
+
+ return FALSE;
+}
+
+// Maximum number of lines to search back for a "namespace" line.
+#define FIND_NAMESPACE_LIM 20
+
+/*
+ * Recognize a "namespace" scope declaration.
+ */
+ static int
+cin_is_cpp_namespace(char_u *s)
+{
+ char_u *p;
+ int has_name = FALSE;
+ int has_name_start = FALSE;
+
+ s = cin_skipcomment(s);
+ if (STRNCMP(s, "namespace", 9) == 0 && (s[9] == NUL || !vim_iswordc(s[9])))
+ {
+ p = cin_skipcomment(skipwhite(s + 9));
+ while (*p != NUL)
+ {
+ if (VIM_ISWHITE(*p))
+ {
+ has_name = TRUE; // found end of a name
+ p = cin_skipcomment(skipwhite(p));
+ }
+ else if (*p == '{')
+ {
+ break;
+ }
+ else if (vim_iswordc(*p))
+ {
+ has_name_start = TRUE;
+ if (has_name)
+ return FALSE; // word character after skipping past name
+ ++p;
+ }
+ else if (p[0] == ':' && p[1] == ':' && vim_iswordc(p[2]))
+ {
+ if (!has_name_start || has_name)
+ return FALSE;
+ // C++ 17 nested namespace
+ p += 3;
+ }
+ else
+ {
+ return FALSE;
+ }
+ }
+ return TRUE;
+ }
+ return FALSE;
+}
+
+/*
+ * Recognize a `extern "C"` or `extern "C++"` linkage specifications.
+ */
+ static int
+cin_is_cpp_extern_c(char_u *s)
+{
+ char_u *p;
+ int has_string_literal = FALSE;
+
+ s = cin_skipcomment(s);
+ if (STRNCMP(s, "extern", 6) == 0 && (s[6] == NUL || !vim_iswordc(s[6])))
+ {
+ p = cin_skipcomment(skipwhite(s + 6));
+ while (*p != NUL)
+ {
+ if (VIM_ISWHITE(*p))
+ {
+ p = cin_skipcomment(skipwhite(p));
+ }
+ else if (*p == '{')
+ {
+ break;
+ }
+ else if (p[0] == '"' && p[1] == 'C' && p[2] == '"')
+ {
+ if (has_string_literal)
+ return FALSE;
+ has_string_literal = TRUE;
+ p += 3;
+ }
+ else if (p[0] == '"' && p[1] == 'C' && p[2] == '+' && p[3] == '+'
+ && p[4] == '"')
+ {
+ if (has_string_literal)
+ return FALSE;
+ has_string_literal = TRUE;
+ p += 5;
+ }
+ else
+ {
+ return FALSE;
+ }
+ }
+ return has_string_literal ? TRUE : FALSE;
+ }
+ return FALSE;
+}
+
+/*
+ * Return a pointer to the first non-empty non-comment character after a ':'.
+ * Return NULL if not found.
+ * case 234: a = b;
+ * ^
+ */
+ static char_u *
+after_label(char_u *l)
+{
+ for ( ; *l; ++l)
+ {
+ if (*l == ':')
+ {
+ if (l[1] == ':') // skip over "::" for C++
+ ++l;
+ else if (!cin_iscase(l + 1, FALSE))
+ break;
+ }
+ else if (*l == '\'' && l[1] && l[2] == '\'')
+ l += 2; // skip over 'x'
+ }
+ if (*l == NUL)
+ return NULL;
+ l = cin_skipcomment(l + 1);
+ if (*l == NUL)
+ return NULL;
+ return l;
+}
+
+/*
+ * Get indent of line "lnum", skipping a label.
+ * Return 0 if there is nothing after the label.
+ */
+ static int
+get_indent_nolabel (linenr_T lnum) // XXX
+{
+ char_u *l;
+ pos_T fp;
+ colnr_T col;
+ char_u *p;
+
+ l = ml_get(lnum);
+ p = after_label(l);
+ if (p == NULL)
+ return 0;
+
+ fp.col = (colnr_T)(p - l);
+ fp.lnum = lnum;
+ getvcol(curwin, &fp, &col, NULL, NULL);
+ return (int)col;
+}
+
+/*
+ * Find indent for line "lnum", ignoring any case or jump label.
+ * Also return a pointer to the text (after the label) in "pp".
+ * label: if (asdf && asdfasdf)
+ * ^
+ */
+ static int
+skip_label(linenr_T lnum, char_u **pp)
+{
+ char_u *l;
+ int amount;
+ pos_T cursor_save;
+
+ cursor_save = curwin->w_cursor;
+ curwin->w_cursor.lnum = lnum;
+ l = ml_get_curline();
+ // XXX
+ if (cin_iscase(l, FALSE) || cin_isscopedecl(l) || cin_islabel())
+ {
+ amount = get_indent_nolabel(lnum);
+ l = after_label(ml_get_curline());
+ if (l == NULL) // just in case
+ l = ml_get_curline();
+ }
+ else
+ {
+ amount = get_indent();
+ l = ml_get_curline();
+ }
+ *pp = l;
+
+ curwin->w_cursor = cursor_save;
+ return amount;
+}
+
+/*
+ * Return the indent of the first variable name after a type in a declaration.
+ * int a, indent of "a"
+ * static struct foo b, indent of "b"
+ * enum bla c, indent of "c"
+ * Returns zero when it doesn't look like a declaration.
+ */
+ static int
+cin_first_id_amount(void)
+{
+ char_u *line, *p, *s;
+ int len;
+ pos_T fp;
+ colnr_T col;
+
+ line = ml_get_curline();
+ p = skipwhite(line);
+ len = (int)(skiptowhite(p) - p);
+ if (len == 6 && STRNCMP(p, "static", 6) == 0)
+ {
+ p = skipwhite(p + 6);
+ len = (int)(skiptowhite(p) - p);
+ }
+ if (len == 6 && STRNCMP(p, "struct", 6) == 0)
+ p = skipwhite(p + 6);
+ else if (len == 4 && STRNCMP(p, "enum", 4) == 0)
+ p = skipwhite(p + 4);
+ else if ((len == 8 && STRNCMP(p, "unsigned", 8) == 0)
+ || (len == 6 && STRNCMP(p, "signed", 6) == 0))
+ {
+ s = skipwhite(p + len);
+ if ((STRNCMP(s, "int", 3) == 0 && VIM_ISWHITE(s[3]))
+ || (STRNCMP(s, "long", 4) == 0 && VIM_ISWHITE(s[4]))
+ || (STRNCMP(s, "short", 5) == 0 && VIM_ISWHITE(s[5]))
+ || (STRNCMP(s, "char", 4) == 0 && VIM_ISWHITE(s[4])))
+ p = s;
+ }
+ for (len = 0; vim_isIDc(p[len]); ++len)
+ ;
+ if (len == 0 || !VIM_ISWHITE(p[len]) || cin_nocode(p))
+ return 0;
+
+ p = skipwhite(p + len);
+ fp.lnum = curwin->w_cursor.lnum;
+ fp.col = (colnr_T)(p - line);
+ getvcol(curwin, &fp, &col, NULL, NULL);
+ return (int)col;
+}
+
+/*
+ * Return the indent of the first non-blank after an equal sign.
+ * char *foo = "here";
+ * Return zero if no (useful) equal sign found.
+ * Return -1 if the line above "lnum" ends in a backslash.
+ * foo = "asdf\
+ * asdf\
+ * here";
+ */
+ static int
+cin_get_equal_amount(linenr_T lnum)
+{
+ char_u *line;
+ char_u *s;
+ colnr_T col;
+ pos_T fp;
+
+ if (lnum > 1)
+ {
+ line = ml_get(lnum - 1);
+ if (*line != NUL && line[STRLEN(line) - 1] == '\\')
+ return -1;
+ }
+
+ line = s = ml_get(lnum);
+ while (*s != NUL && vim_strchr((char_u *)"=;{}\"'", *s) == NULL)
+ {
+ if (cin_iscomment(s)) // ignore comments
+ s = cin_skipcomment(s);
+ else
+ ++s;
+ }
+ if (*s != '=')
+ return 0;
+
+ s = skipwhite(s + 1);
+ if (cin_nocode(s))
+ return 0;
+
+ if (*s == '"') // nice alignment for continued strings
+ ++s;
+
+ fp.lnum = lnum;
+ fp.col = (colnr_T)(s - line);
+ getvcol(curwin, &fp, &col, NULL, NULL);
+ return (int)col;
+}
+
+/*
+ * Skip strings, chars and comments until at or past "trypos".
+ * Return the column found.
+ */
+ static int
+cin_skip2pos(pos_T *trypos)
+{
+ char_u *line;
+ char_u *p;
+ char_u *new_p;
+
+ p = line = ml_get(trypos->lnum);
+ while (*p && (colnr_T)(p - line) < trypos->col)
+ {
+ if (cin_iscomment(p))
+ p = cin_skipcomment(p);
+ else
+ {
+ new_p = skip_string(p);
+ if (new_p == p)
+ ++p;
+ else
+ p = new_p;
+ }
+ }
+ return (int)(p - line);
+}
+
+ static pos_T *
+find_match_char(int c, int ind_maxparen) // XXX
+{
+ pos_T cursor_save;
+ pos_T *trypos;
+ static pos_T pos_copy;
+ int ind_maxp_wk;
+
+ cursor_save = curwin->w_cursor;
+ ind_maxp_wk = ind_maxparen;
+retry:
+ if ((trypos = findmatchlimit(NULL, c, 0, ind_maxp_wk)) != NULL)
+ {
+ // check if the ( is in a // comment
+ if ((colnr_T)cin_skip2pos(trypos) > trypos->col)
+ {
+ ind_maxp_wk = ind_maxparen - (int)(cursor_save.lnum - trypos->lnum);
+ if (ind_maxp_wk > 0)
+ {
+ curwin->w_cursor = *trypos;
+ curwin->w_cursor.col = 0; // XXX
+ goto retry;
+ }
+ trypos = NULL;
+ }
+ else
+ {
+ pos_T *trypos_wk;
+
+ pos_copy = *trypos; // copy trypos, findmatch will change it
+ trypos = &pos_copy;
+ curwin->w_cursor = *trypos;
+ if ((trypos_wk = ind_find_start_CORS(NULL)) != NULL) // XXX
+ {
+ ind_maxp_wk = ind_maxparen - (int)(cursor_save.lnum
+ - trypos_wk->lnum);
+ if (ind_maxp_wk > 0)
+ {
+ curwin->w_cursor = *trypos_wk;
+ goto retry;
+ }
+ trypos = NULL;
+ }
+ }
+ }
+ curwin->w_cursor = cursor_save;
+ return trypos;
+}
+
+/*
+ * Find the matching '(', ignoring it if it is in a comment.
+ * Return NULL if no match found.
+ */
+ static pos_T *
+find_match_paren(int ind_maxparen) // XXX
+{
+ return find_match_char('(', ind_maxparen);
+}
+
+/*
+ * Set w_cursor.col to the column number of the last unmatched ')' or '{' in
+ * line "l". "l" must point to the start of the line.
+ */
+ static int
+find_last_paren(char_u *l, int start, int end)
+{
+ int i;
+ int retval = FALSE;
+ int open_count = 0;
+
+ curwin->w_cursor.col = 0; // default is start of line
+
+ for (i = 0; l[i] != NUL; i++)
+ {
+ i = (int)(cin_skipcomment(l + i) - l); // ignore parens in comments
+ i = (int)(skip_string(l + i) - l); // ignore parens in quotes
+ if (l[i] == start)
+ ++open_count;
+ else if (l[i] == end)
+ {
+ if (open_count > 0)
+ --open_count;
+ else
+ {
+ curwin->w_cursor.col = i;
+ retval = TRUE;
+ }
+ }
+ }
+ return retval;
+}
+
+/*
+ * Recognize the basic picture of a function declaration -- it needs to
+ * have an open paren somewhere and a close paren at the end of the line and
+ * no semicolons anywhere.
+ * When a line ends in a comma we continue looking in the next line.
+ * "sp" points to a string with the line. When looking at other lines it must
+ * be restored to the line. When it's NULL fetch lines here.
+ * "first_lnum" is where we start looking.
+ * "min_lnum" is the line before which we will not be looking.
+ */
+ static int
+cin_isfuncdecl(
+ char_u **sp,
+ linenr_T first_lnum,
+ linenr_T min_lnum)
+{
+ char_u *s;
+ linenr_T lnum = first_lnum;
+ linenr_T save_lnum = curwin->w_cursor.lnum;
+ int retval = FALSE;
+ pos_T *trypos;
+ int just_started = TRUE;
+
+ if (sp == NULL)
+ s = ml_get(lnum);
+ else
+ s = *sp;
+
+ curwin->w_cursor.lnum = lnum;
+ if (find_last_paren(s, '(', ')')
+ && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
+ {
+ lnum = trypos->lnum;
+ if (lnum < min_lnum)
+ {
+ curwin->w_cursor.lnum = save_lnum;
+ return FALSE;
+ }
+
+ s = ml_get(lnum);
+ }
+ curwin->w_cursor.lnum = save_lnum;
+
+ // Ignore line starting with #.
+ if (cin_ispreproc(s))
+ return FALSE;
+
+ while (*s && *s != '(' && *s != ';' && *s != '\'' && *s != '"')
+ {
+ if (cin_iscomment(s)) // ignore comments
+ s = cin_skipcomment(s);
+ else if (*s == ':')
+ {
+ if (*(s + 1) == ':')
+ s += 2;
+ else
+ // To avoid a mistake in the following situation:
+ // A::A(int a, int b)
+ // : a(0) // <--not a function decl
+ // , b(0)
+ // {...
+ return FALSE;
+ }
+ else
+ ++s;
+ }
+ if (*s != '(')
+ return FALSE; // ';', ' or " before any () or no '('
+
+ while (*s && *s != ';' && *s != '\'' && *s != '"')
+ {
+ if (*s == ')' && cin_nocode(s + 1))
+ {
+ // ')' at the end: may have found a match
+ // Check for he previous line not to end in a backslash:
+ // #if defined(x) && {backslash}
+ // defined(y)
+ lnum = first_lnum - 1;
+ s = ml_get(lnum);
+ if (*s == NUL || s[STRLEN(s) - 1] != '\\')
+ retval = TRUE;
+ goto done;
+ }
+ if ((*s == ',' && cin_nocode(s + 1)) || s[1] == NUL || cin_nocode(s))
+ {
+ int comma = (*s == ',');
+
+ // ',' at the end: continue looking in the next line.
+ // At the end: check for ',' in the next line, for this style:
+ // func(arg1
+ // , arg2)
+ for (;;)
+ {
+ if (lnum >= curbuf->b_ml.ml_line_count)
+ break;
+ s = ml_get(++lnum);
+ if (!cin_ispreproc(s))
+ break;
+ }
+ if (lnum >= curbuf->b_ml.ml_line_count)
+ break;
+ // Require a comma at end of the line or a comma or ')' at the
+ // start of next line.
+ s = skipwhite(s);
+ if (!just_started && (!comma && *s != ',' && *s != ')'))
+ break;
+ just_started = FALSE;
+ }
+ else if (cin_iscomment(s)) // ignore comments
+ s = cin_skipcomment(s);
+ else
+ {
+ ++s;
+ just_started = FALSE;
+ }
+ }
+
+done:
+ if (lnum != first_lnum && sp != NULL)
+ *sp = ml_get(first_lnum);
+
+ return retval;
+}
+
+ static int
+cin_isif(char_u *p)
+{
+ return (STRNCMP(p, "if", 2) == 0 && !vim_isIDc(p[2]));
+}
+
+ static int
+cin_isdo(char_u *p)
+{
+ return (STRNCMP(p, "do", 2) == 0 && !vim_isIDc(p[2]));
+}
+
+/*
+ * Check if this is a "while" that should have a matching "do".
+ * We only accept a "while (condition) ;", with only white space between the
+ * ')' and ';'. The condition may be spread over several lines.
+ */
+ static int
+cin_iswhileofdo (char_u *p, linenr_T lnum) // XXX
+{
+ pos_T cursor_save;
+ pos_T *trypos;
+ int retval = FALSE;
+
+ p = cin_skipcomment(p);
+ if (*p == '}') // accept "} while (cond);"
+ p = cin_skipcomment(p + 1);
+ if (cin_starts_with(p, "while"))
+ {
+ cursor_save = curwin->w_cursor;
+ curwin->w_cursor.lnum = lnum;
+ curwin->w_cursor.col = 0;
+ p = ml_get_curline();
+ while (*p && *p != 'w') // skip any '}', until the 'w' of the "while"
+ {
+ ++p;
+ ++curwin->w_cursor.col;
+ }
+ if ((trypos = findmatchlimit(NULL, 0, 0,
+ curbuf->b_ind_maxparen)) != NULL
+ && *cin_skipcomment(ml_get_pos(trypos) + 1) == ';')
+ retval = TRUE;
+ curwin->w_cursor = cursor_save;
+ }
+ return retval;
+}
+
+/*
+ * Check whether in "p" there is an "if", "for" or "while" before "*poffset".
+ * Return 0 if there is none.
+ * Otherwise return !0 and update "*poffset" to point to the place where the
+ * string was found.
+ */
+ static int
+cin_is_if_for_while_before_offset(char_u *line, int *poffset)
+{
+ int offset = *poffset;
+
+ if (offset-- < 2)
+ return 0;
+ while (offset > 2 && VIM_ISWHITE(line[offset]))
+ --offset;
+
+ offset -= 1;
+ if (!STRNCMP(line + offset, "if", 2))
+ goto probablyFound;
+
+ if (offset >= 1)
+ {
+ offset -= 1;
+ if (!STRNCMP(line + offset, "for", 3))
+ goto probablyFound;
+
+ if (offset >= 2)
+ {
+ offset -= 2;
+ if (!STRNCMP(line + offset, "while", 5))
+ goto probablyFound;
+ }
+ }
+ return 0;
+
+probablyFound:
+ if (!offset || !vim_isIDc(line[offset - 1]))
+ {
+ *poffset = offset;
+ return 1;
+ }
+ return 0;
+}
+
+/*
+ * Return TRUE if we are at the end of a do-while.
+ * do
+ * nothing;
+ * while (foo
+ * && bar); <-- here
+ * Adjust the cursor to the line with "while".
+ */
+ static int
+cin_iswhileofdo_end(int terminated)
+{
+ char_u *line;
+ char_u *p;
+ char_u *s;
+ pos_T *trypos;
+ int i;
+
+ if (terminated != ';') // there must be a ';' at the end
+ return FALSE;
+
+ p = line = ml_get_curline();
+ while (*p != NUL)
+ {
+ p = cin_skipcomment(p);
+ if (*p == ')')
+ {
+ s = skipwhite(p + 1);
+ if (*s == ';' && cin_nocode(s + 1))
+ {
+ // Found ");" at end of the line, now check there is "while"
+ // before the matching '('. XXX
+ i = (int)(p - line);
+ curwin->w_cursor.col = i;
+ trypos = find_match_paren(curbuf->b_ind_maxparen);
+ if (trypos != NULL)
+ {
+ s = cin_skipcomment(ml_get(trypos->lnum));
+ if (*s == '}') // accept "} while (cond);"
+ s = cin_skipcomment(s + 1);
+ if (cin_starts_with(s, "while"))
+ {
+ curwin->w_cursor.lnum = trypos->lnum;
+ return TRUE;
+ }
+ }
+
+ // Searching may have made "line" invalid, get it again.
+ line = ml_get_curline();
+ p = line + i;
+ }
+ }
+ if (*p != NUL)
+ ++p;
+ }
+ return FALSE;
+}
+
+ static int
+cin_isbreak(char_u *p)
+{
+ return (STRNCMP(p, "break", 5) == 0 && !vim_isIDc(p[5]));
+}
+
+/*
+ * Find the position of a C++ base-class declaration or
+ * constructor-initialization. eg:
+ *
+ * class MyClass :
+ * baseClass <-- here
+ * class MyClass : public baseClass,
+ * anotherBaseClass <-- here (should probably lineup ??)
+ * MyClass::MyClass(...) :
+ * baseClass(...) <-- here (constructor-initialization)
+ *
+ * This is a lot of guessing. Watch out for "cond ? func() : foo".
+ */
+ static int
+cin_is_cpp_baseclass(
+ cpp_baseclass_cache_T *cached) // input and output
+{
+ lpos_T *pos = &cached->lpos; // find position
+ char_u *s;
+ int class_or_struct, lookfor_ctor_init, cpp_base_class;
+ linenr_T lnum = curwin->w_cursor.lnum;
+ char_u *line = ml_get_curline();
+
+ if (pos->lnum <= lnum)
+ return cached->found; // Use the cached result
+
+ pos->col = 0;
+
+ s = skipwhite(line);
+ if (*s == '#') // skip #define FOO x ? (x) : x
+ return FALSE;
+ s = cin_skipcomment(s);
+ if (*s == NUL)
+ return FALSE;
+
+ cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
+
+ // Search for a line starting with '#', empty, ending in ';' or containing
+ // '{' or '}' and start below it. This handles the following situations:
+ // a = cond ?
+ // func() :
+ // asdf;
+ // func::foo()
+ // : something
+ // {}
+ // Foo::Foo (int one, int two)
+ // : something(4),
+ // somethingelse(3)
+ // {}
+ while (lnum > 1)
+ {
+ line = ml_get(lnum - 1);
+ s = skipwhite(line);
+ if (*s == '#' || *s == NUL)
+ break;
+ while (*s != NUL)
+ {
+ s = cin_skipcomment(s);
+ if (*s == '{' || *s == '}'
+ || (*s == ';' && cin_nocode(s + 1)))
+ break;
+ if (*s != NUL)
+ ++s;
+ }
+ if (*s != NUL)
+ break;
+ --lnum;
+ }
+
+ pos->lnum = lnum;
+ line = ml_get(lnum);
+ s = line;
+ for (;;)
+ {
+ if (*s == NUL)
+ {
+ if (lnum == curwin->w_cursor.lnum)
+ break;
+ // Continue in the cursor line.
+ line = ml_get(++lnum);
+ s = line;
+ }
+ if (s == line)
+ {
+ // don't recognize "case (foo):" as a baseclass
+ if (cin_iscase(s, FALSE))
+ break;
+ s = cin_skipcomment(line);
+ if (*s == NUL)
+ continue;
+ }
+
+ if (s[0] == '"' || (s[0] == 'R' && s[1] == '"'))
+ s = skip_string(s) + 1;
+ else if (s[0] == ':')
+ {
+ if (s[1] == ':')
+ {
+ // skip double colon. It can't be a constructor
+ // initialization any more
+ lookfor_ctor_init = FALSE;
+ s = cin_skipcomment(s + 2);
+ }
+ else if (lookfor_ctor_init || class_or_struct)
+ {
+ // we have something found, that looks like the start of
+ // cpp-base-class-declaration or constructor-initialization
+ cpp_base_class = TRUE;
+ lookfor_ctor_init = class_or_struct = FALSE;
+ pos->col = 0;
+ s = cin_skipcomment(s + 1);
+ }
+ else
+ s = cin_skipcomment(s + 1);
+ }
+ else if ((STRNCMP(s, "class", 5) == 0 && !vim_isIDc(s[5]))
+ || (STRNCMP(s, "struct", 6) == 0 && !vim_isIDc(s[6])))
+ {
+ class_or_struct = TRUE;
+ lookfor_ctor_init = FALSE;
+
+ if (*s == 'c')
+ s = cin_skipcomment(s + 5);
+ else
+ s = cin_skipcomment(s + 6);
+ }
+ else
+ {
+ if (s[0] == '{' || s[0] == '}' || s[0] == ';')
+ {
+ cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
+ }
+ else if (s[0] == ')')
+ {
+ // Constructor-initialization is assumed if we come across
+ // something like "):"
+ class_or_struct = FALSE;
+ lookfor_ctor_init = TRUE;
+ }
+ else if (s[0] == '?')
+ {
+ // Avoid seeing '() :' after '?' as constructor init.
+ return FALSE;
+ }
+ else if (!vim_isIDc(s[0]))
+ {
+ // if it is not an identifier, we are wrong
+ class_or_struct = FALSE;
+ lookfor_ctor_init = FALSE;
+ }
+ else if (pos->col == 0)
+ {
+ // it can't be a constructor-initialization any more
+ lookfor_ctor_init = FALSE;
+
+ // the first statement starts here: lineup with this one...
+ if (cpp_base_class)
+ pos->col = (colnr_T)(s - line);
+ }
+
+ // When the line ends in a comma don't align with it.
+ if (lnum == curwin->w_cursor.lnum && *s == ',' && cin_nocode(s + 1))
+ pos->col = 0;
+
+ s = cin_skipcomment(s + 1);
+ }
+ }
+
+ cached->found = cpp_base_class;
+ if (cpp_base_class)
+ pos->lnum = lnum;
+ return cpp_base_class;
+}
+
+ static int
+get_baseclass_amount(int col)
+{
+ int amount;
+ colnr_T vcol;
+ pos_T *trypos;
+
+ if (col == 0)
+ {
+ amount = get_indent();
+ if (find_last_paren(ml_get_curline(), '(', ')')
+ && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
+ amount = get_indent_lnum(trypos->lnum); // XXX
+ if (!cin_ends_in(ml_get_curline(), (char_u *)",", NULL))
+ amount += curbuf->b_ind_cpp_baseclass;
+ }
+ else
+ {
+ curwin->w_cursor.col = col;
+ getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
+ amount = (int)vcol;
+ }
+ if (amount < curbuf->b_ind_cpp_baseclass)
+ amount = curbuf->b_ind_cpp_baseclass;
+ return amount;
+}
+
+/*
+ * Find the '{' at the start of the block we are in.
+ * Return NULL if no match found.
+ * Ignore a '{' that is in a comment, makes indenting the next three lines
+ * work.
+ */
+/* foo() */
+/* { */
+/* } */
+
+ static pos_T *
+find_start_brace(void) // XXX
+{
+ pos_T cursor_save;
+ pos_T *trypos;
+ pos_T *pos;
+ static pos_T pos_copy;
+
+ cursor_save = curwin->w_cursor;
+ while ((trypos = findmatchlimit(NULL, '{', FM_BLOCKSTOP, 0)) != NULL)
+ {
+ pos_copy = *trypos; // copy pos_T, next findmatch will change it
+ trypos = &pos_copy;
+ curwin->w_cursor = *trypos;
+ pos = NULL;
+ // ignore the { if it's in a // or / * * / comment
+ if ((colnr_T)cin_skip2pos(trypos) == trypos->col
+ && (pos = ind_find_start_CORS(NULL)) == NULL) // XXX
+ break;
+ if (pos != NULL)
+ curwin->w_cursor.lnum = pos->lnum;
+ }
+ curwin->w_cursor = cursor_save;
+ return trypos;
+}
+
+/*
+ * Find the matching '(', ignoring it if it is in a comment or before an
+ * unmatched {.
+ * Return NULL if no match found.
+ */
+ static pos_T *
+find_match_paren_after_brace (int ind_maxparen) // XXX
+{
+ pos_T *trypos = find_match_paren(ind_maxparen);
+
+ if (trypos != NULL)
+ {
+ pos_T *tryposBrace = find_start_brace();
+
+ // If both an unmatched '(' and '{' is found. Ignore the '('
+ // position if the '{' is further down.
+ if (tryposBrace != NULL
+ && (trypos->lnum != tryposBrace->lnum
+ ? trypos->lnum < tryposBrace->lnum
+ : trypos->col < tryposBrace->col))
+ trypos = NULL;
+ }
+ return trypos;
+}
+
+/*
+ * Return ind_maxparen corrected for the difference in line number between the
+ * cursor position and "startpos". This makes sure that searching for a
+ * matching paren above the cursor line doesn't find a match because of
+ * looking a few lines further.
+ */
+ static int
+corr_ind_maxparen(pos_T *startpos)
+{
+ long n = (long)startpos->lnum - (long)curwin->w_cursor.lnum;
+
+ if (n > 0 && n < curbuf->b_ind_maxparen / 2)
+ return curbuf->b_ind_maxparen - (int)n;
+ return curbuf->b_ind_maxparen;
+}
+
+/*
+ * Parse 'cinoptions' and set the values in "curbuf".
+ * Must be called when 'cinoptions', 'shiftwidth' and/or 'tabstop' changes.
+ */
+ void
+parse_cino(buf_T *buf)
+{
+ char_u *p;
+ char_u *l;
+ char_u *digits;
+ int n;
+ int divider;
+ int fraction = 0;
+ int sw = (int)get_sw_value(buf);
+
+ // Set the default values.
+
+ // Spaces from a block's opening brace the prevailing indent for that
+ // block should be.
+ buf->b_ind_level = sw;
+
+ // Spaces from the edge of the line an open brace that's at the end of a
+ // line is imagined to be.
+ buf->b_ind_open_imag = 0;
+
+ // Spaces from the prevailing indent for a line that is not preceded by
+ // an opening brace.
+ buf->b_ind_no_brace = 0;
+
+ // Column where the first { of a function should be located }.
+ buf->b_ind_first_open = 0;
+
+ // Spaces from the prevailing indent a leftmost open brace should be
+ // located.
+ buf->b_ind_open_extra = 0;
+
+ // Spaces from the matching open brace (real location for one at the left
+ // edge; imaginary location from one that ends a line) the matching close
+ // brace should be located.
+ buf->b_ind_close_extra = 0;
+
+ // Spaces from the edge of the line an open brace sitting in the leftmost
+ // column is imagined to be.
+ buf->b_ind_open_left_imag = 0;
+
+ // Spaces jump labels should be shifted to the left if N is non-negative,
+ // otherwise the jump label will be put to column 1.
+ buf->b_ind_jump_label = -1;
+
+ // Spaces from the switch() indent a "case xx" label should be located.
+ buf->b_ind_case = sw;
+
+ // Spaces from the "case xx:" code after a switch() should be located.
+ buf->b_ind_case_code = sw;
+
+ // Lineup break at end of case in switch() with case label.
+ buf->b_ind_case_break = 0;
+
+ // Spaces from the class declaration indent a scope declaration label
+ // should be located.
+ buf->b_ind_scopedecl = sw;
+
+ // Spaces from the scope declaration label code should be located.
+ buf->b_ind_scopedecl_code = sw;
+
+ // Amount K&R-style parameters should be indented.
+ buf->b_ind_param = sw;
+
+ // Amount a function type spec should be indented.
+ buf->b_ind_func_type = sw;
+
+ // Amount a cpp base class declaration or constructor initialization
+ // should be indented.
+ buf->b_ind_cpp_baseclass = sw;
+
+ // additional spaces beyond the prevailing indent a continuation line
+ // should be located.
+ buf->b_ind_continuation = sw;
+
+ // Spaces from the indent of the line with an unclosed parentheses.
+ buf->b_ind_unclosed = sw * 2;
+
+ // Spaces from the indent of the line with an unclosed parentheses, which
+ // itself is also unclosed.
+ buf->b_ind_unclosed2 = sw;
+
+ // Suppress ignoring spaces from the indent of a line starting with an
+ // unclosed parentheses.
+ buf->b_ind_unclosed_noignore = 0;
+
+ // If the opening paren is the last nonwhite character on the line, and
+ // b_ind_unclosed_wrapped is nonzero, use this indent relative to the outer
+ // context (for very long lines).
+ buf->b_ind_unclosed_wrapped = 0;
+
+ // Suppress ignoring white space when lining up with the character after
+ // an unclosed parentheses.
+ buf->b_ind_unclosed_whiteok = 0;
+
+ // Indent a closing parentheses under the line start of the matching
+ // opening parentheses.
+ buf->b_ind_matching_paren = 0;
+
+ // Indent a closing parentheses under the previous line.
+ buf->b_ind_paren_prev = 0;
+
+ // Extra indent for comments.
+ buf->b_ind_comment = 0;
+
+ // Spaces from the comment opener when there is nothing after it.
+ buf->b_ind_in_comment = 3;
+
+ // Boolean: if non-zero, use b_ind_in_comment even if there is something
+ // after the comment opener.
+ buf->b_ind_in_comment2 = 0;
+
+ // Max lines to search for an open paren.
+ buf->b_ind_maxparen = 20;
+
+ // Max lines to search for an open comment.
+ buf->b_ind_maxcomment = 70;
+
+ // Handle braces for java code.
+ buf->b_ind_java = 0;
+
+ // Not to confuse JS object properties with labels.
+ buf->b_ind_js = 0;
+
+ // Handle blocked cases correctly.
+ buf->b_ind_keep_case_label = 0;
+
+ // Handle C++ namespace.
+ buf->b_ind_cpp_namespace = 0;
+
+ // Handle continuation lines containing conditions of if(), for() and
+ // while().
+ buf->b_ind_if_for_while = 0;
+
+ // indentation for # comments
+ buf->b_ind_hash_comment = 0;
+
+ // Handle C++ extern "C" or "C++"
+ buf->b_ind_cpp_extern_c = 0;
+
+ for (p = buf->b_p_cino; *p; )
+ {
+ l = p++;
+ if (*p == '-')
+ ++p;
+ digits = p; // remember where the digits start
+ n = getdigits(&p);
+ divider = 0;
+ if (*p == '.') // ".5s" means a fraction
+ {
+ fraction = atol((char *)++p);
+ while (VIM_ISDIGIT(*p))
+ {
+ ++p;
+ if (divider)
+ divider *= 10;
+ else
+ divider = 10;
+ }
+ }
+ if (*p == 's') // "2s" means two times 'shiftwidth'
+ {
+ if (p == digits)
+ n = sw; // just "s" is one 'shiftwidth'
+ else
+ {
+ n *= sw;
+ if (divider)
+ n += (sw * fraction + divider / 2) / divider;
+ }
+ ++p;
+ }
+ if (l[1] == '-')
+ n = -n;
+
+ // When adding an entry here, also update the default 'cinoptions' in
+ // doc/indent.txt, and add explanation for it!
+ switch (*l)
+ {
+ case '>': buf->b_ind_level = n; break;
+ case 'e': buf->b_ind_open_imag = n; break;
+ case 'n': buf->b_ind_no_brace = n; break;
+ case 'f': buf->b_ind_first_open = n; break;
+ case '{': buf->b_ind_open_extra = n; break;
+ case '}': buf->b_ind_close_extra = n; break;
+ case '^': buf->b_ind_open_left_imag = n; break;
+ case 'L': buf->b_ind_jump_label = n; break;
+ case ':': buf->b_ind_case = n; break;
+ case '=': buf->b_ind_case_code = n; break;
+ case 'b': buf->b_ind_case_break = n; break;
+ case 'p': buf->b_ind_param = n; break;
+ case 't': buf->b_ind_func_type = n; break;
+ case '/': buf->b_ind_comment = n; break;
+ case 'c': buf->b_ind_in_comment = n; break;
+ case 'C': buf->b_ind_in_comment2 = n; break;
+ case 'i': buf->b_ind_cpp_baseclass = n; break;
+ case '+': buf->b_ind_continuation = n; break;
+ case '(': buf->b_ind_unclosed = n; break;
+ case 'u': buf->b_ind_unclosed2 = n; break;
+ case 'U': buf->b_ind_unclosed_noignore = n; break;
+ case 'W': buf->b_ind_unclosed_wrapped = n; break;
+ case 'w': buf->b_ind_unclosed_whiteok = n; break;
+ case 'm': buf->b_ind_matching_paren = n; break;
+ case 'M': buf->b_ind_paren_prev = n; break;
+ case ')': buf->b_ind_maxparen = n; break;
+ case '*': buf->b_ind_maxcomment = n; break;
+ case 'g': buf->b_ind_scopedecl = n; break;
+ case 'h': buf->b_ind_scopedecl_code = n; break;
+ case 'j': buf->b_ind_java = n; break;
+ case 'J': buf->b_ind_js = n; break;
+ case 'l': buf->b_ind_keep_case_label = n; break;
+ case '#': buf->b_ind_hash_comment = n; break;
+ case 'N': buf->b_ind_cpp_namespace = n; break;
+ case 'k': buf->b_ind_if_for_while = n; break;
+ case 'E': buf->b_ind_cpp_extern_c = n; break;
+ }
+ if (*p == ',')
+ ++p;
+ }
+}
+
+ static int
+find_match(int lookfor, linenr_T ourscope)
+{
+ char_u *look;
+ pos_T *theirscope;
+ char_u *mightbeif;
+ int elselevel;
+ int whilelevel;
+
+ if (lookfor == LOOKFOR_IF)
+ {
+ elselevel = 1;
+ whilelevel = 0;
+ }
+ else
+ {
+ elselevel = 0;
+ whilelevel = 1;
+ }
+
+ curwin->w_cursor.col = 0;
+
+ while (curwin->w_cursor.lnum > ourscope + 1)
+ {
+ curwin->w_cursor.lnum--;
+ curwin->w_cursor.col = 0;
+
+ look = cin_skipcomment(ml_get_curline());
+ if (cin_iselse(look)
+ || cin_isif(look)
+ || cin_isdo(look) // XXX
+ || cin_iswhileofdo(look, curwin->w_cursor.lnum))
+ {
+ // if we've gone outside the braces entirely,
+ // we must be out of scope...
+ theirscope = find_start_brace(); // XXX
+ if (theirscope == NULL)
+ break;
+
+ // and if the brace enclosing this is further
+ // back than the one enclosing the else, we're
+ // out of luck too.
+ if (theirscope->lnum < ourscope)
+ break;
+
+ // and if they're enclosed in a *deeper* brace,
+ // then we can ignore it because it's in a
+ // different scope...
+ if (theirscope->lnum > ourscope)
+ continue;
+
+ // if it was an "else" (that's not an "else if")
+ // then we need to go back to another if, so
+ // increment elselevel
+ look = cin_skipcomment(ml_get_curline());
+ if (cin_iselse(look))
+ {
+ mightbeif = cin_skipcomment(look + 4);
+ if (!cin_isif(mightbeif))
+ ++elselevel;
+ continue;
+ }
+
+ // if it was a "while" then we need to go back to
+ // another "do", so increment whilelevel. XXX
+ if (cin_iswhileofdo(look, curwin->w_cursor.lnum))
+ {
+ ++whilelevel;
+ continue;
+ }
+
+ // If it's an "if" decrement elselevel
+ look = cin_skipcomment(ml_get_curline());
+ if (cin_isif(look))
+ {
+ elselevel--;
+ // When looking for an "if" ignore "while"s that
+ // get in the way.
+ if (elselevel == 0 && lookfor == LOOKFOR_IF)
+ whilelevel = 0;
+ }
+
+ // If it's a "do" decrement whilelevel
+ if (cin_isdo(look))
+ whilelevel--;
+
+ // if we've used up all the elses, then
+ // this must be the if that we want!
+ // match the indent level of that if.
+ if (elselevel <= 0 && whilelevel <= 0)
+ return OK;
+ }
+ }
+ return FAIL;
+}
+
+/*
+ * Return the desired indent for C code.
+ * Return -1 if the indent should be left alone (inside a raw string).
+ */
+ int
+get_c_indent(void)
+{
+ pos_T cur_curpos;
+ int amount;
+ int scope_amount;
+ int cur_amount = MAXCOL;
+ colnr_T col;
+ char_u *theline;
+ char_u *linecopy;
+ pos_T *trypos;
+ pos_T *comment_pos;
+ pos_T *tryposBrace = NULL;
+ pos_T tryposCopy;
+ pos_T our_paren_pos;
+ char_u *start;
+ int start_brace;
+#define BRACE_IN_COL0 1 // '{' is in column 0
+#define BRACE_AT_START 2 // '{' is at start of line
+#define BRACE_AT_END 3 // '{' is at end of line
+ linenr_T ourscope;
+ char_u *l;
+ char_u *look;
+ char_u terminated;
+ int lookfor;
+ int whilelevel;
+ linenr_T lnum;
+ int n;
+ int iscase;
+ int lookfor_break;
+ int lookfor_cpp_namespace = FALSE;
+ int cont_amount = 0; // amount for continuation line
+ int original_line_islabel;
+ int added_to_amount = 0;
+ int js_cur_has_key = 0;
+ linenr_T raw_string_start = 0;
+ cpp_baseclass_cache_T cache_cpp_baseclass = { FALSE, { MAXLNUM, 0 } };
+
+ // make a copy, value is changed below
+ int ind_continuation = curbuf->b_ind_continuation;
+
+ // remember where the cursor was when we started
+ cur_curpos = curwin->w_cursor;
+
+ // if we are at line 1 zero indent is fine, right?
+ if (cur_curpos.lnum == 1)
+ return 0;
+
+ // Get a copy of the current contents of the line.
+ // This is required, because only the most recent line obtained with
+ // ml_get is valid!
+ linecopy = vim_strsave(ml_get(cur_curpos.lnum));
+ if (linecopy == NULL)
+ return 0;
+
+ // In insert mode and the cursor is on a ')' truncate the line at the
+ // cursor position. We don't want to line up with the matching '(' when
+ // inserting new stuff.
+ // For unknown reasons the cursor might be past the end of the line, thus
+ // check for that.
+ if ((State & INSERT)
+ && curwin->w_cursor.col < (colnr_T)STRLEN(linecopy)
+ && linecopy[curwin->w_cursor.col] == ')')
+ linecopy[curwin->w_cursor.col] = NUL;
+
+ theline = skipwhite(linecopy);
+
+ // move the cursor to the start of the line
+
+ curwin->w_cursor.col = 0;
+
+ original_line_islabel = cin_islabel(); // XXX
+
+ // If we are inside a raw string don't change the indent.
+ // Ignore a raw string inside a comment.
+ comment_pos = ind_find_start_comment();
+ if (comment_pos != NULL)
+ {
+ // findmatchlimit() static pos is overwritten, make a copy
+ tryposCopy = *comment_pos;
+ comment_pos = &tryposCopy;
+ }
+ trypos = find_start_rawstring(curbuf->b_ind_maxcomment);
+ if (trypos != NULL && (comment_pos == NULL
+ || LT_POS(*trypos, *comment_pos)))
+ {
+ amount = -1;
+ goto laterend;
+ }
+
+ // #defines and so on always go at the left when included in 'cinkeys'.
+ if (*theline == '#' && (*linecopy == '#' || in_cinkeys('#', ' ', TRUE)))
+ {
+ amount = curbuf->b_ind_hash_comment;
+ goto theend;
+ }
+
+ // Is it a non-case label? Then that goes at the left margin too unless:
+ // - JS flag is set.
+ // - 'L' item has a positive value.
+ if (original_line_islabel && !curbuf->b_ind_js
+ && curbuf->b_ind_jump_label < 0)
+ {
+ amount = 0;
+ goto theend;
+ }
+
+ // If we're inside a "//" comment and there is a "//" comment in a
+ // previous line, lineup with that one.
+ if (cin_islinecomment(theline)
+ && (trypos = find_line_comment()) != NULL) // XXX
+ {
+ // find how indented the line beginning the comment is
+ getvcol(curwin, trypos, &col, NULL, NULL);
+ amount = col;
+ goto theend;
+ }
+
+ // If we're inside a comment and not looking at the start of the
+ // comment, try using the 'comments' option.
+ if (!cin_iscomment(theline) && comment_pos != NULL) // XXX
+ {
+ int lead_start_len = 2;
+ int lead_middle_len = 1;
+ char_u lead_start[COM_MAX_LEN]; // start-comment string
+ char_u lead_middle[COM_MAX_LEN]; // middle-comment string
+ char_u lead_end[COM_MAX_LEN]; // end-comment string
+ char_u *p;
+ int start_align = 0;
+ int start_off = 0;
+ int done = FALSE;
+
+ // find how indented the line beginning the comment is
+ getvcol(curwin, comment_pos, &col, NULL, NULL);
+ amount = col;
+ *lead_start = NUL;
+ *lead_middle = NUL;
+
+ p = curbuf->b_p_com;
+ while (*p != NUL)
+ {
+ int align = 0;
+ int off = 0;
+ int what = 0;
+
+ while (*p != NUL && *p != ':')
+ {
+ if (*p == COM_START || *p == COM_END || *p == COM_MIDDLE)
+ what = *p++;
+ else if (*p == COM_LEFT || *p == COM_RIGHT)
+ align = *p++;
+ else if (VIM_ISDIGIT(*p) || *p == '-')
+ off = getdigits(&p);
+ else
+ ++p;
+ }
+
+ if (*p == ':')
+ ++p;
+ (void)copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
+ if (what == COM_START)
+ {
+ STRCPY(lead_start, lead_end);
+ lead_start_len = (int)STRLEN(lead_start);
+ start_off = off;
+ start_align = align;
+ }
+ else if (what == COM_MIDDLE)
+ {
+ STRCPY(lead_middle, lead_end);
+ lead_middle_len = (int)STRLEN(lead_middle);
+ }
+ else if (what == COM_END)
+ {
+ // If our line starts with the middle comment string, line it
+ // up with the comment opener per the 'comments' option.
+ if (STRNCMP(theline, lead_middle, lead_middle_len) == 0
+ && STRNCMP(theline, lead_end, STRLEN(lead_end)) != 0)
+ {
+ done = TRUE;
+ if (curwin->w_cursor.lnum > 1)
+ {
+ // If the start comment string matches in the previous
+ // line, use the indent of that line plus offset. If
+ // the middle comment string matches in the previous
+ // line, use the indent of that line. XXX
+ look = skipwhite(ml_get(curwin->w_cursor.lnum - 1));
+ if (STRNCMP(look, lead_start, lead_start_len) == 0)
+ amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
+ else if (STRNCMP(look, lead_middle,
+ lead_middle_len) == 0)
+ {
+ amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
+ break;
+ }
+ // If the start comment string doesn't match with the
+ // start of the comment, skip this entry. XXX
+ else if (STRNCMP(ml_get(comment_pos->lnum) + comment_pos->col,
+ lead_start, lead_start_len) != 0)
+ continue;
+ }
+ if (start_off != 0)
+ amount += start_off;
+ else if (start_align == COM_RIGHT)
+ amount += vim_strsize(lead_start)
+ - vim_strsize(lead_middle);
+ break;
+ }
+
+ // If our line starts with the end comment string, line it up
+ // with the middle comment
+ if (STRNCMP(theline, lead_middle, lead_middle_len) != 0
+ && STRNCMP(theline, lead_end, STRLEN(lead_end)) == 0)
+ {
+ amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
+ // XXX
+ if (off != 0)
+ amount += off;
+ else if (align == COM_RIGHT)
+ amount += vim_strsize(lead_start)
+ - vim_strsize(lead_middle);
+ done = TRUE;
+ break;
+ }
+ }
+ }
+
+ // If our line starts with an asterisk, line up with the
+ // asterisk in the comment opener; otherwise, line up
+ // with the first character of the comment text.
+ if (done)
+ ;
+ else if (theline[0] == '*')
+ amount += 1;
+ else
+ {
+ // If we are more than one line away from the comment opener, take
+ // the indent of the previous non-empty line. If 'cino' has "CO"
+ // and we are just below the comment opener and there are any
+ // white characters after it line up with the text after it;
+ // otherwise, add the amount specified by "c" in 'cino'
+ amount = -1;
+ for (lnum = cur_curpos.lnum - 1; lnum > comment_pos->lnum; --lnum)
+ {
+ if (linewhite(lnum)) // skip blank lines
+ continue;
+ amount = get_indent_lnum(lnum); // XXX
+ break;
+ }
+ if (amount == -1) // use the comment opener
+ {
+ if (!curbuf->b_ind_in_comment2)
+ {
+ start = ml_get(comment_pos->lnum);
+ look = start + comment_pos->col + 2; // skip / and *
+ if (*look != NUL) // if something after it
+ comment_pos->col = (colnr_T)(skipwhite(look) - start);
+ }
+ getvcol(curwin, comment_pos, &col, NULL, NULL);
+ amount = col;
+ if (curbuf->b_ind_in_comment2 || *look == NUL)
+ amount += curbuf->b_ind_in_comment;
+ }
+ }
+ goto theend;
+ }
+
+ // Are we looking at a ']' that has a match?
+ if (*skipwhite(theline) == ']'
+ && (trypos = find_match_char('[', curbuf->b_ind_maxparen)) != NULL)
+ {
+ // align with the line containing the '['.
+ amount = get_indent_lnum(trypos->lnum);
+ goto theend;
+ }
+
+ // Are we inside parentheses or braces? XXX
+ if (((trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL
+ && curbuf->b_ind_java == 0)
+ || (tryposBrace = find_start_brace()) != NULL
+ || trypos != NULL)
+ {
+ if (trypos != NULL && tryposBrace != NULL)
+ {
+ // Both an unmatched '(' and '{' is found. Use the one which is
+ // closer to the current cursor position, set the other to NULL.
+ if (trypos->lnum != tryposBrace->lnum
+ ? trypos->lnum < tryposBrace->lnum
+ : trypos->col < tryposBrace->col)
+ trypos = NULL;
+ else
+ tryposBrace = NULL;
+ }
+
+ if (trypos != NULL)
+ {
+ // If the matching paren is more than one line away, use the indent of
+ // a previous non-empty line that matches the same paren.
+ if (theline[0] == ')' && curbuf->b_ind_paren_prev)
+ {
+ // Line up with the start of the matching paren line.
+ amount = get_indent_lnum(curwin->w_cursor.lnum - 1); // XXX
+ }
+ else
+ {
+ amount = -1;
+ our_paren_pos = *trypos;
+ for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; --lnum)
+ {
+ l = skipwhite(ml_get(lnum));
+ if (cin_nocode(l)) // skip comment lines
+ continue;
+ if (cin_ispreproc_cont(&l, &lnum, &amount))
+ continue; // ignore #define, #if, etc.
+ curwin->w_cursor.lnum = lnum;
+
+ // Skip a comment or raw string. XXX
+ if ((trypos = ind_find_start_CORS(NULL)) != NULL)
+ {
+ lnum = trypos->lnum + 1;
+ continue;
+ }
+
+ // XXX
+ if ((trypos = find_match_paren(
+ corr_ind_maxparen(&cur_curpos))) != NULL
+ && trypos->lnum == our_paren_pos.lnum
+ && trypos->col == our_paren_pos.col)
+ {
+ amount = get_indent_lnum(lnum); // XXX
+
+ if (theline[0] == ')')
+ {
+ if (our_paren_pos.lnum != lnum
+ && cur_amount > amount)
+ cur_amount = amount;
+ amount = -1;
+ }
+ break;
+ }
+ }
+ }
+
+ // Line up with line where the matching paren is. XXX
+ // If the line starts with a '(' or the indent for unclosed
+ // parentheses is zero, line up with the unclosed parentheses.
+ if (amount == -1)
+ {
+ int ignore_paren_col = 0;
+ int is_if_for_while = 0;
+
+ if (curbuf->b_ind_if_for_while)
+ {
+ // Look for the outermost opening parenthesis on this line
+ // and check whether it belongs to an "if", "for" or "while".
+
+ pos_T cursor_save = curwin->w_cursor;
+ pos_T outermost;
+ char_u *line;
+
+ trypos = &our_paren_pos;
+ do {
+ outermost = *trypos;
+ curwin->w_cursor.lnum = outermost.lnum;
+ curwin->w_cursor.col = outermost.col;
+
+ trypos = find_match_paren(curbuf->b_ind_maxparen);
+ } while (trypos && trypos->lnum == outermost.lnum);
+
+ curwin->w_cursor = cursor_save;
+
+ line = ml_get(outermost.lnum);
+
+ is_if_for_while =
+ cin_is_if_for_while_before_offset(line, &outermost.col);
+ }
+
+ amount = skip_label(our_paren_pos.lnum, &look);
+ look = skipwhite(look);
+ if (*look == '(')
+ {
+ linenr_T save_lnum = curwin->w_cursor.lnum;
+ char_u *line;
+ int look_col;
+
+ // Ignore a '(' in front of the line that has a match before
+ // our matching '('.
+ curwin->w_cursor.lnum = our_paren_pos.lnum;
+ line = ml_get_curline();
+ look_col = (int)(look - line);
+ curwin->w_cursor.col = look_col + 1;
+ if ((trypos = findmatchlimit(NULL, ')', 0,
+ curbuf->b_ind_maxparen))
+ != NULL
+ && trypos->lnum == our_paren_pos.lnum
+ && trypos->col < our_paren_pos.col)
+ ignore_paren_col = trypos->col + 1;
+
+ curwin->w_cursor.lnum = save_lnum;
+ look = ml_get(our_paren_pos.lnum) + look_col;
+ }
+ if (theline[0] == ')' || (curbuf->b_ind_unclosed == 0
+ && is_if_for_while == 0)
+ || (!curbuf->b_ind_unclosed_noignore && *look == '('
+ && ignore_paren_col == 0))
+ {
+ // If we're looking at a close paren, line up right there;
+ // otherwise, line up with the next (non-white) character.
+ // When b_ind_unclosed_wrapped is set and the matching paren is
+ // the last nonwhite character of the line, use either the
+ // indent of the current line or the indentation of the next
+ // outer paren and add b_ind_unclosed_wrapped (for very long
+ // lines).
+ if (theline[0] != ')')
+ {
+ cur_amount = MAXCOL;
+ l = ml_get(our_paren_pos.lnum);
+ if (curbuf->b_ind_unclosed_wrapped
+ && cin_ends_in(l, (char_u *)"(", NULL))
+ {
+ // look for opening unmatched paren, indent one level
+ // for each additional level
+ n = 1;
+ for (col = 0; col < our_paren_pos.col; ++col)
+ {
+ switch (l[col])
+ {
+ case '(':
+ case '{': ++n;
+ break;
+
+ case ')':
+ case '}': if (n > 1)
+ --n;
+ break;
+ }
+ }
+
+ our_paren_pos.col = 0;
+ amount += n * curbuf->b_ind_unclosed_wrapped;
+ }
+ else if (curbuf->b_ind_unclosed_whiteok)
+ our_paren_pos.col++;
+ else
+ {
+ col = our_paren_pos.col + 1;
+ while (VIM_ISWHITE(l[col]))
+ col++;
+ if (l[col] != NUL) // In case of trailing space
+ our_paren_pos.col = col;
+ else
+ our_paren_pos.col++;
+ }
+ }
+
+ // Find how indented the paren is, or the character after it
+ // if we did the above "if".
+ if (our_paren_pos.col > 0)
+ {
+ getvcol(curwin, &our_paren_pos, &col, NULL, NULL);
+ if (cur_amount > (int)col)
+ cur_amount = col;
+ }
+ }
+
+ if (theline[0] == ')' && curbuf->b_ind_matching_paren)
+ {
+ // Line up with the start of the matching paren line.
+ }
+ else if ((curbuf->b_ind_unclosed == 0 && is_if_for_while == 0)
+ || (!curbuf->b_ind_unclosed_noignore
+ && *look == '(' && ignore_paren_col == 0))
+ {
+ if (cur_amount != MAXCOL)
+ amount = cur_amount;
+ }
+ else
+ {
+ // Add b_ind_unclosed2 for each '(' before our matching one,
+ // but ignore (void) before the line (ignore_paren_col).
+ col = our_paren_pos.col;
+ while ((int)our_paren_pos.col > ignore_paren_col)
+ {
+ --our_paren_pos.col;
+ switch (*ml_get_pos(&our_paren_pos))
+ {
+ case '(': amount += curbuf->b_ind_unclosed2;
+ col = our_paren_pos.col;
+ break;
+ case ')': amount -= curbuf->b_ind_unclosed2;
+ col = MAXCOL;
+ break;
+ }
+ }
+
+ // Use b_ind_unclosed once, when the first '(' is not inside
+ // braces
+ if (col == MAXCOL)
+ amount += curbuf->b_ind_unclosed;
+ else
+ {
+ curwin->w_cursor.lnum = our_paren_pos.lnum;
+ curwin->w_cursor.col = col;
+ if (find_match_paren_after_brace(curbuf->b_ind_maxparen)
+ != NULL)
+ amount += curbuf->b_ind_unclosed2;
+ else
+ {
+ if (is_if_for_while)
+ amount += curbuf->b_ind_if_for_while;
+ else
+ amount += curbuf->b_ind_unclosed;
+ }
+ }
+ // For a line starting with ')' use the minimum of the two
+ // positions, to avoid giving it more indent than the previous
+ // lines:
+ // func_long_name( if (x
+ // arg && yy
+ // ) ^ not here ) ^ not here
+ if (cur_amount < amount)
+ amount = cur_amount;
+ }
+ }
+
+ // add extra indent for a comment
+ if (cin_iscomment(theline))
+ amount += curbuf->b_ind_comment;
+ }
+ else
+ {
+ // We are inside braces, there is a { before this line at the position
+ // stored in tryposBrace.
+ // Make a copy of tryposBrace, it may point to pos_copy inside
+ // find_start_brace(), which may be changed somewhere.
+ tryposCopy = *tryposBrace;
+ tryposBrace = &tryposCopy;
+ trypos = tryposBrace;
+ ourscope = trypos->lnum;
+ start = ml_get(ourscope);
+
+ // Now figure out how indented the line is in general.
+ // If the brace was at the start of the line, we use that;
+ // otherwise, check out the indentation of the line as
+ // a whole and then add the "imaginary indent" to that.
+ look = skipwhite(start);
+ if (*look == '{')
+ {
+ getvcol(curwin, trypos, &col, NULL, NULL);
+ amount = col;
+ if (*start == '{')
+ start_brace = BRACE_IN_COL0;
+ else
+ start_brace = BRACE_AT_START;
+ }
+ else
+ {
+ // That opening brace might have been on a continuation
+ // line. if so, find the start of the line.
+ curwin->w_cursor.lnum = ourscope;
+
+ // Position the cursor over the rightmost paren, so that
+ // matching it will take us back to the start of the line.
+ lnum = ourscope;
+ if (find_last_paren(start, '(', ')')
+ && (trypos = find_match_paren(curbuf->b_ind_maxparen))
+ != NULL)
+ lnum = trypos->lnum;
+
+ // It could have been something like
+ // case 1: if (asdf &&
+ // ldfd) {
+ // }
+ if ((curbuf->b_ind_js || curbuf->b_ind_keep_case_label)
+ && cin_iscase(skipwhite(ml_get_curline()), FALSE))
+ amount = get_indent();
+ else if (curbuf->b_ind_js)
+ amount = get_indent_lnum(lnum);
+ else
+ amount = skip_label(lnum, &l);
+
+ start_brace = BRACE_AT_END;
+ }
+
+ // For Javascript check if the line starts with "key:".
+ if (curbuf->b_ind_js)
+ js_cur_has_key = cin_has_js_key(theline);
+
+ // If we're looking at a closing brace, that's where
+ // we want to be. otherwise, add the amount of room
+ // that an indent is supposed to be.
+ if (theline[0] == '}')
+ {
+ // they may want closing braces to line up with something
+ // other than the open brace. indulge them, if so.
+ amount += curbuf->b_ind_close_extra;
+ }
+ else
+ {
+ // If we're looking at an "else", try to find an "if"
+ // to match it with.
+ // If we're looking at a "while", try to find a "do"
+ // to match it with.
+ lookfor = LOOKFOR_INITIAL;
+ if (cin_iselse(theline))
+ lookfor = LOOKFOR_IF;
+ else if (cin_iswhileofdo(theline, cur_curpos.lnum)) // XXX
+ lookfor = LOOKFOR_DO;
+ if (lookfor != LOOKFOR_INITIAL)
+ {
+ curwin->w_cursor.lnum = cur_curpos.lnum;
+ if (find_match(lookfor, ourscope) == OK)
+ {
+ amount = get_indent(); // XXX
+ goto theend;
+ }
+ }
+
+ // We get here if we are not on an "while-of-do" or "else" (or
+ // failed to find a matching "if").
+ // Search backwards for something to line up with.
+ // First set amount for when we don't find anything.
+
+ // if the '{' is _really_ at the left margin, use the imaginary
+ // location of a left-margin brace. Otherwise, correct the
+ // location for b_ind_open_extra.
+
+ if (start_brace == BRACE_IN_COL0) // '{' is in column 0
+ {
+ amount = curbuf->b_ind_open_left_imag;
+ lookfor_cpp_namespace = TRUE;
+ }
+ else if (start_brace == BRACE_AT_START &&
+ lookfor_cpp_namespace) // '{' is at start
+ {
+
+ lookfor_cpp_namespace = TRUE;
+ }
+ else
+ {
+ if (start_brace == BRACE_AT_END) // '{' is at end of line
+ {
+ amount += curbuf->b_ind_open_imag;
+
+ l = skipwhite(ml_get_curline());
+ if (cin_is_cpp_namespace(l))
+ amount += curbuf->b_ind_cpp_namespace;
+ else if (cin_is_cpp_extern_c(l))
+ amount += curbuf->b_ind_cpp_extern_c;
+ }
+ else
+ {
+ // Compensate for adding b_ind_open_extra later.
+ amount -= curbuf->b_ind_open_extra;
+ if (amount < 0)
+ amount = 0;
+ }
+ }
+
+ lookfor_break = FALSE;
+
+ if (cin_iscase(theline, FALSE)) // it's a switch() label
+ {
+ lookfor = LOOKFOR_CASE; // find a previous switch() label
+ amount += curbuf->b_ind_case;
+ }
+ else if (cin_isscopedecl(theline)) // private:, ...
+ {
+ lookfor = LOOKFOR_SCOPEDECL; // class decl is this block
+ amount += curbuf->b_ind_scopedecl;
+ }
+ else
+ {
+ if (curbuf->b_ind_case_break && cin_isbreak(theline))
+ // break; ...
+ lookfor_break = TRUE;
+
+ lookfor = LOOKFOR_INITIAL;
+ // b_ind_level from start of block
+ amount += curbuf->b_ind_level;
+ }
+ scope_amount = amount;
+ whilelevel = 0;
+
+ // Search backwards. If we find something we recognize, line up
+ // with that.
+ //
+ // If we're looking at an open brace, indent
+ // the usual amount relative to the conditional
+ // that opens the block.
+ curwin->w_cursor = cur_curpos;
+ for (;;)
+ {
+ curwin->w_cursor.lnum--;
+ curwin->w_cursor.col = 0;
+
+ // If we went all the way back to the start of our scope, line
+ // up with it.
+ if (curwin->w_cursor.lnum <= ourscope)
+ {
+ // We reached end of scope:
+ // If looking for a enum or structure initialization
+ // go further back:
+ // If it is an initializer (enum xxx or xxx =), then
+ // don't add ind_continuation, otherwise it is a variable
+ // declaration:
+ // int x,
+ // here; <-- add ind_continuation
+ if (lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ if (curwin->w_cursor.lnum == 0
+ || curwin->w_cursor.lnum
+ < ourscope - curbuf->b_ind_maxparen)
+ {
+ // nothing found (abuse curbuf->b_ind_maxparen as
+ // limit) assume terminated line (i.e. a variable
+ // initialization)
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else if (!curbuf->b_ind_js)
+ amount += ind_continuation;
+ break;
+ }
+
+ l = ml_get_curline();
+
+ // If we're in a comment or raw string now, skip to
+ // the start of it.
+ trypos = ind_find_start_CORS(NULL);
+ if (trypos != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+
+ // Skip preprocessor directives and blank lines.
+ if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum,
+ &amount))
+ continue;
+
+ if (cin_nocode(l))
+ continue;
+
+ terminated = cin_isterminated(l, FALSE, TRUE);
+
+ // If we are at top level and the line looks like a
+ // function declaration, we are done
+ // (it's a variable declaration).
+ if (start_brace != BRACE_IN_COL0
+ || !cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0))
+ {
+ // if the line is terminated with another ','
+ // it is a continued variable initialization.
+ // don't add extra indent.
+ // TODO: does not work, if a function
+ // declaration is split over multiple lines:
+ // cin_isfuncdecl returns FALSE then.
+ if (terminated == ',')
+ break;
+
+ // if it es a enum declaration or an assignment,
+ // we are done.
+ if (terminated != ';' && cin_isinit())
+ break;
+
+ // nothing useful found
+ if (terminated == 0 || terminated == '{')
+ continue;
+ }
+
+ if (terminated != ';')
+ {
+ // Skip parens and braces. Position the cursor
+ // over the rightmost paren, so that matching it
+ // will take us back to the start of the line.
+ // XXX
+ trypos = NULL;
+ if (find_last_paren(l, '(', ')'))
+ trypos = find_match_paren(
+ curbuf->b_ind_maxparen);
+
+ if (trypos == NULL && find_last_paren(l, '{', '}'))
+ trypos = find_start_brace();
+
+ if (trypos != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+ }
+
+ // it's a variable declaration, add indentation
+ // like in
+ // int a,
+ // b;
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ }
+ else if (lookfor == LOOKFOR_UNTERM)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ }
+ else
+ {
+ if (lookfor != LOOKFOR_TERM
+ && lookfor != LOOKFOR_CPP_BASECLASS
+ && lookfor != LOOKFOR_COMMA)
+ {
+ amount = scope_amount;
+ if (theline[0] == '{')
+ {
+ amount += curbuf->b_ind_open_extra;
+ added_to_amount = curbuf->b_ind_open_extra;
+ }
+ }
+
+ if (lookfor_cpp_namespace)
+ {
+ // Looking for C++ namespace, need to look further
+ // back.
+ if (curwin->w_cursor.lnum == ourscope)
+ continue;
+
+ if (curwin->w_cursor.lnum == 0
+ || curwin->w_cursor.lnum
+ < ourscope - FIND_NAMESPACE_LIM)
+ break;
+
+ l = ml_get_curline();
+
+ // If we're in a comment or raw string now, skip
+ // to the start of it.
+ trypos = ind_find_start_CORS(NULL);
+ if (trypos != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+
+ // Skip preprocessor directives and blank lines.
+ if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum,
+ &amount))
+ continue;
+
+ // Finally the actual check for "namespace".
+ if (cin_is_cpp_namespace(l))
+ {
+ amount += curbuf->b_ind_cpp_namespace
+ - added_to_amount;
+ break;
+ }
+ else if (cin_is_cpp_extern_c(l))
+ {
+ amount += curbuf->b_ind_cpp_extern_c
+ - added_to_amount;
+ break;
+ }
+
+ if (cin_nocode(l))
+ continue;
+ }
+ }
+ break;
+ }
+
+ // If we're in a comment or raw string now, skip to the start
+ // of it. XXX
+ if ((trypos = ind_find_start_CORS(&raw_string_start)) != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+
+ l = ml_get_curline();
+
+ // If this is a switch() label, may line up relative to that.
+ // If this is a C++ scope declaration, do the same.
+ iscase = cin_iscase(l, FALSE);
+ if (iscase || cin_isscopedecl(l))
+ {
+ // we are only looking for cpp base class
+ // declaration/initialization any longer
+ if (lookfor == LOOKFOR_CPP_BASECLASS)
+ break;
+
+ // When looking for a "do" we are not interested in
+ // labels.
+ if (whilelevel > 0)
+ continue;
+
+ // case xx:
+ // c = 99 + <- this indent plus continuation
+ //-> here;
+ if (lookfor == LOOKFOR_UNTERM
+ || lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ break;
+ }
+
+ // case xx: <- line up with this case
+ // x = 333;
+ // case yy:
+ if ( (iscase && lookfor == LOOKFOR_CASE)
+ || (iscase && lookfor_break)
+ || (!iscase && lookfor == LOOKFOR_SCOPEDECL))
+ {
+ // Check that this case label is not for another
+ // switch() XXX
+ if ((trypos = find_start_brace()) == NULL
+ || trypos->lnum == ourscope)
+ {
+ amount = get_indent(); // XXX
+ break;
+ }
+ continue;
+ }
+
+ n = get_indent_nolabel(curwin->w_cursor.lnum); // XXX
+
+ // case xx: if (cond) <- line up with this if
+ // y = y + 1;
+ // -> s = 99;
+ //
+ // case xx:
+ // if (cond) <- line up with this line
+ // y = y + 1;
+ // -> s = 99;
+ if (lookfor == LOOKFOR_TERM)
+ {
+ if (n)
+ amount = n;
+
+ if (!lookfor_break)
+ break;
+ }
+
+ // case xx: x = x + 1; <- line up with this x
+ // -> y = y + 1;
+ //
+ // case xx: if (cond) <- line up with this if
+ // -> y = y + 1;
+ if (n)
+ {
+ amount = n;
+ l = after_label(ml_get_curline());
+ if (l != NULL && cin_is_cinword(l))
+ {
+ if (theline[0] == '{')
+ amount += curbuf->b_ind_open_extra;
+ else
+ amount += curbuf->b_ind_level
+ + curbuf->b_ind_no_brace;
+ }
+ break;
+ }
+
+ // Try to get the indent of a statement before the switch
+ // label. If nothing is found, line up relative to the
+ // switch label.
+ // break; <- may line up with this line
+ // case xx:
+ // -> y = 1;
+ scope_amount = get_indent() + (iscase // XXX
+ ? curbuf->b_ind_case_code
+ : curbuf->b_ind_scopedecl_code);
+ lookfor = curbuf->b_ind_case_break
+ ? LOOKFOR_NOBREAK : LOOKFOR_ANY;
+ continue;
+ }
+
+ // Looking for a switch() label or C++ scope declaration,
+ // ignore other lines, skip {}-blocks.
+ if (lookfor == LOOKFOR_CASE || lookfor == LOOKFOR_SCOPEDECL)
+ {
+ if (find_last_paren(l, '{', '}')
+ && (trypos = find_start_brace()) != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ }
+ continue;
+ }
+
+ // Ignore jump labels with nothing after them.
+ if (!curbuf->b_ind_js && cin_islabel())
+ {
+ l = after_label(ml_get_curline());
+ if (l == NULL || cin_nocode(l))
+ continue;
+ }
+
+ // Ignore #defines, #if, etc.
+ // Ignore comment and empty lines.
+ // (need to get the line again, cin_islabel() may have
+ // unlocked it)
+ l = ml_get_curline();
+ if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount)
+ || cin_nocode(l))
+ continue;
+
+ // Are we at the start of a cpp base class declaration or
+ // constructor initialization? XXX
+ n = FALSE;
+ if (lookfor != LOOKFOR_TERM && curbuf->b_ind_cpp_baseclass > 0)
+ {
+ n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
+ l = ml_get_curline();
+ }
+ if (n)
+ {
+ if (lookfor == LOOKFOR_UNTERM)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ }
+ else if (theline[0] == '{')
+ {
+ // Need to find start of the declaration.
+ lookfor = LOOKFOR_UNTERM;
+ ind_continuation = 0;
+ continue;
+ }
+ else
+ // XXX
+ amount = get_baseclass_amount(
+ cache_cpp_baseclass.lpos.col);
+ break;
+ }
+ else if (lookfor == LOOKFOR_CPP_BASECLASS)
+ {
+ // only look, whether there is a cpp base class
+ // declaration or initialization before the opening brace.
+ if (cin_isterminated(l, TRUE, FALSE))
+ break;
+ else
+ continue;
+ }
+
+ // What happens next depends on the line being terminated.
+ // If terminated with a ',' only consider it terminating if
+ // there is another unterminated statement behind, eg:
+ // 123,
+ // sizeof
+ // here
+ // Otherwise check whether it is a enumeration or structure
+ // initialisation (not indented) or a variable declaration
+ // (indented).
+ terminated = cin_isterminated(l, FALSE, TRUE);
+
+ if (js_cur_has_key)
+ {
+ js_cur_has_key = 0; // only check the first line
+ if (curbuf->b_ind_js && terminated == ',')
+ {
+ // For Javascript we might be inside an object:
+ // key: something, <- align with this
+ // key: something
+ // or:
+ // key: something + <- align with this
+ // something,
+ // key: something
+ lookfor = LOOKFOR_JS_KEY;
+ }
+ }
+ if (lookfor == LOOKFOR_JS_KEY && cin_has_js_key(l))
+ {
+ amount = get_indent();
+ break;
+ }
+ if (lookfor == LOOKFOR_COMMA)
+ {
+ if (tryposBrace != NULL && tryposBrace->lnum
+ >= curwin->w_cursor.lnum)
+ break;
+ if (terminated == ',')
+ // line below current line is the one that starts a
+ // (possibly broken) line ending in a comma.
+ break;
+ else
+ {
+ amount = get_indent();
+ if (curwin->w_cursor.lnum - 1 == ourscope)
+ // line above is start of the scope, thus current
+ // line is the one that stars a (possibly broken)
+ // line ending in a comma.
+ break;
+ }
+ }
+
+ if (terminated == 0 || (lookfor != LOOKFOR_UNTERM
+ && terminated == ','))
+ {
+ if (lookfor != LOOKFOR_ENUM_OR_INIT &&
+ (*skipwhite(l) == '[' || l[STRLEN(l) - 1] == '['))
+ amount += ind_continuation;
+ // if we're in the middle of a paren thing,
+ // go back to the line that starts it so
+ // we can get the right prevailing indent
+ // if ( foo &&
+ // bar )
+
+ // Position the cursor over the rightmost paren, so that
+ // matching it will take us back to the start of the line.
+ // Ignore a match before the start of the block.
+ (void)find_last_paren(l, '(', ')');
+ trypos = find_match_paren(corr_ind_maxparen(&cur_curpos));
+ if (trypos != NULL && (trypos->lnum < tryposBrace->lnum
+ || (trypos->lnum == tryposBrace->lnum
+ && trypos->col < tryposBrace->col)))
+ trypos = NULL;
+
+ // If we are looking for ',', we also look for matching
+ // braces.
+ if (trypos == NULL && terminated == ','
+ && find_last_paren(l, '{', '}'))
+ trypos = find_start_brace();
+
+ if (trypos != NULL)
+ {
+ // Check if we are on a case label now. This is
+ // handled above.
+ // case xx: if ( asdf &&
+ // asdf)
+ curwin->w_cursor = *trypos;
+ l = ml_get_curline();
+ if (cin_iscase(l, FALSE) || cin_isscopedecl(l))
+ {
+ ++curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+ }
+
+ // Skip over continuation lines to find the one to get the
+ // indent from
+ // char *usethis = "bla{backslash}
+ // bla",
+ // here;
+ if (terminated == ',')
+ {
+ while (curwin->w_cursor.lnum > 1)
+ {
+ l = ml_get(curwin->w_cursor.lnum - 1);
+ if (*l == NUL || l[STRLEN(l) - 1] != '\\')
+ break;
+ --curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0;
+ }
+ }
+
+ // Get indent and pointer to text for current line,
+ // ignoring any jump label. XXX
+ if (curbuf->b_ind_js)
+ cur_amount = get_indent();
+ else
+ cur_amount = skip_label(curwin->w_cursor.lnum, &l);
+ // If this is just above the line we are indenting, and it
+ // starts with a '{', line it up with this line.
+ // while (not)
+ // -> {
+ // }
+ if (terminated != ',' && lookfor != LOOKFOR_TERM
+ && theline[0] == '{')
+ {
+ amount = cur_amount;
+ // Only add b_ind_open_extra when the current line
+ // doesn't start with a '{', which must have a match
+ // in the same line (scope is the same). Probably:
+ // { 1, 2 },
+ // -> { 3, 4 }
+ if (*skipwhite(l) != '{')
+ amount += curbuf->b_ind_open_extra;
+
+ if (curbuf->b_ind_cpp_baseclass && !curbuf->b_ind_js)
+ {
+ // have to look back, whether it is a cpp base
+ // class declaration or initialization
+ lookfor = LOOKFOR_CPP_BASECLASS;
+ continue;
+ }
+ break;
+ }
+
+ // Check if we are after an "if", "while", etc.
+ // Also allow " } else".
+ if (cin_is_cinword(l) || cin_iselse(skipwhite(l)))
+ {
+ // Found an unterminated line after an if (), line up
+ // with the last one.
+ // if (cond)
+ // 100 +
+ // -> here;
+ if (lookfor == LOOKFOR_UNTERM
+ || lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ break;
+ }
+
+ // If this is just above the line we are indenting, we
+ // are finished.
+ // while (not)
+ // -> here;
+ // Otherwise this indent can be used when the line
+ // before this is terminated.
+ // yyy;
+ // if (stat)
+ // while (not)
+ // xxx;
+ // -> here;
+ amount = cur_amount;
+ if (theline[0] == '{')
+ amount += curbuf->b_ind_open_extra;
+ if (lookfor != LOOKFOR_TERM)
+ {
+ amount += curbuf->b_ind_level
+ + curbuf->b_ind_no_brace;
+ break;
+ }
+
+ // Special trick: when expecting the while () after a
+ // do, line up with the while()
+ // do
+ // x = 1;
+ // -> here
+ l = skipwhite(ml_get_curline());
+ if (cin_isdo(l))
+ {
+ if (whilelevel == 0)
+ break;
+ --whilelevel;
+ }
+
+ // When searching for a terminated line, don't use the
+ // one between the "if" and the matching "else".
+ // Need to use the scope of this "else". XXX
+ // If whilelevel != 0 continue looking for a "do {".
+ if (cin_iselse(l) && whilelevel == 0)
+ {
+ // If we're looking at "} else", let's make sure we
+ // find the opening brace of the enclosing scope,
+ // not the one from "if () {".
+ if (*l == '}')
+ curwin->w_cursor.col =
+ (colnr_T)(l - ml_get_curline()) + 1;
+
+ if ((trypos = find_start_brace()) == NULL
+ || find_match(LOOKFOR_IF, trypos->lnum)
+ == FAIL)
+ break;
+ }
+ }
+
+ // If we're below an unterminated line that is not an
+ // "if" or something, we may line up with this line or
+ // add something for a continuation line, depending on
+ // the line before this one.
+ else
+ {
+ // Found two unterminated lines on a row, line up with
+ // the last one.
+ // c = 99 +
+ // 100 +
+ // -> here;
+ if (lookfor == LOOKFOR_UNTERM)
+ {
+ // When line ends in a comma add extra indent
+ if (terminated == ',')
+ amount += ind_continuation;
+ break;
+ }
+
+ if (lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ // Found two lines ending in ',', lineup with the
+ // lowest one, but check for cpp base class
+ // declaration/initialization, if it is an
+ // opening brace or we are looking just for
+ // enumerations/initializations.
+ if (terminated == ',')
+ {
+ if (curbuf->b_ind_cpp_baseclass == 0)
+ break;
+
+ lookfor = LOOKFOR_CPP_BASECLASS;
+ continue;
+ }
+
+ // Ignore unterminated lines in between, but
+ // reduce indent.
+ if (amount > cur_amount)
+ amount = cur_amount;
+ }
+ else
+ {
+ // Found first unterminated line on a row, may
+ // line up with this line, remember its indent
+ // 100 +
+ // -> here;
+ l = ml_get_curline();
+ amount = cur_amount;
+
+ n = (int)STRLEN(l);
+ if (terminated == ',' && (*skipwhite(l) == ']'
+ || (n >=2 && l[n - 2] == ']')))
+ break;
+
+ // If previous line ends in ',', check whether we
+ // are in an initialization or enum
+ // struct xxx =
+ // {
+ // sizeof a,
+ // 124 };
+ // or a normal possible continuation line.
+ // but only, of no other statement has been found
+ // yet.
+ if (lookfor == LOOKFOR_INITIAL && terminated == ',')
+ {
+ if (curbuf->b_ind_js)
+ {
+ // Search for a line ending in a comma
+ // and line up with the line below it
+ // (could be the current line).
+ // some = [
+ // 1, <- line up here
+ // 2,
+ // some = [
+ // 3 + <- line up here
+ // 4 *
+ // 5,
+ // 6,
+ if (cin_iscomment(skipwhite(l)))
+ break;
+ lookfor = LOOKFOR_COMMA;
+ trypos = find_match_char('[',
+ curbuf->b_ind_maxparen);
+ if (trypos != NULL)
+ {
+ if (trypos->lnum
+ == curwin->w_cursor.lnum - 1)
+ {
+ // Current line is first inside
+ // [], line up with it.
+ break;
+ }
+ ourscope = trypos->lnum;
+ }
+ }
+ else
+ {
+ lookfor = LOOKFOR_ENUM_OR_INIT;
+ cont_amount = cin_first_id_amount();
+ }
+ }
+ else
+ {
+ if (lookfor == LOOKFOR_INITIAL
+ && *l != NUL
+ && l[STRLEN(l) - 1] == '\\')
+ // XXX
+ cont_amount = cin_get_equal_amount(
+ curwin->w_cursor.lnum);
+ if (lookfor != LOOKFOR_TERM
+ && lookfor != LOOKFOR_JS_KEY
+ && lookfor != LOOKFOR_COMMA
+ && raw_string_start != curwin->w_cursor.lnum)
+ lookfor = LOOKFOR_UNTERM;
+ }
+ }
+ }
+ }
+
+ // Check if we are after a while (cond);
+ // If so: Ignore until the matching "do".
+ else if (cin_iswhileofdo_end(terminated)) // XXX
+ {
+ // Found an unterminated line after a while ();, line up
+ // with the last one.
+ // while (cond);
+ // 100 + <- line up with this one
+ // -> here;
+ if (lookfor == LOOKFOR_UNTERM
+ || lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ break;
+ }
+
+ if (whilelevel == 0)
+ {
+ lookfor = LOOKFOR_TERM;
+ amount = get_indent(); // XXX
+ if (theline[0] == '{')
+ amount += curbuf->b_ind_open_extra;
+ }
+ ++whilelevel;
+ }
+
+ // We are after a "normal" statement.
+ // If we had another statement we can stop now and use the
+ // indent of that other statement.
+ // Otherwise the indent of the current statement may be used,
+ // search backwards for the next "normal" statement.
+ else
+ {
+ // Skip single break line, if before a switch label. It
+ // may be lined up with the case label.
+ if (lookfor == LOOKFOR_NOBREAK
+ && cin_isbreak(skipwhite(ml_get_curline())))
+ {
+ lookfor = LOOKFOR_ANY;
+ continue;
+ }
+
+ // Handle "do {" line.
+ if (whilelevel > 0)
+ {
+ l = cin_skipcomment(ml_get_curline());
+ if (cin_isdo(l))
+ {
+ amount = get_indent(); // XXX
+ --whilelevel;
+ continue;
+ }
+ }
+
+ // Found a terminated line above an unterminated line. Add
+ // the amount for a continuation line.
+ // x = 1;
+ // y = foo +
+ // -> here;
+ // or
+ // int x = 1;
+ // int foo,
+ // -> here;
+ if (lookfor == LOOKFOR_UNTERM
+ || lookfor == LOOKFOR_ENUM_OR_INIT)
+ {
+ if (cont_amount > 0)
+ amount = cont_amount;
+ else
+ amount += ind_continuation;
+ break;
+ }
+
+ // Found a terminated line above a terminated line or "if"
+ // etc. line. Use the amount of the line below us.
+ // x = 1; x = 1;
+ // if (asdf) y = 2;
+ // while (asdf) ->here;
+ // here;
+ // ->foo;
+ if (lookfor == LOOKFOR_TERM)
+ {
+ if (!lookfor_break && whilelevel == 0)
+ break;
+ }
+
+ // First line above the one we're indenting is terminated.
+ // To know what needs to be done look further backward for
+ // a terminated line.
+ else
+ {
+ // position the cursor over the rightmost paren, so
+ // that matching it will take us back to the start of
+ // the line. Helps for:
+ // func(asdr,
+ // asdfasdf);
+ // here;
+term_again:
+ l = ml_get_curline();
+ if (find_last_paren(l, '(', ')')
+ && (trypos = find_match_paren(
+ curbuf->b_ind_maxparen)) != NULL)
+ {
+ // Check if we are on a case label now. This is
+ // handled above.
+ // case xx: if ( asdf &&
+ // asdf)
+ curwin->w_cursor = *trypos;
+ l = ml_get_curline();
+ if (cin_iscase(l, FALSE) || cin_isscopedecl(l))
+ {
+ ++curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+ }
+
+ // When aligning with the case statement, don't align
+ // with a statement after it.
+ // case 1: { <-- don't use this { position
+ // stat;
+ // }
+ // case 2:
+ // stat;
+ // }
+ iscase = (curbuf->b_ind_keep_case_label
+ && cin_iscase(l, FALSE));
+
+ // Get indent and pointer to text for current line,
+ // ignoring any jump label.
+ amount = skip_label(curwin->w_cursor.lnum, &l);
+
+ if (theline[0] == '{')
+ amount += curbuf->b_ind_open_extra;
+ // See remark above: "Only add b_ind_open_extra.."
+ l = skipwhite(l);
+ if (*l == '{')
+ amount -= curbuf->b_ind_open_extra;
+ lookfor = iscase ? LOOKFOR_ANY : LOOKFOR_TERM;
+
+ // When a terminated line starts with "else" skip to
+ // the matching "if":
+ // else 3;
+ // indent this;
+ // Need to use the scope of this "else". XXX
+ // If whilelevel != 0 continue looking for a "do {".
+ if (lookfor == LOOKFOR_TERM
+ && *l != '}'
+ && cin_iselse(l)
+ && whilelevel == 0)
+ {
+ if ((trypos = find_start_brace()) == NULL
+ || find_match(LOOKFOR_IF, trypos->lnum)
+ == FAIL)
+ break;
+ continue;
+ }
+
+ // If we're at the end of a block, skip to the start of
+ // that block.
+ l = ml_get_curline();
+ if (find_last_paren(l, '{', '}') // XXX
+ && (trypos = find_start_brace()) != NULL)
+ {
+ curwin->w_cursor = *trypos;
+ // if not "else {" check for terminated again
+ // but skip block for "} else {"
+ l = cin_skipcomment(ml_get_curline());
+ if (*l == '}' || !cin_iselse(l))
+ goto term_again;
+ ++curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // add extra indent for a comment
+ if (cin_iscomment(theline))
+ amount += curbuf->b_ind_comment;
+
+ // subtract extra left-shift for jump labels
+ if (curbuf->b_ind_jump_label > 0 && original_line_islabel)
+ amount -= curbuf->b_ind_jump_label;
+
+ goto theend;
+ }
+
+ // ok -- we're not inside any sort of structure at all!
+ //
+ // This means we're at the top level, and everything should
+ // basically just match where the previous line is, except
+ // for the lines immediately following a function declaration,
+ // which are K&R-style parameters and need to be indented.
+ //
+ // if our line starts with an open brace, forget about any
+ // prevailing indent and make sure it looks like the start
+ // of a function
+
+ if (theline[0] == '{')
+ {
+ amount = curbuf->b_ind_first_open;
+ goto theend;
+ }
+
+ // If the NEXT line is a function declaration, the current
+ // line needs to be indented as a function type spec.
+ // Don't do this if the current line looks like a comment or if the
+ // current line is terminated, ie. ends in ';', or if the current line
+ // contains { or }: "void f() {\n if (1)"
+ if (cur_curpos.lnum < curbuf->b_ml.ml_line_count
+ && !cin_nocode(theline)
+ && vim_strchr(theline, '{') == NULL
+ && vim_strchr(theline, '}') == NULL
+ && !cin_ends_in(theline, (char_u *)":", NULL)
+ && !cin_ends_in(theline, (char_u *)",", NULL)
+ && cin_isfuncdecl(NULL, cur_curpos.lnum + 1,
+ cur_curpos.lnum + 1)
+ && !cin_isterminated(theline, FALSE, TRUE))
+ {
+ amount = curbuf->b_ind_func_type;
+ goto theend;
+ }
+
+ // search backwards until we find something we recognize
+ amount = 0;
+ curwin->w_cursor = cur_curpos;
+ while (curwin->w_cursor.lnum > 1)
+ {
+ curwin->w_cursor.lnum--;
+ curwin->w_cursor.col = 0;
+
+ l = ml_get_curline();
+
+ // If we're in a comment or raw string now, skip to the start
+ // of it. XXX
+ if ((trypos = ind_find_start_CORS(NULL)) != NULL)
+ {
+ curwin->w_cursor.lnum = trypos->lnum + 1;
+ curwin->w_cursor.col = 0;
+ continue;
+ }
+
+ // Are we at the start of a cpp base class declaration or
+ // constructor initialization? XXX
+ n = FALSE;
+ if (curbuf->b_ind_cpp_baseclass != 0 && theline[0] != '{')
+ {
+ n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
+ l = ml_get_curline();
+ }
+ if (n)
+ {
+ // XXX
+ amount = get_baseclass_amount(cache_cpp_baseclass.lpos.col);
+ break;
+ }
+
+ // Skip preprocessor directives and blank lines.
+ if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount))
+ continue;
+
+ if (cin_nocode(l))
+ continue;
+
+ // If the previous line ends in ',', use one level of
+ // indentation:
+ // int foo,
+ // bar;
+ // do this before checking for '}' in case of eg.
+ // enum foobar
+ // {
+ // ...
+ // } foo,
+ // bar;
+ n = 0;
+ if (cin_ends_in(l, (char_u *)",", NULL)
+ || (*l != NUL && (n = l[STRLEN(l) - 1]) == '\\'))
+ {
+ // take us back to opening paren
+ if (find_last_paren(l, '(', ')')
+ && (trypos = find_match_paren(
+ curbuf->b_ind_maxparen)) != NULL)
+ curwin->w_cursor = *trypos;
+
+ // For a line ending in ',' that is a continuation line go
+ // back to the first line with a backslash:
+ // char *foo = "bla{backslash}
+ // bla",
+ // here;
+ while (n == 0 && curwin->w_cursor.lnum > 1)
+ {
+ l = ml_get(curwin->w_cursor.lnum - 1);
+ if (*l == NUL || l[STRLEN(l) - 1] != '\\')
+ break;
+ --curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0;
+ }
+
+ amount = get_indent(); // XXX
+
+ if (amount == 0)
+ amount = cin_first_id_amount();
+ if (amount == 0)
+ amount = ind_continuation;
+ break;
+ }
+
+ // If the line looks like a function declaration, and we're
+ // not in a comment, put it the left margin.
+ if (cin_isfuncdecl(NULL, cur_curpos.lnum, 0)) // XXX
+ break;
+ l = ml_get_curline();
+
+ // Finding the closing '}' of a previous function. Put
+ // current line at the left margin. For when 'cino' has "fs".
+ if (*skipwhite(l) == '}')
+ break;
+
+ // (matching {)
+ // If the previous line ends on '};' (maybe followed by
+ // comments) align at column 0. For example:
+ // char *string_array[] = { "foo",
+ // / * x * / "b};ar" }; / * foobar * /
+ if (cin_ends_in(l, (char_u *)"};", NULL))
+ break;
+
+ // If the previous line ends on '[' we are probably in an
+ // array constant:
+ // something = [
+ // 234, <- extra indent
+ if (cin_ends_in(l, (char_u *)"[", NULL))
+ {
+ amount = get_indent() + ind_continuation;
+ break;
+ }
+
+ // Find a line only has a semicolon that belongs to a previous
+ // line ending in '}', e.g. before an #endif. Don't increase
+ // indent then.
+ if (*(look = skipwhite(l)) == ';' && cin_nocode(look + 1))
+ {
+ pos_T curpos_save = curwin->w_cursor;
+
+ while (curwin->w_cursor.lnum > 1)
+ {
+ look = ml_get(--curwin->w_cursor.lnum);
+ if (!(cin_nocode(look) || cin_ispreproc_cont(
+ &look, &curwin->w_cursor.lnum, &amount)))
+ break;
+ }
+ if (curwin->w_cursor.lnum > 0
+ && cin_ends_in(look, (char_u *)"}", NULL))
+ break;
+
+ curwin->w_cursor = curpos_save;
+ }
+
+ // If the PREVIOUS line is a function declaration, the current
+ // line (and the ones that follow) needs to be indented as
+ // parameters.
+ if (cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0))
+ {
+ amount = curbuf->b_ind_param;
+ break;
+ }
+
+ // If the previous line ends in ';' and the line before the
+ // previous line ends in ',' or '\', ident to column zero:
+ // int foo,
+ // bar;
+ // indent_to_0 here;
+ if (cin_ends_in(l, (char_u *)";", NULL))
+ {
+ l = ml_get(curwin->w_cursor.lnum - 1);
+ if (cin_ends_in(l, (char_u *)",", NULL)
+ || (*l != NUL && l[STRLEN(l) - 1] == '\\'))
+ break;
+ l = ml_get_curline();
+ }
+
+ // Doesn't look like anything interesting -- so just
+ // use the indent of this line.
+ //
+ // Position the cursor over the rightmost paren, so that
+ // matching it will take us back to the start of the line.
+ find_last_paren(l, '(', ')');
+
+ if ((trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
+ curwin->w_cursor = *trypos;
+ amount = get_indent(); // XXX
+ break;
+ }
+
+ // add extra indent for a comment
+ if (cin_iscomment(theline))
+ amount += curbuf->b_ind_comment;
+
+ // add extra indent if the previous line ended in a backslash:
+ // "asdfasdf{backslash}
+ // here";
+ // char *foo = "asdf{backslash}
+ // here";
+ if (cur_curpos.lnum > 1)
+ {
+ l = ml_get(cur_curpos.lnum - 1);
+ if (*l != NUL && l[STRLEN(l) - 1] == '\\')
+ {
+ cur_amount = cin_get_equal_amount(cur_curpos.lnum - 1);
+ if (cur_amount > 0)
+ amount = cur_amount;
+ else if (cur_amount == 0)
+ amount += ind_continuation;
+ }
+ }
+
+theend:
+ if (amount < 0)
+ amount = 0;
+
+laterend:
+ // put the cursor back where it belongs
+ curwin->w_cursor = cur_curpos;
+
+ vim_free(linecopy);
+
+ return amount;
+}
+
+/*
+ * return TRUE if 'cinkeys' contains the key "keytyped",
+ * when == '*': Only if key is preceded with '*' (indent before insert)
+ * when == '!': Only if key is preceded with '!' (don't insert)
+ * when == ' ': Only if key is not preceded with '*'(indent afterwards)
+ *
+ * "keytyped" can have a few special values:
+ * KEY_OPEN_FORW
+ * KEY_OPEN_BACK
+ * KEY_COMPLETE just finished completion.
+ *
+ * If line_is_empty is TRUE accept keys with '0' before them.
+ */
+ int
+in_cinkeys(
+ int keytyped,
+ int when,
+ int line_is_empty)
+{
+ char_u *look;
+ int try_match;
+ int try_match_word;
+ char_u *p;
+ char_u *line;
+ int icase;
+ int i;
+
+ if (keytyped == NUL)
+ // Can happen with CTRL-Y and CTRL-E on a short line.
+ return FALSE;
+
+#ifdef FEAT_EVAL
+ if (*curbuf->b_p_inde != NUL)
+ look = curbuf->b_p_indk; // 'indentexpr' set: use 'indentkeys'
+ else
+#endif
+ look = curbuf->b_p_cink; // 'indentexpr' empty: use 'cinkeys'
+ while (*look)
+ {
+ // Find out if we want to try a match with this key, depending on
+ // 'when' and a '*' or '!' before the key.
+ switch (when)
+ {
+ case '*': try_match = (*look == '*'); break;
+ case '!': try_match = (*look == '!'); break;
+ default: try_match = (*look != '*'); break;
+ }
+ if (*look == '*' || *look == '!')
+ ++look;
+
+ // If there is a '0', only accept a match if the line is empty.
+ // But may still match when typing last char of a word.
+ if (*look == '0')
+ {
+ try_match_word = try_match;
+ if (!line_is_empty)
+ try_match = FALSE;
+ ++look;
+ }
+ else
+ try_match_word = FALSE;
+
+ // does it look like a control character?
+ if (*look == '^'
+#ifdef EBCDIC
+ && (Ctrl_chr(look[1]) != 0)
+#else
+ && look[1] >= '?' && look[1] <= '_'
+#endif
+ )
+ {
+ if (try_match && keytyped == Ctrl_chr(look[1]))
+ return TRUE;
+ look += 2;
+ }
+ // 'o' means "o" command, open forward.
+ // 'O' means "O" command, open backward.
+ else if (*look == 'o')
+ {
+ if (try_match && keytyped == KEY_OPEN_FORW)
+ return TRUE;
+ ++look;
+ }
+ else if (*look == 'O')
+ {
+ if (try_match && keytyped == KEY_OPEN_BACK)
+ return TRUE;
+ ++look;
+ }
+
+ // 'e' means to check for "else" at start of line and just before the
+ // cursor.
+ else if (*look == 'e')
+ {
+ if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4)
+ {
+ p = ml_get_curline();
+ if (skipwhite(p) == p + curwin->w_cursor.col - 4 &&
+ STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0)
+ return TRUE;
+ }
+ ++look;
+ }
+
+ // ':' only causes an indent if it is at the end of a label or case
+ // statement, or when it was before typing the ':' (to fix
+ // class::method for C++).
+ else if (*look == ':')
+ {
+ if (try_match && keytyped == ':')
+ {
+ p = ml_get_curline();
+ if (cin_iscase(p, FALSE) || cin_isscopedecl(p) || cin_islabel())
+ return TRUE;
+ // Need to get the line again after cin_islabel().
+ p = ml_get_curline();
+ if (curwin->w_cursor.col > 2
+ && p[curwin->w_cursor.col - 1] == ':'
+ && p[curwin->w_cursor.col - 2] == ':')
+ {
+ p[curwin->w_cursor.col - 1] = ' ';
+ i = (cin_iscase(p, FALSE) || cin_isscopedecl(p)
+ || cin_islabel());
+ p = ml_get_curline();
+ p[curwin->w_cursor.col - 1] = ':';
+ if (i)
+ return TRUE;
+ }
+ }
+ ++look;
+ }
+
+
+ // Is it a key in <>, maybe?
+ else if (*look == '<')
+ {
+ if (try_match)
+ {
+ // make up some named keys <o>, <O>, <e>, <0>, <>>, <<>, <*>,
+ // <:> and <!> so that people can re-indent on o, O, e, 0, <,
+ // >, *, : and ! keys if they really really want to.
+ if (vim_strchr((char_u *)"<>!*oOe0:", look[1]) != NULL
+ && keytyped == look[1])
+ return TRUE;
+
+ if (keytyped == get_special_key_code(look + 1))
+ return TRUE;
+ }
+ while (*look && *look != '>')
+ look++;
+ while (*look == '>')
+ look++;
+ }
+
+ // Is it a word: "=word"?
+ else if (*look == '=' && look[1] != ',' && look[1] != NUL)
+ {
+ ++look;
+ if (*look == '~')
+ {
+ icase = TRUE;
+ ++look;
+ }
+ else
+ icase = FALSE;
+ p = vim_strchr(look, ',');
+ if (p == NULL)
+ p = look + STRLEN(look);
+ if ((try_match || try_match_word)
+ && curwin->w_cursor.col >= (colnr_T)(p - look))
+ {
+ int match = FALSE;
+
+ if (keytyped == KEY_COMPLETE)
+ {
+ char_u *s;
+
+ // Just completed a word, check if it starts with "look".
+ // search back for the start of a word.
+ line = ml_get_curline();
+ if (has_mbyte)
+ {
+ char_u *n;
+
+ for (s = line + curwin->w_cursor.col; s > line; s = n)
+ {
+ n = mb_prevptr(line, s);
+ if (!vim_iswordp(n))
+ break;
+ }
+ }
+ else
+ for (s = line + curwin->w_cursor.col; s > line; --s)
+ if (!vim_iswordc(s[-1]))
+ break;
+ if (s + (p - look) <= line + curwin->w_cursor.col
+ && (icase
+ ? MB_STRNICMP(s, look, p - look)
+ : STRNCMP(s, look, p - look)) == 0)
+ match = TRUE;
+ }
+ else
+ // TODO: multi-byte
+ if (keytyped == (int)p[-1] || (icase && keytyped < 256
+ && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1])))
+ {
+ line = ml_get_cursor();
+ if ((curwin->w_cursor.col == (colnr_T)(p - look)
+ || !vim_iswordc(line[-(p - look) - 1]))
+ && (icase
+ ? MB_STRNICMP(line - (p - look), look, p - look)
+ : STRNCMP(line - (p - look), look, p - look))
+ == 0)
+ match = TRUE;
+ }
+ if (match && try_match_word && !try_match)
+ {
+ // "0=word": Check if there are only blanks before the
+ // word.
+ if (getwhitecols_curline() !=
+ (int)(curwin->w_cursor.col - (p - look)))
+ match = FALSE;
+ }
+ if (match)
+ return TRUE;
+ }
+ look = p;
+ }
+
+ // ok, it's a boring generic character.
+ else
+ {
+ if (try_match && *look == keytyped)
+ return TRUE;
+ if (*look != NUL)
+ ++look;
+ }
+
+ // Skip over ", ".
+ look = skip_to_option_part(look);
+ }
+ return FALSE;
+}
+
+/*
+ * Do C or expression indenting on the current line.
+ */
+ void
+do_c_expr_indent(void)
+{
+# ifdef FEAT_EVAL
+ if (*curbuf->b_p_inde != NUL)
+ fixthisline(get_expr_indent);
+ else
+# endif
+ fixthisline(get_c_indent);
+}
+#endif
+
+#if defined(FEAT_EVAL) || defined(PROTO)
+/*
+ * "cindent(lnum)" function
+ */
+ void
+f_cindent(typval_T *argvars UNUSED, typval_T *rettv)
+{
+# ifdef FEAT_CINDENT
+ pos_T pos;
+ linenr_T lnum;
+
+ pos = curwin->w_cursor;
+ lnum = tv_get_lnum(argvars);
+ if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
+ {
+ curwin->w_cursor.lnum = lnum;
+ rettv->vval.v_number = get_c_indent();
+ curwin->w_cursor = pos;
+ }
+ else
+# endif
+ rettv->vval.v_number = -1;
+}
+#endif
#include "vim.h"
-#if defined(FEAT_CINDENT) || defined(FEAT_SMARTINDENT)
-
-static int cin_iscase(char_u *s, int strict);
-static int cin_isscopedecl(char_u *s);
+#if defined(FEAT_VARTABS) || defined(PROTO)
/*
- * Return TRUE if the string "line" starts with a word from 'cinwords'.
+ * Set the integer values corresponding to the string setting of 'vartabstop'.
+ * "array" will be set, caller must free it if needed.
*/
int
-cin_is_cinword(char_u *line)
+tabstop_set(char_u *var, int **array)
{
- char_u *cinw;
- char_u *cinw_buf;
- int cinw_len;
- int retval = FALSE;
- int len;
+ int valcount = 1;
+ int t;
+ char_u *cp;
+
+ if (var[0] == NUL || (var[0] == '0' && var[1] == NUL))
+ {
+ *array = NULL;
+ return TRUE;
+ }
- cinw_len = (int)STRLEN(curbuf->b_p_cinw) + 1;
- cinw_buf = alloc(cinw_len);
- if (cinw_buf != NULL)
+ for (cp = var; *cp != NUL; ++cp)
{
- line = skipwhite(line);
- for (cinw = curbuf->b_p_cinw; *cinw; )
+ if (cp == var || cp[-1] == ',')
{
- len = copy_option_part(&cinw, cinw_buf, cinw_len, ",");
- if (STRNCMP(line, cinw_buf, len) == 0
- && (!vim_iswordc(line[len]) || !vim_iswordc(line[len - 1])))
+ char_u *end;
+
+ if (strtol((char *)cp, (char **)&end, 10) <= 0)
{
- retval = TRUE;
- break;
+ if (cp != end)
+ emsg(_(e_positive));
+ else
+ emsg(_(e_invarg));
+ return FALSE;
}
}
- vim_free(cinw_buf);
- }
- return retval;
-}
-#endif
-
-#if defined(FEAT_CINDENT) || defined(FEAT_SYN_HL)
-static char_u *skip_string(char_u *p);
-static pos_T *find_start_rawstring(int ind_maxcomment);
-
-/*
- * Find the start of a comment, not knowing if we are in a comment right now.
- * Search starts at w_cursor.lnum and goes backwards.
- * Return NULL when not inside a comment.
- */
- static pos_T *
-ind_find_start_comment(void) // XXX
-{
- return find_start_comment(curbuf->b_ind_maxcomment);
-}
-
- pos_T *
-find_start_comment(int ind_maxcomment) // XXX
-{
- pos_T *pos;
- char_u *line;
- char_u *p;
- int cur_maxcomment = ind_maxcomment;
-
- for (;;)
- {
- pos = findmatchlimit(NULL, '*', FM_BACKWARD, cur_maxcomment);
- if (pos == NULL)
- break;
-
- // Check if the comment start we found is inside a string.
- // If it is then restrict the search to below this line and try again.
- line = ml_get(pos->lnum);
- for (p = line; *p && (colnr_T)(p - line) < pos->col; ++p)
- p = skip_string(p);
- if ((colnr_T)(p - line) <= pos->col)
- break;
- cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
- if (cur_maxcomment <= 0)
+ if (VIM_ISDIGIT(*cp))
+ continue;
+ if (cp[0] == ',' && cp > var && cp[-1] != ',' && cp[1] != NUL)
{
- pos = NULL;
- break;
+ ++valcount;
+ continue;
}
+ emsg(_(e_invarg));
+ return FALSE;
}
- return pos;
-}
-/*
- * Find the start of a comment or raw string, not knowing if we are in a
- * comment or raw string right now.
- * Search starts at w_cursor.lnum and goes backwards.
- * If is_raw is given and returns start of raw_string, sets it to true.
- * Return NULL when not inside a comment or raw string.
- * "CORS" -> Comment Or Raw String
- */
- static pos_T *
-ind_find_start_CORS(linenr_T *is_raw) // XXX
-{
- static pos_T comment_pos_copy;
- pos_T *comment_pos;
- pos_T *rs_pos;
+ *array = ALLOC_MULT(int, valcount + 1);
+ if (*array == NULL)
+ return FALSE;
+ (*array)[0] = valcount;
- comment_pos = find_start_comment(curbuf->b_ind_maxcomment);
- if (comment_pos != NULL)
+ t = 1;
+ for (cp = var; *cp != NUL;)
{
- // Need to make a copy of the static pos in findmatchlimit(),
- // calling find_start_rawstring() may change it.
- comment_pos_copy = *comment_pos;
- comment_pos = &comment_pos_copy;
+ (*array)[t++] = atoi((char *)cp);
+ while (*cp != NUL && *cp != ',')
+ ++cp;
+ if (*cp != NUL)
+ ++cp;
}
- rs_pos = find_start_rawstring(curbuf->b_ind_maxcomment);
- // If comment_pos is before rs_pos the raw string is inside the comment.
- // If rs_pos is before comment_pos the comment is inside the raw string.
- if (comment_pos == NULL || (rs_pos != NULL
- && LT_POS(*rs_pos, *comment_pos)))
- {
- if (is_raw != NULL && rs_pos != NULL)
- *is_raw = rs_pos->lnum;
- return rs_pos;
- }
- return comment_pos;
+ return TRUE;
}
/*
- * Find the start of a raw string, not knowing if we are in one right now.
- * Search starts at w_cursor.lnum and goes backwards.
- * Return NULL when not inside a raw string.
+ * Calculate the number of screen spaces a tab will occupy.
+ * If "vts" is set then the tab widths are taken from that array,
+ * otherwise the value of ts is used.
*/
- static pos_T *
-find_start_rawstring(int ind_maxcomment) // XXX
+ int
+tabstop_padding(colnr_T col, int ts_arg, int *vts)
{
- pos_T *pos;
- char_u *line;
- char_u *p;
- int cur_maxcomment = ind_maxcomment;
+ int ts = ts_arg == 0 ? 8 : ts_arg;
+ int tabcount;
+ colnr_T tabcol = 0;
+ int t;
+ int padding = 0;
- for (;;)
- {
- pos = findmatchlimit(NULL, 'R', FM_BACKWARD, cur_maxcomment);
- if (pos == NULL)
- break;
+ if (vts == NULL || vts[0] == 0)
+ return ts - (col % ts);
- // Check if the raw string start we found is inside a string.
- // If it is then restrict the search to below this line and try again.
- line = ml_get(pos->lnum);
- for (p = line; *p && (colnr_T)(p - line) < pos->col; ++p)
- p = skip_string(p);
- if ((colnr_T)(p - line) <= pos->col)
- break;
- cur_maxcomment = curwin->w_cursor.lnum - pos->lnum - 1;
- if (cur_maxcomment <= 0)
+ tabcount = vts[0];
+
+ for (t = 1; t <= tabcount; ++t)
+ {
+ tabcol += vts[t];
+ if (tabcol > col)
{
- pos = NULL;
+ padding = (int)(tabcol - col);
break;
}
}
- return pos;
+ if (t > tabcount)
+ padding = vts[tabcount] - (int)((col - tabcol) % vts[tabcount]);
+
+ return padding;
}
/*
- * Skip to the end of a "string" and a 'c' character.
- * If there is no string or character, return argument unmodified.
+ * Find the size of the tab that covers a particular column.
*/
- static char_u *
-skip_string(char_u *p)
+ int
+tabstop_at(colnr_T col, int ts, int *vts)
{
- int i;
+ int tabcount;
+ colnr_T tabcol = 0;
+ int t;
+ int tab_size = 0;
+
+ if (vts == 0 || vts[0] == 0)
+ return ts;
- // We loop, because strings may be concatenated: "date""time".
- for ( ; ; ++p)
+ tabcount = vts[0];
+ for (t = 1; t <= tabcount; ++t)
{
- if (p[0] == '\'') // 'c' or '\n' or '\000'
- {
- if (!p[1]) // ' at end of line
- break;
- i = 2;
- if (p[1] == '\\') // '\n' or '\000'
- {
- ++i;
- while (vim_isdigit(p[i - 1])) // '\000'
- ++i;
- }
- if (p[i] == '\'') // check for trailing '
- {
- p += i;
- continue;
- }
- }
- else if (p[0] == '"') // start of string
- {
- for (++p; p[0]; ++p)
- {
- if (p[0] == '\\' && p[1] != NUL)
- ++p;
- else if (p[0] == '"') // end of string
- break;
- }
- if (p[0] == '"')
- continue; // continue for another string
- }
- else if (p[0] == 'R' && p[1] == '"')
+ tabcol += vts[t];
+ if (tabcol > col)
{
- // Raw string: R"[delim](...)[delim]"
- char_u *delim = p + 2;
- char_u *paren = vim_strchr(delim, '(');
-
- if (paren != NULL)
- {
- size_t delim_len = paren - delim;
-
- for (p += 3; *p; ++p)
- if (p[0] == ')' && STRNCMP(p + 1, delim, delim_len) == 0
- && p[delim_len + 1] == '"')
- {
- p += delim_len + 1;
- break;
- }
- if (p[0] == '"')
- continue; // continue for another string
- }
+ tab_size = vts[t];
+ break;
}
- break; // no string found
}
- if (!*p)
- --p; // backup from NUL
- return p;
-}
-#endif // FEAT_CINDENT || FEAT_SYN_HL
+ if (t > tabcount)
+ tab_size = vts[tabcount];
-#if defined(FEAT_CINDENT) || defined(PROTO)
+ return tab_size;
+}
/*
- * Return TRUE if C-indenting is on.
+ * Find the column on which a tab starts.
*/
- int
-cindent_on(void)
+ colnr_T
+tabstop_start(colnr_T col, int ts, int *vts)
{
- return (!p_paste && (curbuf->b_p_cin
-# ifdef FEAT_EVAL
- || *curbuf->b_p_inde != NUL
-# endif
- ));
-}
+ int tabcount;
+ colnr_T tabcol = 0;
+ int t;
+ int excess;
-// Find result cache for cpp_baseclass
-typedef struct {
- int found;
- lpos_T lpos;
-} cpp_baseclass_cache_T;
+ if (vts == NULL || vts[0] == 0)
+ return (col / ts) * ts;
-/*
- * Functions for C-indenting.
- * Most of this originally comes from Eric Fischer.
- */
-/*
- * Below "XXX" means that this function may unlock the current line.
- */
+ tabcount = vts[0];
+ for (t = 1; t <= tabcount; ++t)
+ {
+ tabcol += vts[t];
+ if (tabcol > col)
+ return tabcol - vts[t];
+ }
-static int cin_isdefault(char_u *);
-static int cin_ispreproc(char_u *);
-static int cin_iscomment(char_u *);
-static int cin_islinecomment(char_u *);
-static int cin_isterminated(char_u *, int, int);
-static int cin_iselse(char_u *);
-static int cin_ends_in(char_u *, char_u *, char_u *);
-static int cin_starts_with(char_u *s, char *word);
-static pos_T *find_match_paren(int);
-static pos_T *find_match_char(int c, int ind_maxparen);
-static int find_last_paren(char_u *l, int start, int end);
-static int find_match(int lookfor, linenr_T ourscope);
+ excess = tabcol % vts[tabcount];
+ return excess + ((col - excess) / vts[tabcount]) * vts[tabcount];
+}
/*
- * Skip over white space and C comments within the line.
- * Also skip over Perl/shell comments if desired.
+ * Find the number of tabs and spaces necessary to get from one column
+ * to another.
*/
- static char_u *
-cin_skipcomment(char_u *s)
+ void
+tabstop_fromto(
+ colnr_T start_col,
+ colnr_T end_col,
+ int ts_arg,
+ int *vts,
+ int *ntabs,
+ int *nspcs)
{
- while (*s)
- {
- char_u *prev_s = s;
+ int spaces = end_col - start_col;
+ colnr_T tabcol = 0;
+ int padding = 0;
+ int tabcount;
+ int t;
+ int ts = ts_arg == 0 ? curbuf->b_p_ts : ts_arg;
- s = skipwhite(s);
+ if (vts == NULL || vts[0] == 0)
+ {
+ int tabs = 0;
+ int initspc = 0;
- // Perl/shell # comment comment continues until eol. Require a space
- // before # to avoid recognizing $#array.
- if (curbuf->b_ind_hash_comment != 0 && s != prev_s && *s == '#')
+ initspc = ts - (start_col % ts);
+ if (spaces >= initspc)
{
- s += STRLEN(s);
- break;
+ spaces -= initspc;
+ tabs++;
}
- if (*s != '/')
- break;
- ++s;
- if (*s == '/') // slash-slash comment continues till eol
+ tabs += spaces / ts;
+ spaces -= (spaces / ts) * ts;
+
+ *ntabs = tabs;
+ *nspcs = spaces;
+ return;
+ }
+
+ // Find the padding needed to reach the next tabstop.
+ tabcount = vts[0];
+ for (t = 1; t <= tabcount; ++t)
+ {
+ tabcol += vts[t];
+ if (tabcol > start_col)
{
- s += STRLEN(s);
+ padding = (int)(tabcol - start_col);
break;
}
- if (*s != '*')
- break;
- for (++s; *s; ++s) // skip slash-star comment
- if (s[0] == '*' && s[1] == '/')
- {
- s += 2;
- break;
- }
}
- return s;
-}
+ if (t > tabcount)
+ padding = vts[tabcount] - (int)((start_col - tabcol) % vts[tabcount]);
-/*
- * Return TRUE if there is no code at *s. White space and comments are
- * not considered code.
- */
- static int
-cin_nocode(char_u *s)
-{
- return *cin_skipcomment(s) == NUL;
-}
+ // If the space needed is less than the padding no tabs can be used.
+ if (spaces < padding)
+ {
+ *ntabs = 0;
+ *nspcs = spaces;
+ return;
+ }
-/*
- * Check previous lines for a "//" line comment, skipping over blank lines.
- */
- static pos_T *
-find_line_comment(void) // XXX
-{
- static pos_T pos;
- char_u *line;
- char_u *p;
+ *ntabs = 1;
+ spaces -= padding;
- pos = curwin->w_cursor;
- while (--pos.lnum > 0)
+ // At least one tab has been used. See if any more will fit.
+ while (spaces != 0 && ++t <= tabcount)
{
- line = ml_get(pos.lnum);
- p = skipwhite(line);
- if (cin_islinecomment(p))
+ padding = vts[t];
+ if (spaces < padding)
{
- pos.col = (int)(p - line);
- return &pos;
+ *nspcs = spaces;
+ return;
}
- if (*p != NUL)
- break;
+ ++*ntabs;
+ spaces -= padding;
}
- return NULL;
+
+ *ntabs += spaces / vts[tabcount];
+ *nspcs = spaces % vts[tabcount];
}
/*
- * Return TRUE if "text" starts with "key:".
+ * See if two tabstop arrays contain the same values.
*/
static int
-cin_has_js_key(char_u *text)
+tabstop_eq(int *ts1, int *ts2)
{
- char_u *s = skipwhite(text);
- int quote = -1;
+ int t;
- if (*s == '\'' || *s == '"')
- {
- // can be 'key': or "key":
- quote = *s;
- ++s;
- }
- if (!vim_isIDc(*s)) // need at least one ID character
+ if ((ts1 == 0 && ts2) || (ts1 && ts2 == 0))
+ return FALSE;
+ if (ts1 == ts2)
+ return TRUE;
+ if (ts1[0] != ts2[0])
return FALSE;
- while (vim_isIDc(*s))
- ++s;
- if (*s == quote)
- ++s;
-
- s = cin_skipcomment(s);
-
- // "::" is not a label, it's C++
- return (*s == ':' && s[1] != ':');
-}
-
-/*
- * Check if string matches "label:"; move to character after ':' if true.
- * "*s" must point to the start of the label, if there is one.
- */
- static int
-cin_islabel_skip(char_u **s)
-{
- if (!vim_isIDc(**s)) // need at least one ID character
- return FALSE;
-
- while (vim_isIDc(**s))
- (*s)++;
-
- *s = cin_skipcomment(*s);
+ for (t = 1; t <= ts1[0]; ++t)
+ if (ts1[t] != ts2[t])
+ return FALSE;
- // "::" is not a label, it's C++
- return (**s == ':' && *++*s != ':');
+ return TRUE;
}
+# if defined(FEAT_BEVAL) || defined(PROTO)
/*
- * Recognize a label: "label:".
- * Note: curwin->w_cursor must be where we are looking for the label.
+ * Copy a tabstop array, allocating space for the new array.
*/
- static int
-cin_islabel(void) // XXX
+ int *
+tabstop_copy(int *oldts)
{
- char_u *s;
-
- s = cin_skipcomment(ml_get_curline());
-
- // Exclude "default" from labels, since it should be indented
- // like a switch label. Same for C++ scope declarations.
- if (cin_isdefault(s))
- return FALSE;
- if (cin_isscopedecl(s))
- return FALSE;
-
- if (cin_islabel_skip(&s))
- {
- // Only accept a label if the previous line is terminated or is a case
- // label.
- pos_T cursor_save;
- pos_T *trypos;
- char_u *line;
-
- cursor_save = curwin->w_cursor;
- while (curwin->w_cursor.lnum > 1)
- {
- --curwin->w_cursor.lnum;
-
- // If we're in a comment or raw string now, skip to the start of
- // it.
- curwin->w_cursor.col = 0;
- if ((trypos = ind_find_start_CORS(NULL)) != NULL) // XXX
- curwin->w_cursor = *trypos;
-
- line = ml_get_curline();
- if (cin_ispreproc(line)) // ignore #defines, #if, etc.
- continue;
- if (*(line = cin_skipcomment(line)) == NUL)
- continue;
+ int *newts;
+ int t;
- curwin->w_cursor = cursor_save;
- if (cin_isterminated(line, TRUE, FALSE)
- || cin_isscopedecl(line)
- || cin_iscase(line, TRUE)
- || (cin_islabel_skip(&line) && cin_nocode(line)))
- return TRUE;
- return FALSE;
- }
- curwin->w_cursor = cursor_save;
- return TRUE; // label at start of file???
- }
- return FALSE;
+ if (oldts == NULL)
+ return NULL;
+ newts = ALLOC_MULT(int, oldts[0] + 1);
+ if (newts != NULL)
+ for (t = 0; t <= oldts[0]; ++t)
+ newts[t] = oldts[t];
+ return newts;
}
+# endif
/*
- * Recognize structure initialization and enumerations:
- * "[typedef] [static|public|protected|private] enum"
- * "[typedef] [static|public|protected|private] = {"
+ * Return a count of the number of tabstops.
*/
- static int
-cin_isinit(void)
+ int
+tabstop_count(int *ts)
{
- char_u *s;
- static char *skip[] = {"static", "public", "protected", "private"};
-
- s = cin_skipcomment(ml_get_curline());
-
- if (cin_starts_with(s, "typedef"))
- s = cin_skipcomment(s + 7);
-
- for (;;)
- {
- int i, l;
-
- for (i = 0; i < (int)(sizeof(skip) / sizeof(char *)); ++i)
- {
- l = (int)strlen(skip[i]);
- if (cin_starts_with(s, skip[i]))
- {
- s = cin_skipcomment(s + l);
- l = 0;
- break;
- }
- }
- if (l != 0)
- break;
- }
-
- if (cin_starts_with(s, "enum"))
- return TRUE;
-
- if (cin_ends_in(s, (char_u *)"=", (char_u *)"{"))
- return TRUE;
-
- return FALSE;
+ return ts != NULL ? ts[0] : 0;
}
/*
- * Recognize a switch label: "case .*:" or "default:".
+ * Return the first tabstop, or 8 if there are no tabstops defined.
*/
- static int
-cin_iscase(
- char_u *s,
- int strict) // Allow relaxed check of case statement for JS
+ int
+tabstop_first(int *ts)
{
- s = cin_skipcomment(s);
- if (cin_starts_with(s, "case"))
- {
- for (s += 4; *s; ++s)
- {
- s = cin_skipcomment(s);
- if (*s == ':')
- {
- if (s[1] == ':') // skip over "::" for C++
- ++s;
- else
- return TRUE;
- }
- if (*s == '\'' && s[1] && s[2] == '\'')
- s += 2; // skip over ':'
- else if (*s == '/' && (s[1] == '*' || s[1] == '/'))
- return FALSE; // stop at comment
- else if (*s == '"')
- {
- // JS etc.
- if (strict)
- return FALSE; // stop at string
- else
- return TRUE;
- }
- }
- return FALSE;
- }
-
- if (cin_isdefault(s))
- return TRUE;
- return FALSE;
+ return ts != NULL ? ts[1] : 8;
}
+#endif
+
/*
- * Recognize a "default" switch label.
+ * Return the effective shiftwidth value for current buffer, using the
+ * 'tabstop' value when 'shiftwidth' is zero.
*/
- static int
-cin_isdefault(char_u *s)
+ long
+get_sw_value(buf_T *buf)
{
- return (STRNCMP(s, "default", 7) == 0
- && *(s = cin_skipcomment(s + 7)) == ':'
- && s[1] != ':');
+ return get_sw_value_col(buf, 0);
}
/*
- * Recognize a "public/private/protected" scope declaration label.
+ * Idem, using "pos".
*/
- static int
-cin_isscopedecl(char_u *s)
+ static long
+get_sw_value_pos(buf_T *buf, pos_T *pos)
{
- int i;
+ pos_T save_cursor = curwin->w_cursor;
+ long sw_value;
- s = cin_skipcomment(s);
- if (STRNCMP(s, "public", 6) == 0)
- i = 6;
- else if (STRNCMP(s, "protected", 9) == 0)
- i = 9;
- else if (STRNCMP(s, "private", 7) == 0)
- i = 7;
- else
- return FALSE;
- return (*(s = cin_skipcomment(s + i)) == ':' && s[1] != ':');
+ curwin->w_cursor = *pos;
+ sw_value = get_sw_value_col(buf, get_nolist_virtcol());
+ curwin->w_cursor = save_cursor;
+ return sw_value;
}
-// Maximum number of lines to search back for a "namespace" line.
-#define FIND_NAMESPACE_LIM 20
-
/*
- * Recognize a "namespace" scope declaration.
+ * Idem, using the first non-black in the current line.
*/
- static int
-cin_is_cpp_namespace(char_u *s)
+ long
+get_sw_value_indent(buf_T *buf)
{
- char_u *p;
- int has_name = FALSE;
- int has_name_start = FALSE;
+ pos_T pos = curwin->w_cursor;
- s = cin_skipcomment(s);
- if (STRNCMP(s, "namespace", 9) == 0 && (s[9] == NUL || !vim_iswordc(s[9])))
- {
- p = cin_skipcomment(skipwhite(s + 9));
- while (*p != NUL)
- {
- if (VIM_ISWHITE(*p))
- {
- has_name = TRUE; // found end of a name
- p = cin_skipcomment(skipwhite(p));
- }
- else if (*p == '{')
- {
- break;
- }
- else if (vim_iswordc(*p))
- {
- has_name_start = TRUE;
- if (has_name)
- return FALSE; // word character after skipping past name
- ++p;
- }
- else if (p[0] == ':' && p[1] == ':' && vim_iswordc(p[2]))
- {
- if (!has_name_start || has_name)
- return FALSE;
- // C++ 17 nested namespace
- p += 3;
- }
- else
- {
- return FALSE;
- }
- }
- return TRUE;
- }
- return FALSE;
+ pos.col = getwhitecols_curline();
+ return get_sw_value_pos(buf, &pos);
}
/*
- * Recognize a `extern "C"` or `extern "C++"` linkage specifications.
+ * Idem, using virtual column "col".
*/
- static int
-cin_is_cpp_extern_c(char_u *s)
+ long
+get_sw_value_col(buf_T *buf, colnr_T col UNUSED)
{
- char_u *p;
- int has_string_literal = FALSE;
-
- s = cin_skipcomment(s);
- if (STRNCMP(s, "extern", 6) == 0 && (s[6] == NUL || !vim_iswordc(s[6])))
- {
- p = cin_skipcomment(skipwhite(s + 6));
- while (*p != NUL)
- {
- if (VIM_ISWHITE(*p))
- {
- p = cin_skipcomment(skipwhite(p));
- }
- else if (*p == '{')
- {
- break;
- }
- else if (p[0] == '"' && p[1] == 'C' && p[2] == '"')
- {
- if (has_string_literal)
- return FALSE;
- has_string_literal = TRUE;
- p += 3;
- }
- else if (p[0] == '"' && p[1] == 'C' && p[2] == '+' && p[3] == '+'
- && p[4] == '"')
- {
- if (has_string_literal)
- return FALSE;
- has_string_literal = TRUE;
- p += 5;
- }
- else
- {
- return FALSE;
- }
- }
- return has_string_literal ? TRUE : FALSE;
- }
- return FALSE;
+ return buf->b_p_sw ? buf->b_p_sw :
+#ifdef FEAT_VARTABS
+ tabstop_at(col, buf->b_p_ts, buf->b_p_vts_array);
+#else
+ buf->b_p_ts;
+#endif
}
/*
- * Return a pointer to the first non-empty non-comment character after a ':'.
- * Return NULL if not found.
- * case 234: a = b;
- * ^
+ * Return the effective softtabstop value for the current buffer, using the
+ * 'shiftwidth' value when 'softtabstop' is negative.
*/
- static char_u *
-after_label(char_u *l)
+ long
+get_sts_value(void)
{
- for ( ; *l; ++l)
- {
- if (*l == ':')
- {
- if (l[1] == ':') // skip over "::" for C++
- ++l;
- else if (!cin_iscase(l + 1, FALSE))
- break;
- }
- else if (*l == '\'' && l[1] && l[2] == '\'')
- l += 2; // skip over 'x'
- }
- if (*l == NUL)
- return NULL;
- l = cin_skipcomment(l + 1);
- if (*l == NUL)
- return NULL;
- return l;
+ return curbuf->b_p_sts < 0 ? get_sw_value(curbuf) : curbuf->b_p_sts;
}
/*
- * Get indent of line "lnum", skipping a label.
- * Return 0 if there is nothing after the label.
+ * Count the size (in window cells) of the indent in the current line.
*/
- static int
-get_indent_nolabel (linenr_T lnum) // XXX
+ int
+get_indent(void)
{
- char_u *l;
- pos_T fp;
- colnr_T col;
- char_u *p;
-
- l = ml_get(lnum);
- p = after_label(l);
- if (p == NULL)
- return 0;
-
- fp.col = (colnr_T)(p - l);
- fp.lnum = lnum;
- getvcol(curwin, &fp, &col, NULL, NULL);
- return (int)col;
+#ifdef FEAT_VARTABS
+ return get_indent_str_vtab(ml_get_curline(), (int)curbuf->b_p_ts,
+ curbuf->b_p_vts_array, FALSE);
+#else
+ return get_indent_str(ml_get_curline(), (int)curbuf->b_p_ts, FALSE);
+#endif
}
/*
- * Find indent for line "lnum", ignoring any case or jump label.
- * Also return a pointer to the text (after the label) in "pp".
- * label: if (asdf && asdfasdf)
- * ^
+ * Count the size (in window cells) of the indent in line "lnum".
*/
- static int
-skip_label(linenr_T lnum, char_u **pp)
+ int
+get_indent_lnum(linenr_T lnum)
{
- char_u *l;
- int amount;
- pos_T cursor_save;
-
- cursor_save = curwin->w_cursor;
- curwin->w_cursor.lnum = lnum;
- l = ml_get_curline();
- // XXX
- if (cin_iscase(l, FALSE) || cin_isscopedecl(l) || cin_islabel())
- {
- amount = get_indent_nolabel(lnum);
- l = after_label(ml_get_curline());
- if (l == NULL) // just in case
- l = ml_get_curline();
- }
- else
- {
- amount = get_indent();
- l = ml_get_curline();
- }
- *pp = l;
-
- curwin->w_cursor = cursor_save;
- return amount;
+#ifdef FEAT_VARTABS
+ return get_indent_str_vtab(ml_get(lnum), (int)curbuf->b_p_ts,
+ curbuf->b_p_vts_array, FALSE);
+#else
+ return get_indent_str(ml_get(lnum), (int)curbuf->b_p_ts, FALSE);
+#endif
}
+#if defined(FEAT_FOLDING) || defined(PROTO)
/*
- * Return the indent of the first variable name after a type in a declaration.
- * int a, indent of "a"
- * static struct foo b, indent of "b"
- * enum bla c, indent of "c"
- * Returns zero when it doesn't look like a declaration.
+ * Count the size (in window cells) of the indent in line "lnum" of buffer
+ * "buf".
*/
- static int
-cin_first_id_amount(void)
+ int
+get_indent_buf(buf_T *buf, linenr_T lnum)
{
- char_u *line, *p, *s;
- int len;
- pos_T fp;
- colnr_T col;
-
- line = ml_get_curline();
- p = skipwhite(line);
- len = (int)(skiptowhite(p) - p);
- if (len == 6 && STRNCMP(p, "static", 6) == 0)
- {
- p = skipwhite(p + 6);
- len = (int)(skiptowhite(p) - p);
- }
- if (len == 6 && STRNCMP(p, "struct", 6) == 0)
- p = skipwhite(p + 6);
- else if (len == 4 && STRNCMP(p, "enum", 4) == 0)
- p = skipwhite(p + 4);
- else if ((len == 8 && STRNCMP(p, "unsigned", 8) == 0)
- || (len == 6 && STRNCMP(p, "signed", 6) == 0))
- {
- s = skipwhite(p + len);
- if ((STRNCMP(s, "int", 3) == 0 && VIM_ISWHITE(s[3]))
- || (STRNCMP(s, "long", 4) == 0 && VIM_ISWHITE(s[4]))
- || (STRNCMP(s, "short", 5) == 0 && VIM_ISWHITE(s[5]))
- || (STRNCMP(s, "char", 4) == 0 && VIM_ISWHITE(s[4])))
- p = s;
- }
- for (len = 0; vim_isIDc(p[len]); ++len)
- ;
- if (len == 0 || !VIM_ISWHITE(p[len]) || cin_nocode(p))
- return 0;
-
- p = skipwhite(p + len);
- fp.lnum = curwin->w_cursor.lnum;
- fp.col = (colnr_T)(p - line);
- getvcol(curwin, &fp, &col, NULL, NULL);
- return (int)col;
+# ifdef FEAT_VARTABS
+ return get_indent_str_vtab(ml_get_buf(buf, lnum, FALSE),
+ (int)curbuf->b_p_ts, buf->b_p_vts_array, FALSE);
+# else
+ return get_indent_str(ml_get_buf(buf, lnum, FALSE), (int)buf->b_p_ts, FALSE);
+# endif
}
+#endif
/*
- * Return the indent of the first non-blank after an equal sign.
- * char *foo = "here";
- * Return zero if no (useful) equal sign found.
- * Return -1 if the line above "lnum" ends in a backslash.
- * foo = "asdf\
- * asdf\
- * here";
+ * count the size (in window cells) of the indent in line "ptr", with
+ * 'tabstop' at "ts"
*/
- static int
-cin_get_equal_amount(linenr_T lnum)
+ int
+get_indent_str(
+ char_u *ptr,
+ int ts,
+ int list) // if TRUE, count only screen size for tabs
{
- char_u *line;
- char_u *s;
- colnr_T col;
- pos_T fp;
-
- if (lnum > 1)
- {
- line = ml_get(lnum - 1);
- if (*line != NUL && line[STRLEN(line) - 1] == '\\')
- return -1;
- }
+ int count = 0;
- line = s = ml_get(lnum);
- while (*s != NUL && vim_strchr((char_u *)"=;{}\"'", *s) == NULL)
+ for ( ; *ptr; ++ptr)
{
- if (cin_iscomment(s)) // ignore comments
- s = cin_skipcomment(s);
+ if (*ptr == TAB)
+ {
+ if (!list || lcs_tab1) // count a tab for what it is worth
+ count += ts - (count % ts);
+ else
+ // In list mode, when tab is not set, count screen char width
+ // for Tab, displays: ^I
+ count += ptr2cells(ptr);
+ }
+ else if (*ptr == ' ')
+ ++count; // count a space for one
else
- ++s;
+ break;
}
- if (*s != '=')
- return 0;
-
- s = skipwhite(s + 1);
- if (cin_nocode(s))
- return 0;
-
- if (*s == '"') // nice alignment for continued strings
- ++s;
-
- fp.lnum = lnum;
- fp.col = (colnr_T)(s - line);
- getvcol(curwin, &fp, &col, NULL, NULL);
- return (int)col;
-}
-
-/*
- * Recognize a preprocessor statement: Any line that starts with '#'.
- */
- static int
-cin_ispreproc(char_u *s)
-{
- if (*skipwhite(s) == '#')
- return TRUE;
- return FALSE;
+ return count;
}
+#ifdef FEAT_VARTABS
/*
- * Return TRUE if line "*pp" at "*lnump" is a preprocessor statement or a
- * continuation line of a preprocessor statement. Decrease "*lnump" to the
- * start and return the line in "*pp".
- * Put the amount of indent in "*amount".
+ * Count the size (in window cells) of the indent in line "ptr", using
+ * variable tabstops.
+ * if "list" is TRUE, count only screen size for tabs.
*/
- static int
-cin_ispreproc_cont(char_u **pp, linenr_T *lnump, int *amount)
+ int
+get_indent_str_vtab(char_u *ptr, int ts, int *vts, int list)
{
- char_u *line = *pp;
- linenr_T lnum = *lnump;
- int retval = FALSE;
- int candidate_amount = *amount;
-
- if (*line != NUL && line[STRLEN(line) - 1] == '\\')
- candidate_amount = get_indent_lnum(lnum);
+ int count = 0;
- for (;;)
+ for ( ; *ptr; ++ptr)
{
- if (cin_ispreproc(line))
+ if (*ptr == TAB) // count a tab for what it is worth
{
- retval = TRUE;
- *lnump = lnum;
- break;
+ if (!list || lcs_tab1)
+ count += tabstop_padding(count, ts, vts);
+ else
+ // In list mode, when tab is not set, count screen char width
+ // for Tab, displays: ^I
+ count += ptr2cells(ptr);
}
- if (lnum == 1)
- break;
- line = ml_get(--lnum);
- if (*line == NUL || line[STRLEN(line) - 1] != '\\')
+ else if (*ptr == ' ')
+ ++count; // count a space for one
+ else
break;
}
-
- if (lnum != *lnump)
- *pp = ml_get(*lnump);
- if (retval)
- *amount = candidate_amount;
- return retval;
+ return count;
}
+#endif
/*
- * Recognize the start of a C or C++ comment.
+ * Set the indent of the current line.
+ * Leaves the cursor on the first non-blank in the line.
+ * Caller must take care of undo.
+ * "flags":
+ * SIN_CHANGED: call changed_bytes() if the line was changed.
+ * SIN_INSERT: insert the indent in front of the line.
+ * SIN_UNDO: save line for undo before changing it.
+ * Returns TRUE if the line was changed.
*/
- static int
-cin_iscomment(char_u *p)
+ int
+set_indent(
+ int size, // measured in spaces
+ int flags)
{
- return (p[0] == '/' && (p[1] == '*' || p[1] == '/'));
-}
+ char_u *p;
+ char_u *newline;
+ char_u *oldline;
+ char_u *s;
+ int todo;
+ int ind_len; // measured in characters
+ int line_len;
+ int doit = FALSE;
+ int ind_done = 0; // measured in spaces
+#ifdef FEAT_VARTABS
+ int ind_col = 0;
+#endif
+ int tab_pad;
+ int retval = FALSE;
+ int orig_char_len = -1; // number of initial whitespace chars when
+ // 'et' and 'pi' are both set
-/*
- * Recognize the start of a "//" comment.
- */
- static int
-cin_islinecomment(char_u *p)
-{
- return (p[0] == '/' && p[1] == '/');
-}
+ // First check if there is anything to do and compute the number of
+ // characters needed for the indent.
+ todo = size;
+ ind_len = 0;
+ p = oldline = ml_get_curline();
-/*
- * Recognize a line that starts with '{' or '}', or ends with ';', ',', '{' or
- * '}'.
- * Don't consider "} else" a terminated line.
- * If a line begins with an "else", only consider it terminated if no unmatched
- * opening braces follow (handle "else { foo();" correctly).
- * Return the character terminating the line (ending char's have precedence if
- * both apply in order to determine initializations).
- */
- static int
-cin_isterminated(
- char_u *s,
- int incl_open, // include '{' at the end as terminator
- int incl_comma) // recognize a trailing comma
-{
- char_u found_start = 0;
- unsigned n_open = 0;
- int is_else = FALSE;
+ // Calculate the buffer size for the new indent, and check to see if it
+ // isn't already set
- s = cin_skipcomment(s);
+ // if 'expandtab' isn't set: use TABs; if both 'expandtab' and
+ // 'preserveindent' are set count the number of characters at the
+ // beginning of the line to be copied
+ if (!curbuf->b_p_et || (!(flags & SIN_INSERT) && curbuf->b_p_pi))
+ {
+ // If 'preserveindent' is set then reuse as much as possible of
+ // the existing indent structure for the new indent
+ if (!(flags & SIN_INSERT) && curbuf->b_p_pi)
+ {
+ ind_done = 0;
- if (*s == '{' || (*s == '}' && !cin_iselse(s)))
- found_start = *s;
+ // count as many characters as we can use
+ while (todo > 0 && VIM_ISWHITE(*p))
+ {
+ if (*p == TAB)
+ {
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts
+ - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ // stop if this tab will overshoot the target
+ if (todo < tab_pad)
+ break;
+ todo -= tab_pad;
+ ++ind_len;
+ ind_done += tab_pad;
+ }
+ else
+ {
+ --todo;
+ ++ind_len;
+ ++ind_done;
+ }
+ ++p;
+ }
- if (!found_start)
- is_else = cin_iselse(s);
+#ifdef FEAT_VARTABS
+ // These diverge from this point.
+ ind_col = ind_done;
+#endif
+ // Set initial number of whitespace chars to copy if we are
+ // preserving indent but expandtab is set
+ if (curbuf->b_p_et)
+ orig_char_len = ind_len;
+
+ // Fill to next tabstop with a tab, if possible
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ if (todo >= tab_pad && orig_char_len == -1)
+ {
+ doit = TRUE;
+ todo -= tab_pad;
+ ++ind_len;
+ // ind_done += tab_pad;
+#ifdef FEAT_VARTABS
+ ind_col += tab_pad;
+#endif
+ }
+ }
- while (*s)
- {
- // skip over comments, "" strings and 'c'haracters
- s = skip_string(cin_skipcomment(s));
- if (*s == '}' && n_open > 0)
- --n_open;
- if ((!is_else || n_open == 0)
- && (*s == ';' || *s == '}' || (incl_comma && *s == ','))
- && cin_nocode(s + 1))
- return *s;
- else if (*s == '{')
+ // count tabs required for indent
+#ifdef FEAT_VARTABS
+ for (;;)
{
- if (incl_open && cin_nocode(s + 1))
- return *s;
+ tab_pad = tabstop_padding(ind_col, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+ if (todo < tab_pad)
+ break;
+ if (*p != TAB)
+ doit = TRUE;
else
- ++n_open;
+ ++p;
+ todo -= tab_pad;
+ ++ind_len;
+ ind_col += tab_pad;
}
-
- if (*s)
- s++;
+#else
+ while (todo >= (int)curbuf->b_p_ts)
+ {
+ if (*p != TAB)
+ doit = TRUE;
+ else
+ ++p;
+ todo -= (int)curbuf->b_p_ts;
+ ++ind_len;
+ // ind_done += (int)curbuf->b_p_ts;
+ }
+#endif
+ }
+ // count spaces required for indent
+ while (todo > 0)
+ {
+ if (*p != ' ')
+ doit = TRUE;
+ else
+ ++p;
+ --todo;
+ ++ind_len;
+ // ++ind_done;
}
- return found_start;
-}
-/*
- * Recognize the basic picture of a function declaration -- it needs to
- * have an open paren somewhere and a close paren at the end of the line and
- * no semicolons anywhere.
- * When a line ends in a comma we continue looking in the next line.
- * "sp" points to a string with the line. When looking at other lines it must
- * be restored to the line. When it's NULL fetch lines here.
- * "first_lnum" is where we start looking.
- * "min_lnum" is the line before which we will not be looking.
- */
- static int
-cin_isfuncdecl(
- char_u **sp,
- linenr_T first_lnum,
- linenr_T min_lnum)
-{
- char_u *s;
- linenr_T lnum = first_lnum;
- linenr_T save_lnum = curwin->w_cursor.lnum;
- int retval = FALSE;
- pos_T *trypos;
- int just_started = TRUE;
+ // Return if the indent is OK already.
+ if (!doit && !VIM_ISWHITE(*p) && !(flags & SIN_INSERT))
+ return FALSE;
- if (sp == NULL)
- s = ml_get(lnum);
+ // Allocate memory for the new line.
+ if (flags & SIN_INSERT)
+ p = oldline;
else
- s = *sp;
+ p = skipwhite(p);
+ line_len = (int)STRLEN(p) + 1;
- curwin->w_cursor.lnum = lnum;
- if (find_last_paren(s, '(', ')')
- && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
+ // If 'preserveindent' and 'expandtab' are both set keep the original
+ // characters and allocate accordingly. We will fill the rest with spaces
+ // after the if (!curbuf->b_p_et) below.
+ if (orig_char_len != -1)
{
- lnum = trypos->lnum;
- if (lnum < min_lnum)
- {
- curwin->w_cursor.lnum = save_lnum;
+ newline = alloc(orig_char_len + size - ind_done + line_len);
+ if (newline == NULL)
return FALSE;
+ todo = size - ind_done;
+ ind_len = orig_char_len + todo; // Set total length of indent in
+ // characters, which may have been
+ // undercounted until now
+ p = oldline;
+ s = newline;
+ while (orig_char_len > 0)
+ {
+ *s++ = *p++;
+ orig_char_len--;
}
- s = ml_get(lnum);
- }
- curwin->w_cursor.lnum = save_lnum;
-
- // Ignore line starting with #.
- if (cin_ispreproc(s))
- return FALSE;
+ // Skip over any additional white space (useful when newindent is less
+ // than old)
+ while (VIM_ISWHITE(*p))
+ ++p;
- while (*s && *s != '(' && *s != ';' && *s != '\'' && *s != '"')
+ }
+ else
{
- if (cin_iscomment(s)) // ignore comments
- s = cin_skipcomment(s);
- else if (*s == ':')
- {
- if (*(s + 1) == ':')
- s += 2;
- else
- // To avoid a mistake in the following situation:
- // A::A(int a, int b)
- // : a(0) // <--not a function decl
- // , b(0)
- // {...
- return FALSE;
- }
- else
- ++s;
+ todo = size;
+ newline = alloc(ind_len + line_len);
+ if (newline == NULL)
+ return FALSE;
+ s = newline;
}
- if (*s != '(')
- return FALSE; // ';', ' or " before any () or no '('
- while (*s && *s != ';' && *s != '\'' && *s != '"')
+ // Put the characters in the new line.
+ // if 'expandtab' isn't set: use TABs
+ if (!curbuf->b_p_et)
{
- if (*s == ')' && cin_nocode(s + 1))
- {
- /*
- * ')' at the end: may have found a match
- * Check for he previous line not to end in a backslash:
- * #if defined(x) && \
- * defined(y)
- */
- lnum = first_lnum - 1;
- s = ml_get(lnum);
- if (*s == NUL || s[STRLEN(s) - 1] != '\\')
- retval = TRUE;
- goto done;
- }
- if ((*s == ',' && cin_nocode(s + 1)) || s[1] == NUL || cin_nocode(s))
+ // If 'preserveindent' is set then reuse as much as possible of
+ // the existing indent structure for the new indent
+ if (!(flags & SIN_INSERT) && curbuf->b_p_pi)
{
- int comma = (*s == ',');
+ p = oldline;
+ ind_done = 0;
- // ',' at the end: continue looking in the next line.
- // At the end: check for ',' in the next line, for this style:
- // func(arg1
- // , arg2)
- for (;;)
+ while (todo > 0 && VIM_ISWHITE(*p))
{
- if (lnum >= curbuf->b_ml.ml_line_count)
- break;
- s = ml_get(++lnum);
- if (!cin_ispreproc(s))
- break;
+ if (*p == TAB)
+ {
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts
+ - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ // stop if this tab will overshoot the target
+ if (todo < tab_pad)
+ break;
+ todo -= tab_pad;
+ ind_done += tab_pad;
+ }
+ else
+ {
+ --todo;
+ ++ind_done;
+ }
+ *s++ = *p++;
}
- if (lnum >= curbuf->b_ml.ml_line_count)
- break;
- // Require a comma at end of the line or a comma or ')' at the
- // start of next line.
- s = skipwhite(s);
- if (!just_started && (!comma && *s != ',' && *s != ')'))
+
+ // Fill to next tabstop with a tab, if possible
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ if (todo >= tab_pad)
+ {
+ *s++ = TAB;
+ todo -= tab_pad;
+#ifdef FEAT_VARTABS
+ ind_done += tab_pad;
+#endif
+ }
+
+ p = skipwhite(p);
+ }
+
+#ifdef FEAT_VARTABS
+ for (;;)
+ {
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+ if (todo < tab_pad)
break;
- just_started = FALSE;
+ *s++ = TAB;
+ todo -= tab_pad;
+ ind_done += tab_pad;
}
- else if (cin_iscomment(s)) // ignore comments
- s = cin_skipcomment(s);
- else
+#else
+ while (todo >= (int)curbuf->b_p_ts)
{
- ++s;
- just_started = FALSE;
+ *s++ = TAB;
+ todo -= (int)curbuf->b_p_ts;
}
+#endif
}
+ while (todo > 0)
+ {
+ *s++ = ' ';
+ --todo;
+ }
+ mch_memmove(s, p, (size_t)line_len);
-done:
- if (lnum != first_lnum && sp != NULL)
- *sp = ml_get(first_lnum);
-
- return retval;
-}
+ // Replace the line (unless undo fails).
+ if (!(flags & SIN_UNDO) || u_savesub(curwin->w_cursor.lnum) == OK)
+ {
+ ml_replace(curwin->w_cursor.lnum, newline, FALSE);
+ if (flags & SIN_CHANGED)
+ changed_bytes(curwin->w_cursor.lnum, 0);
- static int
-cin_isif(char_u *p)
-{
- return (STRNCMP(p, "if", 2) == 0 && !vim_isIDc(p[2]));
-}
+ // Correct saved cursor position if it is in this line.
+ if (saved_cursor.lnum == curwin->w_cursor.lnum)
+ {
+ if (saved_cursor.col >= (colnr_T)(p - oldline))
+ // cursor was after the indent, adjust for the number of
+ // bytes added/removed
+ saved_cursor.col += ind_len - (colnr_T)(p - oldline);
+ else if (saved_cursor.col >= (colnr_T)(s - newline))
+ // cursor was in the indent, and is now after it, put it back
+ // at the start of the indent (replacing spaces with TAB)
+ saved_cursor.col = (colnr_T)(s - newline);
+ }
+#ifdef FEAT_TEXT_PROP
+ {
+ int added = ind_len - (colnr_T)(p - oldline);
- static int
-cin_iselse(
- char_u *p)
-{
- if (*p == '}') // accept "} else"
- p = cin_skipcomment(p + 1);
- return (STRNCMP(p, "else", 4) == 0 && !vim_isIDc(p[4]));
-}
+ // When increasing indent this behaves like spaces were inserted at
+ // the old indent, when decreasing indent it behaves like spaces
+ // were deleted at the new indent.
+ adjust_prop_columns(curwin->w_cursor.lnum,
+ (colnr_T)(added > 0 ? (p - oldline) : ind_len), added, 0);
+ }
+#endif
+ retval = TRUE;
+ }
+ else
+ vim_free(newline);
- static int
-cin_isdo(char_u *p)
-{
- return (STRNCMP(p, "do", 2) == 0 && !vim_isIDc(p[2]));
+ curwin->w_cursor.col = ind_len;
+ return retval;
}
/*
- * Check if this is a "while" that should have a matching "do".
- * We only accept a "while (condition) ;", with only white space between the
- * ')' and ';'. The condition may be spread over several lines.
+ * Return the indent of the current line after a number. Return -1 if no
+ * number was found. Used for 'n' in 'formatoptions': numbered list.
+ * Since a pattern is used it can actually handle more than numbers.
*/
- static int
-cin_iswhileofdo (char_u *p, linenr_T lnum) // XXX
+ int
+get_number_indent(linenr_T lnum)
{
- pos_T cursor_save;
- pos_T *trypos;
- int retval = FALSE;
+ colnr_T col;
+ pos_T pos;
+
+ regmatch_T regmatch;
+ int lead_len = 0; // length of comment leader
- p = cin_skipcomment(p);
- if (*p == '}') // accept "} while (cond);"
- p = cin_skipcomment(p + 1);
- if (cin_starts_with(p, "while"))
+ if (lnum > curbuf->b_ml.ml_line_count)
+ return -1;
+ pos.lnum = 0;
+
+ // In format_lines() (i.e. not insert mode), fo+=q is needed too...
+ if ((State & INSERT) || has_format_option(FO_Q_COMS))
+ lead_len = get_leader_len(ml_get(lnum), NULL, FALSE, TRUE);
+
+ regmatch.regprog = vim_regcomp(curbuf->b_p_flp, RE_MAGIC);
+ if (regmatch.regprog != NULL)
{
- cursor_save = curwin->w_cursor;
- curwin->w_cursor.lnum = lnum;
- curwin->w_cursor.col = 0;
- p = ml_get_curline();
- while (*p && *p != 'w') // skip any '}', until the 'w' of the "while"
+ regmatch.rm_ic = FALSE;
+
+ // vim_regexec() expects a pointer to a line. This lets us
+ // start matching for the flp beyond any comment leader...
+ if (vim_regexec(®match, ml_get(lnum) + lead_len, (colnr_T)0))
{
- ++p;
- ++curwin->w_cursor.col;
+ pos.lnum = lnum;
+ pos.col = (colnr_T)(*regmatch.endp - ml_get(lnum));
+ pos.coladd = 0;
}
- if ((trypos = findmatchlimit(NULL, 0, 0,
- curbuf->b_ind_maxparen)) != NULL
- && *cin_skipcomment(ml_get_pos(trypos) + 1) == ';')
- retval = TRUE;
- curwin->w_cursor = cursor_save;
+ vim_regfree(regmatch.regprog);
}
- return retval;
+
+ if (pos.lnum == 0 || *ml_get_pos(&pos) == NUL)
+ return -1;
+ getvcol(curwin, &pos, &col, NULL, NULL);
+ return (int)col;
}
+#if defined(FEAT_LINEBREAK) || defined(PROTO)
/*
- * Check whether in "p" there is an "if", "for" or "while" before "*poffset".
- * Return 0 if there is none.
- * Otherwise return !0 and update "*poffset" to point to the place where the
- * string was found.
+ * Return appropriate space number for breakindent, taking influencing
+ * parameters into account. Window must be specified, since it is not
+ * necessarily always the current one.
*/
- static int
-cin_is_if_for_while_before_offset(char_u *line, int *poffset)
+ int
+get_breakindent_win(
+ win_T *wp,
+ char_u *line) // start of the line
+{
+ static int prev_indent = 0; // cached indent value
+ static long prev_ts = 0L; // cached tabstop value
+ static char_u *prev_line = NULL; // cached pointer to line
+ static varnumber_T prev_tick = 0; // changedtick of cached value
+# ifdef FEAT_VARTABS
+ static int *prev_vts = NULL; // cached vartabs values
+# endif
+ int bri = 0;
+ // window width minus window margin space, i.e. what rests for text
+ const int eff_wwidth = wp->w_width
+ - ((wp->w_p_nu || wp->w_p_rnu)
+ && (vim_strchr(p_cpo, CPO_NUMCOL) == NULL)
+ ? number_width(wp) + 1 : 0);
+
+ // used cached indent, unless pointer or 'tabstop' changed
+ if (prev_line != line || prev_ts != wp->w_buffer->b_p_ts
+ || prev_tick != CHANGEDTICK(wp->w_buffer)
+# ifdef FEAT_VARTABS
+ || prev_vts != wp->w_buffer->b_p_vts_array
+# endif
+ )
+ {
+ prev_line = line;
+ prev_ts = wp->w_buffer->b_p_ts;
+ prev_tick = CHANGEDTICK(wp->w_buffer);
+# ifdef FEAT_VARTABS
+ prev_vts = wp->w_buffer->b_p_vts_array;
+ prev_indent = get_indent_str_vtab(line,
+ (int)wp->w_buffer->b_p_ts,
+ wp->w_buffer->b_p_vts_array, wp->w_p_list);
+# else
+ prev_indent = get_indent_str(line,
+ (int)wp->w_buffer->b_p_ts, wp->w_p_list);
+# endif
+ }
+ bri = prev_indent + wp->w_p_brishift;
+
+ // indent minus the length of the showbreak string
+ if (wp->w_p_brisbr)
+ bri -= vim_strsize(p_sbr);
+
+ // Add offset for number column, if 'n' is in 'cpoptions'
+ bri += win_col_off2(wp);
+
+ // never indent past left window margin
+ if (bri < 0)
+ bri = 0;
+ // always leave at least bri_min characters on the left,
+ // if text width is sufficient
+ else if (bri > eff_wwidth - wp->w_p_brimin)
+ bri = (eff_wwidth - wp->w_p_brimin < 0)
+ ? 0 : eff_wwidth - wp->w_p_brimin;
+
+ return bri;
+}
+#endif
+
+/*
+ * When extra == 0: Return TRUE if the cursor is before or on the first
+ * non-blank in the line.
+ * When extra == 1: Return TRUE if the cursor is before the first non-blank in
+ * the line.
+ */
+ int
+inindent(int extra)
{
- int offset = *poffset;
+ char_u *ptr;
+ colnr_T col;
+
+ for (col = 0, ptr = ml_get_curline(); VIM_ISWHITE(*ptr); ++col)
+ ++ptr;
+ if (col >= curwin->w_cursor.col + extra)
+ return TRUE;
+ else
+ return FALSE;
+}
- if (offset-- < 2)
- return 0;
- while (offset > 2 && VIM_ISWHITE(line[offset]))
- --offset;
+#if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO)
+/*
+ * op_reindent - handle reindenting a block of lines.
+ */
+ void
+op_reindent(oparg_T *oap, int (*how)(void))
+{
+ long i;
+ char_u *l;
+ int amount;
+ linenr_T first_changed = 0;
+ linenr_T last_changed = 0;
+ linenr_T start_lnum = curwin->w_cursor.lnum;
- offset -= 1;
- if (!STRNCMP(line + offset, "if", 2))
- goto probablyFound;
+ // Don't even try when 'modifiable' is off.
+ if (!curbuf->b_p_ma)
+ {
+ emsg(_(e_modifiable));
+ return;
+ }
- if (offset >= 1)
+ for (i = oap->line_count; --i >= 0 && !got_int; )
{
- offset -= 1;
- if (!STRNCMP(line + offset, "for", 3))
- goto probablyFound;
+ // it's a slow thing to do, so give feedback so there's no worry that
+ // the computer's just hung.
+
+ if (i > 1
+ && (i % 50 == 0 || i == oap->line_count - 1)
+ && oap->line_count > p_report)
+ smsg(_("%ld lines to indent... "), i);
- if (offset >= 2)
+ // Be vi-compatible: For lisp indenting the first line is not
+ // indented, unless there is only one line.
+# ifdef FEAT_LISP
+ if (i != oap->line_count - 1 || oap->line_count == 1
+ || how != get_lisp_indent)
+# endif
{
- offset -= 2;
- if (!STRNCMP(line + offset, "while", 5))
- goto probablyFound;
+ l = skipwhite(ml_get_curline());
+ if (*l == NUL) // empty or blank line
+ amount = 0;
+ else
+ amount = how(); // get the indent for this line
+
+ if (amount >= 0 && set_indent(amount, SIN_UNDO))
+ {
+ // did change the indent, call changed_lines() later
+ if (first_changed == 0)
+ first_changed = curwin->w_cursor.lnum;
+ last_changed = curwin->w_cursor.lnum;
+ }
}
+ ++curwin->w_cursor.lnum;
+ curwin->w_cursor.col = 0; // make sure it's valid
}
- return 0;
-probablyFound:
- if (!offset || !vim_isIDc(line[offset - 1]))
+ // put cursor on first non-blank of indented line
+ curwin->w_cursor.lnum = start_lnum;
+ beginline(BL_SOL | BL_FIX);
+
+ // Mark changed lines so that they will be redrawn. When Visual
+ // highlighting was present, need to continue until the last line. When
+ // there is no change still need to remove the Visual highlighting.
+ if (last_changed != 0)
+ changed_lines(first_changed, 0,
+ oap->is_VIsual ? start_lnum + oap->line_count :
+ last_changed + 1, 0L);
+ else if (oap->is_VIsual)
+ redraw_curbuf_later(INVERTED);
+
+ if (oap->line_count > p_report)
{
- *poffset = offset;
- return 1;
+ i = oap->line_count - (i + 1);
+ smsg(NGETTEXT("%ld line indented ",
+ "%ld lines indented ", i), i);
}
- return 0;
+ // set '[ and '] marks
+ curbuf->b_op_start = oap->start;
+ curbuf->b_op_end = oap->end;
}
+#endif // defined(FEAT_LISP) || defined(FEAT_CINDENT)
+#if defined(FEAT_SMARTINDENT) || defined(FEAT_CINDENT) || defined(PROTO)
/*
- * Return TRUE if we are at the end of a do-while.
- * do
- * nothing;
- * while (foo
- * && bar); <-- here
- * Adjust the cursor to the line with "while".
+ * Return TRUE if lines starting with '#' should be left aligned.
*/
- static int
-cin_iswhileofdo_end(int terminated)
+ int
+preprocs_left(void)
+{
+ return
+# ifdef FEAT_SMARTINDENT
+# ifdef FEAT_CINDENT
+ (curbuf->b_p_si && !curbuf->b_p_cin) ||
+# else
+ curbuf->b_p_si
+# endif
+# endif
+# ifdef FEAT_CINDENT
+ (curbuf->b_p_cin && in_cinkeys('#', ' ', TRUE)
+ && curbuf->b_ind_hash_comment == 0)
+# endif
+ ;
+}
+#endif
+
+#ifdef FEAT_SMARTINDENT
+/*
+ * Try to do some very smart auto-indenting.
+ * Used when inserting a "normal" character.
+ */
+ void
+ins_try_si(int c)
{
- char_u *line;
- char_u *p;
- char_u *s;
- pos_T *trypos;
+ pos_T *pos, old_pos;
+ char_u *ptr;
int i;
-
- if (terminated != ';') // there must be a ';' at the end
- return FALSE;
-
- p = line = ml_get_curline();
- while (*p != NUL)
- {
- p = cin_skipcomment(p);
- if (*p == ')')
+ int temp;
+
+ // do some very smart indenting when entering '{' or '}'
+ if (((did_si || can_si_back) && c == '{') || (can_si && c == '}'))
+ {
+ // for '}' set indent equal to indent of line containing matching '{'
+ if (c == '}' && (pos = findmatch(NULL, '{')) != NULL)
+ {
+ old_pos = curwin->w_cursor;
+ // If the matching '{' has a ')' immediately before it (ignoring
+ // white-space), then line up with the start of the line
+ // containing the matching '(' if there is one. This handles the
+ // case where an "if (..\n..) {" statement continues over multiple
+ // lines -- webb
+ ptr = ml_get(pos->lnum);
+ i = pos->col;
+ if (i > 0) // skip blanks before '{'
+ while (--i > 0 && VIM_ISWHITE(ptr[i]))
+ ;
+ curwin->w_cursor.lnum = pos->lnum;
+ curwin->w_cursor.col = i;
+ if (ptr[i] == ')' && (pos = findmatch(NULL, '(')) != NULL)
+ curwin->w_cursor = *pos;
+ i = get_indent();
+ curwin->w_cursor = old_pos;
+ if (State & VREPLACE_FLAG)
+ change_indent(INDENT_SET, i, FALSE, NUL, TRUE);
+ else
+ (void)set_indent(i, SIN_CHANGED);
+ }
+ else if (curwin->w_cursor.col > 0)
{
- s = skipwhite(p + 1);
- if (*s == ';' && cin_nocode(s + 1))
+ // when inserting '{' after "O" reduce indent, but not
+ // more than indent of previous line
+ temp = TRUE;
+ if (c == '{' && can_si_back && curwin->w_cursor.lnum > 1)
{
- // Found ");" at end of the line, now check there is "while"
- // before the matching '('. XXX
- i = (int)(p - line);
- curwin->w_cursor.col = i;
- trypos = find_match_paren(curbuf->b_ind_maxparen);
- if (trypos != NULL)
+ old_pos = curwin->w_cursor;
+ i = get_indent();
+ while (curwin->w_cursor.lnum > 1)
{
- s = cin_skipcomment(ml_get(trypos->lnum));
- if (*s == '}') // accept "} while (cond);"
- s = cin_skipcomment(s + 1);
- if (cin_starts_with(s, "while"))
- {
- curwin->w_cursor.lnum = trypos->lnum;
- return TRUE;
- }
- }
+ ptr = skipwhite(ml_get(--(curwin->w_cursor.lnum)));
- // Searching may have made "line" invalid, get it again.
- line = ml_get_curline();
- p = line + i;
+ // ignore empty lines and lines starting with '#'.
+ if (*ptr != '#' && *ptr != NUL)
+ break;
+ }
+ if (get_indent() >= i)
+ temp = FALSE;
+ curwin->w_cursor = old_pos;
}
+ if (temp)
+ shift_line(TRUE, FALSE, 1, TRUE);
}
- if (*p != NUL)
- ++p;
}
- return FALSE;
-}
- static int
-cin_isbreak(char_u *p)
-{
- return (STRNCMP(p, "break", 5) == 0 && !vim_isIDc(p[5]));
+ // set indent of '#' always to 0
+ if (curwin->w_cursor.col > 0 && can_si && c == '#')
+ {
+ // remember current indent for next line
+ old_indent = get_indent();
+ (void)set_indent(0, SIN_CHANGED);
+ }
+
+ // Adjust ai_col, the char at this position can be deleted.
+ if (ai_col > curwin->w_cursor.col)
+ ai_col = curwin->w_cursor.col;
}
+#endif
/*
- * Find the position of a C++ base-class declaration or
- * constructor-initialization. eg:
- *
- * class MyClass :
- * baseClass <-- here
- * class MyClass : public baseClass,
- * anotherBaseClass <-- here (should probably lineup ??)
- * MyClass::MyClass(...) :
- * baseClass(...) <-- here (constructor-initialization)
- *
- * This is a lot of guessing. Watch out for "cond ? func() : foo".
+ * Insert an indent (for <Tab> or CTRL-T) or delete an indent (for CTRL-D).
+ * Keep the cursor on the same character.
+ * type == INDENT_INC increase indent (for CTRL-T or <Tab>)
+ * type == INDENT_DEC decrease indent (for CTRL-D)
+ * type == INDENT_SET set indent to "amount"
+ * if round is TRUE, round the indent to 'shiftwidth' (only with _INC and _Dec).
*/
- static int
-cin_is_cpp_baseclass(
- cpp_baseclass_cache_T *cached) // input and output
-{
- lpos_T *pos = &cached->lpos; // find position
- char_u *s;
- int class_or_struct, lookfor_ctor_init, cpp_base_class;
- linenr_T lnum = curwin->w_cursor.lnum;
- char_u *line = ml_get_curline();
+ void
+change_indent(
+ int type,
+ int amount,
+ int round,
+ int replaced, // replaced character, put on replace stack
+ int call_changed_bytes) // call changed_bytes()
+{
+ int vcol;
+ int last_vcol;
+ int insstart_less; // reduction for Insstart.col
+ int new_cursor_col;
+ int i;
+ char_u *ptr;
+ int save_p_list;
+ int start_col;
+ colnr_T vc;
+ colnr_T orig_col = 0; // init for GCC
+ char_u *new_line, *orig_line = NULL; // init for GCC
- if (pos->lnum <= lnum)
- return cached->found; // Use the cached result
+ // VREPLACE mode needs to know what the line was like before changing
+ if (State & VREPLACE_FLAG)
+ {
+ orig_line = vim_strsave(ml_get_curline()); // Deal with NULL below
+ orig_col = curwin->w_cursor.col;
+ }
- pos->col = 0;
+ // for the following tricks we don't want list mode
+ save_p_list = curwin->w_p_list;
+ curwin->w_p_list = FALSE;
+ vc = getvcol_nolist(&curwin->w_cursor);
+ vcol = vc;
- s = skipwhite(line);
- if (*s == '#') // skip #define FOO x ? (x) : x
- return FALSE;
- s = cin_skipcomment(s);
- if (*s == NUL)
- return FALSE;
+ // For Replace mode we need to fix the replace stack later, which is only
+ // possible when the cursor is in the indent. Remember the number of
+ // characters before the cursor if it's possible.
+ start_col = curwin->w_cursor.col;
- cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
-
- // Search for a line starting with '#', empty, ending in ';' or containing
- // '{' or '}' and start below it. This handles the following situations:
- // a = cond ?
- // func() :
- // asdf;
- // func::foo()
- // : something
- // {}
- // Foo::Foo (int one, int two)
- // : something(4),
- // somethingelse(3)
- // {}
- while (lnum > 1)
- {
- line = ml_get(lnum - 1);
- s = skipwhite(line);
- if (*s == '#' || *s == NUL)
- break;
- while (*s != NUL)
- {
- s = cin_skipcomment(s);
- if (*s == '{' || *s == '}'
- || (*s == ';' && cin_nocode(s + 1)))
- break;
- if (*s != NUL)
- ++s;
- }
- if (*s != NUL)
- break;
- --lnum;
- }
+ // determine offset from first non-blank
+ new_cursor_col = curwin->w_cursor.col;
+ beginline(BL_WHITE);
+ new_cursor_col -= curwin->w_cursor.col;
- pos->lnum = lnum;
- line = ml_get(lnum);
- s = line;
- for (;;)
+ insstart_less = curwin->w_cursor.col;
+
+ // If the cursor is in the indent, compute how many screen columns the
+ // cursor is to the left of the first non-blank.
+ if (new_cursor_col < 0)
+ vcol = get_indent() - vcol;
+
+ if (new_cursor_col > 0) // can't fix replace stack
+ start_col = -1;
+
+ // Set the new indent. The cursor will be put on the first non-blank.
+ if (type == INDENT_SET)
+ (void)set_indent(amount, call_changed_bytes ? SIN_CHANGED : 0);
+ else
{
- if (*s == NUL)
- {
- if (lnum == curwin->w_cursor.lnum)
- break;
- // Continue in the cursor line.
- line = ml_get(++lnum);
- s = line;
- }
- if (s == line)
+ int save_State = State;
+
+ // Avoid being called recursively.
+ if (State & VREPLACE_FLAG)
+ State = INSERT;
+ shift_line(type == INDENT_DEC, round, 1, call_changed_bytes);
+ State = save_State;
+ }
+ insstart_less -= curwin->w_cursor.col;
+
+ // Try to put cursor on same character.
+ // If the cursor is at or after the first non-blank in the line,
+ // compute the cursor column relative to the column of the first
+ // non-blank character.
+ // If we are not in insert mode, leave the cursor on the first non-blank.
+ // If the cursor is before the first non-blank, position it relative
+ // to the first non-blank, counted in screen columns.
+ if (new_cursor_col >= 0)
+ {
+ // When changing the indent while the cursor is touching it, reset
+ // Insstart_col to 0.
+ if (new_cursor_col == 0)
+ insstart_less = MAXCOL;
+ new_cursor_col += curwin->w_cursor.col;
+ }
+ else if (!(State & INSERT))
+ new_cursor_col = curwin->w_cursor.col;
+ else
+ {
+ // Compute the screen column where the cursor should be.
+ vcol = get_indent() - vcol;
+ curwin->w_virtcol = (colnr_T)((vcol < 0) ? 0 : vcol);
+
+ // Advance the cursor until we reach the right screen column.
+ vcol = last_vcol = 0;
+ new_cursor_col = -1;
+ ptr = ml_get_curline();
+ while (vcol <= (int)curwin->w_virtcol)
{
- // don't recognize "case (foo):" as a baseclass
- if (cin_iscase(s, FALSE))
- break;
- s = cin_skipcomment(line);
- if (*s == NUL)
- continue;
+ last_vcol = vcol;
+ if (has_mbyte && new_cursor_col >= 0)
+ new_cursor_col += (*mb_ptr2len)(ptr + new_cursor_col);
+ else
+ ++new_cursor_col;
+ vcol += lbr_chartabsize(ptr, ptr + new_cursor_col, (colnr_T)vcol);
}
+ vcol = last_vcol;
- if (s[0] == '"' || (s[0] == 'R' && s[1] == '"'))
- s = skip_string(s) + 1;
- else if (s[0] == ':')
+ // May need to insert spaces to be able to position the cursor on
+ // the right screen column.
+ if (vcol != (int)curwin->w_virtcol)
{
- if (s[1] == ':')
- {
- // skip double colon. It can't be a constructor
- // initialization any more
- lookfor_ctor_init = FALSE;
- s = cin_skipcomment(s + 2);
- }
- else if (lookfor_ctor_init || class_or_struct)
+ curwin->w_cursor.col = (colnr_T)new_cursor_col;
+ i = (int)curwin->w_virtcol - vcol;
+ ptr = alloc(i + 1);
+ if (ptr != NULL)
{
- // we have something found, that looks like the start of
- // cpp-base-class-declaration or constructor-initialization
- cpp_base_class = TRUE;
- lookfor_ctor_init = class_or_struct = FALSE;
- pos->col = 0;
- s = cin_skipcomment(s + 1);
+ new_cursor_col += i;
+ ptr[i] = NUL;
+ while (--i >= 0)
+ ptr[i] = ' ';
+ ins_str(ptr);
+ vim_free(ptr);
}
- else
- s = cin_skipcomment(s + 1);
}
- else if ((STRNCMP(s, "class", 5) == 0 && !vim_isIDc(s[5]))
- || (STRNCMP(s, "struct", 6) == 0 && !vim_isIDc(s[6])))
- {
- class_or_struct = TRUE;
- lookfor_ctor_init = FALSE;
- if (*s == 'c')
- s = cin_skipcomment(s + 5);
+ // When changing the indent while the cursor is in it, reset
+ // Insstart_col to 0.
+ insstart_less = MAXCOL;
+ }
+
+ curwin->w_p_list = save_p_list;
+
+ if (new_cursor_col <= 0)
+ curwin->w_cursor.col = 0;
+ else
+ curwin->w_cursor.col = (colnr_T)new_cursor_col;
+ curwin->w_set_curswant = TRUE;
+ changed_cline_bef_curs();
+
+ // May have to adjust the start of the insert.
+ if (State & INSERT)
+ {
+ if (curwin->w_cursor.lnum == Insstart.lnum && Insstart.col != 0)
+ {
+ if ((int)Insstart.col <= insstart_less)
+ Insstart.col = 0;
else
- s = cin_skipcomment(s + 6);
+ Insstart.col -= insstart_less;
}
+ if ((int)ai_col <= insstart_less)
+ ai_col = 0;
else
+ ai_col -= insstart_less;
+ }
+
+ // For REPLACE mode, may have to fix the replace stack, if it's possible.
+ // If the number of characters before the cursor decreased, need to pop a
+ // few characters from the replace stack.
+ // If the number of characters before the cursor increased, need to push a
+ // few NULs onto the replace stack.
+ if (REPLACE_NORMAL(State) && start_col >= 0)
+ {
+ while (start_col > (int)curwin->w_cursor.col)
{
- if (s[0] == '{' || s[0] == '}' || s[0] == ';')
- {
- cpp_base_class = lookfor_ctor_init = class_or_struct = FALSE;
- }
- else if (s[0] == ')')
+ replace_join(0); // remove a NUL from the replace stack
+ --start_col;
+ }
+ while (start_col < (int)curwin->w_cursor.col || replaced)
+ {
+ replace_push(NUL);
+ if (replaced)
{
- // Constructor-initialization is assumed if we come across
- // something like "):"
- class_or_struct = FALSE;
- lookfor_ctor_init = TRUE;
+ replace_push(replaced);
+ replaced = NUL;
}
- else if (s[0] == '?')
- {
- // Avoid seeing '() :' after '?' as constructor init.
- return FALSE;
- }
- else if (!vim_isIDc(s[0]))
- {
- // if it is not an identifier, we are wrong
- class_or_struct = FALSE;
- lookfor_ctor_init = FALSE;
- }
- else if (pos->col == 0)
- {
- // it can't be a constructor-initialization any more
- lookfor_ctor_init = FALSE;
-
- // the first statement starts here: lineup with this one...
- if (cpp_base_class)
- pos->col = (colnr_T)(s - line);
- }
-
- // When the line ends in a comma don't align with it.
- if (lnum == curwin->w_cursor.lnum && *s == ',' && cin_nocode(s + 1))
- pos->col = 0;
-
- s = cin_skipcomment(s + 1);
+ ++start_col;
}
}
- cached->found = cpp_base_class;
- if (cpp_base_class)
- pos->lnum = lnum;
- return cpp_base_class;
-}
-
- static int
-get_baseclass_amount(int col)
-{
- int amount;
- colnr_T vcol;
- pos_T *trypos;
-
- if (col == 0)
+ // For VREPLACE mode, we also have to fix the replace stack. In this case
+ // it is always possible because we backspace over the whole line and then
+ // put it back again the way we wanted it.
+ if (State & VREPLACE_FLAG)
{
- amount = get_indent();
- if (find_last_paren(ml_get_curline(), '(', ')')
- && (trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
- amount = get_indent_lnum(trypos->lnum); // XXX
- if (!cin_ends_in(ml_get_curline(), (char_u *)",", NULL))
- amount += curbuf->b_ind_cpp_baseclass;
- }
- else
- {
- curwin->w_cursor.col = col;
- getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
- amount = (int)vcol;
- }
- if (amount < curbuf->b_ind_cpp_baseclass)
- amount = curbuf->b_ind_cpp_baseclass;
- return amount;
-}
+ // If orig_line didn't allocate, just return. At least we did the job,
+ // even if you can't backspace.
+ if (orig_line == NULL)
+ return;
-/*
- * Return TRUE if string "s" ends with the string "find", possibly followed by
- * white space and comments. Skip strings and comments.
- * Ignore "ignore" after "find" if it's not NULL.
- */
- static int
-cin_ends_in(char_u *s, char_u *find, char_u *ignore)
-{
- char_u *p = s;
- char_u *r;
- int len = (int)STRLEN(find);
+ // Save new line
+ new_line = vim_strsave(ml_get_curline());
+ if (new_line == NULL)
+ return;
- while (*p != NUL)
- {
- p = cin_skipcomment(p);
- if (STRNCMP(p, find, len) == 0)
- {
- r = skipwhite(p + len);
- if (ignore != NULL && STRNCMP(r, ignore, STRLEN(ignore)) == 0)
- r = skipwhite(r + STRLEN(ignore));
- if (cin_nocode(r))
- return TRUE;
- }
- if (*p != NUL)
- ++p;
- }
- return FALSE;
-}
+ // We only put back the new line up to the cursor
+ new_line[curwin->w_cursor.col] = NUL;
-/*
- * Return TRUE when "s" starts with "word" and then a non-ID character.
- */
- static int
-cin_starts_with(char_u *s, char *word)
-{
- int l = (int)STRLEN(word);
+ // Put back original line
+ ml_replace(curwin->w_cursor.lnum, orig_line, FALSE);
+ curwin->w_cursor.col = orig_col;
- return (STRNCMP(s, word, l) == 0 && !vim_isIDc(s[l]));
-}
+ // Backspace from cursor to start of line
+ backspace_until_column(0);
-/*
- * Skip strings, chars and comments until at or past "trypos".
- * Return the column found.
- */
- static int
-cin_skip2pos(pos_T *trypos)
-{
- char_u *line;
- char_u *p;
- char_u *new_p;
+ // Insert new stuff into line again
+ ins_bytes(new_line);
- p = line = ml_get(trypos->lnum);
- while (*p && (colnr_T)(p - line) < trypos->col)
- {
- if (cin_iscomment(p))
- p = cin_skipcomment(p);
- else
- {
- new_p = skip_string(p);
- if (new_p == p)
- ++p;
- else
- p = new_p;
- }
+ vim_free(new_line);
}
- return (int)(p - line);
}
/*
- * Find the '{' at the start of the block we are in.
- * Return NULL if no match found.
- * Ignore a '{' that is in a comment, makes indenting the next three lines
- * work.
+ * Copy the indent from ptr to the current line (and fill to size)
+ * Leaves the cursor on the first non-blank in the line.
+ * Returns TRUE if the line was changed.
*/
-/* foo() */
-/* { */
-/* } */
-
- static pos_T *
-find_start_brace(void) // XXX
+ int
+copy_indent(int size, char_u *src)
{
- pos_T cursor_save;
- pos_T *trypos;
- pos_T *pos;
- static pos_T pos_copy;
+ char_u *p = NULL;
+ char_u *line = NULL;
+ char_u *s;
+ int todo;
+ int ind_len;
+ int line_len = 0;
+ int tab_pad;
+ int ind_done;
+ int round;
+#ifdef FEAT_VARTABS
+ int ind_col;
+#endif
- cursor_save = curwin->w_cursor;
- while ((trypos = findmatchlimit(NULL, '{', FM_BLOCKSTOP, 0)) != NULL)
+ // Round 1: compute the number of characters needed for the indent
+ // Round 2: copy the characters.
+ for (round = 1; round <= 2; ++round)
{
- pos_copy = *trypos; // copy pos_T, next findmatch will change it
- trypos = &pos_copy;
- curwin->w_cursor = *trypos;
- pos = NULL;
- // ignore the { if it's in a // or / * * / comment
- if ((colnr_T)cin_skip2pos(trypos) == trypos->col
- && (pos = ind_find_start_CORS(NULL)) == NULL) // XXX
- break;
- if (pos != NULL)
- curwin->w_cursor.lnum = pos->lnum;
- }
- curwin->w_cursor = cursor_save;
- return trypos;
-}
-
-/*
- * Find the matching '(', ignoring it if it is in a comment.
- * Return NULL if no match found.
- */
- static pos_T *
-find_match_paren(int ind_maxparen) // XXX
-{
- return find_match_char('(', ind_maxparen);
-}
+ todo = size;
+ ind_len = 0;
+ ind_done = 0;
+#ifdef FEAT_VARTABS
+ ind_col = 0;
+#endif
+ s = src;
- static pos_T *
-find_match_char(int c, int ind_maxparen) // XXX
-{
- pos_T cursor_save;
- pos_T *trypos;
- static pos_T pos_copy;
- int ind_maxp_wk;
-
- cursor_save = curwin->w_cursor;
- ind_maxp_wk = ind_maxparen;
-retry:
- if ((trypos = findmatchlimit(NULL, c, 0, ind_maxp_wk)) != NULL)
- {
- // check if the ( is in a // comment
- if ((colnr_T)cin_skip2pos(trypos) > trypos->col)
+ // Count/copy the usable portion of the source line
+ while (todo > 0 && VIM_ISWHITE(*s))
{
- ind_maxp_wk = ind_maxparen - (int)(cursor_save.lnum - trypos->lnum);
- if (ind_maxp_wk > 0)
+ if (*s == TAB)
{
- curwin->w_cursor = *trypos;
- curwin->w_cursor.col = 0; // XXX
- goto retry;
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts
+ - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ // Stop if this tab will overshoot the target
+ if (todo < tab_pad)
+ break;
+ todo -= tab_pad;
+ ind_done += tab_pad;
+#ifdef FEAT_VARTABS
+ ind_col += tab_pad;
+#endif
}
- trypos = NULL;
- }
- else
- {
- pos_T *trypos_wk;
-
- pos_copy = *trypos; // copy trypos, findmatch will change it
- trypos = &pos_copy;
- curwin->w_cursor = *trypos;
- if ((trypos_wk = ind_find_start_CORS(NULL)) != NULL) // XXX
+ else
{
- ind_maxp_wk = ind_maxparen - (int)(cursor_save.lnum
- - trypos_wk->lnum);
- if (ind_maxp_wk > 0)
- {
- curwin->w_cursor = *trypos_wk;
- goto retry;
- }
- trypos = NULL;
+ --todo;
+ ++ind_done;
+#ifdef FEAT_VARTABS
+ ++ind_col;
+#endif
}
+ ++ind_len;
+ if (p != NULL)
+ *p++ = *s;
+ ++s;
}
- }
- curwin->w_cursor = cursor_save;
- return trypos;
-}
-
-/*
- * Find the matching '(', ignoring it if it is in a comment or before an
- * unmatched {.
- * Return NULL if no match found.
- */
- static pos_T *
-find_match_paren_after_brace (int ind_maxparen) // XXX
-{
- pos_T *trypos = find_match_paren(ind_maxparen);
-
- if (trypos != NULL)
- {
- pos_T *tryposBrace = find_start_brace();
-
- // If both an unmatched '(' and '{' is found. Ignore the '('
- // position if the '{' is further down.
- if (tryposBrace != NULL
- && (trypos->lnum != tryposBrace->lnum
- ? trypos->lnum < tryposBrace->lnum
- : trypos->col < tryposBrace->col))
- trypos = NULL;
- }
- return trypos;
-}
-
-/*
- * Return ind_maxparen corrected for the difference in line number between the
- * cursor position and "startpos". This makes sure that searching for a
- * matching paren above the cursor line doesn't find a match because of
- * looking a few lines further.
- */
- static int
-corr_ind_maxparen(pos_T *startpos)
-{
- long n = (long)startpos->lnum - (long)curwin->w_cursor.lnum;
-
- if (n > 0 && n < curbuf->b_ind_maxparen / 2)
- return curbuf->b_ind_maxparen - (int)n;
- return curbuf->b_ind_maxparen;
-}
-
-/*
- * Set w_cursor.col to the column number of the last unmatched ')' or '{' in
- * line "l". "l" must point to the start of the line.
- */
- static int
-find_last_paren(char_u *l, int start, int end)
-{
- int i;
- int retval = FALSE;
- int open_count = 0;
- curwin->w_cursor.col = 0; // default is start of line
-
- for (i = 0; l[i] != NUL; i++)
- {
- i = (int)(cin_skipcomment(l + i) - l); // ignore parens in comments
- i = (int)(skip_string(l + i) - l); // ignore parens in quotes
- if (l[i] == start)
- ++open_count;
- else if (l[i] == end)
+ // Fill to next tabstop with a tab, if possible
+#ifdef FEAT_VARTABS
+ tab_pad = tabstop_padding(ind_done, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+#else
+ tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
+#endif
+ if (todo >= tab_pad && !curbuf->b_p_et)
{
- if (open_count > 0)
- --open_count;
- else
- {
- curwin->w_cursor.col = i;
- retval = TRUE;
- }
+ todo -= tab_pad;
+ ++ind_len;
+#ifdef FEAT_VARTABS
+ ind_col += tab_pad;
+#endif
+ if (p != NULL)
+ *p++ = TAB;
}
- }
- return retval;
-}
-
-/*
- * Parse 'cinoptions' and set the values in "curbuf".
- * Must be called when 'cinoptions', 'shiftwidth' and/or 'tabstop' changes.
- */
- void
-parse_cino(buf_T *buf)
-{
- char_u *p;
- char_u *l;
- char_u *digits;
- int n;
- int divider;
- int fraction = 0;
- int sw = (int)get_sw_value(buf);
-
- // Set the default values.
-
- // Spaces from a block's opening brace the prevailing indent for that
- // block should be.
- buf->b_ind_level = sw;
-
- // Spaces from the edge of the line an open brace that's at the end of a
- // line is imagined to be.
- buf->b_ind_open_imag = 0;
-
- // Spaces from the prevailing indent for a line that is not preceded by
- // an opening brace.
- buf->b_ind_no_brace = 0;
-
- // Column where the first { of a function should be located }.
- buf->b_ind_first_open = 0;
-
- // Spaces from the prevailing indent a leftmost open brace should be
- // located.
- buf->b_ind_open_extra = 0;
- // Spaces from the matching open brace (real location for one at the left
- // edge; imaginary location from one that ends a line) the matching close
- // brace should be located.
- buf->b_ind_close_extra = 0;
-
- // Spaces from the edge of the line an open brace sitting in the leftmost
- // column is imagined to be.
- buf->b_ind_open_left_imag = 0;
-
- // Spaces jump labels should be shifted to the left if N is non-negative,
- // otherwise the jump label will be put to column 1.
- buf->b_ind_jump_label = -1;
-
- // Spaces from the switch() indent a "case xx" label should be located.
- buf->b_ind_case = sw;
-
- // Spaces from the "case xx:" code after a switch() should be located.
- buf->b_ind_case_code = sw;
-
- // Lineup break at end of case in switch() with case label.
- buf->b_ind_case_break = 0;
-
- // Spaces from the class declaration indent a scope declaration label
- // should be located.
- buf->b_ind_scopedecl = sw;
-
- // Spaces from the scope declaration label code should be located.
- buf->b_ind_scopedecl_code = sw;
-
- // Amount K&R-style parameters should be indented.
- buf->b_ind_param = sw;
-
- // Amount a function type spec should be indented.
- buf->b_ind_func_type = sw;
-
- // Amount a cpp base class declaration or constructor initialization
- // should be indented.
- buf->b_ind_cpp_baseclass = sw;
-
- // additional spaces beyond the prevailing indent a continuation line
- // should be located.
- buf->b_ind_continuation = sw;
-
- // Spaces from the indent of the line with an unclosed parentheses.
- buf->b_ind_unclosed = sw * 2;
-
- // Spaces from the indent of the line with an unclosed parentheses, which
- // itself is also unclosed.
- buf->b_ind_unclosed2 = sw;
-
- // Suppress ignoring spaces from the indent of a line starting with an
- // unclosed parentheses.
- buf->b_ind_unclosed_noignore = 0;
-
- // If the opening paren is the last nonwhite character on the line, and
- // b_ind_unclosed_wrapped is nonzero, use this indent relative to the outer
- // context (for very long lines).
- buf->b_ind_unclosed_wrapped = 0;
-
- // Suppress ignoring white space when lining up with the character after
- // an unclosed parentheses.
- buf->b_ind_unclosed_whiteok = 0;
-
- // Indent a closing parentheses under the line start of the matching
- // opening parentheses.
- buf->b_ind_matching_paren = 0;
-
- // Indent a closing parentheses under the previous line.
- buf->b_ind_paren_prev = 0;
-
- // Extra indent for comments.
- buf->b_ind_comment = 0;
-
- // Spaces from the comment opener when there is nothing after it.
- buf->b_ind_in_comment = 3;
-
- // Boolean: if non-zero, use b_ind_in_comment even if there is something
- // after the comment opener.
- buf->b_ind_in_comment2 = 0;
-
- // Max lines to search for an open paren.
- buf->b_ind_maxparen = 20;
-
- // Max lines to search for an open comment.
- buf->b_ind_maxcomment = 70;
-
- // Handle braces for java code.
- buf->b_ind_java = 0;
-
- // Not to confuse JS object properties with labels.
- buf->b_ind_js = 0;
-
- // Handle blocked cases correctly.
- buf->b_ind_keep_case_label = 0;
-
- // Handle C++ namespace.
- buf->b_ind_cpp_namespace = 0;
-
- // Handle continuation lines containing conditions of if(), for() and
- // while().
- buf->b_ind_if_for_while = 0;
-
- // indentation for # comments
- buf->b_ind_hash_comment = 0;
-
- // Handle C++ extern "C" or "C++"
- buf->b_ind_cpp_extern_c = 0;
-
- for (p = buf->b_p_cino; *p; )
- {
- l = p++;
- if (*p == '-')
- ++p;
- digits = p; // remember where the digits start
- n = getdigits(&p);
- divider = 0;
- if (*p == '.') // ".5s" means a fraction
+ // Add tabs required for indent
+ if (!curbuf->b_p_et)
{
- fraction = atol((char *)++p);
- while (VIM_ISDIGIT(*p))
+#ifdef FEAT_VARTABS
+ for (;;)
{
- ++p;
- if (divider)
- divider *= 10;
- else
- divider = 10;
+ tab_pad = tabstop_padding(ind_col, curbuf->b_p_ts,
+ curbuf->b_p_vts_array);
+ if (todo < tab_pad)
+ break;
+ todo -= tab_pad;
+ ++ind_len;
+ ind_col += tab_pad;
+ if (p != NULL)
+ *p++ = TAB;
}
- }
- if (*p == 's') // "2s" means two times 'shiftwidth'
- {
- if (p == digits)
- n = sw; // just "s" is one 'shiftwidth'
- else
+#else
+ while (todo >= (int)curbuf->b_p_ts)
{
- n *= sw;
- if (divider)
- n += (sw * fraction + divider / 2) / divider;
+ todo -= (int)curbuf->b_p_ts;
+ ++ind_len;
+ if (p != NULL)
+ *p++ = TAB;
}
- ++p;
+#endif
}
- if (l[1] == '-')
- n = -n;
- // When adding an entry here, also update the default 'cinoptions' in
- // doc/indent.txt, and add explanation for it!
- switch (*l)
+ // Count/add spaces required for indent
+ while (todo > 0)
{
- case '>': buf->b_ind_level = n; break;
- case 'e': buf->b_ind_open_imag = n; break;
- case 'n': buf->b_ind_no_brace = n; break;
- case 'f': buf->b_ind_first_open = n; break;
- case '{': buf->b_ind_open_extra = n; break;
- case '}': buf->b_ind_close_extra = n; break;
- case '^': buf->b_ind_open_left_imag = n; break;
- case 'L': buf->b_ind_jump_label = n; break;
- case ':': buf->b_ind_case = n; break;
- case '=': buf->b_ind_case_code = n; break;
- case 'b': buf->b_ind_case_break = n; break;
- case 'p': buf->b_ind_param = n; break;
- case 't': buf->b_ind_func_type = n; break;
- case '/': buf->b_ind_comment = n; break;
- case 'c': buf->b_ind_in_comment = n; break;
- case 'C': buf->b_ind_in_comment2 = n; break;
- case 'i': buf->b_ind_cpp_baseclass = n; break;
- case '+': buf->b_ind_continuation = n; break;
- case '(': buf->b_ind_unclosed = n; break;
- case 'u': buf->b_ind_unclosed2 = n; break;
- case 'U': buf->b_ind_unclosed_noignore = n; break;
- case 'W': buf->b_ind_unclosed_wrapped = n; break;
- case 'w': buf->b_ind_unclosed_whiteok = n; break;
- case 'm': buf->b_ind_matching_paren = n; break;
- case 'M': buf->b_ind_paren_prev = n; break;
- case ')': buf->b_ind_maxparen = n; break;
- case '*': buf->b_ind_maxcomment = n; break;
- case 'g': buf->b_ind_scopedecl = n; break;
- case 'h': buf->b_ind_scopedecl_code = n; break;
- case 'j': buf->b_ind_java = n; break;
- case 'J': buf->b_ind_js = n; break;
- case 'l': buf->b_ind_keep_case_label = n; break;
- case '#': buf->b_ind_hash_comment = n; break;
- case 'N': buf->b_ind_cpp_namespace = n; break;
- case 'k': buf->b_ind_if_for_while = n; break;
- case 'E': buf->b_ind_cpp_extern_c = n; break;
+ --todo;
+ ++ind_len;
+ if (p != NULL)
+ *p++ = ' ';
+ }
+
+ if (p == NULL)
+ {
+ // Allocate memory for the result: the copied indent, new indent
+ // and the rest of the line.
+ line_len = (int)STRLEN(ml_get_curline()) + 1;
+ line = alloc(ind_len + line_len);
+ if (line == NULL)
+ return FALSE;
+ p = line;
}
- if (*p == ',')
- ++p;
}
+
+ // Append the original line
+ mch_memmove(p, ml_get_curline(), (size_t)line_len);
+
+ // Replace the line
+ ml_replace(curwin->w_cursor.lnum, line, FALSE);
+
+ // Put the cursor after the indent.
+ curwin->w_cursor.col = ind_len;
+ return TRUE;
}
/*
- * Return the desired indent for C code.
- * Return -1 if the indent should be left alone (inside a raw string).
+ * ":retab".
*/
- int
-get_c_indent(void)
+ void
+ex_retab(exarg_T *eap)
{
- pos_T cur_curpos;
- int amount;
- int scope_amount;
- int cur_amount = MAXCOL;
- colnr_T col;
- char_u *theline;
- char_u *linecopy;
- pos_T *trypos;
- pos_T *comment_pos;
- pos_T *tryposBrace = NULL;
- pos_T tryposCopy;
- pos_T our_paren_pos;
- char_u *start;
- int start_brace;
-#define BRACE_IN_COL0 1 // '{' is in column 0
-#define BRACE_AT_START 2 // '{' is at start of line
-#define BRACE_AT_END 3 // '{' is at end of line
- linenr_T ourscope;
- char_u *l;
- char_u *look;
- char_u terminated;
- int lookfor;
-#define LOOKFOR_INITIAL 0
-#define LOOKFOR_IF 1
-#define LOOKFOR_DO 2
-#define LOOKFOR_CASE 3
-#define LOOKFOR_ANY 4
-#define LOOKFOR_TERM 5
-#define LOOKFOR_UNTERM 6
-#define LOOKFOR_SCOPEDECL 7
-#define LOOKFOR_NOBREAK 8
-#define LOOKFOR_CPP_BASECLASS 9
-#define LOOKFOR_ENUM_OR_INIT 10
-#define LOOKFOR_JS_KEY 11
-#define LOOKFOR_COMMA 12
-
- int whilelevel;
linenr_T lnum;
- int n;
- int iscase;
- int lookfor_break;
- int lookfor_cpp_namespace = FALSE;
- int cont_amount = 0; // amount for continuation line
- int original_line_islabel;
- int added_to_amount = 0;
- int js_cur_has_key = 0;
- linenr_T raw_string_start = 0;
- cpp_baseclass_cache_T cache_cpp_baseclass = { FALSE, { MAXLNUM, 0 } };
-
- // make a copy, value is changed below
- int ind_continuation = curbuf->b_ind_continuation;
-
- // remember where the cursor was when we started
- cur_curpos = curwin->w_cursor;
-
- // if we are at line 1 zero indent is fine, right?
- if (cur_curpos.lnum == 1)
- return 0;
-
- // Get a copy of the current contents of the line.
- // This is required, because only the most recent line obtained with
- // ml_get is valid!
- linecopy = vim_strsave(ml_get(cur_curpos.lnum));
- if (linecopy == NULL)
- return 0;
-
- // In insert mode and the cursor is on a ')' truncate the line at the
- // cursor position. We don't want to line up with the matching '(' when
- // inserting new stuff.
- // For unknown reasons the cursor might be past the end of the line, thus
- // check for that.
- if ((State & INSERT)
- && curwin->w_cursor.col < (colnr_T)STRLEN(linecopy)
- && linecopy[curwin->w_cursor.col] == ')')
- linecopy[curwin->w_cursor.col] = NUL;
-
- theline = skipwhite(linecopy);
-
- // move the cursor to the start of the line
-
- curwin->w_cursor.col = 0;
-
- original_line_islabel = cin_islabel(); // XXX
+ int got_tab = FALSE;
+ long num_spaces = 0;
+ long num_tabs;
+ long len;
+ long col;
+ long vcol;
+ long start_col = 0; /* For start of white-space string */
+ long start_vcol = 0; /* For start of white-space string */
+ long old_len;
+ char_u *ptr;
+ char_u *new_line = (char_u *)1; /* init to non-NULL */
+ int did_undo; /* called u_save for current line */
+#ifdef FEAT_VARTABS
+ int *new_vts_array = NULL;
+ char_u *new_ts_str; /* string value of tab argument */
+#else
+ int temp;
+ int new_ts;
+#endif
+ int save_list;
+ linenr_T first_line = 0; /* first changed line */
+ linenr_T last_line = 0; /* last changed line */
- // If we are inside a raw string don't change the indent.
- // Ignore a raw string inside a comment.
- comment_pos = ind_find_start_comment();
- if (comment_pos != NULL)
- {
- // findmatchlimit() static pos is overwritten, make a copy
- tryposCopy = *comment_pos;
- comment_pos = &tryposCopy;
- }
- trypos = find_start_rawstring(curbuf->b_ind_maxcomment);
- if (trypos != NULL && (comment_pos == NULL
- || LT_POS(*trypos, *comment_pos)))
- {
- amount = -1;
- goto laterend;
- }
+ save_list = curwin->w_p_list;
+ curwin->w_p_list = 0; /* don't want list mode here */
- // #defines and so on always go at the left when included in 'cinkeys'.
- if (*theline == '#' && (*linecopy == '#' || in_cinkeys('#', ' ', TRUE)))
- {
- amount = curbuf->b_ind_hash_comment;
- goto theend;
- }
+#ifdef FEAT_VARTABS
+ new_ts_str = eap->arg;
+ if (!tabstop_set(eap->arg, &new_vts_array))
+ return;
+ while (vim_isdigit(*(eap->arg)) || *(eap->arg) == ',')
+ ++(eap->arg);
- // Is it a non-case label? Then that goes at the left margin too unless:
- // - JS flag is set.
- // - 'L' item has a positive value.
- if (original_line_islabel && !curbuf->b_ind_js
- && curbuf->b_ind_jump_label < 0)
+ // This ensures that either new_vts_array and new_ts_str are freshly
+ // allocated, or new_vts_array points to an existing array and new_ts_str
+ // is null.
+ if (new_vts_array == NULL)
{
- amount = 0;
- goto theend;
+ new_vts_array = curbuf->b_p_vts_array;
+ new_ts_str = NULL;
}
-
- // If we're inside a "//" comment and there is a "//" comment in a
- // previous line, lineup with that one.
- if (cin_islinecomment(theline)
- && (trypos = find_line_comment()) != NULL) // XXX
+ else
+ new_ts_str = vim_strnsave(new_ts_str, eap->arg - new_ts_str);
+#else
+ new_ts = getdigits(&(eap->arg));
+ if (new_ts < 0)
{
- // find how indented the line beginning the comment is
- getvcol(curwin, trypos, &col, NULL, NULL);
- amount = col;
- goto theend;
+ emsg(_(e_positive));
+ return;
}
-
- // If we're inside a comment and not looking at the start of the
- // comment, try using the 'comments' option.
- if (!cin_iscomment(theline) && comment_pos != NULL) // XXX
+ if (new_ts == 0)
+ new_ts = curbuf->b_p_ts;
+#endif
+ for (lnum = eap->line1; !got_int && lnum <= eap->line2; ++lnum)
{
- int lead_start_len = 2;
- int lead_middle_len = 1;
- char_u lead_start[COM_MAX_LEN]; // start-comment string
- char_u lead_middle[COM_MAX_LEN]; // middle-comment string
- char_u lead_end[COM_MAX_LEN]; // end-comment string
- char_u *p;
- int start_align = 0;
- int start_off = 0;
- int done = FALSE;
-
- // find how indented the line beginning the comment is
- getvcol(curwin, comment_pos, &col, NULL, NULL);
- amount = col;
- *lead_start = NUL;
- *lead_middle = NUL;
-
- p = curbuf->b_p_com;
- while (*p != NUL)
+ ptr = ml_get(lnum);
+ col = 0;
+ vcol = 0;
+ did_undo = FALSE;
+ for (;;)
{
- int align = 0;
- int off = 0;
- int what = 0;
-
- while (*p != NUL && *p != ':')
+ if (VIM_ISWHITE(ptr[col]))
{
- if (*p == COM_START || *p == COM_END || *p == COM_MIDDLE)
- what = *p++;
- else if (*p == COM_LEFT || *p == COM_RIGHT)
- align = *p++;
- else if (VIM_ISDIGIT(*p) || *p == '-')
- off = getdigits(&p);
+ if (!got_tab && num_spaces == 0)
+ {
+ /* First consecutive white-space */
+ start_vcol = vcol;
+ start_col = col;
+ }
+ if (ptr[col] == ' ')
+ num_spaces++;
else
- ++p;
- }
-
- if (*p == ':')
- ++p;
- (void)copy_option_part(&p, lead_end, COM_MAX_LEN, ",");
- if (what == COM_START)
- {
- STRCPY(lead_start, lead_end);
- lead_start_len = (int)STRLEN(lead_start);
- start_off = off;
- start_align = align;
- }
- else if (what == COM_MIDDLE)
- {
- STRCPY(lead_middle, lead_end);
- lead_middle_len = (int)STRLEN(lead_middle);
+ got_tab = TRUE;
}
- else if (what == COM_END)
+ else
{
- // If our line starts with the middle comment string, line it
- // up with the comment opener per the 'comments' option.
- if (STRNCMP(theline, lead_middle, lead_middle_len) == 0
- && STRNCMP(theline, lead_end, STRLEN(lead_end)) != 0)
+ if (got_tab || (eap->forceit && num_spaces > 1))
{
- done = TRUE;
- if (curwin->w_cursor.lnum > 1)
+ /* Retabulate this string of white-space */
+
+ /* len is virtual length of white string */
+ len = num_spaces = vcol - start_vcol;
+ num_tabs = 0;
+ if (!curbuf->b_p_et)
{
- // If the start comment string matches in the previous
- // line, use the indent of that line plus offset. If
- // the middle comment string matches in the previous
- // line, use the indent of that line. XXX
- look = skipwhite(ml_get(curwin->w_cursor.lnum - 1));
- if (STRNCMP(look, lead_start, lead_start_len) == 0)
- amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
- else if (STRNCMP(look, lead_middle,
- lead_middle_len) == 0)
+#ifdef FEAT_VARTABS
+ int t, s;
+
+ tabstop_fromto(start_vcol, vcol,
+ curbuf->b_p_ts, new_vts_array, &t, &s);
+ num_tabs = t;
+ num_spaces = s;
+#else
+ temp = new_ts - (start_vcol % new_ts);
+ if (num_spaces >= temp)
{
- amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
- break;
+ num_spaces -= temp;
+ num_tabs++;
}
- // If the start comment string doesn't match with the
- // start of the comment, skip this entry. XXX
- else if (STRNCMP(ml_get(comment_pos->lnum) + comment_pos->col,
- lead_start, lead_start_len) != 0)
- continue;
+ num_tabs += num_spaces / new_ts;
+ num_spaces -= (num_spaces / new_ts) * new_ts;
+#endif
}
- if (start_off != 0)
- amount += start_off;
- else if (start_align == COM_RIGHT)
- amount += vim_strsize(lead_start)
- - vim_strsize(lead_middle);
- break;
- }
+ if (curbuf->b_p_et || got_tab ||
+ (num_spaces + num_tabs < len))
+ {
+ if (did_undo == FALSE)
+ {
+ did_undo = TRUE;
+ if (u_save((linenr_T)(lnum - 1),
+ (linenr_T)(lnum + 1)) == FAIL)
+ {
+ new_line = NULL; /* flag out-of-memory */
+ break;
+ }
+ }
- // If our line starts with the end comment string, line it up
- // with the middle comment
- if (STRNCMP(theline, lead_middle, lead_middle_len) != 0
- && STRNCMP(theline, lead_end, STRLEN(lead_end)) == 0)
- {
- amount = get_indent_lnum(curwin->w_cursor.lnum - 1);
- // XXX
- if (off != 0)
- amount += off;
- else if (align == COM_RIGHT)
- amount += vim_strsize(lead_start)
- - vim_strsize(lead_middle);
- done = TRUE;
- break;
+ /* len is actual number of white characters used */
+ len = num_spaces + num_tabs;
+ old_len = (long)STRLEN(ptr);
+ new_line = alloc(old_len - col + start_col + len + 1);
+ if (new_line == NULL)
+ break;
+ if (start_col > 0)
+ mch_memmove(new_line, ptr, (size_t)start_col);
+ mch_memmove(new_line + start_col + len,
+ ptr + col, (size_t)(old_len - col + 1));
+ ptr = new_line + start_col;
+ for (col = 0; col < len; col++)
+ ptr[col] = (col < num_tabs) ? '\t' : ' ';
+ ml_replace(lnum, new_line, FALSE);
+ if (first_line == 0)
+ first_line = lnum;
+ last_line = lnum;
+ ptr = new_line;
+ col = start_col + len;
+ }
}
+ got_tab = FALSE;
+ num_spaces = 0;
}
- }
-
- // If our line starts with an asterisk, line up with the
- // asterisk in the comment opener; otherwise, line up
- // with the first character of the comment text.
- if (done)
- ;
- else if (theline[0] == '*')
- amount += 1;
- else
- {
- // If we are more than one line away from the comment opener, take
- // the indent of the previous non-empty line. If 'cino' has "CO"
- // and we are just below the comment opener and there are any
- // white characters after it line up with the text after it;
- // otherwise, add the amount specified by "c" in 'cino'
- amount = -1;
- for (lnum = cur_curpos.lnum - 1; lnum > comment_pos->lnum; --lnum)
- {
- if (linewhite(lnum)) // skip blank lines
- continue;
- amount = get_indent_lnum(lnum); // XXX
+ if (ptr[col] == NUL)
break;
- }
- if (amount == -1) // use the comment opener
- {
- if (!curbuf->b_ind_in_comment2)
- {
- start = ml_get(comment_pos->lnum);
- look = start + comment_pos->col + 2; // skip / and *
- if (*look != NUL) // if something after it
- comment_pos->col = (colnr_T)(skipwhite(look) - start);
- }
- getvcol(curwin, comment_pos, &col, NULL, NULL);
- amount = col;
- if (curbuf->b_ind_in_comment2 || *look == NUL)
- amount += curbuf->b_ind_in_comment;
- }
+ vcol += chartabsize(ptr + col, (colnr_T)vcol);
+ if (has_mbyte)
+ col += (*mb_ptr2len)(ptr + col);
+ else
+ ++col;
}
- goto theend;
- }
+ if (new_line == NULL) /* out of memory */
+ break;
+ line_breakcheck();
+ }
+ if (got_int)
+ emsg(_(e_interr));
+
+#ifdef FEAT_VARTABS
+ // If a single value was given then it can be considered equal to
+ // either the value of 'tabstop' or the value of 'vartabstop'.
+ if (tabstop_count(curbuf->b_p_vts_array) == 0
+ && tabstop_count(new_vts_array) == 1
+ && curbuf->b_p_ts == tabstop_first(new_vts_array))
+ ; /* not changed */
+ else if (tabstop_count(curbuf->b_p_vts_array) > 0
+ && tabstop_eq(curbuf->b_p_vts_array, new_vts_array))
+ ; /* not changed */
+ else
+ redraw_curbuf_later(NOT_VALID);
+#else
+ if (curbuf->b_p_ts != new_ts)
+ redraw_curbuf_later(NOT_VALID);
+#endif
+ if (first_line != 0)
+ changed_lines(first_line, 0, last_line + 1, 0L);
- // Are we looking at a ']' that has a match?
- if (*skipwhite(theline) == ']'
- && (trypos = find_match_char('[', curbuf->b_ind_maxparen)) != NULL)
- {
- // align with the line containing the '['.
- amount = get_indent_lnum(trypos->lnum);
- goto theend;
- }
+ curwin->w_p_list = save_list; /* restore 'list' */
- // Are we inside parentheses or braces? XXX
- if (((trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL
- && curbuf->b_ind_java == 0)
- || (tryposBrace = find_start_brace()) != NULL
- || trypos != NULL)
+#ifdef FEAT_VARTABS
+ if (new_ts_str != NULL) /* set the new tabstop */
{
- if (trypos != NULL && tryposBrace != NULL)
- {
- // Both an unmatched '(' and '{' is found. Use the one which is
- // closer to the current cursor position, set the other to NULL.
- if (trypos->lnum != tryposBrace->lnum
- ? trypos->lnum < tryposBrace->lnum
- : trypos->col < tryposBrace->col)
- trypos = NULL;
- else
- tryposBrace = NULL;
- }
-
- if (trypos != NULL)
- {
- // If the matching paren is more than one line away, use the indent of
- // a previous non-empty line that matches the same paren.
- if (theline[0] == ')' && curbuf->b_ind_paren_prev)
+ // If 'vartabstop' is in use or if the value given to retab has more
+ // than one tabstop then update 'vartabstop'.
+ int *old_vts_ary = curbuf->b_p_vts_array;
+
+ if (tabstop_count(old_vts_ary) > 0 || tabstop_count(new_vts_array) > 1)
{
- // Line up with the start of the matching paren line.
- amount = get_indent_lnum(curwin->w_cursor.lnum - 1); // XXX
+ set_string_option_direct((char_u *)"vts", -1, new_ts_str,
+ OPT_FREE|OPT_LOCAL, 0);
+ curbuf->b_p_vts_array = new_vts_array;
+ vim_free(old_vts_ary);
}
else
{
- amount = -1;
- our_paren_pos = *trypos;
- for (lnum = cur_curpos.lnum - 1; lnum > our_paren_pos.lnum; --lnum)
- {
- l = skipwhite(ml_get(lnum));
- if (cin_nocode(l)) // skip comment lines
- continue;
- if (cin_ispreproc_cont(&l, &lnum, &amount))
- continue; // ignore #define, #if, etc.
- curwin->w_cursor.lnum = lnum;
-
- // Skip a comment or raw string. XXX
- if ((trypos = ind_find_start_CORS(NULL)) != NULL)
- {
- lnum = trypos->lnum + 1;
- continue;
- }
+ // 'vartabstop' wasn't in use and a single value was given to
+ // retab then update 'tabstop'.
+ curbuf->b_p_ts = tabstop_first(new_vts_array);
+ vim_free(new_vts_array);
+ }
+ vim_free(new_ts_str);
+ }
+#else
+ curbuf->b_p_ts = new_ts;
+#endif
+ coladvance(curwin->w_curswant);
- // XXX
- if ((trypos = find_match_paren(
- corr_ind_maxparen(&cur_curpos))) != NULL
- && trypos->lnum == our_paren_pos.lnum
- && trypos->col == our_paren_pos.col)
- {
- amount = get_indent_lnum(lnum); // XXX
+ u_clearline();
+}
- if (theline[0] == ')')
- {
- if (our_paren_pos.lnum != lnum
- && cur_amount > amount)
- cur_amount = amount;
- amount = -1;
- }
- break;
- }
- }
- }
+#if (defined(FEAT_CINDENT) && defined(FEAT_EVAL)) || defined(PROTO)
+/*
+ * Get indent level from 'indentexpr'.
+ */
+ int
+get_expr_indent(void)
+{
+ int indent = -1;
+ char_u *inde_copy;
+ pos_T save_pos;
+ colnr_T save_curswant;
+ int save_set_curswant;
+ int save_State;
+ int use_sandbox = was_set_insecurely((char_u *)"indentexpr",
+ OPT_LOCAL);
- // Line up with line where the matching paren is. XXX
- // If the line starts with a '(' or the indent for unclosed
- // parentheses is zero, line up with the unclosed parentheses.
- if (amount == -1)
- {
- int ignore_paren_col = 0;
- int is_if_for_while = 0;
+ // Save and restore cursor position and curswant, in case it was changed
+ // via :normal commands
+ save_pos = curwin->w_cursor;
+ save_curswant = curwin->w_curswant;
+ save_set_curswant = curwin->w_set_curswant;
+ set_vim_var_nr(VV_LNUM, curwin->w_cursor.lnum);
+ if (use_sandbox)
+ ++sandbox;
+ ++textlock;
- if (curbuf->b_ind_if_for_while)
- {
- // Look for the outermost opening parenthesis on this line
- // and check whether it belongs to an "if", "for" or "while".
+ // Need to make a copy, the 'indentexpr' option could be changed while
+ // evaluating it.
+ inde_copy = vim_strsave(curbuf->b_p_inde);
+ if (inde_copy != NULL)
+ {
+ indent = (int)eval_to_number(inde_copy);
+ vim_free(inde_copy);
+ }
- pos_T cursor_save = curwin->w_cursor;
- pos_T outermost;
- char_u *line;
+ if (use_sandbox)
+ --sandbox;
+ --textlock;
- trypos = &our_paren_pos;
- do {
- outermost = *trypos;
- curwin->w_cursor.lnum = outermost.lnum;
- curwin->w_cursor.col = outermost.col;
+ // Restore the cursor position so that 'indentexpr' doesn't need to.
+ // Pretend to be in Insert mode, allow cursor past end of line for "o"
+ // command.
+ save_State = State;
+ State = INSERT;
+ curwin->w_cursor = save_pos;
+ curwin->w_curswant = save_curswant;
+ curwin->w_set_curswant = save_set_curswant;
+ check_cursor();
+ State = save_State;
- trypos = find_match_paren(curbuf->b_ind_maxparen);
- } while (trypos && trypos->lnum == outermost.lnum);
+ // If there is an error, just keep the current indent.
+ if (indent < 0)
+ indent = get_indent();
- curwin->w_cursor = cursor_save;
+ return indent;
+}
+#endif
- line = ml_get(outermost.lnum);
+#if defined(FEAT_LISP) || defined(PROTO)
- is_if_for_while =
- cin_is_if_for_while_before_offset(line, &outermost.col);
- }
+ static int
+lisp_match(char_u *p)
+{
+ char_u buf[LSIZE];
+ int len;
+ char_u *word = *curbuf->b_p_lw != NUL ? curbuf->b_p_lw : p_lispwords;
- amount = skip_label(our_paren_pos.lnum, &look);
- look = skipwhite(look);
- if (*look == '(')
- {
- linenr_T save_lnum = curwin->w_cursor.lnum;
- char_u *line;
- int look_col;
-
- // Ignore a '(' in front of the line that has a match before
- // our matching '('.
- curwin->w_cursor.lnum = our_paren_pos.lnum;
- line = ml_get_curline();
- look_col = (int)(look - line);
- curwin->w_cursor.col = look_col + 1;
- if ((trypos = findmatchlimit(NULL, ')', 0,
- curbuf->b_ind_maxparen))
- != NULL
- && trypos->lnum == our_paren_pos.lnum
- && trypos->col < our_paren_pos.col)
- ignore_paren_col = trypos->col + 1;
-
- curwin->w_cursor.lnum = save_lnum;
- look = ml_get(our_paren_pos.lnum) + look_col;
- }
- if (theline[0] == ')' || (curbuf->b_ind_unclosed == 0
- && is_if_for_while == 0)
- || (!curbuf->b_ind_unclosed_noignore && *look == '('
- && ignore_paren_col == 0))
- {
- // If we're looking at a close paren, line up right there;
- // otherwise, line up with the next (non-white) character.
- // When b_ind_unclosed_wrapped is set and the matching paren is
- // the last nonwhite character of the line, use either the
- // indent of the current line or the indentation of the next
- // outer paren and add b_ind_unclosed_wrapped (for very long
- // lines).
- if (theline[0] != ')')
- {
- cur_amount = MAXCOL;
- l = ml_get(our_paren_pos.lnum);
- if (curbuf->b_ind_unclosed_wrapped
- && cin_ends_in(l, (char_u *)"(", NULL))
- {
- // look for opening unmatched paren, indent one level
- // for each additional level
- n = 1;
- for (col = 0; col < our_paren_pos.col; ++col)
- {
- switch (l[col])
- {
- case '(':
- case '{': ++n;
- break;
-
- case ')':
- case '}': if (n > 1)
- --n;
- break;
- }
- }
+ while (*word != NUL)
+ {
+ (void)copy_option_part(&word, buf, LSIZE, ",");
+ len = (int)STRLEN(buf);
+ if (STRNCMP(buf, p, len) == 0 && p[len] == ' ')
+ return TRUE;
+ }
+ return FALSE;
+}
- our_paren_pos.col = 0;
- amount += n * curbuf->b_ind_unclosed_wrapped;
- }
- else if (curbuf->b_ind_unclosed_whiteok)
- our_paren_pos.col++;
- else
- {
- col = our_paren_pos.col + 1;
- while (VIM_ISWHITE(l[col]))
- col++;
- if (l[col] != NUL) // In case of trailing space
- our_paren_pos.col = col;
- else
- our_paren_pos.col++;
- }
- }
+/*
+ * When 'p' is present in 'cpoptions, a Vi compatible method is used.
+ * The incompatible newer method is quite a bit better at indenting
+ * code in lisp-like languages than the traditional one; it's still
+ * mostly heuristics however -- Dirk van Deun, dirk@rave.org
+ *
+ * TODO:
+ * Findmatch() should be adapted for lisp, also to make showmatch
+ * work correctly: now (v5.3) it seems all C/C++ oriented:
+ * - it does not recognize the #\( and #\) notations as character literals
+ * - it doesn't know about comments starting with a semicolon
+ * - it incorrectly interprets '(' as a character literal
+ * All this messes up get_lisp_indent in some rare cases.
+ * Update from Sergey Khorev:
+ * I tried to fix the first two issues.
+ */
+ int
+get_lisp_indent(void)
+{
+ pos_T *pos, realpos, paren;
+ int amount;
+ char_u *that;
+ colnr_T col;
+ colnr_T firsttry;
+ int parencount, quotecount;
+ int vi_lisp;
- // Find how indented the paren is, or the character after it
- // if we did the above "if".
- if (our_paren_pos.col > 0)
- {
- getvcol(curwin, &our_paren_pos, &col, NULL, NULL);
- if (cur_amount > (int)col)
- cur_amount = col;
- }
- }
+ // Set vi_lisp to use the vi-compatible method
+ vi_lisp = (vim_strchr(p_cpo, CPO_LISP) != NULL);
- if (theline[0] == ')' && curbuf->b_ind_matching_paren)
- {
- // Line up with the start of the matching paren line.
- }
- else if ((curbuf->b_ind_unclosed == 0 && is_if_for_while == 0)
- || (!curbuf->b_ind_unclosed_noignore
- && *look == '(' && ignore_paren_col == 0))
- {
- if (cur_amount != MAXCOL)
- amount = cur_amount;
- }
- else
+ realpos = curwin->w_cursor;
+ curwin->w_cursor.col = 0;
+
+ if ((pos = findmatch(NULL, '(')) == NULL)
+ pos = findmatch(NULL, '[');
+ else
+ {
+ paren = *pos;
+ pos = findmatch(NULL, '[');
+ if (pos == NULL || LT_POSP(pos, &paren))
+ pos = &paren;
+ }
+ if (pos != NULL)
+ {
+ // Extra trick: Take the indent of the first previous non-white
+ // line that is at the same () level.
+ amount = -1;
+ parencount = 0;
+
+ while (--curwin->w_cursor.lnum >= pos->lnum)
+ {
+ if (linewhite(curwin->w_cursor.lnum))
+ continue;
+ for (that = ml_get_curline(); *that != NUL; ++that)
{
- // Add b_ind_unclosed2 for each '(' before our matching one,
- // but ignore (void) before the line (ignore_paren_col).
- col = our_paren_pos.col;
- while ((int)our_paren_pos.col > ignore_paren_col)
+ if (*that == ';')
{
- --our_paren_pos.col;
- switch (*ml_get_pos(&our_paren_pos))
- {
- case '(': amount += curbuf->b_ind_unclosed2;
- col = our_paren_pos.col;
- break;
- case ')': amount -= curbuf->b_ind_unclosed2;
- col = MAXCOL;
- break;
- }
+ while (*(that + 1) != NUL)
+ ++that;
+ continue;
}
-
- // Use b_ind_unclosed once, when the first '(' is not inside
- // braces
- if (col == MAXCOL)
- amount += curbuf->b_ind_unclosed;
- else
+ if (*that == '\\')
+ {
+ if (*(that + 1) != NUL)
+ ++that;
+ continue;
+ }
+ if (*that == '"' && *(that + 1) != NUL)
{
- curwin->w_cursor.lnum = our_paren_pos.lnum;
- curwin->w_cursor.col = col;
- if (find_match_paren_after_brace(curbuf->b_ind_maxparen)
- != NULL)
- amount += curbuf->b_ind_unclosed2;
- else
+ while (*++that && *that != '"')
{
- if (is_if_for_while)
- amount += curbuf->b_ind_if_for_while;
- else
- amount += curbuf->b_ind_unclosed;
+ // skipping escaped characters in the string
+ if (*that == '\\')
+ {
+ if (*++that == NUL)
+ break;
+ if (that[1] == NUL)
+ {
+ ++that;
+ break;
+ }
+ }
}
}
- // For a line starting with ')' use the minimum of the two
- // positions, to avoid giving it more indent than the previous
- // lines:
- // func_long_name( if (x
- // arg && yy
- // ) ^ not here ) ^ not here
- if (cur_amount < amount)
- amount = cur_amount;
+ if (*that == '(' || *that == '[')
+ ++parencount;
+ else if (*that == ')' || *that == ']')
+ --parencount;
}
- }
-
- // add extra indent for a comment
- if (cin_iscomment(theline))
- amount += curbuf->b_ind_comment;
- }
- else
- {
- // We are inside braces, there is a { before this line at the position
- // stored in tryposBrace.
- // Make a copy of tryposBrace, it may point to pos_copy inside
- // find_start_brace(), which may be changed somewhere.
- tryposCopy = *tryposBrace;
- tryposBrace = &tryposCopy;
- trypos = tryposBrace;
- ourscope = trypos->lnum;
- start = ml_get(ourscope);
-
- // Now figure out how indented the line is in general.
- // If the brace was at the start of the line, we use that;
- // otherwise, check out the indentation of the line as
- // a whole and then add the "imaginary indent" to that.
- look = skipwhite(start);
- if (*look == '{')
- {
- getvcol(curwin, trypos, &col, NULL, NULL);
- amount = col;
- if (*start == '{')
- start_brace = BRACE_IN_COL0;
- else
- start_brace = BRACE_AT_START;
- }
- else
- {
- // That opening brace might have been on a continuation
- // line. if so, find the start of the line.
- curwin->w_cursor.lnum = ourscope;
-
- // Position the cursor over the rightmost paren, so that
- // matching it will take us back to the start of the line.
- lnum = ourscope;
- if (find_last_paren(start, '(', ')')
- && (trypos = find_match_paren(curbuf->b_ind_maxparen))
- != NULL)
- lnum = trypos->lnum;
-
- // It could have been something like
- // case 1: if (asdf &&
- // ldfd) {
- // }
- if ((curbuf->b_ind_js || curbuf->b_ind_keep_case_label)
- && cin_iscase(skipwhite(ml_get_curline()), FALSE))
+ if (parencount == 0)
+ {
amount = get_indent();
- else if (curbuf->b_ind_js)
- amount = get_indent_lnum(lnum);
- else
- amount = skip_label(lnum, &l);
-
- start_brace = BRACE_AT_END;
+ break;
+ }
}
- // For Javascript check if the line starts with "key:".
- if (curbuf->b_ind_js)
- js_cur_has_key = cin_has_js_key(theline);
-
- // If we're looking at a closing brace, that's where
- // we want to be. otherwise, add the amount of room
- // that an indent is supposed to be.
- if (theline[0] == '}')
- {
- // they may want closing braces to line up with something
- // other than the open brace. indulge them, if so.
- amount += curbuf->b_ind_close_extra;
- }
- else
+ if (amount == -1)
{
- // If we're looking at an "else", try to find an "if"
- // to match it with.
- // If we're looking at a "while", try to find a "do"
- // to match it with.
- lookfor = LOOKFOR_INITIAL;
- if (cin_iselse(theline))
- lookfor = LOOKFOR_IF;
- else if (cin_iswhileofdo(theline, cur_curpos.lnum)) // XXX
- lookfor = LOOKFOR_DO;
- if (lookfor != LOOKFOR_INITIAL)
- {
- curwin->w_cursor.lnum = cur_curpos.lnum;
- if (find_match(lookfor, ourscope) == OK)
- {
- amount = get_indent(); // XXX
- goto theend;
- }
- }
-
- // We get here if we are not on an "while-of-do" or "else" (or
- // failed to find a matching "if").
- // Search backwards for something to line up with.
- // First set amount for when we don't find anything.
-
- // if the '{' is _really_ at the left margin, use the imaginary
- // location of a left-margin brace. Otherwise, correct the
- // location for b_ind_open_extra.
+ curwin->w_cursor.lnum = pos->lnum;
+ curwin->w_cursor.col = pos->col;
+ col = pos->col;
- if (start_brace == BRACE_IN_COL0) // '{' is in column 0
- {
- amount = curbuf->b_ind_open_left_imag;
- lookfor_cpp_namespace = TRUE;
- }
- else if (start_brace == BRACE_AT_START &&
- lookfor_cpp_namespace) // '{' is at start
- {
+ that = ml_get_curline();
- lookfor_cpp_namespace = TRUE;
- }
+ if (vi_lisp && get_indent() == 0)
+ amount = 2;
else
{
- if (start_brace == BRACE_AT_END) // '{' is at end of line
- {
- amount += curbuf->b_ind_open_imag;
+ char_u *line = that;
- l = skipwhite(ml_get_curline());
- if (cin_is_cpp_namespace(l))
- amount += curbuf->b_ind_cpp_namespace;
- else if (cin_is_cpp_extern_c(l))
- amount += curbuf->b_ind_cpp_extern_c;
- }
- else
+ amount = 0;
+ while (*that && col)
{
- // Compensate for adding b_ind_open_extra later.
- amount -= curbuf->b_ind_open_extra;
- if (amount < 0)
- amount = 0;
+ amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
+ col--;
}
- }
-
- lookfor_break = FALSE;
-
- if (cin_iscase(theline, FALSE)) // it's a switch() label
- {
- lookfor = LOOKFOR_CASE; // find a previous switch() label
- amount += curbuf->b_ind_case;
- }
- else if (cin_isscopedecl(theline)) // private:, ...
- {
- lookfor = LOOKFOR_SCOPEDECL; // class decl is this block
- amount += curbuf->b_ind_scopedecl;
- }
- else
- {
- if (curbuf->b_ind_case_break && cin_isbreak(theline))
- // break; ...
- lookfor_break = TRUE;
- lookfor = LOOKFOR_INITIAL;
- // b_ind_level from start of block
- amount += curbuf->b_ind_level;
- }
- scope_amount = amount;
- whilelevel = 0;
-
- // Search backwards. If we find something we recognize, line up
- // with that.
- //
- // If we're looking at an open brace, indent
- // the usual amount relative to the conditional
- // that opens the block.
- curwin->w_cursor = cur_curpos;
- for (;;)
- {
- curwin->w_cursor.lnum--;
- curwin->w_cursor.col = 0;
+ // Some keywords require "body" indenting rules (the
+ // non-standard-lisp ones are Scheme special forms):
+ //
+ // (let ((a 1)) instead (let ((a 1))
+ // (...)) of (...))
- // If we went all the way back to the start of our scope, line
- // up with it.
- if (curwin->w_cursor.lnum <= ourscope)
+ if (!vi_lisp && (*that == '(' || *that == '[')
+ && lisp_match(that + 1))
+ amount += 2;
+ else
{
- // We reached end of scope:
- // If looking for a enum or structure initialization
- // go further back:
- // If it is an initializer (enum xxx or xxx =), then
- // don't add ind_continuation, otherwise it is a variable
- // declaration:
- // int x,
- // here; <-- add ind_continuation
- if (lookfor == LOOKFOR_ENUM_OR_INIT)
+ that++;
+ amount++;
+ firsttry = amount;
+
+ while (VIM_ISWHITE(*that))
{
- if (curwin->w_cursor.lnum == 0
- || curwin->w_cursor.lnum
- < ourscope - curbuf->b_ind_maxparen)
- {
- // nothing found (abuse curbuf->b_ind_maxparen as
- // limit) assume terminated line (i.e. a variable
- // initialization)
- if (cont_amount > 0)
- amount = cont_amount;
- else if (!curbuf->b_ind_js)
- amount += ind_continuation;
- break;
- }
-
- l = ml_get_curline();
-
- // If we're in a comment or raw string now, skip to
- // the start of it.
- trypos = ind_find_start_CORS(NULL);
- if (trypos != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- continue;
- }
-
- // Skip preprocessor directives and blank lines.
- if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum,
- &amount))
- continue;
-
- if (cin_nocode(l))
- continue;
-
- terminated = cin_isterminated(l, FALSE, TRUE);
-
- // If we are at top level and the line looks like a
- // function declaration, we are done
- // (it's a variable declaration).
- if (start_brace != BRACE_IN_COL0
- || !cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0))
- {
- // if the line is terminated with another ','
- // it is a continued variable initialization.
- // don't add extra indent.
- // TODO: does not work, if a function
- // declaration is split over multiple lines:
- // cin_isfuncdecl returns FALSE then.
- if (terminated == ',')
- break;
-
- // if it es a enum declaration or an assignment,
- // we are done.
- if (terminated != ';' && cin_isinit())
- break;
-
- // nothing useful found
- if (terminated == 0 || terminated == '{')
- continue;
- }
-
- if (terminated != ';')
- {
- // Skip parens and braces. Position the cursor
- // over the rightmost paren, so that matching it
- // will take us back to the start of the line.
- // XXX
- trypos = NULL;
- if (find_last_paren(l, '(', ')'))
- trypos = find_match_paren(
- curbuf->b_ind_maxparen);
-
- if (trypos == NULL && find_last_paren(l, '{', '}'))
- trypos = find_start_brace();
-
- if (trypos != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- continue;
- }
- }
-
- // it's a variable declaration, add indentation
- // like in
- // int a,
- // b;
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- }
- else if (lookfor == LOOKFOR_UNTERM)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- }
- else
- {
- if (lookfor != LOOKFOR_TERM
- && lookfor != LOOKFOR_CPP_BASECLASS
- && lookfor != LOOKFOR_COMMA)
- {
- amount = scope_amount;
- if (theline[0] == '{')
- {
- amount += curbuf->b_ind_open_extra;
- added_to_amount = curbuf->b_ind_open_extra;
- }
- }
-
- if (lookfor_cpp_namespace)
- {
- // Looking for C++ namespace, need to look further
- // back.
- if (curwin->w_cursor.lnum == ourscope)
- continue;
-
- if (curwin->w_cursor.lnum == 0
- || curwin->w_cursor.lnum
- < ourscope - FIND_NAMESPACE_LIM)
- break;
-
- l = ml_get_curline();
-
- // If we're in a comment or raw string now, skip
- // to the start of it.
- trypos = ind_find_start_CORS(NULL);
- if (trypos != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- continue;
- }
-
- // Skip preprocessor directives and blank lines.
- if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum,
- &amount))
- continue;
-
- // Finally the actual check for "namespace".
- if (cin_is_cpp_namespace(l))
- {
- amount += curbuf->b_ind_cpp_namespace
- - added_to_amount;
- break;
- }
- else if (cin_is_cpp_extern_c(l))
- {
- amount += curbuf->b_ind_cpp_extern_c
- - added_to_amount;
- break;
- }
-
- if (cin_nocode(l))
- continue;
- }
- }
- break;
- }
-
- // If we're in a comment or raw string now, skip to the start
- // of it. XXX
- if ((trypos = ind_find_start_CORS(&raw_string_start)) != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- continue;
- }
-
- l = ml_get_curline();
-
- // If this is a switch() label, may line up relative to that.
- // If this is a C++ scope declaration, do the same.
- iscase = cin_iscase(l, FALSE);
- if (iscase || cin_isscopedecl(l))
- {
- // we are only looking for cpp base class
- // declaration/initialization any longer
- if (lookfor == LOOKFOR_CPP_BASECLASS)
- break;
-
- // When looking for a "do" we are not interested in
- // labels.
- if (whilelevel > 0)
- continue;
-
- // case xx:
- // c = 99 + <- this indent plus continuation
- //-> here;
- if (lookfor == LOOKFOR_UNTERM
- || lookfor == LOOKFOR_ENUM_OR_INIT)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- break;
- }
-
- // case xx: <- line up with this case
- // x = 333;
- // case yy:
- if ( (iscase && lookfor == LOOKFOR_CASE)
- || (iscase && lookfor_break)
- || (!iscase && lookfor == LOOKFOR_SCOPEDECL))
- {
- // Check that this case label is not for another
- // switch() XXX
- if ((trypos = find_start_brace()) == NULL
- || trypos->lnum == ourscope)
- {
- amount = get_indent(); // XXX
- break;
- }
- continue;
- }
-
- n = get_indent_nolabel(curwin->w_cursor.lnum); // XXX
-
- // case xx: if (cond) <- line up with this if
- // y = y + 1;
- // -> s = 99;
- //
- // case xx:
- // if (cond) <- line up with this line
- // y = y + 1;
- // -> s = 99;
- if (lookfor == LOOKFOR_TERM)
- {
- if (n)
- amount = n;
-
- if (!lookfor_break)
- break;
- }
-
- // case xx: x = x + 1; <- line up with this x
- // -> y = y + 1;
- //
- // case xx: if (cond) <- line up with this if
- // -> y = y + 1;
- if (n)
- {
- amount = n;
- l = after_label(ml_get_curline());
- if (l != NULL && cin_is_cinword(l))
- {
- if (theline[0] == '{')
- amount += curbuf->b_ind_open_extra;
- else
- amount += curbuf->b_ind_level
- + curbuf->b_ind_no_brace;
- }
- break;
- }
-
- // Try to get the indent of a statement before the switch
- // label. If nothing is found, line up relative to the
- // switch label.
- // break; <- may line up with this line
- // case xx:
- // -> y = 1;
- scope_amount = get_indent() + (iscase // XXX
- ? curbuf->b_ind_case_code
- : curbuf->b_ind_scopedecl_code);
- lookfor = curbuf->b_ind_case_break
- ? LOOKFOR_NOBREAK : LOOKFOR_ANY;
- continue;
- }
-
- // Looking for a switch() label or C++ scope declaration,
- // ignore other lines, skip {}-blocks.
- if (lookfor == LOOKFOR_CASE || lookfor == LOOKFOR_SCOPEDECL)
- {
- if (find_last_paren(l, '{', '}')
- && (trypos = find_start_brace()) != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- }
- continue;
- }
-
- // Ignore jump labels with nothing after them.
- if (!curbuf->b_ind_js && cin_islabel())
- {
- l = after_label(ml_get_curline());
- if (l == NULL || cin_nocode(l))
- continue;
- }
-
- // Ignore #defines, #if, etc.
- // Ignore comment and empty lines.
- // (need to get the line again, cin_islabel() may have
- // unlocked it)
- l = ml_get_curline();
- if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount)
- || cin_nocode(l))
- continue;
-
- // Are we at the start of a cpp base class declaration or
- // constructor initialization? XXX
- n = FALSE;
- if (lookfor != LOOKFOR_TERM && curbuf->b_ind_cpp_baseclass > 0)
- {
- n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
- l = ml_get_curline();
- }
- if (n)
- {
- if (lookfor == LOOKFOR_UNTERM)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- }
- else if (theline[0] == '{')
- {
- // Need to find start of the declaration.
- lookfor = LOOKFOR_UNTERM;
- ind_continuation = 0;
- continue;
- }
- else
- // XXX
- amount = get_baseclass_amount(
- cache_cpp_baseclass.lpos.col);
- break;
- }
- else if (lookfor == LOOKFOR_CPP_BASECLASS)
- {
- // only look, whether there is a cpp base class
- // declaration or initialization before the opening brace.
- if (cin_isterminated(l, TRUE, FALSE))
- break;
- else
- continue;
- }
-
- // What happens next depends on the line being terminated.
- // If terminated with a ',' only consider it terminating if
- // there is another unterminated statement behind, eg:
- // 123,
- // sizeof
- // here
- // Otherwise check whether it is a enumeration or structure
- // initialisation (not indented) or a variable declaration
- // (indented).
- terminated = cin_isterminated(l, FALSE, TRUE);
-
- if (js_cur_has_key)
- {
- js_cur_has_key = 0; // only check the first line
- if (curbuf->b_ind_js && terminated == ',')
- {
- // For Javascript we might be inside an object:
- // key: something, <- align with this
- // key: something
- // or:
- // key: something + <- align with this
- // something,
- // key: something
- lookfor = LOOKFOR_JS_KEY;
- }
- }
- if (lookfor == LOOKFOR_JS_KEY && cin_has_js_key(l))
- {
- amount = get_indent();
- break;
- }
- if (lookfor == LOOKFOR_COMMA)
- {
- if (tryposBrace != NULL && tryposBrace->lnum
- >= curwin->w_cursor.lnum)
- break;
- if (terminated == ',')
- // line below current line is the one that starts a
- // (possibly broken) line ending in a comma.
- break;
- else
- {
- amount = get_indent();
- if (curwin->w_cursor.lnum - 1 == ourscope)
- // line above is start of the scope, thus current
- // line is the one that stars a (possibly broken)
- // line ending in a comma.
- break;
- }
- }
-
- if (terminated == 0 || (lookfor != LOOKFOR_UNTERM
- && terminated == ','))
- {
- if (lookfor != LOOKFOR_ENUM_OR_INIT &&
- (*skipwhite(l) == '[' || l[STRLEN(l) - 1] == '['))
- amount += ind_continuation;
- // if we're in the middle of a paren thing,
- // go back to the line that starts it so
- // we can get the right prevailing indent
- // if ( foo &&
- // bar )
-
- // Position the cursor over the rightmost paren, so that
- // matching it will take us back to the start of the line.
- // Ignore a match before the start of the block.
- (void)find_last_paren(l, '(', ')');
- trypos = find_match_paren(corr_ind_maxparen(&cur_curpos));
- if (trypos != NULL && (trypos->lnum < tryposBrace->lnum
- || (trypos->lnum == tryposBrace->lnum
- && trypos->col < tryposBrace->col)))
- trypos = NULL;
-
- // If we are looking for ',', we also look for matching
- // braces.
- if (trypos == NULL && terminated == ','
- && find_last_paren(l, '{', '}'))
- trypos = find_start_brace();
-
- if (trypos != NULL)
- {
- // Check if we are on a case label now. This is
- // handled above.
- // case xx: if ( asdf &&
- // asdf)
- curwin->w_cursor = *trypos;
- l = ml_get_curline();
- if (cin_iscase(l, FALSE) || cin_isscopedecl(l))
- {
- ++curwin->w_cursor.lnum;
- curwin->w_cursor.col = 0;
- continue;
- }
- }
-
- /*
- * Skip over continuation lines to find the one to get the
- * indent from
- * char *usethis = "bla\
- * bla",
- * here;
- */
- if (terminated == ',')
- {
- while (curwin->w_cursor.lnum > 1)
- {
- l = ml_get(curwin->w_cursor.lnum - 1);
- if (*l == NUL || l[STRLEN(l) - 1] != '\\')
- break;
- --curwin->w_cursor.lnum;
- curwin->w_cursor.col = 0;
- }
- }
-
- // Get indent and pointer to text for current line,
- // ignoring any jump label. XXX
- if (curbuf->b_ind_js)
- cur_amount = get_indent();
- else
- cur_amount = skip_label(curwin->w_cursor.lnum, &l);
- // If this is just above the line we are indenting, and it
- // starts with a '{', line it up with this line.
- // while (not)
- // -> {
- // }
- if (terminated != ',' && lookfor != LOOKFOR_TERM
- && theline[0] == '{')
- {
- amount = cur_amount;
- // Only add b_ind_open_extra when the current line
- // doesn't start with a '{', which must have a match
- // in the same line (scope is the same). Probably:
- // { 1, 2 },
- // -> { 3, 4 }
- if (*skipwhite(l) != '{')
- amount += curbuf->b_ind_open_extra;
-
- if (curbuf->b_ind_cpp_baseclass && !curbuf->b_ind_js)
- {
- // have to look back, whether it is a cpp base
- // class declaration or initialization
- lookfor = LOOKFOR_CPP_BASECLASS;
- continue;
- }
- break;
- }
-
- // Check if we are after an "if", "while", etc.
- // Also allow " } else".
- if (cin_is_cinword(l) || cin_iselse(skipwhite(l)))
- {
- // Found an unterminated line after an if (), line up
- // with the last one.
- // if (cond)
- // 100 +
- // -> here;
- if (lookfor == LOOKFOR_UNTERM
- || lookfor == LOOKFOR_ENUM_OR_INIT)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- break;
- }
-
- // If this is just above the line we are indenting, we
- // are finished.
- // while (not)
- // -> here;
- // Otherwise this indent can be used when the line
- // before this is terminated.
- // yyy;
- // if (stat)
- // while (not)
- // xxx;
- // -> here;
- amount = cur_amount;
- if (theline[0] == '{')
- amount += curbuf->b_ind_open_extra;
- if (lookfor != LOOKFOR_TERM)
- {
- amount += curbuf->b_ind_level
- + curbuf->b_ind_no_brace;
- break;
- }
-
- // Special trick: when expecting the while () after a
- // do, line up with the while()
- // do
- // x = 1;
- // -> here
- l = skipwhite(ml_get_curline());
- if (cin_isdo(l))
- {
- if (whilelevel == 0)
- break;
- --whilelevel;
- }
-
- // When searching for a terminated line, don't use the
- // one between the "if" and the matching "else".
- // Need to use the scope of this "else". XXX
- // If whilelevel != 0 continue looking for a "do {".
- if (cin_iselse(l) && whilelevel == 0)
- {
- // If we're looking at "} else", let's make sure we
- // find the opening brace of the enclosing scope,
- // not the one from "if () {".
- if (*l == '}')
- curwin->w_cursor.col =
- (colnr_T)(l - ml_get_curline()) + 1;
-
- if ((trypos = find_start_brace()) == NULL
- || find_match(LOOKFOR_IF, trypos->lnum)
- == FAIL)
- break;
- }
- }
-
- // If we're below an unterminated line that is not an
- // "if" or something, we may line up with this line or
- // add something for a continuation line, depending on
- // the line before this one.
- else
- {
- // Found two unterminated lines on a row, line up with
- // the last one.
- // c = 99 +
- // 100 +
- // -> here;
- if (lookfor == LOOKFOR_UNTERM)
- {
- // When line ends in a comma add extra indent
- if (terminated == ',')
- amount += ind_continuation;
- break;
- }
-
- if (lookfor == LOOKFOR_ENUM_OR_INIT)
- {
- // Found two lines ending in ',', lineup with the
- // lowest one, but check for cpp base class
- // declaration/initialization, if it is an
- // opening brace or we are looking just for
- // enumerations/initializations.
- if (terminated == ',')
- {
- if (curbuf->b_ind_cpp_baseclass == 0)
- break;
-
- lookfor = LOOKFOR_CPP_BASECLASS;
- continue;
- }
-
- // Ignore unterminated lines in between, but
- // reduce indent.
- if (amount > cur_amount)
- amount = cur_amount;
- }
- else
- {
- // Found first unterminated line on a row, may
- // line up with this line, remember its indent
- // 100 +
- // -> here;
- l = ml_get_curline();
- amount = cur_amount;
-
- n = (int)STRLEN(l);
- if (terminated == ',' && (*skipwhite(l) == ']'
- || (n >=2 && l[n - 2] == ']')))
- break;
-
- // If previous line ends in ',', check whether we
- // are in an initialization or enum
- // struct xxx =
- // {
- // sizeof a,
- // 124 };
- // or a normal possible continuation line.
- // but only, of no other statement has been found
- // yet.
- if (lookfor == LOOKFOR_INITIAL && terminated == ',')
- {
- if (curbuf->b_ind_js)
- {
- // Search for a line ending in a comma
- // and line up with the line below it
- // (could be the current line).
- // some = [
- // 1, <- line up here
- // 2,
- // some = [
- // 3 + <- line up here
- // 4 *
- // 5,
- // 6,
- if (cin_iscomment(skipwhite(l)))
- break;
- lookfor = LOOKFOR_COMMA;
- trypos = find_match_char('[',
- curbuf->b_ind_maxparen);
- if (trypos != NULL)
- {
- if (trypos->lnum
- == curwin->w_cursor.lnum - 1)
- {
- // Current line is first inside
- // [], line up with it.
- break;
- }
- ourscope = trypos->lnum;
- }
- }
- else
- {
- lookfor = LOOKFOR_ENUM_OR_INIT;
- cont_amount = cin_first_id_amount();
- }
- }
- else
- {
- if (lookfor == LOOKFOR_INITIAL
- && *l != NUL
- && l[STRLEN(l) - 1] == '\\')
- // XXX
- cont_amount = cin_get_equal_amount(
- curwin->w_cursor.lnum);
- if (lookfor != LOOKFOR_TERM
- && lookfor != LOOKFOR_JS_KEY
- && lookfor != LOOKFOR_COMMA
- && raw_string_start != curwin->w_cursor.lnum)
- lookfor = LOOKFOR_UNTERM;
- }
- }
- }
- }
-
- // Check if we are after a while (cond);
- // If so: Ignore until the matching "do".
- else if (cin_iswhileofdo_end(terminated)) // XXX
- {
- // Found an unterminated line after a while ();, line up
- // with the last one.
- // while (cond);
- // 100 + <- line up with this one
- // -> here;
- if (lookfor == LOOKFOR_UNTERM
- || lookfor == LOOKFOR_ENUM_OR_INIT)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- break;
- }
-
- if (whilelevel == 0)
- {
- lookfor = LOOKFOR_TERM;
- amount = get_indent(); // XXX
- if (theline[0] == '{')
- amount += curbuf->b_ind_open_extra;
- }
- ++whilelevel;
- }
-
- // We are after a "normal" statement.
- // If we had another statement we can stop now and use the
- // indent of that other statement.
- // Otherwise the indent of the current statement may be used,
- // search backwards for the next "normal" statement.
- else
- {
- // Skip single break line, if before a switch label. It
- // may be lined up with the case label.
- if (lookfor == LOOKFOR_NOBREAK
- && cin_isbreak(skipwhite(ml_get_curline())))
- {
- lookfor = LOOKFOR_ANY;
- continue;
- }
-
- // Handle "do {" line.
- if (whilelevel > 0)
- {
- l = cin_skipcomment(ml_get_curline());
- if (cin_isdo(l))
- {
- amount = get_indent(); // XXX
- --whilelevel;
- continue;
- }
- }
-
- // Found a terminated line above an unterminated line. Add
- // the amount for a continuation line.
- // x = 1;
- // y = foo +
- // -> here;
- // or
- // int x = 1;
- // int foo,
- // -> here;
- if (lookfor == LOOKFOR_UNTERM
- || lookfor == LOOKFOR_ENUM_OR_INIT)
- {
- if (cont_amount > 0)
- amount = cont_amount;
- else
- amount += ind_continuation;
- break;
- }
-
- // Found a terminated line above a terminated line or "if"
- // etc. line. Use the amount of the line below us.
- // x = 1; x = 1;
- // if (asdf) y = 2;
- // while (asdf) ->here;
- // here;
- // ->foo;
- if (lookfor == LOOKFOR_TERM)
- {
- if (!lookfor_break && whilelevel == 0)
- break;
- }
-
- // First line above the one we're indenting is terminated.
- // To know what needs to be done look further backward for
- // a terminated line.
- else
- {
- // position the cursor over the rightmost paren, so
- // that matching it will take us back to the start of
- // the line. Helps for:
- // func(asdr,
- // asdfasdf);
- // here;
-term_again:
- l = ml_get_curline();
- if (find_last_paren(l, '(', ')')
- && (trypos = find_match_paren(
- curbuf->b_ind_maxparen)) != NULL)
- {
- // Check if we are on a case label now. This is
- // handled above.
- // case xx: if ( asdf &&
- // asdf)
- curwin->w_cursor = *trypos;
- l = ml_get_curline();
- if (cin_iscase(l, FALSE) || cin_isscopedecl(l))
- {
- ++curwin->w_cursor.lnum;
- curwin->w_cursor.col = 0;
- continue;
- }
- }
-
- // When aligning with the case statement, don't align
- // with a statement after it.
- // case 1: { <-- don't use this { position
- // stat;
- // }
- // case 2:
- // stat;
- // }
- iscase = (curbuf->b_ind_keep_case_label
- && cin_iscase(l, FALSE));
-
- // Get indent and pointer to text for current line,
- // ignoring any jump label.
- amount = skip_label(curwin->w_cursor.lnum, &l);
-
- if (theline[0] == '{')
- amount += curbuf->b_ind_open_extra;
- // See remark above: "Only add b_ind_open_extra.."
- l = skipwhite(l);
- if (*l == '{')
- amount -= curbuf->b_ind_open_extra;
- lookfor = iscase ? LOOKFOR_ANY : LOOKFOR_TERM;
-
- // When a terminated line starts with "else" skip to
- // the matching "if":
- // else 3;
- // indent this;
- // Need to use the scope of this "else". XXX
- // If whilelevel != 0 continue looking for a "do {".
- if (lookfor == LOOKFOR_TERM
- && *l != '}'
- && cin_iselse(l)
- && whilelevel == 0)
- {
- if ((trypos = find_start_brace()) == NULL
- || find_match(LOOKFOR_IF, trypos->lnum)
- == FAIL)
- break;
- continue;
- }
-
- // If we're at the end of a block, skip to the start of
- // that block.
- l = ml_get_curline();
- if (find_last_paren(l, '{', '}') // XXX
- && (trypos = find_start_brace()) != NULL)
- {
- curwin->w_cursor = *trypos;
- // if not "else {" check for terminated again
- // but skip block for "} else {"
- l = cin_skipcomment(ml_get_curline());
- if (*l == '}' || !cin_iselse(l))
- goto term_again;
- ++curwin->w_cursor.lnum;
- curwin->w_cursor.col = 0;
- }
- }
- }
- }
- }
- }
-
- // add extra indent for a comment
- if (cin_iscomment(theline))
- amount += curbuf->b_ind_comment;
-
- // subtract extra left-shift for jump labels
- if (curbuf->b_ind_jump_label > 0 && original_line_islabel)
- amount -= curbuf->b_ind_jump_label;
-
- goto theend;
- }
-
- // ok -- we're not inside any sort of structure at all!
- //
- // This means we're at the top level, and everything should
- // basically just match where the previous line is, except
- // for the lines immediately following a function declaration,
- // which are K&R-style parameters and need to be indented.
- //
- // if our line starts with an open brace, forget about any
- // prevailing indent and make sure it looks like the start
- // of a function
-
- if (theline[0] == '{')
- {
- amount = curbuf->b_ind_first_open;
- goto theend;
- }
-
- // If the NEXT line is a function declaration, the current
- // line needs to be indented as a function type spec.
- // Don't do this if the current line looks like a comment or if the
- // current line is terminated, ie. ends in ';', or if the current line
- // contains { or }: "void f() {\n if (1)"
- if (cur_curpos.lnum < curbuf->b_ml.ml_line_count
- && !cin_nocode(theline)
- && vim_strchr(theline, '{') == NULL
- && vim_strchr(theline, '}') == NULL
- && !cin_ends_in(theline, (char_u *)":", NULL)
- && !cin_ends_in(theline, (char_u *)",", NULL)
- && cin_isfuncdecl(NULL, cur_curpos.lnum + 1,
- cur_curpos.lnum + 1)
- && !cin_isterminated(theline, FALSE, TRUE))
- {
- amount = curbuf->b_ind_func_type;
- goto theend;
- }
-
- // search backwards until we find something we recognize
- amount = 0;
- curwin->w_cursor = cur_curpos;
- while (curwin->w_cursor.lnum > 1)
- {
- curwin->w_cursor.lnum--;
- curwin->w_cursor.col = 0;
-
- l = ml_get_curline();
-
- // If we're in a comment or raw string now, skip to the start
- // of it. XXX
- if ((trypos = ind_find_start_CORS(NULL)) != NULL)
- {
- curwin->w_cursor.lnum = trypos->lnum + 1;
- curwin->w_cursor.col = 0;
- continue;
- }
-
- // Are we at the start of a cpp base class declaration or
- // constructor initialization? XXX
- n = FALSE;
- if (curbuf->b_ind_cpp_baseclass != 0 && theline[0] != '{')
- {
- n = cin_is_cpp_baseclass(&cache_cpp_baseclass);
- l = ml_get_curline();
- }
- if (n)
- {
- // XXX
- amount = get_baseclass_amount(cache_cpp_baseclass.lpos.col);
- break;
- }
-
- // Skip preprocessor directives and blank lines.
- if (cin_ispreproc_cont(&l, &curwin->w_cursor.lnum, &amount))
- continue;
-
- if (cin_nocode(l))
- continue;
-
- // If the previous line ends in ',', use one level of
- // indentation:
- // int foo,
- // bar;
- // do this before checking for '}' in case of eg.
- // enum foobar
- // {
- // ...
- // } foo,
- // bar;
- n = 0;
- if (cin_ends_in(l, (char_u *)",", NULL)
- || (*l != NUL && (n = l[STRLEN(l) - 1]) == '\\'))
- {
- // take us back to opening paren
- if (find_last_paren(l, '(', ')')
- && (trypos = find_match_paren(
- curbuf->b_ind_maxparen)) != NULL)
- curwin->w_cursor = *trypos;
-
- /*
- * For a line ending in ',' that is a continuation line go
- * back to the first line with a backslash:
- * char *foo = "bla\
- * bla",
- * here;
- */
- while (n == 0 && curwin->w_cursor.lnum > 1)
- {
- l = ml_get(curwin->w_cursor.lnum - 1);
- if (*l == NUL || l[STRLEN(l) - 1] != '\\')
- break;
- --curwin->w_cursor.lnum;
- curwin->w_cursor.col = 0;
- }
-
- amount = get_indent(); // XXX
-
- if (amount == 0)
- amount = cin_first_id_amount();
- if (amount == 0)
- amount = ind_continuation;
- break;
- }
-
- // If the line looks like a function declaration, and we're
- // not in a comment, put it the left margin.
- if (cin_isfuncdecl(NULL, cur_curpos.lnum, 0)) // XXX
- break;
- l = ml_get_curline();
-
- // Finding the closing '}' of a previous function. Put
- // current line at the left margin. For when 'cino' has "fs".
- if (*skipwhite(l) == '}')
- break;
-
- // (matching {)
- // If the previous line ends on '};' (maybe followed by
- // comments) align at column 0. For example:
- // char *string_array[] = { "foo",
- // / * x * / "b};ar" }; / * foobar * /
- if (cin_ends_in(l, (char_u *)"};", NULL))
- break;
-
- // If the previous line ends on '[' we are probably in an
- // array constant:
- // something = [
- // 234, <- extra indent
- if (cin_ends_in(l, (char_u *)"[", NULL))
- {
- amount = get_indent() + ind_continuation;
- break;
- }
-
- // Find a line only has a semicolon that belongs to a previous
- // line ending in '}', e.g. before an #endif. Don't increase
- // indent then.
- if (*(look = skipwhite(l)) == ';' && cin_nocode(look + 1))
- {
- pos_T curpos_save = curwin->w_cursor;
-
- while (curwin->w_cursor.lnum > 1)
- {
- look = ml_get(--curwin->w_cursor.lnum);
- if (!(cin_nocode(look) || cin_ispreproc_cont(
- &look, &curwin->w_cursor.lnum, &amount)))
- break;
- }
- if (curwin->w_cursor.lnum > 0
- && cin_ends_in(look, (char_u *)"}", NULL))
- break;
-
- curwin->w_cursor = curpos_save;
- }
-
- // If the PREVIOUS line is a function declaration, the current
- // line (and the ones that follow) needs to be indented as
- // parameters.
- if (cin_isfuncdecl(&l, curwin->w_cursor.lnum, 0))
- {
- amount = curbuf->b_ind_param;
- break;
- }
-
- // If the previous line ends in ';' and the line before the
- // previous line ends in ',' or '\', ident to column zero:
- // int foo,
- // bar;
- // indent_to_0 here;
- if (cin_ends_in(l, (char_u *)";", NULL))
- {
- l = ml_get(curwin->w_cursor.lnum - 1);
- if (cin_ends_in(l, (char_u *)",", NULL)
- || (*l != NUL && l[STRLEN(l) - 1] == '\\'))
- break;
- l = ml_get_curline();
- }
-
- // Doesn't look like anything interesting -- so just
- // use the indent of this line.
- //
- // Position the cursor over the rightmost paren, so that
- // matching it will take us back to the start of the line.
- find_last_paren(l, '(', ')');
-
- if ((trypos = find_match_paren(curbuf->b_ind_maxparen)) != NULL)
- curwin->w_cursor = *trypos;
- amount = get_indent(); // XXX
- break;
- }
-
- // add extra indent for a comment
- if (cin_iscomment(theline))
- amount += curbuf->b_ind_comment;
-
- /*
- * add extra indent if the previous line ended in a backslash:
- * "asdfasdf\
- * here";
- * char *foo = "asdf\
- * here";
- */
- if (cur_curpos.lnum > 1)
- {
- l = ml_get(cur_curpos.lnum - 1);
- if (*l != NUL && l[STRLEN(l) - 1] == '\\')
- {
- cur_amount = cin_get_equal_amount(cur_curpos.lnum - 1);
- if (cur_amount > 0)
- amount = cur_amount;
- else if (cur_amount == 0)
- amount += ind_continuation;
- }
- }
-
-theend:
- if (amount < 0)
- amount = 0;
-
-laterend:
- // put the cursor back where it belongs
- curwin->w_cursor = cur_curpos;
-
- vim_free(linecopy);
-
- return amount;
-}
-
- static int
-find_match(int lookfor, linenr_T ourscope)
-{
- char_u *look;
- pos_T *theirscope;
- char_u *mightbeif;
- int elselevel;
- int whilelevel;
-
- if (lookfor == LOOKFOR_IF)
- {
- elselevel = 1;
- whilelevel = 0;
- }
- else
- {
- elselevel = 0;
- whilelevel = 1;
- }
-
- curwin->w_cursor.col = 0;
-
- while (curwin->w_cursor.lnum > ourscope + 1)
- {
- curwin->w_cursor.lnum--;
- curwin->w_cursor.col = 0;
-
- look = cin_skipcomment(ml_get_curline());
- if (cin_iselse(look)
- || cin_isif(look)
- || cin_isdo(look) // XXX
- || cin_iswhileofdo(look, curwin->w_cursor.lnum))
- {
- // if we've gone outside the braces entirely,
- // we must be out of scope...
- theirscope = find_start_brace(); // XXX
- if (theirscope == NULL)
- break;
-
- // and if the brace enclosing this is further
- // back than the one enclosing the else, we're
- // out of luck too.
- if (theirscope->lnum < ourscope)
- break;
-
- // and if they're enclosed in a *deeper* brace,
- // then we can ignore it because it's in a
- // different scope...
- if (theirscope->lnum > ourscope)
- continue;
-
- // if it was an "else" (that's not an "else if")
- // then we need to go back to another if, so
- // increment elselevel
- look = cin_skipcomment(ml_get_curline());
- if (cin_iselse(look))
- {
- mightbeif = cin_skipcomment(look + 4);
- if (!cin_isif(mightbeif))
- ++elselevel;
- continue;
- }
-
- // if it was a "while" then we need to go back to
- // another "do", so increment whilelevel. XXX
- if (cin_iswhileofdo(look, curwin->w_cursor.lnum))
- {
- ++whilelevel;
- continue;
- }
-
- // If it's an "if" decrement elselevel
- look = cin_skipcomment(ml_get_curline());
- if (cin_isif(look))
- {
- elselevel--;
- // When looking for an "if" ignore "while"s that
- // get in the way.
- if (elselevel == 0 && lookfor == LOOKFOR_IF)
- whilelevel = 0;
- }
-
- // If it's a "do" decrement whilelevel
- if (cin_isdo(look))
- whilelevel--;
-
- // if we've used up all the elses, then
- // this must be the if that we want!
- // match the indent level of that if.
- if (elselevel <= 0 && whilelevel <= 0)
- return OK;
- }
- }
- return FAIL;
-}
-
-# if defined(FEAT_EVAL) || defined(PROTO)
-/*
- * Get indent level from 'indentexpr'.
- */
- int
-get_expr_indent(void)
-{
- int indent = -1;
- char_u *inde_copy;
- pos_T save_pos;
- colnr_T save_curswant;
- int save_set_curswant;
- int save_State;
- int use_sandbox = was_set_insecurely((char_u *)"indentexpr",
- OPT_LOCAL);
-
- // Save and restore cursor position and curswant, in case it was changed
- // via :normal commands
- save_pos = curwin->w_cursor;
- save_curswant = curwin->w_curswant;
- save_set_curswant = curwin->w_set_curswant;
- set_vim_var_nr(VV_LNUM, curwin->w_cursor.lnum);
- if (use_sandbox)
- ++sandbox;
- ++textlock;
-
- // Need to make a copy, the 'indentexpr' option could be changed while
- // evaluating it.
- inde_copy = vim_strsave(curbuf->b_p_inde);
- if (inde_copy != NULL)
- {
- indent = (int)eval_to_number(inde_copy);
- vim_free(inde_copy);
- }
-
- if (use_sandbox)
- --sandbox;
- --textlock;
-
- // Restore the cursor position so that 'indentexpr' doesn't need to.
- // Pretend to be in Insert mode, allow cursor past end of line for "o"
- // command.
- save_State = State;
- State = INSERT;
- curwin->w_cursor = save_pos;
- curwin->w_curswant = save_curswant;
- curwin->w_set_curswant = save_set_curswant;
- check_cursor();
- State = save_State;
-
- // If there is an error, just keep the current indent.
- if (indent < 0)
- indent = get_indent();
-
- return indent;
-}
-# endif
-
-/*
- * return TRUE if 'cinkeys' contains the key "keytyped",
- * when == '*': Only if key is preceded with '*' (indent before insert)
- * when == '!': Only if key is preceded with '!' (don't insert)
- * when == ' ': Only if key is not preceded with '*'(indent afterwards)
- *
- * "keytyped" can have a few special values:
- * KEY_OPEN_FORW
- * KEY_OPEN_BACK
- * KEY_COMPLETE just finished completion.
- *
- * If line_is_empty is TRUE accept keys with '0' before them.
- */
- int
-in_cinkeys(
- int keytyped,
- int when,
- int line_is_empty)
-{
- char_u *look;
- int try_match;
- int try_match_word;
- char_u *p;
- char_u *line;
- int icase;
- int i;
-
- if (keytyped == NUL)
- // Can happen with CTRL-Y and CTRL-E on a short line.
- return FALSE;
-
-#ifdef FEAT_EVAL
- if (*curbuf->b_p_inde != NUL)
- look = curbuf->b_p_indk; // 'indentexpr' set: use 'indentkeys'
- else
-#endif
- look = curbuf->b_p_cink; // 'indentexpr' empty: use 'cinkeys'
- while (*look)
- {
- // Find out if we want to try a match with this key, depending on
- // 'when' and a '*' or '!' before the key.
- switch (when)
- {
- case '*': try_match = (*look == '*'); break;
- case '!': try_match = (*look == '!'); break;
- default: try_match = (*look != '*'); break;
- }
- if (*look == '*' || *look == '!')
- ++look;
-
- // If there is a '0', only accept a match if the line is empty.
- // But may still match when typing last char of a word.
- if (*look == '0')
- {
- try_match_word = try_match;
- if (!line_is_empty)
- try_match = FALSE;
- ++look;
- }
- else
- try_match_word = FALSE;
-
- // does it look like a control character?
- if (*look == '^'
-#ifdef EBCDIC
- && (Ctrl_chr(look[1]) != 0)
-#else
- && look[1] >= '?' && look[1] <= '_'
-#endif
- )
- {
- if (try_match && keytyped == Ctrl_chr(look[1]))
- return TRUE;
- look += 2;
- }
- // 'o' means "o" command, open forward.
- // 'O' means "O" command, open backward.
- else if (*look == 'o')
- {
- if (try_match && keytyped == KEY_OPEN_FORW)
- return TRUE;
- ++look;
- }
- else if (*look == 'O')
- {
- if (try_match && keytyped == KEY_OPEN_BACK)
- return TRUE;
- ++look;
- }
-
- // 'e' means to check for "else" at start of line and just before the
- // cursor.
- else if (*look == 'e')
- {
- if (try_match && keytyped == 'e' && curwin->w_cursor.col >= 4)
- {
- p = ml_get_curline();
- if (skipwhite(p) == p + curwin->w_cursor.col - 4 &&
- STRNCMP(p + curwin->w_cursor.col - 4, "else", 4) == 0)
- return TRUE;
- }
- ++look;
- }
-
- // ':' only causes an indent if it is at the end of a label or case
- // statement, or when it was before typing the ':' (to fix
- // class::method for C++).
- else if (*look == ':')
- {
- if (try_match && keytyped == ':')
- {
- p = ml_get_curline();
- if (cin_iscase(p, FALSE) || cin_isscopedecl(p) || cin_islabel())
- return TRUE;
- // Need to get the line again after cin_islabel().
- p = ml_get_curline();
- if (curwin->w_cursor.col > 2
- && p[curwin->w_cursor.col - 1] == ':'
- && p[curwin->w_cursor.col - 2] == ':')
- {
- p[curwin->w_cursor.col - 1] = ' ';
- i = (cin_iscase(p, FALSE) || cin_isscopedecl(p)
- || cin_islabel());
- p = ml_get_curline();
- p[curwin->w_cursor.col - 1] = ':';
- if (i)
- return TRUE;
- }
- }
- ++look;
- }
-
-
- // Is it a key in <>, maybe?
- else if (*look == '<')
- {
- if (try_match)
- {
- // make up some named keys <o>, <O>, <e>, <0>, <>>, <<>, <*>,
- // <:> and <!> so that people can re-indent on o, O, e, 0, <,
- // >, *, : and ! keys if they really really want to.
- if (vim_strchr((char_u *)"<>!*oOe0:", look[1]) != NULL
- && keytyped == look[1])
- return TRUE;
-
- if (keytyped == get_special_key_code(look + 1))
- return TRUE;
- }
- while (*look && *look != '>')
- look++;
- while (*look == '>')
- look++;
- }
-
- // Is it a word: "=word"?
- else if (*look == '=' && look[1] != ',' && look[1] != NUL)
- {
- ++look;
- if (*look == '~')
- {
- icase = TRUE;
- ++look;
- }
- else
- icase = FALSE;
- p = vim_strchr(look, ',');
- if (p == NULL)
- p = look + STRLEN(look);
- if ((try_match || try_match_word)
- && curwin->w_cursor.col >= (colnr_T)(p - look))
- {
- int match = FALSE;
-
- if (keytyped == KEY_COMPLETE)
- {
- char_u *s;
-
- // Just completed a word, check if it starts with "look".
- // search back for the start of a word.
- line = ml_get_curline();
- if (has_mbyte)
- {
- char_u *n;
-
- for (s = line + curwin->w_cursor.col; s > line; s = n)
- {
- n = mb_prevptr(line, s);
- if (!vim_iswordp(n))
- break;
- }
- }
- else
- for (s = line + curwin->w_cursor.col; s > line; --s)
- if (!vim_iswordc(s[-1]))
- break;
- if (s + (p - look) <= line + curwin->w_cursor.col
- && (icase
- ? MB_STRNICMP(s, look, p - look)
- : STRNCMP(s, look, p - look)) == 0)
- match = TRUE;
- }
- else
- // TODO: multi-byte
- if (keytyped == (int)p[-1] || (icase && keytyped < 256
- && TOLOWER_LOC(keytyped) == TOLOWER_LOC((int)p[-1])))
- {
- line = ml_get_cursor();
- if ((curwin->w_cursor.col == (colnr_T)(p - look)
- || !vim_iswordc(line[-(p - look) - 1]))
- && (icase
- ? MB_STRNICMP(line - (p - look), look, p - look)
- : STRNCMP(line - (p - look), look, p - look))
- == 0)
- match = TRUE;
- }
- if (match && try_match_word && !try_match)
- {
- // "0=word": Check if there are only blanks before the
- // word.
- if (getwhitecols_curline() !=
- (int)(curwin->w_cursor.col - (p - look)))
- match = FALSE;
- }
- if (match)
- return TRUE;
- }
- look = p;
- }
-
- // ok, it's a boring generic character.
- else
- {
- if (try_match && *look == keytyped)
- return TRUE;
- if (*look != NUL)
- ++look;
- }
-
- // Skip over ", ".
- look = skip_to_option_part(look);
- }
- return FALSE;
-}
-#endif // FEAT_CINDENT
-
-#if defined(FEAT_LISP) || defined(PROTO)
-
- static int
-lisp_match(char_u *p)
-{
- char_u buf[LSIZE];
- int len;
- char_u *word = *curbuf->b_p_lw != NUL ? curbuf->b_p_lw : p_lispwords;
-
- while (*word != NUL)
- {
- (void)copy_option_part(&word, buf, LSIZE, ",");
- len = (int)STRLEN(buf);
- if (STRNCMP(buf, p, len) == 0 && p[len] == ' ')
- return TRUE;
- }
- return FALSE;
-}
-
-/*
- * When 'p' is present in 'cpoptions, a Vi compatible method is used.
- * The incompatible newer method is quite a bit better at indenting
- * code in lisp-like languages than the traditional one; it's still
- * mostly heuristics however -- Dirk van Deun, dirk@rave.org
- *
- * TODO:
- * Findmatch() should be adapted for lisp, also to make showmatch
- * work correctly: now (v5.3) it seems all C/C++ oriented:
- * - it does not recognize the #\( and #\) notations as character literals
- * - it doesn't know about comments starting with a semicolon
- * - it incorrectly interprets '(' as a character literal
- * All this messes up get_lisp_indent in some rare cases.
- * Update from Sergey Khorev:
- * I tried to fix the first two issues.
- */
- int
-get_lisp_indent(void)
-{
- pos_T *pos, realpos, paren;
- int amount;
- char_u *that;
- colnr_T col;
- colnr_T firsttry;
- int parencount, quotecount;
- int vi_lisp;
-
- // Set vi_lisp to use the vi-compatible method
- vi_lisp = (vim_strchr(p_cpo, CPO_LISP) != NULL);
-
- realpos = curwin->w_cursor;
- curwin->w_cursor.col = 0;
-
- if ((pos = findmatch(NULL, '(')) == NULL)
- pos = findmatch(NULL, '[');
- else
- {
- paren = *pos;
- pos = findmatch(NULL, '[');
- if (pos == NULL || LT_POSP(pos, &paren))
- pos = &paren;
- }
- if (pos != NULL)
- {
- // Extra trick: Take the indent of the first previous non-white
- // line that is at the same () level.
- amount = -1;
- parencount = 0;
-
- while (--curwin->w_cursor.lnum >= pos->lnum)
- {
- if (linewhite(curwin->w_cursor.lnum))
- continue;
- for (that = ml_get_curline(); *that != NUL; ++that)
- {
- if (*that == ';')
- {
- while (*(that + 1) != NUL)
- ++that;
- continue;
- }
- if (*that == '\\')
- {
- if (*(that + 1) != NUL)
- ++that;
- continue;
- }
- if (*that == '"' && *(that + 1) != NUL)
- {
- while (*++that && *that != '"')
- {
- // skipping escaped characters in the string
- if (*that == '\\')
- {
- if (*++that == NUL)
- break;
- if (that[1] == NUL)
- {
- ++that;
- break;
- }
- }
- }
- }
- if (*that == '(' || *that == '[')
- ++parencount;
- else if (*that == ')' || *that == ']')
- --parencount;
- }
- if (parencount == 0)
- {
- amount = get_indent();
- break;
- }
- }
-
- if (amount == -1)
- {
- curwin->w_cursor.lnum = pos->lnum;
- curwin->w_cursor.col = pos->col;
- col = pos->col;
-
- that = ml_get_curline();
-
- if (vi_lisp && get_indent() == 0)
- amount = 2;
- else
- {
- char_u *line = that;
-
- amount = 0;
- while (*that && col)
- {
- amount += lbr_chartabsize_adv(line, &that, (colnr_T)amount);
- col--;
- }
-
- // Some keywords require "body" indenting rules (the
- // non-standard-lisp ones are Scheme special forms):
- //
- // (let ((a 1)) instead (let ((a 1))
- // (...)) of (...))
-
- if (!vi_lisp && (*that == '(' || *that == '[')
- && lisp_match(that + 1))
- amount += 2;
- else
- {
- that++;
- amount++;
- firsttry = amount;
-
- while (VIM_ISWHITE(*that))
- {
- amount += lbr_chartabsize(line, that, (colnr_T)amount);
- ++that;
- }
-
- if (*that && *that != ';') // not a comment line
- {
- // test *that != '(' to accommodate first let/do
- // argument if it is more than one line
- if (!vi_lisp && *that != '(' && *that != '[')
- firsttry++;
-
- parencount = 0;
- quotecount = 0;
-
- if (vi_lisp
- || (*that != '"'
- && *that != '\''
- && *that != '#'
- && (*that < '0' || *that > '9')))
- {
- while (*that
- && (!VIM_ISWHITE(*that)
- || quotecount
- || parencount)
- && (!((*that == '(' || *that == '[')
- && !quotecount
- && !parencount
- && vi_lisp)))
- {
- if (*that == '"')
- quotecount = !quotecount;
- if ((*that == '(' || *that == '[')
- && !quotecount)
- ++parencount;
- if ((*that == ')' || *that == ']')
- && !quotecount)
- --parencount;
- if (*that == '\\' && *(that+1) != NUL)
- amount += lbr_chartabsize_adv(
- line, &that, (colnr_T)amount);
- amount += lbr_chartabsize_adv(
- line, &that, (colnr_T)amount);
- }
- }
- while (VIM_ISWHITE(*that))
- {
- amount += lbr_chartabsize(
- line, that, (colnr_T)amount);
- that++;
- }
- if (!*that || *that == ';')
- amount = firsttry;
- }
- }
- }
- }
- }
- else
- amount = 0; // no matching '(' or '[' found, use zero indent
-
- curwin->w_cursor = realpos;
-
- return amount;
-}
-#endif // FEAT_LISP
-
-#if defined(FEAT_CINDENT) || defined(PROTO)
-/*
- * Do C or expression indenting on the current line.
- */
- void
-do_c_expr_indent(void)
-{
-# ifdef FEAT_EVAL
- if (*curbuf->b_p_inde != NUL)
- fixthisline(get_expr_indent);
- else
-# endif
- fixthisline(get_c_indent);
-}
-#endif
-
-#if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO)
-/*
- * Re-indent the current line, based on the current contents of it and the
- * surrounding lines. Fixing the cursor position seems really easy -- I'm very
- * confused what all the part that handles Control-T is doing that I'm not.
- * "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent.
- */
-
- void
-fixthisline(int (*get_the_indent)(void))
-{
- int amount = get_the_indent();
-
- if (amount >= 0)
- {
- change_indent(INDENT_SET, amount, FALSE, 0, TRUE);
- if (linewhite(curwin->w_cursor.lnum))
- did_ai = TRUE; // delete the indent if the line stays empty
- }
-}
-
- void
-fix_indent(void)
-{
- if (p_paste)
- return;
-# ifdef FEAT_LISP
- if (curbuf->b_p_lisp && curbuf->b_p_ai)
- fixthisline(get_lisp_indent);
-# endif
-# if defined(FEAT_LISP) && defined(FEAT_CINDENT)
- else
-# endif
-# ifdef FEAT_CINDENT
- if (cindent_on())
- do_c_expr_indent();
-# endif
-}
-
-#endif
-
-#if defined(FEAT_VARTABS) || defined(PROTO)
-
-/*
- * Set the integer values corresponding to the string setting of 'vartabstop'.
- * "array" will be set, caller must free it if needed.
- */
- int
-tabstop_set(char_u *var, int **array)
-{
- int valcount = 1;
- int t;
- char_u *cp;
-
- if (var[0] == NUL || (var[0] == '0' && var[1] == NUL))
- {
- *array = NULL;
- return TRUE;
- }
-
- for (cp = var; *cp != NUL; ++cp)
- {
- if (cp == var || cp[-1] == ',')
- {
- char_u *end;
-
- if (strtol((char *)cp, (char **)&end, 10) <= 0)
- {
- if (cp != end)
- emsg(_(e_positive));
- else
- emsg(_(e_invarg));
- return FALSE;
- }
- }
-
- if (VIM_ISDIGIT(*cp))
- continue;
- if (cp[0] == ',' && cp > var && cp[-1] != ',' && cp[1] != NUL)
- {
- ++valcount;
- continue;
- }
- emsg(_(e_invarg));
- return FALSE;
- }
-
- *array = ALLOC_MULT(int, valcount + 1);
- if (*array == NULL)
- return FALSE;
- (*array)[0] = valcount;
-
- t = 1;
- for (cp = var; *cp != NUL;)
- {
- (*array)[t++] = atoi((char *)cp);
- while (*cp != NUL && *cp != ',')
- ++cp;
- if (*cp != NUL)
- ++cp;
- }
-
- return TRUE;
-}
-
-/*
- * Calculate the number of screen spaces a tab will occupy.
- * If "vts" is set then the tab widths are taken from that array,
- * otherwise the value of ts is used.
- */
- int
-tabstop_padding(colnr_T col, int ts_arg, int *vts)
-{
- int ts = ts_arg == 0 ? 8 : ts_arg;
- int tabcount;
- colnr_T tabcol = 0;
- int t;
- int padding = 0;
-
- if (vts == NULL || vts[0] == 0)
- return ts - (col % ts);
-
- tabcount = vts[0];
-
- for (t = 1; t <= tabcount; ++t)
- {
- tabcol += vts[t];
- if (tabcol > col)
- {
- padding = (int)(tabcol - col);
- break;
- }
- }
- if (t > tabcount)
- padding = vts[tabcount] - (int)((col - tabcol) % vts[tabcount]);
-
- return padding;
-}
-
-/*
- * Find the size of the tab that covers a particular column.
- */
- int
-tabstop_at(colnr_T col, int ts, int *vts)
-{
- int tabcount;
- colnr_T tabcol = 0;
- int t;
- int tab_size = 0;
-
- if (vts == 0 || vts[0] == 0)
- return ts;
-
- tabcount = vts[0];
- for (t = 1; t <= tabcount; ++t)
- {
- tabcol += vts[t];
- if (tabcol > col)
- {
- tab_size = vts[t];
- break;
- }
- }
- if (t > tabcount)
- tab_size = vts[tabcount];
-
- return tab_size;
-}
-
-/*
- * Find the column on which a tab starts.
- */
- colnr_T
-tabstop_start(colnr_T col, int ts, int *vts)
-{
- int tabcount;
- colnr_T tabcol = 0;
- int t;
- int excess;
-
- if (vts == NULL || vts[0] == 0)
- return (col / ts) * ts;
-
- tabcount = vts[0];
- for (t = 1; t <= tabcount; ++t)
- {
- tabcol += vts[t];
- if (tabcol > col)
- return tabcol - vts[t];
- }
-
- excess = tabcol % vts[tabcount];
- return excess + ((col - excess) / vts[tabcount]) * vts[tabcount];
-}
-
-/*
- * Find the number of tabs and spaces necessary to get from one column
- * to another.
- */
- void
-tabstop_fromto(
- colnr_T start_col,
- colnr_T end_col,
- int ts_arg,
- int *vts,
- int *ntabs,
- int *nspcs)
-{
- int spaces = end_col - start_col;
- colnr_T tabcol = 0;
- int padding = 0;
- int tabcount;
- int t;
- int ts = ts_arg == 0 ? curbuf->b_p_ts : ts_arg;
-
- if (vts == NULL || vts[0] == 0)
- {
- int tabs = 0;
- int initspc = 0;
+ amount += lbr_chartabsize(line, that, (colnr_T)amount);
+ ++that;
+ }
- initspc = ts - (start_col % ts);
- if (spaces >= initspc)
- {
- spaces -= initspc;
- tabs++;
- }
- tabs += spaces / ts;
- spaces -= (spaces / ts) * ts;
+ if (*that && *that != ';') // not a comment line
+ {
+ // test *that != '(' to accommodate first let/do
+ // argument if it is more than one line
+ if (!vi_lisp && *that != '(' && *that != '[')
+ firsttry++;
- *ntabs = tabs;
- *nspcs = spaces;
- return;
- }
+ parencount = 0;
+ quotecount = 0;
- // Find the padding needed to reach the next tabstop.
- tabcount = vts[0];
- for (t = 1; t <= tabcount; ++t)
- {
- tabcol += vts[t];
- if (tabcol > start_col)
- {
- padding = (int)(tabcol - start_col);
- break;
+ if (vi_lisp
+ || (*that != '"'
+ && *that != '\''
+ && *that != '#'
+ && (*that < '0' || *that > '9')))
+ {
+ while (*that
+ && (!VIM_ISWHITE(*that)
+ || quotecount
+ || parencount)
+ && (!((*that == '(' || *that == '[')
+ && !quotecount
+ && !parencount
+ && vi_lisp)))
+ {
+ if (*that == '"')
+ quotecount = !quotecount;
+ if ((*that == '(' || *that == '[')
+ && !quotecount)
+ ++parencount;
+ if ((*that == ')' || *that == ']')
+ && !quotecount)
+ --parencount;
+ if (*that == '\\' && *(that+1) != NUL)
+ amount += lbr_chartabsize_adv(
+ line, &that, (colnr_T)amount);
+ amount += lbr_chartabsize_adv(
+ line, &that, (colnr_T)amount);
+ }
+ }
+ while (VIM_ISWHITE(*that))
+ {
+ amount += lbr_chartabsize(
+ line, that, (colnr_T)amount);
+ that++;
+ }
+ if (!*that || *that == ';')
+ amount = firsttry;
+ }
+ }
+ }
}
}
- if (t > tabcount)
- padding = vts[tabcount] - (int)((start_col - tabcol) % vts[tabcount]);
-
- // If the space needed is less than the padding no tabs can be used.
- if (spaces < padding)
- {
- *ntabs = 0;
- *nspcs = spaces;
- return;
- }
-
- *ntabs = 1;
- spaces -= padding;
+ else
+ amount = 0; // no matching '(' or '[' found, use zero indent
- // At least one tab has been used. See if any more will fit.
- while (spaces != 0 && ++t <= tabcount)
- {
- padding = vts[t];
- if (spaces < padding)
- {
- *nspcs = spaces;
- return;
- }
- ++*ntabs;
- spaces -= padding;
- }
+ curwin->w_cursor = realpos;
- *ntabs += spaces / vts[tabcount];
- *nspcs = spaces % vts[tabcount];
+ return amount;
}
+#endif // FEAT_LISP
+#if defined(FEAT_LISP) || defined(FEAT_CINDENT) || defined(PROTO)
/*
- * See if two tabstop arrays contain the same values.
+ * Re-indent the current line, based on the current contents of it and the
+ * surrounding lines. Fixing the cursor position seems really easy -- I'm very
+ * confused what all the part that handles Control-T is doing that I'm not.
+ * "get_the_indent" should be get_c_indent, get_expr_indent or get_lisp_indent.
*/
- int
-tabstop_eq(int *ts1, int *ts2)
-{
- int t;
-
- if ((ts1 == 0 && ts2) || (ts1 && ts2 == 0))
- return FALSE;
- if (ts1 == ts2)
- return TRUE;
- if (ts1[0] != ts2[0])
- return FALSE;
- for (t = 1; t <= ts1[0]; ++t)
- if (ts1[t] != ts2[t])
- return FALSE;
-
- return TRUE;
-}
-
-#if defined(FEAT_BEVAL) || defined(PROTO)
-/*
- * Copy a tabstop array, allocating space for the new array.
- */
- int *
-tabstop_copy(int *oldts)
+ void
+fixthisline(int (*get_the_indent)(void))
{
- int *newts;
- int t;
-
- if (oldts == NULL)
- return NULL;
- newts = ALLOC_MULT(int, oldts[0] + 1);
- if (newts != NULL)
- for (t = 0; t <= oldts[0]; ++t)
- newts[t] = oldts[t];
- return newts;
-}
-#endif
+ int amount = get_the_indent();
-/*
- * Return a count of the number of tabstops.
- */
- int
-tabstop_count(int *ts)
-{
- return ts != NULL ? ts[0] : 0;
+ if (amount >= 0)
+ {
+ change_indent(INDENT_SET, amount, FALSE, 0, TRUE);
+ if (linewhite(curwin->w_cursor.lnum))
+ did_ai = TRUE; // delete the indent if the line stays empty
+ }
}
-/*
- * Return the first tabstop, or 8 if there are no tabstops defined.
- */
- int
-tabstop_first(int *ts)
+ void
+fix_indent(void)
{
- return ts != NULL ? ts[1] : 8;
+ if (p_paste)
+ return;
+# ifdef FEAT_LISP
+ if (curbuf->b_p_lisp && curbuf->b_p_ai)
+ fixthisline(get_lisp_indent);
+# endif
+# if defined(FEAT_LISP) && defined(FEAT_CINDENT)
+ else
+# endif
+# ifdef FEAT_CINDENT
+ if (cindent_on())
+ do_c_expr_indent();
+# endif
}
-
#endif
+#if defined(FEAT_EVAL) || defined(PROTO)
/*
- * Return the effective shiftwidth value for current buffer, using the
- * 'tabstop' value when 'shiftwidth' is zero.
- */
- long
-get_sw_value(buf_T *buf)
-{
- return get_sw_value_col(buf, 0);
-}
-
-/*
- * Idem, using "pos".
- */
- static long
-get_sw_value_pos(buf_T *buf, pos_T *pos)
-{
- pos_T save_cursor = curwin->w_cursor;
- long sw_value;
-
- curwin->w_cursor = *pos;
- sw_value = get_sw_value_col(buf, get_nolist_virtcol());
- curwin->w_cursor = save_cursor;
- return sw_value;
-}
-
-/*
- * Idem, using the first non-black in the current line.
+ * "indent()" function
*/
- long
-get_sw_value_indent(buf_T *buf)
+ void
+f_indent(typval_T *argvars, typval_T *rettv)
{
- pos_T pos = curwin->w_cursor;
+ linenr_T lnum;
- pos.col = getwhitecols_curline();
- return get_sw_value_pos(buf, &pos);
+ lnum = tv_get_lnum(argvars);
+ if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
+ rettv->vval.v_number = get_indent_lnum(lnum);
+ else
+ rettv->vval.v_number = -1;
}
/*
- * Idem, using virtual column "col".
+ * "lispindent(lnum)" function
*/
- long
-get_sw_value_col(buf_T *buf, colnr_T col UNUSED)
+ void
+f_lispindent(typval_T *argvars UNUSED, typval_T *rettv)
{
- return buf->b_p_sw ? buf->b_p_sw :
- #ifdef FEAT_VARTABS
- tabstop_at(col, buf->b_p_ts, buf->b_p_vts_array);
- #else
- buf->b_p_ts;
- #endif
-}
+#ifdef FEAT_LISP
+ pos_T pos;
+ linenr_T lnum;
-/*
- * Return the effective softtabstop value for the current buffer, using the
- * 'shiftwidth' value when 'softtabstop' is negative.
- */
- long
-get_sts_value(void)
-{
- return curbuf->b_p_sts < 0 ? get_sw_value(curbuf) : curbuf->b_p_sts;
+ pos = curwin->w_cursor;
+ lnum = tv_get_lnum(argvars);
+ if (lnum >= 1 && lnum <= curbuf->b_ml.ml_line_count)
+ {
+ curwin->w_cursor.lnum = lnum;
+ rettv->vval.v_number = get_lisp_indent();
+ curwin->w_cursor = pos;
+ }
+ else
+#endif
+ rettv->vval.v_number = -1;
}
+#endif
projects / vim / commitdiff