kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-19 18:55:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

Cleanup of indent.c to make it comply with style guide.

Browse Source 
- Uncrustify indent.c
- Fix comments
- Fix whitespace
- Format get_lisp_indent (needs to be refactored completely)
- Fix endline comments
- Change to postincrement
- Fix clint.py errors
- Move static function last
- Fix blank endlines
This commit is contained in:
John 2014-03-16 23:54:51 +01:00 committed by Thiago de Arruda
parent 452804638d
commit 7326894a06
1 changed files with 350 additions and 302 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

652
src/indent.c
View File

@ -9,230 +9,243 @@
#include "search.h"
#include "undo.h"
/*
* Count the size (in window cells) of the indent in the current line.
*/
static int lisp_match(char_u *p);
// Count the size (in window cells) of the indent in the current line.
int get_indent(void)
{
return get_indent_str(ml_get_curline(), (int)curbuf->b_p_ts);
}
/*
* Count the size (in window cells) of the indent in line "lnum".
*/
// Count the size (in window cells) of the indent in line "lnum".
int get_indent_lnum(linenr_T lnum)
{
return get_indent_str(ml_get(lnum), (int)curbuf->b_p_ts);
}
/*
* Count the size (in window cells) of the indent in line "lnum" of buffer
* "buf".
*/
// Count the size (in window cells) of the indent in line "lnum" of buffer
// "buf".
int get_indent_buf(buf_T *buf, linenr_T lnum)
{
return get_indent_str(ml_get_buf(buf, lnum, FALSE), (int)buf->b_p_ts);
}
/*
* count the size (in window cells) of the indent in line "ptr", with
* 'tabstop' at "ts"
*/
// Count the size (in window cells) of the indent in line "ptr", with
// 'tabstop' at "ts".
int get_indent_str(char_u *ptr, int ts)
{
int count = 0;
for (; *ptr; ++ptr) {
if (*ptr == TAB) /* count a tab for what it is worth */
// Count a tab for what it is worth.
if (*ptr == TAB) {
count += ts - (count % ts);
else if (*ptr == ' ')
++count; /* count a space for one */
else
} else if (*ptr == ' ') {
// Count a space for one.
count++;
} else {
break;
}
}
return count;
}
/*
* 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.
*/
int
set_indent (
int size, /* measured in spaces */
int flags
)
// 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.
// @param size measured in spaces
// Returns TRUE if the line was changed.
int set_indent(int size, int flags)
{
char_u *p;
char_u *newline;
char_u *oldline;
char_u *s;
char_u *p;
char_u *newline;
char_u *oldline;
char_u *s;
int todo;
int ind_len; /* measured in characters */
int ind_len; // Measured in characters.
int line_len;
int doit = FALSE;
int ind_done = 0; /* measured in spaces */
int ind_done = 0; // Measured in spaces.
int tab_pad;
int retval = FALSE;
int orig_char_len = -1; /* number of initial whitespace chars when
'et' and 'pi' are both set */
/*
* First check if there is anything to do and compute the number of
* characters needed for the indent.
*/
// Number of initial whitespace chars when 'et' and 'pi' are both set.
int orig_char_len = -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();
/* Calculate the buffer size for the new indent, and check to see if it
* isn't already set */
/* 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 */
// Calculate the buffer size for the new indent, and check to see if it
// isn't already set.
// 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 '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;
/* count as many characters as we can use */
// Count as many characters as we can use.
while (todo > 0 && vim_iswhite(*p)) {
if (*p == TAB) {
tab_pad = (int)curbuf->b_p_ts
- (ind_done % (int)curbuf->b_p_ts);
/* stop if this tab will overshoot the target */
if (todo < tab_pad)
tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
// Stop if this tab will overshoot the target.
if (todo < tab_pad) {
break;
}
todo -= tab_pad;
++ind_len;
ind_len++;
ind_done += tab_pad;
} else {
--todo;
++ind_len;
++ind_done;
todo--;
ind_len++;
ind_done++;
}
++p;
p++;
}
/* Set initial number of whitespace chars to copy if we are
* preserving indent but expandtab is set */
if (curbuf->b_p_et)
// 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 */
// Fill to next tabstop with a tab, if possible.
tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
if (todo >= tab_pad && orig_char_len == -1) {
if ((todo >= tab_pad) && (orig_char_len == -1)) {
doit = TRUE;
todo -= tab_pad;
++ind_len;
/* ind_done += tab_pad; */
ind_len++;
// ind_done += tab_pad;
}
}
/* count tabs required for indent */
// Count tabs required for indent.
while (todo >= (int)curbuf->b_p_ts) {
if (*p != TAB)
if (*p != TAB) {
doit = TRUE;
else
++p;
} else {
p++;
}
todo -= (int)curbuf->b_p_ts;
++ind_len;
/* ind_done += (int)curbuf->b_p_ts; */
ind_len++;
// ind_done += (int)curbuf->b_p_ts;
}
}
/* count spaces required for indent */
// Count spaces required for indent.
while (todo > 0) {
if (*p != ' ')
if (*p != ' ') {
doit = TRUE;
else
++p;
--todo;
++ind_len;
/* ++ind_done; */
} else {
p++;
}
todo--;
ind_len++;
// ind_done++;
}
/* Return if the indent is OK already. */
if (!doit && !vim_iswhite(*p) && !(flags & SIN_INSERT))
// Return if the indent is OK already.
if (!doit && !vim_iswhite(*p) && !(flags & SIN_INSERT)) {
return FALSE;
}
/* Allocate memory for the new line. */
if (flags & SIN_INSERT)
// Allocate memory for the new line.
if (flags & SIN_INSERT) {
p = oldline;
else
} else {
p = skipwhite(p);
}
line_len = (int)STRLEN(p) + 1;
/* 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 '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) {
newline = alloc(orig_char_len + size - ind_done + line_len);
if (newline == NULL)
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 */
// Set total length of indent in characters, which may have been
// undercounted until now.
ind_len = orig_char_len + todo;
p = oldline;
s = newline;
while (orig_char_len > 0) {
*s++ = *p++;
orig_char_len--;
}
/* Skip over any additional white space (useful when newindent is less
* than old) */
while (vim_iswhite(*p))
++p;
// Skip over any additional white space (useful when newindent is less
// than old).
while (vim_iswhite(*p)) {
p++;
}
} else {
todo = size;
newline = alloc(ind_len + line_len);
if (newline == NULL)
if (newline == NULL) {
return FALSE;
}
s = newline;
}
/* Put the characters in the new line. */
/* if 'expandtab' isn't set: use TABs */
// Put the characters in the new line.
// if 'expandtab' isn't set: use TABs
if (!curbuf->b_p_et) {
/* If 'preserveindent' is set then reuse as much as possible of
* the existing indent structure for the new indent */
// 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) {
p = oldline;
ind_done = 0;
while (todo > 0 && vim_iswhite(*p)) {
if (*p == TAB) {
tab_pad = (int)curbuf->b_p_ts
- (ind_done % (int)curbuf->b_p_ts);
/* stop if this tab will overshoot the target */
if (todo < tab_pad)
tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
// Stop if this tab will overshoot the target.
if (todo < tab_pad) {
break;
}
todo -= tab_pad;
ind_done += tab_pad;
} else {
--todo;
++ind_done;
todo--;
ind_done++;
}
*s++ = *p++;
}
/* Fill to next tabstop with a tab, if possible */
// Fill to next tabstop with a tab, if possible.
tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
if (todo >= tab_pad) {
*s++ = TAB;
todo -= tab_pad;
}
p = skipwhite(p);
}
@ -241,46 +254,51 @@ set_indent (
todo -= (int)curbuf->b_p_ts;
}
}
while (todo > 0) {
*s++ = ' ';
--todo;
todo--;
}
memmove(s, p, (size_t)line_len);
/* Replace the line (unless undo fails). */
if (!(flags & SIN_UNDO) || u_savesub(curwin->w_cursor.lnum) == OK) {
// 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)
if (flags & SIN_CHANGED) {
changed_bytes(curwin->w_cursor.lnum, 0);
/* Correct saved cursor position if it is in this line. */
}
// 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 */
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) */
} 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);
}
}
retval = TRUE;
} else
} else {
vim_free(newline);
}
curwin->w_cursor.col = ind_len;
return retval;
}
/*
* 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.
*/
// Copy the indent from ptr to the current line (and fill to size).
// Leaves the cursor on the first non-blank in the line.
// @return TRUE if the line was changed.
int copy_indent(int size, char_u *src)
{
char_u *p = NULL;
char_u *line = NULL;
char_u *s;
char_u *p = NULL;
char_u *line = NULL;
char_u *s;
int todo;
int ind_len;
int line_len = 0;
@ -288,107 +306,121 @@ int copy_indent(int size, char_u *src)
int ind_done;
int round;
/* Round 1: compute the number of characters needed for the indent
* Round 2: copy the characters. */
// Round 1: compute the number of characters needed for the indent
// Round 2: copy the characters.
for (round = 1; round <= 2; ++round) {
todo = size;
ind_len = 0;
ind_done = 0;
s = src;
/* Count/copy the usable portion of the source line */
// Count/copy the usable portion of the source line.
while (todo > 0 && vim_iswhite(*s)) {
if (*s == TAB) {
tab_pad = (int)curbuf->b_p_ts
- (ind_done % (int)curbuf->b_p_ts);
/* Stop if this tab will overshoot the target */
if (todo < tab_pad)
// Stop if this tab will overshoot the target.
if (todo < tab_pad) {
break;
}
todo -= tab_pad;
ind_done += tab_pad;
} else {
--todo;
++ind_done;
todo--;
ind_done++;
}
++ind_len;
if (p != NULL)
ind_len++;
if (p != NULL) {
*p++ = *s;
++s;
}
s++;
}
/* Fill to next tabstop with a tab, if possible */
// Fill to next tabstop with a tab, if possible.
tab_pad = (int)curbuf->b_p_ts - (ind_done % (int)curbuf->b_p_ts);
if (todo >= tab_pad && !curbuf->b_p_et) {
if ((todo >= tab_pad) && !curbuf->b_p_et) {
todo -= tab_pad;
++ind_len;
if (p != NULL)
ind_len++;
if (p != NULL) {
*p++ = TAB;
}
}
/* Add tabs required for indent */
// Add tabs required for indent.
while (todo >= (int)curbuf->b_p_ts && !curbuf->b_p_et) {
todo -= (int)curbuf->b_p_ts;
++ind_len;
if (p != NULL)
ind_len++;
if (p != NULL) {
*p++ = TAB;
}
}
/* Count/add spaces required for indent */
// Count/add spaces required for indent.
while (todo > 0) {
--todo;
++ind_len;
if (p != NULL)
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. */
// 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)
if (line == NULL) {
return FALSE;
}
p = line;
}
}
/* Append the original line */
// Append the original line
memmove(p, ml_get_curline(), (size_t)line_len);
/* Replace the line */
// Replace the line
ml_replace(curwin->w_cursor.lnum, line, FALSE);
/* Put the cursor after the indent. */
// Put the cursor after the indent.
curwin->w_cursor.col = ind_len;
return TRUE;
}
/*
* 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.
*/
// 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.
int get_number_indent(linenr_T lnum)
{
colnr_T col;
pos_T pos;
regmatch_T regmatch;
int lead_len = 0; /* length of comment leader */
int lead_len = 0; // Length of comment leader.
if (lnum > curbuf->b_ml.ml_line_count)
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))
// 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) {
regmatch.rm_ic = FALSE;
/* vim_regexec() expects a pointer to a line. This lets us
* start matching for the flp beyond any comment leader... */
// vim_regexec() expects a pointer to a line. This lets us
// start matching for the flp beyond any comment leader...
if (vim_regexec(&regmatch, ml_get(lnum) + lead_len, (colnr_T)0)) {
pos.lnum = lnum;
pos.col = (colnr_T)(*regmatch.endp - ml_get(lnum));
@ -397,34 +429,36 @@ int get_number_indent(linenr_T lnum)
vim_regfree(regmatch.regprog);
}
if (pos.lnum == 0 || *ml_get_pos(&pos) == NUL)
if ((pos.lnum == 0) || (*ml_get_pos(&pos) == NUL)) {
return -1;
}
getvcol(curwin, &pos, &col, NULL, NULL);
return (int)col;
}
/*
* 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.
*/
// 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)
{
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)
for (col = 0, ptr = ml_get_curline(); vim_iswhite(*ptr); ++col) {
ptr++;
}
if (col >= curwin->w_cursor.col + extra) {
return TRUE;
else
} else {
return FALSE;
}
}
/*
* Get indent level from 'indentexpr'.
*/
// Get indent level from 'indentexpr'.
int get_expr_indent(void)
{
int indent;
@ -432,26 +466,29 @@ int get_expr_indent(void)
colnr_T save_curswant;
int save_set_curswant;
int save_State;
int use_sandbox = was_set_insecurely((char_u *)"indentexpr",
OPT_LOCAL);
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 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;
indent = eval_to_number(curbuf->b_p_inde);
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. */
if (use_sandbox) {
sandbox++;
}
textlock++;
indent = eval_to_number(curbuf->b_p_inde);
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;
@ -460,108 +497,104 @@ int get_expr_indent(void)
check_cursor();
State = save_State;
/* If there is an error, just keep the current indent. */
if (indent < 0)
// If there is an error, just keep the current indent.
if (indent < 0) {
indent = get_indent();
}
return indent;
}
static int lisp_match(char_u *p);
static int lisp_match(char_u *p)
{
char_u buf[LSIZE];
int len;
char_u *word = p_lispwords;
// 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
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.
*/
// 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;
pos_T *pos, realpos, paren;
int amount;
char_u *that;
char_u *that;
colnr_T col;
colnr_T firsttry;
int parencount, quotecount;
int parencount;
int quotecount;
int vi_lisp;
/* Set vi_lisp to use the vi-compatible method */
// 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)
if ((pos = findmatch(NULL, '(')) == NULL) {
pos = findmatch(NULL, '[');
else {
} else {
paren = *pos;
pos = findmatch(NULL, '[');
if (pos == NULL || ltp(pos, &paren))
if ((pos == NULL) || ltp(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. */
// 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))
if (linewhite(curwin->w_cursor.lnum)) {
continue;
}
for (that = ml_get_curline(); *that != NUL; ++that) {
if (*that == ';') {
while (*(that + 1) != NUL)
++that;
while (*(that + 1) != NUL) {
that++;
}
continue;
}
if (*that == '\\') {
if (*(that + 1) != NUL)
++that;
if (*(that + 1) != NUL) {
that++;
}
continue;
}
if (*that == '"' && *(that + 1) != NUL) {
if ((*that == '"') && (*(that + 1) != NUL)) {
while (*++that && *that != '"') {
/* skipping escaped characters in the string */
// Skipping escaped characters in the string
if (*that == '\\') {
if (*++that == NUL)
if (*++that == NUL) {
break;
}
if (that[1] == NUL) {
++that;
that++;
break;
}
}
}
}
if (*that == '(' || *that == '[')
++parencount;
else if (*that == ')' || *that == ']')
--parencount;
if ((*that == '(') || (*that == '[')) {
parencount++;
} else if ((*that == ')') || (*that == ']')) {
parencount--;
}
}
if (parencount == 0) {
amount = get_indent();
break;
@ -575,87 +608,102 @@ int get_lisp_indent(void)
that = ml_get_curline();
if (vi_lisp && get_indent() == 0)
if (vi_lisp && (get_indent() == 0)) {
amount = 2;
else {
} else {
amount = 0;
while (*that && col) {
amount += lbr_chartabsize_adv(&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))
// 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 {
} else {
that++;
amount++;
firsttry = amount;
while (vim_iswhite(*that)) {
amount += lbr_chartabsize(that, (colnr_T)amount);
++that;
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 != '[')
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)
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 && !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(&that,
(colnr_T)amount);
amount += lbr_chartabsize_adv(&that,
(colnr_T)amount);
}
if (((*that == '(') || (*that == '[')) && !quotecount) {
parencount++;
}
if (((*that == ')') || (*that == ']')) && !quotecount) {
parencount--;
}
if ((*that == '\\') && (*(that + 1) != NUL)) {
amount += lbr_chartabsize_adv(&that, (colnr_T)amount);
}
amount += lbr_chartabsize_adv(&that, (colnr_T)amount);
}
}
while (vim_iswhite(*that)) {
amount += lbr_chartabsize(that, (colnr_T)amount);
that++;
}
if (!*that || *that == ';')
if (!*that || (*that == ';')) {
amount = firsttry;
}
}
}
}
}
} else
amount = 0; /* no matching '(' or '[' found, use zero indent */
} else {
amount = 0; // No matching '(' or '[' found, use zero indent.
}
curwin->w_cursor = realpos;
return amount;
}
static int lisp_match(char_u *p)
{
char_u buf[LSIZE];
int len;
char_u *word = 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;
}