编辑器/阅读器

开发平台：

DOS

edit.c：源码内容

* Use ins_char() to insert the text, it is a bit slower than
* ins_str(), but it takes care of replace mode.
*/
ptr = curr_match->str + curwin->w_cursor.col - complete_col;
while (*ptr)
ins_char(*ptr++);
update_screenline();
if (temp > 1)
{
if (ctrl_x_mode == 0 || ctrl_x_mode == CTRL_X_WHOLE_LINE)
ptr = (char_u *)"All %d matches have now been found";
else if (ctrl_x_mode == CTRL_X_FILES)
ptr = (char_u *)"There are %d matching file names";
else if (ctrl_x_mode == CTRL_X_TAGS)
ptr = (char_u *)"There are %d matching tags";
else
ptr = (char_u *)"There are %d matches";
sprintf((char *)IObuff, (char *)ptr, temp);
if (dollar_vcol)
curs_columns(FALSE);
msg_attr(IObuff, hl_attr(HLF_R));
if (!char_avail())
{
setcursor();
out_flush();
ui_delay(1500L, FALSE);
}
}
showmode();
if (edit_submode_extra != NULL)
{
if (!p_smd)
msg_attr(edit_submode_extra,
edit_submode_highl < HLF_COUNT
? hl_attr(edit_submode_highl) : 0);
if (!char_avail())
{
setcursor();
out_flush();
ui_delay(1500L, FALSE);
}
edit_submode_extra = NULL;
}
/*
* Show the file name for the match (if any)
* Truncate the file name to avoid a wait for return.
*/
if (curr_match->fname != NULL)
{
STRCPY(IObuff, "match in file ");
i = (vim_strsize(curr_match->fname) + 16) - sc_col;
if (i <= 0)
i = 0;
else
STRCAT(IObuff, "<");
STRCAT(IObuff, curr_match->fname + i);
msg(IObuff);
redraw_cmdline = FALSE; /* don't overwrite! */
}
return TRUE;
}
/*
* Looks in the first "len" chars. of "src" for search-metachars.
* If dest is not NULL the chars. are copied there quoting (with
* a backslash) the metachars, and dest would be NUL terminated.
* Returns the length (needed) of dest
*/
static int
quote_meta(dest, src, len)
char_u *dest;
char_u *src;
int len;
{
int m;
for (m = len; --len >= 0; src++)
{
switch (*src)
{
case '.':
case '*':
case '[':
if (ctrl_x_mode == CTRL_X_DICTIONARY)
break;
case '~':
if (!p_magic) /* quote these only if magic is set */
break;
case '\':
if (ctrl_x_mode == CTRL_X_DICTIONARY)
break;
case '^': /* currently it's not needed. */
case '$':
m++;
if (dest)
*dest++ = '\';
break;
}
if (dest)
*dest++ = *src;
}
if (dest)
*dest = NUL;
return m;
}
#endif /* INSERT_EXPAND */
/*
* Next character is interpreted literally.
* A one, two or three digit decimal number is interpreted as its byte value.
* If one or two digits are entered, the next character is given to vungetc().
*/
int
get_literal()
{
int cc;
int nc;
int i;
int hexmode = 0, octalmode = 0;
if (got_int)
return Ctrl('C');
#ifdef USE_GUI
/*
* In GUI there is no point inserting the internal code for a special key.
* It is more useful to insert the string "<KEY>" instead. This would
* probably be useful in a text window too, but it would not be
* vi-compatible (maybe there should be an option for it?) -- webb
*/
if (gui.in_use)
++allow_keys;
#endif
#ifdef USE_GUI_WIN32
dont_scroll = TRUE; /* disallow scrolling here */
#endif
++no_mapping; /* don't map the next key hits */
cc = 0;
i = 0;
for (;;)
{
do
nc = vgetc();
while (nc == K_IGNORE || nc == K_SCROLLBAR || nc == K_HORIZ_SCROLLBAR);
#ifdef SHOWCMD
if (!(State & CMDLINE)
#ifdef MULTI_BYTE
&& (is_dbcs && !IsLeadByte(nc))
#endif
)
add_to_showcmd(nc);
#endif
if (nc == 'x' || nc == 'X')
hexmode++;
else if (nc == 'o' || nc == 'O')
octalmode++;
else
{
if (hexmode)
{
if (!vim_isdigit(nc) && !isxdigit(nc))
break;
nc = tolower(nc);
if (nc >= 'a')
nc = 10 + nc - 'a';
else
nc = nc - '0';
cc = cc * 16 + nc ;
}
else if (octalmode)
{
if (!vim_isdigit(nc) || (nc > '7'))
break;
cc = cc * 8 + nc - '0';
}
else
{
if (!vim_isdigit(nc))
break;
cc = cc * 10 + nc - '0';
}
++i;
}
if (cc > 255)
cc = 255; /* limit range to 0-255 */
nc = 0;
if (hexmode && (i >= 2))
break;
if (!hexmode && (i >= 3))
break;
}
if (i == 0) /* no number entered */
{
if (nc == K_ZERO) /* NUL is stored as NL */
{
cc = 'n';
nc = 0;
}
else
{
cc = nc;
nc = 0;
}
}
if (cc == 0) /* NUL is stored as NL */
cc = 'n';
--no_mapping;
#ifdef USE_GUI
if (gui.in_use)
--allow_keys;
#endif
if (nc)
vungetc(nc);
got_int = FALSE; /* CTRL-C typed after CTRL-V is not an interrupt */
return cc;
}
/*
* Insert character, taking care of special keys and mod_mask
*/
static void
insert_special(c, allow_modmask, ctrlv)
int c;
int allow_modmask;
int ctrlv; /* c was typed after CTRL-V */
{
char_u *p;
int len;
/*
* Special function key, translate into "<Key>". Up to the last '>' is
* inserted with ins_str(), so as not to replace characters in replace
* mode.
* Only use mod_mask for special keys, to avoid things like <S-Space>,
* unless 'allow_modmask' is TRUE.
*/
if (IS_SPECIAL(c) || (mod_mask && allow_modmask))
{
p = get_special_key_name(c, mod_mask);
len = STRLEN(p);
c = p[len - 1];
if (len > 2)
{
p[len - 1] = NUL;
ins_str(p);
AppendToRedobuff(p);
ctrlv = FALSE;
}
}
insertchar(c, FALSE, -1, ctrlv);
}
/*
* Special characters in this context are those that need processing other
* than the simple insertion that can be performed here. This includes ESC
* which terminates the insert, and CR/NL which need special processing to
* open up a new line. This routine tries to optimize insertions performed by
* the "redo", "undo" or "put" commands, so it needs to know when it should
* stop and defer processing to the "normal" mechanism.
* '0' and '^' are special, because they can be followed by CTRL-D.
*/
#define ISSPECIAL(c) ((c) < ' ' || (c) >= DEL || (c) == '0' || (c) == '^')
void
insertchar(c, force_formatting, second_indent, ctrlv)
unsigned c;
int force_formatting; /* format line regardless of p_fo */
int second_indent; /* indent for second line if >= 0 */
int ctrlv; /* c typed just after CTRL-V */
{
int haveto_redraw = FALSE;
int textwidth;
colnr_t leader_len;
int first_line = TRUE;
int fo_ins_blank;
int save_char = NUL;
int cc;
stop_arrow();
textwidth = comp_textwidth(force_formatting);
fo_ins_blank = has_format_option(FO_INS_BLANK);
/*
* Try to break the line in two or more pieces when:
* - Always do this if we have been called to do formatting only.
* - Otherwise:
* - Don't do this if inserting a blank
* - Don't do this if an existing character is being replaced.
* - Do this if the cursor is not on the line where insert started
* or - 'formatoptions' doesn't have 'l' or the line was not too long
* before the insert.
* - 'formatoptions' doesn't have 'b' or a blank was inserted at or
* before 'textwidth'
*/
if (textwidth
&& (force_formatting
|| (!vim_iswhite(c)
&& !(State == REPLACE && *ml_get_cursor() != NUL)
&& (curwin->w_cursor.lnum != Insstart.lnum
|| ((!has_format_option(FO_INS_LONG)
|| Insstart_textlen <= (colnr_t)textwidth)
&& (!fo_ins_blank
|| Insstart_blank_vcol <= (colnr_t)textwidth
))))))
{
/*
* When 'ai' is off we don't want a space under the cursor to be
* deleted. Replace it with an 'x' temporarily.
*/
if (!curbuf->b_p_ai)
{
cc = gchar_cursor();
if (vim_iswhite(cc))
{
save_char = cc;
pchar_cursor('x');
}
}
/*
* Repeat breaking lines, until the current line is not too long.
*/
while (!got_int)
{
int startcol; /* Cursor column at entry */
int wantcol; /* column at textwidth border */
int foundcol; /* column for start of spaces */
int end_foundcol = 0; /* column for start of word */
colnr_t len;
colnr_t virtcol;
virtcol = get_nolist_virtcol();
if (virtcol < (colnr_t)textwidth)
break;
if (!force_formatting && has_format_option(FO_WRAP_COMS))
fo_do_comments = TRUE;
/* Don't break until after the comment leader */
leader_len = get_leader_len(ml_get_curline(), NULL);
if (!force_formatting && leader_len == 0 &&
!has_format_option(FO_WRAP))
{
textwidth = 0;
break;
}
if ((startcol = curwin->w_cursor.col) == 0)
break;
/* find column of textwidth border */
coladvance((colnr_t)textwidth);
wantcol = curwin->w_cursor.col;
curwin->w_cursor.col = startcol - 1;
foundcol = 0;
/*
* Find position to break at.
* Stop at start of line.
* Stop at first entered white when 'formatoptions' has 'v'
*/
while (curwin->w_cursor.col > 0 &&
((!fo_ins_blank && !has_format_option(FO_INS_VI)) ||
curwin->w_cursor.lnum != Insstart.lnum ||
curwin->w_cursor.col >= Insstart.col))
{
cc = gchar_cursor();
if (vim_iswhite(cc))
{
/* remember position of blank just before text */
end_foundcol = curwin->w_cursor.col;
while (curwin->w_cursor.col > 0 && vim_iswhite(cc))
{
--curwin->w_cursor.col;
cc = gchar_cursor();
}
if (curwin->w_cursor.col == 0 && vim_iswhite(cc))
break; /* only spaces in front of text */
/* Don't break until after the comment leader */
if (curwin->w_cursor.col < leader_len)
break;
foundcol = curwin->w_cursor.col + 1;
if (curwin->w_cursor.col < (colnr_t)wantcol)
break;
}
--curwin->w_cursor.col;
}
if (foundcol == 0) /* no spaces, cannot break line */
{
curwin->w_cursor.col = startcol;
break;
}
/*
* offset between cursor position and line break is used by
* replace stack functions
*/
replace_offset = startcol - end_foundcol - 1;
/*
* adjust startcol for spaces that will be deleted and
* characters that will remain on top line
*/
curwin->w_cursor.col = foundcol;
while (cc = gchar_cursor(), vim_iswhite(cc))
{
++curwin->w_cursor.col;
--startcol;
}
startcol -= foundcol;
if (startcol < 0)
startcol = 0;
/* put cursor after pos. to break line */
curwin->w_cursor.col = foundcol;
/*
* Split the line before just the margin.
* Only insert/delete lines, but don't really redraw the window.
*/
open_line(FORWARD, (redrawing() && !force_formatting) ? -1 : 0,
TRUE, old_indent);
old_indent = 0;
replace_offset = 0;
if (second_indent >= 0 && first_line)
set_indent(second_indent, TRUE);
first_line = FALSE;
/*
* check if cursor is not past the NUL off the line, cindent may
* have added or removed indent.
*/
curwin->w_cursor.col += startcol;
len = STRLEN(ml_get_curline());
if (curwin->w_cursor.col > len)
curwin->w_cursor.col = len;
haveto_redraw = TRUE;
#ifdef CINDENT
can_cindent = TRUE;
#endif
/* moved the cursor, don't autoindent or cindent now */
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
line_breakcheck();
}
if (save_char) /* put back space after cursor */
pchar_cursor(save_char);
if (c == NUL) /* formatting only */
return;
fo_do_comments = FALSE;
if (haveto_redraw)
{
update_topline();
update_screen(NOT_VALID);
}
}
if (c == NUL) /* only formatting was wanted */
return;
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
/*
* If there's any pending input, grab up to INPUT_BUFLEN at once.
* This speeds up normal text input considerably.
* Don't do this when 'cindent' is set, because we might need to re-indent
* at a ':', or any other character.
*/
#ifdef USE_GUI_WIN32
dont_scroll = FALSE; /* allow scrolling here */
#endif
#define INPUT_BUFLEN 100
if ( !ISSPECIAL(c)
&& vpeekc() != NUL
&& State != REPLACE
#ifdef CINDENT
&& !curbuf->b_p_cin
#endif
#ifdef RIGHTLEFT
&& !p_ri
#endif
)
{
char_u p[INPUT_BUFLEN + 1];
int i;
colnr_t virtcol = 0;
p[0] = c;
i = 1;
if (textwidth)
virtcol = get_nolist_virtcol();
while ( (c = vpeekc()) != NUL
&& !ISSPECIAL(c)
&& i < INPUT_BUFLEN
&& (textwidth == 0
|| (virtcol += charsize(p[i - 1])) < (colnr_t)textwidth)
&& !(!no_abbr && !vim_iswordc(c) && vim_iswordc(p[i - 1])))
{
#ifdef RIGHTLEFT
c = vgetc();
if (p_hkmap && KeyTyped)
c = hkmap(c); /* Hebrew mode mapping */
#ifdef FKMAP
if (p_fkmap && KeyTyped)
c = fkmap(c); /* Farsi mode mapping */
#endif
p[i++] = c;
#else
p[i++] = vgetc();
#endif
}
#ifdef DIGRAPHS
do_digraph(-1); /* clear digraphs */
do_digraph(p[i-1]); /* may be the start of a digraph */
#endif
p[i] = NUL;
ins_str(p);
if (ctrlv)
{
redo_literal(*p);
i = 1;
}
else
i = 0;
if (p[i] != NUL)
AppendToRedobuff(p + i);
}
else
{
ins_char(c);
if (ctrlv)
redo_literal(c);
else
AppendCharToRedobuff(c);
}
}
/*
* Find out textwidth to be used for formatting:
* if 'textwidth' option is set, use it
* else if 'wrapmargin' option is set, use Columns - 'wrapmargin'
* if invalid value, use 0.
* Set default to window width (maximum 79) for "Q" command.
*/
int
comp_textwidth(ff)
int ff; /* force formatting (for "Q" command) */
{
int textwidth;
textwidth = curbuf->b_p_tw;
if (textwidth == 0 && curbuf->b_p_wm)
textwidth = Columns - curbuf->b_p_wm;
if (textwidth < 0)
textwidth = 0;
if (ff && textwidth == 0)
{
textwidth = Columns - 1;
if (textwidth > 79)
textwidth = 79;
}
return textwidth;
}
/*
* Put a character in the redo buffer, for when just after a CTRL-V.
*/
static void
redo_literal(c)
int c;
{
char_u buf[10];
/* Only digits need special treatment. Translate them into a string of
* three digits. */
if (vim_isdigit(c))
{
sprintf((char *)buf, "%03d", c);
AppendToRedobuff(buf);
}
else
AppendCharToRedobuff(c);
}
/*
* start_arrow() is called when an arrow key is used in insert mode.
* It resembles hitting the <ESC> key.
*/
static void
start_arrow(end_insert_pos)
FPOS *end_insert_pos;
{
if (!arrow_used) /* something has been inserted */
{
AppendToRedobuff(ESC_STR);
arrow_used = TRUE; /* this means we stopped the current insert */
stop_insert(end_insert_pos);
}
}
/*
* stop_arrow() is called before a change is made in insert mode.
* If an arrow key has been used, start a new insertion.
*/
void
stop_arrow()
{
if (arrow_used)
{
(void)u_save_cursor(); /* errors are ignored! */
Insstart = curwin->w_cursor; /* new insertion starts here */
Insstart_textlen = linetabsize(ml_get_curline());
ResetRedobuff();
AppendToRedobuff((char_u *)"1i"); /* pretend we start an insertion */
arrow_used = FALSE;
}
}
/*
* do a few things to stop inserting
*/
static void
stop_insert(end_insert_pos)
FPOS *end_insert_pos; /* where insert ended */
{
int cc;
stop_redo_ins();
replace_flush(); /* abandon replace stack */
/*
* save the inserted text for later redo with ^@
*/
vim_free(last_insert);
last_insert = get_inserted();
last_insert_skip = new_insert_skip;
/*
* If we just did an auto-indent, remove the white space from the end of
* the line, and put the cursor back.
*/
if (did_ai && !arrow_used)
{
if (gchar_cursor() == NUL && curwin->w_cursor.col > 0)
--curwin->w_cursor.col;
while (cc = gchar_cursor(), vim_iswhite(cc))
(void)del_char(TRUE);
if (cc != NUL)
++curwin->w_cursor.col; /* put cursor back on the NUL */
/* the deletion is only seen in list mode and when 'hls' is set */
if (curwin->w_p_list || p_hls)
update_screenline();
}
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
/* set '[ and '] to the inserted text */
curbuf->b_op_start = Insstart;
curbuf->b_op_end = *end_insert_pos;
}
/*
* Set the last inserted text to a single character.
* Used for the replace command.
*/
void
set_last_insert(c)
int c;
{
vim_free(last_insert);
last_insert = alloc(4);
if (last_insert != NULL)
{
last_insert[0] = Ctrl('V');
last_insert[1] = c;
last_insert[2] = ESC;
last_insert[3] = NUL;
/* Use the CTRL-V only when not entering a digit */
last_insert_skip = isdigit(c) ? 1 : 0;
}
}
/*
* move cursor to start of line
* if flags & BL_WHITE move to first non-white
* if flags & BL_SOL move to first non-white if startofline is set,
* otherwise keep "curswant" column
* if flags & BL_FIX don't leave the cursor on a NUL.
*/
void
beginline(flags)
int flags;
{
if ((flags & BL_SOL) && !p_sol)
coladvance(curwin->w_curswant);
else
{
curwin->w_cursor.col = 0;
if (flags & (BL_WHITE | BL_SOL))
{
char_u *ptr;
for (ptr = ml_get_curline(); vim_iswhite(*ptr)
&& !((flags & BL_FIX) && ptr[1] == NUL); ++ptr)
++curwin->w_cursor.col;
}
curwin->w_set_curswant = TRUE;
}
}
/*
* oneright oneleft cursor_down cursor_up
*
* Move one char {right,left,down,up}.
* Return OK when successful, FAIL when we hit a line of file boundary.
*/
int
oneright()
{
char_u *ptr;
ptr = ml_get_cursor();
if (*ptr++ == NUL || *ptr == NUL)
return FAIL;
#ifdef MULTI_BYTE
if (is_dbcs)
{
/* if the character on the current cursor is a multi-byte character,
move two characters right */
char_u *base;
base = ml_get(curwin->w_cursor.lnum);
if (*(ptr+1) != NUL && IsTrailByte(base, ptr))
++curwin->w_cursor.col;
}
#endif
curwin->w_set_curswant = TRUE;
++curwin->w_cursor.col;
return OK;
}
int
oneleft()
{
if (curwin->w_cursor.col == 0)
return FAIL;
curwin->w_set_curswant = TRUE;
--curwin->w_cursor.col;
#ifdef MULTI_BYTE
/* if the character on the left of the current cursor is a multi-byte
* character, move two characters left */
if (is_dbcs)
AdjustCursorForMultiByteCharacter();
#endif
return OK;
}
int
cursor_up(n, upd_topline)
long n;
int upd_topline; /* When TRUE: update topline */
{
if (n != 0)
{
if (curwin->w_cursor.lnum <= 1)
return FAIL;
if (n >= curwin->w_cursor.lnum)
curwin->w_cursor.lnum = 1;
else
curwin->w_cursor.lnum -= n;
}
/* try to advance to the column we want to be at */
coladvance(curwin->w_curswant);
if (upd_topline)
update_topline(); /* make sure curwin->w_topline is valid */
return OK;
}
int
cursor_down(n, upd_topline)
long n;
int upd_topline; /* When TRUE: update topline */
{
if (n != 0)
{
if (curwin->w_cursor.lnum >= curbuf->b_ml.ml_line_count)
return FAIL;
curwin->w_cursor.lnum += n;
if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
}
/* try to advance to the column we want to be at */
coladvance(curwin->w_curswant);
if (upd_topline)
update_topline(); /* make sure curwin->w_topline is valid */
return OK;
}
/*
* Stuff the last inserted text in the read buffer.
* Last_insert actually is a copy of the redo buffer, so we
* first have to remove the command.
*/
int
stuff_inserted(c, count, no_esc)
int c; /* Command character to be inserted */
long count; /* Repeat this many times */
int no_esc; /* Don't add an ESC at the end */
{
char_u *esc_ptr;
char_u *ptr;
char_u *last_ptr;
char_u last = NUL;
ptr = get_last_insert();
if (ptr == NULL)
{
EMSG(e_noinstext);
return FAIL;
}
/* may want to stuff the command character, to start Insert mode */
if (c)
stuffcharReadbuff(c);
if ((esc_ptr = (char_u *)vim_strrchr(ptr, ESC)) != NULL)
*esc_ptr = NUL; /* remove the ESC */
/* when the last char is either "0" or "^" it will be quoted if no ESC
* comes after it OR if it will inserted more than once and "ptr"
* starts with ^D. -- Acevedo
*/
last_ptr = (esc_ptr ? esc_ptr : ptr + STRLEN(ptr)) - 1;
if (last_ptr >= ptr && (*last_ptr == '0' || *last_ptr == '^')
&& (no_esc || (*ptr == Ctrl('D') && count > 1)))
{
last = *last_ptr;
*last_ptr = NUL;
}
do
{
stuffReadbuff(ptr);
/* a trailing "0" is inserted as "<C-V>048", "^" as "<C-V>^" */
if (last)
stuffReadbuff((char_u *)(last == '0' ? "26048" : "26^"));
}
while (--count > 0);
if (last)
*last_ptr = last;
if (esc_ptr != NULL)
*esc_ptr = ESC; /* put the ESC back */
/* may want to stuff a trailing ESC, to get out of Insert mode */
if (!no_esc)
stuffcharReadbuff(ESC);
return OK;
}
char_u *
get_last_insert()
{
if (last_insert == NULL)
return NULL;
return last_insert + last_insert_skip;
}
/*
* Get last inserted string, and remove trailing <Esc>.
* Returns pointer to allocated memory (must be freed) or NULL.
*/
char_u *
get_last_insert_save()
{
char_u *s;
int len;
if (last_insert == NULL)
return NULL;
s = vim_strsave(last_insert + last_insert_skip);
if (s != NULL)
{
len = STRLEN(s);
if (len > 0 && s[len - 1] == ESC) /* remove trailing ESC */
s[len - 1] = NUL;
}
return s;
}
/*
* Check the word in front of the cursor for an abbreviation.
* Called when the non-id character "c" has been entered.
* When an abbreviation is recognized it is removed from the text and
* the replacement string is inserted in typebuf[], followed by "c".
*/
static int
echeck_abbr(c)
int c;
{
if (p_paste || no_abbr) /* no abbreviations or in paste mode */
return FALSE;
return check_abbr(c, ml_get_curline(), curwin->w_cursor.col,
curwin->w_cursor.lnum == Insstart.lnum ? Insstart.col : 0);
}
/*
* replace-stack functions
*
* When replacing characters, the replaced characters are remembered for each
* new character. This is used to re-insert the old text when backspacing.
*
* There is a NUL headed list of characters for each character that is
* currently in the file after the insertion point. When BS is used, one NUL
* headed list is put back for the deleted character.
*
* For a newline, there are two NUL headed lists. One contains the characters
* that the NL replaced. The extra one stores the characters after the cursor
* that were deleted (always white space).
*
* Replace_offset is normally 0, in which case replace_push will add a new
* character at the end of the stack. If replace_offset is not 0, that many
* characters will be left on the stack above the newly inserted character.
*/
char_u *replace_stack = NULL;
long replace_stack_nr = 0; /* next entry in replace stack */
long replace_stack_len = 0; /* max. number of entries */
void
replace_push(c)
int c; /* character that is replaced (NUL is none) */
{
char_u *p;
if (replace_stack_nr < replace_offset) /* nothing to do */
return;
if (replace_stack_len <= replace_stack_nr)
{
replace_stack_len += 50;
p = lalloc(sizeof(char_u) * replace_stack_len, TRUE);
if (p == NULL) /* out of memory */
{
replace_stack_len -= 50;
return;
}
if (replace_stack != NULL)
{
mch_memmove(p, replace_stack,
(size_t)(replace_stack_nr * sizeof(char_u)));
vim_free(replace_stack);
}
replace_stack = p;
}
p = replace_stack + replace_stack_nr - replace_offset;
if (replace_offset)
mch_memmove(p + 1, p, (size_t)(replace_offset * sizeof(char_u)));
*p = c;
++replace_stack_nr;
}
/*
* call replace_push(c) with replace_offset set to the first NUL.
*/
static void
replace_push_off(c)
int c;
{
char_u *p;
p = replace_stack + replace_stack_nr;
for (replace_offset = 1; replace_offset < replace_stack_nr;
++replace_offset)
if (*--p == NUL)
break;
replace_push(c);
replace_offset = 0;
}
/*
* Pop one item from the replace stack.
* return -1 if stack empty
* return replaced character or NUL otherwise
*/
static int
replace_pop()
{
if (replace_stack_nr == 0)
return -1;
return (int)replace_stack[--replace_stack_nr];
}
/*
* Join the top two items on the replace stack. This removes to "off"'th NUL
* encountered.
*/
static void
replace_join(off)
int off; /* offset for which NUL to remove */
{
int i;
for (i = replace_stack_nr; --i >= 0; )
if (replace_stack[i] == NUL && off-- <= 0)
{
--replace_stack_nr;
mch_memmove(replace_stack + i, replace_stack + i + 1,
(size_t)(replace_stack_nr - i));
return;
}
}
/*
* Pop characters from the replace stack until a NUL is found, and insert them
* before the cursor. Can only be used in REPLACE mode.
*/
static void
replace_pop_ins()
{
int cc;
State = NORMAL; /* don't want REPLACE here */
while ((cc = replace_pop()) > 0)
{
ins_char(cc);
dec_cursor();
}
State = REPLACE;
}
/*
* make the replace stack empty
* (called when exiting replace mode)
*/
static void
replace_flush()
{
vim_free(replace_stack);
replace_stack = NULL;
replace_stack_len = 0;
replace_stack_nr = 0;
}
/*
* Handle doing a BS for one character.
* cc < 0: replace stack empty, just move cursor
* cc == 0: character was inserted, delete it
* cc > 0: character was replace, put original back
*/
static void
replace_do_bs()
{
int cc;
cc = replace_pop();
if (cc > 0)
{
pchar_cursor(cc);
replace_pop_ins();
}
else if (cc == 0)
(void)del_char(FALSE);
}
#if defined(LISPINDENT) || defined(CINDENT)
/*
* 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 or get_lisp_indent.
*/
void
fixthisline(get_the_indent)
int (*get_the_indent) __ARGS((void));
{
change_indent(INDENT_SET, get_the_indent(), FALSE, 0);
if (linewhite(curwin->w_cursor.lnum))
did_ai = TRUE; /* delete the indent if the line stays empty */
}
#endif /* defined(LISPINDENT) || defined(CINDENT) */
#ifdef CINDENT
/*
* return TRUE if 'cinkeys' contains the key "keytyped",
* when == '*': Only if key is preceded with '*' (indent before insert)
* when == '!': Only if key is prededed with '!' (don't insert)
* when == ' ': Only if key is not preceded with '*'(indent afterwards)
*
* If line_is_empty is TRUE accept keys with '0' before them.
*/
int
in_cinkeys(keytyped, when, line_is_empty)
int keytyped;
int when;
int line_is_empty;
{
char_u *look;
int try_match;
char_u *p;
int i;
for (look = curbuf->b_p_cink; *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.
*/
if (*look == '0')
{
if (!line_is_empty)
try_match = FALSE;
++look;
}
/*
* does it look like a control character?
*/
if (*look == '^' && look[1] >= '@' && look[1] <= '_')
{
if (try_match && keytyped == Ctrl(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) || cin_isscopedecl(p) || cin_islabel(30))
return TRUE;
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) || cin_isscopedecl(p)
|| cin_islabel(30));
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++;
}
/*
* ok, it's a boring generic character.
*/
else
{
if (try_match && *look == keytyped)
return TRUE;
++look;
}
/*
* Skip over ", ".
*/
look = skip_to_option_part(look);
}
return FALSE;
}
#endif /* CINDENT */
#if defined(RIGHTLEFT) || defined(PROTO)
/*
* Map Hebrew keyboard when in hkmap mode.
*/
int
hkmap(c)
int c;
{
if (p_hkmapp) /* phonetic mapping, by Ilya Dogolazky */
{
enum {hALEF=0, BET, GIMEL, DALET, HEI, VAV, ZAIN, HET, TET, IUD,
KAFsofit, hKAF, LAMED, MEMsofit, MEM, NUNsofit, NUN, SAMEH, AIN,
PEIsofit, PEI, ZADIsofit, ZADI, KOF, RESH, hSHIN, TAV};
static char_u map[26] =
{(char_u)hALEF/*a*/, (char_u)BET /*b*/, (char_u)hKAF /*c*/,
(char_u)DALET/*d*/, (char_u)-1 /*e*/, (char_u)PEIsofit/*f*/,
(char_u)GIMEL/*g*/, (char_u)HEI /*h*/, (char_u)IUD /*i*/,
(char_u)HET /*j*/, (char_u)KOF /*k*/, (char_u)LAMED /*l*/,
(char_u)MEM /*m*/, (char_u)NUN /*n*/, (char_u)SAMEH /*o*/,
(char_u)PEI /*p*/, (char_u)-1 /*q*/, (char_u)RESH /*r*/,
(char_u)ZAIN /*s*/, (char_u)TAV /*t*/, (char_u)TET /*u*/,
(char_u)VAV /*v*/, (char_u)hSHIN/*w*/, (char_u)-1 /*x*/,
(char_u)AIN /*y*/, (char_u)ZADI /*z*/};
if (c == 'N' || c == 'M' || c == 'P' || c == 'C' || c == 'Z')
return map[tolower(c) - 'a'] - 1 + p_aleph; /* '-1'='sofit' */
else if (c == 'x')
return 'X';
else if (c == 'q')
return '''; /* {geresh}={'} */
else if (c == 246)
return ' '; /* "o --> ' ' for a german keyboard */
else if (c == 228)
return ' '; /* "a --> ' ' -- / -- */
else if (c == 252)
return ' '; /* "u --> ' ' -- / -- */
else if ('a' <= c && c <= 'z')
return map[c - 'a'] + p_aleph;
else
return c;
}
else
{
switch (c)
{
case '`': return ';';
case '/': return '.';
case ''': return ',';
case 'q': return '/';
case 'w': return ''';
/* Hebrew letters - set offset from 'a' */
case ',': c = '{'; break;
case '.': c = 'v'; break;
case ';': c = 't'; break;
default: {
static char str[] = "zqbcxlsjphmkwonu ydafe rig";
if (c < 'a' || c > 'z')
return c;
c = str[c - 'a'];
break;
}
}
return c - 'a' + p_aleph;
}
}
#endif
static int
ins_reg()
{
int need_redraw = FALSE;
int cc;
int literally = FALSE;
/*
* If we are going to wait for a character, show a '"'.
*/
if (redrawing() && !char_avail())
{
edit_putchar('"', TRUE);
#ifdef SHOWCMD
add_to_showcmd_c(Ctrl('R'));
#endif
}
#ifdef USE_GUI_WIN32
dont_scroll = TRUE; /* disallow scrolling here */
#endif
/*
* Don't map the register name. This also prevents the mode message to be
* deleted when ESC is hit.
*/
++no_mapping;
cc = vgetc();
if (cc == Ctrl('R'))
{
literally = TRUE;
cc = vgetc();
}
--no_mapping;
#ifdef HAVE_LANGMAP
LANGMAP_ADJUST(cc, TRUE);
#endif
#ifdef WANT_EVAL
/*
* Don't call u_sync while getting the expression,
* evaluating it or giving an error message for it!
*/
++no_u_sync;
if (cc == '=')
cc = get_expr_register();
if (cc == NUL)
need_redraw = TRUE; /* remove the '"' */
else
{
#endif
if (insert_reg(cc, literally) == FAIL)
{
beep_flush();
need_redraw = TRUE; /* remove the '"' */
}
#ifdef WANT_EVAL
}
--no_u_sync;
#endif
#ifdef SHOWCMD
clear_showcmd();
#endif
/* If the inserted register is empty, we need to remove the '"' */
if (stuff_empty())
need_redraw = TRUE;
return need_redraw;
}
/*
* Handle ESC in insert mode.
* Returns TRUE when leaving insert mode, FALSE when going to repeat the
* insert.
*/
static int
ins_esc(count, need_redraw, cmdchar)
long *count;
int need_redraw;
int cmdchar;
{
int temp;
static int disabled_redraw = FALSE;
#if defined(MULTI_BYTE_IME) && defined(USE_GUI_WIN32)
ImeSetEnglishMode();
#endif
temp = curwin->w_cursor.col;
if (disabled_redraw)
{
--RedrawingDisabled;
disabled_redraw = FALSE;
}
if (!arrow_used)
{
/*
* Don't append the ESC for "r<CR>".
*/
if (cmdchar != 'r')
AppendToRedobuff(ESC_STR);
/*
* Repeating insert may take a long time. Check for
* interrupt now and then.
*/
if (*count)
{
line_breakcheck();
if (got_int)
*count = 0;
}
if (--*count > 0) /* repeat what was typed */
{
(void)start_redo_ins();
++RedrawingDisabled;
disabled_redraw = TRUE;
return FALSE; /* repeat the insert */
}
stop_insert(&curwin->w_cursor);
if (dollar_vcol)
{
dollar_vcol = 0;
/* may have to redraw status line if this was the
* first change, show "[+]" */
if (curwin->w_redr_status == TRUE)
redraw_later(NOT_VALID);
else
need_redraw = TRUE;
}
}
if (need_redraw)
update_screenline();
/* When an autoindent was removed, curswant stays after the
* indent */
if (!restart_edit && (colnr_t)temp == curwin->w_cursor.col)
curwin->w_set_curswant = TRUE;
/*
* The cursor should end up on the last inserted character.
*/
if ( curwin->w_cursor.col != 0
&& (!restart_edit
|| gchar_cursor() == NUL)
#ifdef RIGHTLEFT
&& !revins_on
#endif
)
--curwin->w_cursor.col;
/* need to position cursor again (e.g. when on a TAB ) */
changed_cline_bef_curs();
State = NORMAL;
#ifdef USE_MOUSE
setmouse();
#endif
#ifdef CURSOR_SHAPE
ui_cursor_shape(); /* may show different cursor shape */
#endif
/*
* When recording or for CTRL-O, need to display the new mode.
* Otherwise remove the mode message.
*/
if (Recording || restart_edit)
showmode();
else if (p_smd)
MSG("");
return TRUE; /* exit Insert mode */
}
#ifdef RIGHTLEFT
/*
* Toggle language: khmap and revins_on.
* Move to end of reverse inserted text.
*/
static void
ins_ctrl_()
{
if (revins_on && revins_chars && revins_scol >= 0)
{
while (gchar_cursor() != NUL && revins_chars--)
++curwin->w_cursor.col;
}
p_ri = !p_ri;
revins_on = (State == INSERT && p_ri);
if (revins_on)
{
revins_scol = curwin->w_cursor.col;
revins_legal++;
revins_chars = 0;
undisplay_dollar();
}
else
revins_scol = -1;
#ifdef FKMAP
if (p_altkeymap)
{
/*
* to be consistent also for redo command, using '.'
* set arrow_used to true and stop it - causing to redo
* characters entered in one mode (normal/reverse insert).
*/
arrow_used = TRUE;
stop_arrow();
p_fkmap = curwin->w_p_rl ^ p_ri;
if (p_fkmap && p_ri)
State = INSERT;
}
else
#endif
p_hkmap = curwin->w_p_rl ^ p_ri; /* be consistent! */
showmode();
}
#endif
/*
* If the cursor is on an indent, ^T/^D insert/delete one
* shiftwidth. Otherwise ^T/^D behave like a "<<" or ">>".
* Always round the indent to 'shiftwith', this is compatible
* with vi. But vi only supports ^T and ^D after an
* autoindent, we support it everywhere.
*/
static void
ins_shift(c, lastc)
int c;
int lastc;
{
stop_arrow();
AppendCharToRedobuff(c);
/*
* 0^D and ^^D: remove all indent.
*/
if ((lastc == '0' || lastc == '^') && curwin->w_cursor.col)
{
--curwin->w_cursor.col;
(void)del_char(FALSE); /* delete the '^' or '0' */
/* In Replace mode, restore the characters that '^' or '0' replaced. */
if (State == REPLACE)
replace_pop_ins();
if (lastc == '^')
old_indent = get_indent(); /* remember curr. indent */
change_indent(INDENT_SET, 0, TRUE, 0);
}
else
change_indent(c == Ctrl('D') ? INDENT_DEC : INDENT_INC, 0, TRUE, 0);
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
#ifdef CINDENT
can_cindent = FALSE; /* no cindenting after ^D or ^T */
#endif
}
static void
ins_del()
{
int temp;
stop_arrow();
if (gchar_cursor() == NUL) /* delete newline */
{
temp = curwin->w_cursor.col;
if (!p_bs /* only if 'bs' set */
|| u_save((linenr_t)(curwin->w_cursor.lnum - 1),
(linenr_t)(curwin->w_cursor.lnum + 2)) == FAIL
|| do_join(FALSE, TRUE) == FAIL)
beep_flush();
else
{
curwin->w_cursor.col = temp;
redraw_later(VALID_TO_CURSCHAR);
}
}
else if (del_char(FALSE) == FAIL)/* delete char under cursor */
beep_flush();
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
AppendCharToRedobuff(K_DEL);
}
/*
* Handle Backspace, delete-word and delete-line in Insert mode.
* Return TRUE when backspace was actually used.
*/
static int
ins_bs(c, mode, inserted_space_p)
int c;
int mode;
int *inserted_space_p;
{
linenr_t lnum;
int cc;
int temp = 0; /* init for GCC */
colnr_t mincol;
int did_backspace = FALSE;
int in_indent;
/*
* can't delete anything in an empty file
* can't backup past first character in buffer
* can't backup past starting point unless 'backspace' > 1
* can backup to a previous line if 'backspace' == 0
*/
if ( bufempty()
|| (
#ifdef RIGHTLEFT
!revins_on &&
#endif
((curwin->w_cursor.lnum == 1 && curwin->w_cursor.col <= 0)
|| (p_bs < 2
&& (arrow_used
|| (curwin->w_cursor.lnum == Insstart.lnum
&& curwin->w_cursor.col <= Insstart.col)
|| (curwin->w_cursor.col <= 0 && p_bs == 0))))))
{
beep_flush();
return FALSE;
}
stop_arrow();
in_indent = inindent(0);
#ifdef CINDENT
if (in_indent)
can_cindent = FALSE;
#endif
#ifdef RIGHTLEFT
if (revins_on) /* put cursor after last inserted char */
inc_cursor();
#endif
/*
* delete newline!
*/
if (curwin->w_cursor.col <= 0)
{
lnum = Insstart.lnum;
if (curwin->w_cursor.lnum == Insstart.lnum
#ifdef RIGHTLEFT
|| revins_on
#endif
)
{
if (u_save((linenr_t)(curwin->w_cursor.lnum - 2),
(linenr_t)(curwin->w_cursor.lnum + 1)) == FAIL)
return FALSE;
--Insstart.lnum;
Insstart.col = 0;
}
/*
* In replace mode:
* cc < 0: NL was inserted, delete it
* cc >= 0: NL was replaced, put original characters back
*/
cc = -1;
if (State == REPLACE)
cc = replace_pop(); /* returns -1 if NL was inserted */
/*
* In replace mode, in the line we started replacing, we only move the
* cursor.
*/
if (State != REPLACE || curwin->w_cursor.lnum > lnum)
{
temp = gchar_cursor(); /* remember current char */
--curwin->w_cursor.lnum;
(void)do_join(FALSE, TRUE);
redraw_later(VALID_TO_CURSCHAR);
if (temp == NUL && gchar_cursor() != NUL)
++curwin->w_cursor.col;
/*
* In REPLACE mode we have to put back the text that was replace
* by the NL. On the replace stack is first a NUL-terminated
* sequence of characters that were deleted and then the
* characters that NL replaced.
*/
if (State == REPLACE)
{
/*
* Do the next ins_char() in NORMAL state, to
* prevent ins_char() from replacing characters and
* avoiding showmatch().
*/
State = NORMAL;
/*
* restore characters (blanks) deleted after cursor
*/
while (cc > 0)
{
temp = curwin->w_cursor.col;
ins_char(cc);
curwin->w_cursor.col = temp;
cc = replace_pop();
}
/* restore the characters that NL replaced */
replace_pop_ins(); /* will set State back to REPLACE */
}
}
else
dec_cursor();
did_ai = FALSE;
}
else
{
/*
* Delete character(s) before the cursor.
*/
#ifdef RIGHTLEFT
if (revins_on) /* put cursor on last inserted char */
dec_cursor();
#endif
mincol = 0;
/* keep indent */
if (mode == BACKSPACE_LINE && curbuf->b_p_ai
#ifdef RIGHTLEFT
&& !revins_on
#endif
)
{
temp = curwin->w_cursor.col;
beginline(BL_WHITE);
if (curwin->w_cursor.col < (colnr_t)temp)
mincol = curwin->w_cursor.col;
curwin->w_cursor.col = temp;
}
/*
* Handle deleting one 'shiftwidth' or 'softtabstop'.
*/
if ( mode == BACKSPACE_CHAR
&& ((p_sta && in_indent)
|| (curbuf->b_p_sts
&& (*(ml_get_cursor() - 1) == TAB
|| (*(ml_get_cursor() - 1) == ' '
&& (!*inserted_space_p
|| arrow_used))))))
{
int ts;
colnr_t vcol;
int want_vcol;
int extra = 0;
*inserted_space_p = FALSE;
if (p_sta)
ts = curbuf->b_p_sw;
else
ts = curbuf->b_p_sts;
/* compute the virtual column where we want to be */
getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
want_vcol = ((vcol - 1) / ts) * ts;
/* delete characters until we are at or before want_vcol */
while ((int)vcol > want_vcol
&& (cc = *(ml_get_cursor() - 1), vim_iswhite(cc)))
{
dec_cursor();
/* TODO: calling getvcol() each time is slow */
getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
if (State == REPLACE)
{
/* don't delete characters before the insert point when in
* Replace mode */
if (curwin->w_cursor.lnum != Insstart.lnum
|| curwin->w_cursor.col >= Insstart.col)
{
if ((int)vcol < want_vcol)
{
(void)del_char(FALSE);
extra = 2; /* don't pop too much */
}
else
replace_do_bs();
}
}
else
(void)del_char(FALSE);
}
/* insert extra spaces until we are at want_vcol */
while ((int)vcol < want_vcol)
{
ins_str((char_u *)" ");
if (State == REPLACE && extra <= 1)
{
if (extra)
replace_push_off(NUL);
else
replace_push(NUL);
}
getvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
if (extra == 2)
extra = 1;
}
}
/*
* Delete upto starting point, start of line or previous word.
*/
else do
{
#ifdef RIGHTLEFT
if (!revins_on) /* put cursor on char to be deleted */
#endif
dec_cursor();
/* start of word? */
if (mode == BACKSPACE_WORD && !vim_isspace(gchar_cursor()))
{
mode = BACKSPACE_WORD_NOT_SPACE;
temp = vim_iswordc(gchar_cursor());
}
/* end of word? */
else if (mode == BACKSPACE_WORD_NOT_SPACE
&& (vim_isspace(cc = gchar_cursor())
|| vim_iswordc(cc) != temp))
{
#ifdef RIGHTLEFT
if (!revins_on)
#endif
inc_cursor();
#ifdef RIGHTLEFT
else if (State == REPLACE)
dec_cursor();
#endif
break;
}
if (State == REPLACE)
replace_do_bs();
else /* State != REPLACE */
{
(void)del_char(FALSE);
#ifdef RIGHTLEFT
if (revins_chars)
{
revins_chars--;
revins_legal++;
}
if (revins_on && gchar_cursor() == NUL)
break;
#endif
}
/* Just a single backspace?: */
if (mode == BACKSPACE_CHAR)
break;
} while (
#ifdef RIGHTLEFT
revins_on ||
#endif
(curwin->w_cursor.col > mincol &&
(curwin->w_cursor.lnum != Insstart.lnum ||
curwin->w_cursor.col != Insstart.col)));
did_backspace = TRUE;
}
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
if (curwin->w_cursor.col <= 1)
did_ai = FALSE;
/*
* It's a little strange to put backspaces into the redo
* buffer, but it makes auto-indent a lot easier to deal
* with.
*/
AppendCharToRedobuff(c);
/* If deleted before the insertion point, adjust it */
if (curwin->w_cursor.lnum == Insstart.lnum
&& curwin->w_cursor.col < Insstart.col)
Insstart.col = curwin->w_cursor.col;
return did_backspace;
}
#ifdef USE_MOUSE
static void
ins_mouse(c)
int c;
{
FPOS tpos;
# ifdef USE_GUI
/* When GUI is active, also move/paste when 'mouse' is empty */
if (!gui.in_use)
# endif
if (!mouse_has(MOUSE_INSERT))
return;
undisplay_dollar();
tpos = curwin->w_cursor;
if (do_mouse(NULL, c, BACKWARD, 1L, 0))
{
start_arrow(&tpos);
# ifdef CINDENT
can_cindent = TRUE;
# endif
}
/* redraw status lines (in case another window became active) */
redraw_statuslines();
}
#endif
#ifdef USE_GUI
void
ins_scroll()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if (gui_do_scroll())
{
start_arrow(&tpos);
# ifdef CINDENT
can_cindent = TRUE;
# endif
}
}
void
ins_horscroll()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if (gui_do_horiz_scroll())
{
start_arrow(&tpos);
#ifdef CINDENT
can_cindent = TRUE;
#endif
}
}
#endif
static void
ins_left()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if (oneleft() == OK)
{
start_arrow(&tpos);
#ifdef RIGHTLEFT
/* If exit reversed string, position is fixed */
if (revins_scol != -1 && (int)curwin->w_cursor.col >= revins_scol)
revins_legal++;
revins_chars++;
#endif
}
/*
* if 'whichwrap' set for cursor in insert mode may go to
* previous line
*/
else if (vim_strchr(p_ww, '[') != NULL && curwin->w_cursor.lnum > 1)
{
start_arrow(&tpos);
--(curwin->w_cursor.lnum);
coladvance(MAXCOL);
curwin->w_set_curswant = TRUE; /* so we stay at the end */
}
else
beep_flush();
}
static void
ins_home()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if ((mod_mask & MOD_MASK_CTRL))
curwin->w_cursor.lnum = 1;
curwin->w_cursor.col = 0;
curwin->w_curswant = 0;
start_arrow(&tpos);
}
static void
ins_end()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if ((mod_mask & MOD_MASK_CTRL))
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
coladvance(MAXCOL);
curwin->w_curswant = MAXCOL;
start_arrow(&tpos);
}
static void
ins_s_left()
{
undisplay_dollar();
if (curwin->w_cursor.lnum > 1 || curwin->w_cursor.col > 0)
{
start_arrow(&curwin->w_cursor);
(void)bck_word(1L, 0, FALSE);
}
else
beep_flush();
}
static void
ins_right()
{
undisplay_dollar();
if (gchar_cursor() != NUL)
{
start_arrow(&curwin->w_cursor);
#ifdef MULTI_BYTE
if (is_dbcs)
{
char_u *p = ml_get_pos(&curwin->w_cursor);
if (IsLeadByte(p[0]) && p[1] != NUL)
++curwin->w_cursor.col;
}
#endif
curwin->w_set_curswant = TRUE;
++curwin->w_cursor.col;
#ifdef RIGHTLEFT
revins_legal++;
if (revins_chars)
revins_chars--;
#endif
}
/* if 'whichwrap' set for cursor in insert mode, may move the
* cursor to the next line */
else if (vim_strchr(p_ww, ']') != NULL
&& curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
{
start_arrow(&curwin->w_cursor);
curwin->w_set_curswant = TRUE;
++curwin->w_cursor.lnum;
curwin->w_cursor.col = 0;
}
else
beep_flush();
}
static void
ins_s_right()
{
undisplay_dollar();
if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count
|| gchar_cursor() != NUL)
{
start_arrow(&curwin->w_cursor);
(void)fwd_word(1L, 0, 0);
}
else
beep_flush();
}
static void
ins_up()
{
FPOS tpos;
linenr_t old_topline;
undisplay_dollar();
tpos = curwin->w_cursor;
old_topline = curwin->w_topline;
if (cursor_up(1L, TRUE) == OK)
{
if (old_topline != curwin->w_topline)
update_screen(VALID);
start_arrow(&tpos);
#ifdef CINDENT
can_cindent = TRUE;
#endif
}
else
beep_flush();
}
static void
ins_pageup()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if (onepage(BACKWARD, 1L) == OK)
{
start_arrow(&tpos);
#ifdef CINDENT
can_cindent = TRUE;
#endif
}
else
beep_flush();
}
static void
ins_down()
{
FPOS tpos;
linenr_t old_topline = curwin->w_topline;
undisplay_dollar();
tpos = curwin->w_cursor;
if (cursor_down(1L, TRUE) == OK)
{
if (old_topline != curwin->w_topline)
update_screen(VALID);
start_arrow(&tpos);
#ifdef CINDENT
can_cindent = TRUE;
#endif
}
else
beep_flush();
}
static void
ins_pagedown()
{
FPOS tpos;
undisplay_dollar();
tpos = curwin->w_cursor;
if (onepage(FORWARD, 1L) == OK)
{
start_arrow(&tpos);
#ifdef CINDENT
can_cindent = TRUE;
#endif
}
else
beep_flush();
}
/*
* Handle TAB in Insert or Replace mode.
* Return TRUE when the TAB needs to be inserted like a normal character.
*/
static int
ins_tab()
{
int i;
int temp;
if (Insstart_blank_vcol == MAXCOL && curwin->w_cursor.lnum == Insstart.lnum)
Insstart_blank_vcol = get_nolist_virtcol();
if (echeck_abbr(TAB + ABBR_OFF))
return FALSE;
i = inindent(0);
#ifdef CINDENT
if (i)
can_cindent = FALSE;
#endif
/*
* When nothing special, insert TAB like a normal character
*/
if (!curbuf->b_p_et && !(p_sta && i) && !curbuf->b_p_sts)
return TRUE;
stop_arrow();
did_ai = FALSE;
#ifdef SMARTINDENT
did_si = FALSE;
can_si = FALSE;
can_si_back = FALSE;
#endif
AppendToRedobuff((char_u *)"t");
if (p_sta && i) /* insert tab in indent */
{
if (State == REPLACE) /* delete a char first */
{
i = gchar_cursor();
if (i)
del_char(FALSE);
}
change_indent(INDENT_INC, 0, TRUE, i);
return FALSE;
}
/*
* p_et or p_sts is set: expand a tab into spaces
*/
if (curbuf->b_p_sts)
temp = (int)curbuf->b_p_sts;
else
temp = (int)curbuf->b_p_ts;
temp -= get_nolist_virtcol() % temp;
/*
* Insert the first space with ins_char(). It will delete one char in
* replace mode. Insert the rest with ins_str(); it will not delete any
* chars.
*/
ins_char(' ');
while (--temp)
{
ins_str((char_u *)" ");
if (State == REPLACE) /* no char replaced */
replace_push(NUL);
}
/*
* For 'softtabstop': Replace a number of spaces by a TAB, if possible.
*/
if (curbuf->b_p_sts && !curbuf->b_p_et)
{
char_u *ptr;
FPOS fpos;
colnr_t want_vcol, vcol, tab_vcol;
int did_change = FALSE;
int ts = curbuf->b_p_ts;
/* find first white before the cursor */
ptr = ml_get_cursor();
fpos = curwin->w_cursor;
while (fpos.col > 0 && vim_iswhite(ptr[-1]))
{
--fpos.col;
--ptr;
}
/* In Replace mode, don't change characters before the insert point. */
if (State == REPLACE && fpos.lnum == Insstart.lnum
&& fpos.col < Insstart.col)
{
ptr += Insstart.col - fpos.col;
fpos.col = Insstart.col;
}
/* compute virtual column numbers of first white and cursor */
getvcol(curwin, &fpos, &vcol, NULL, NULL);
getvcol(curwin, &curwin->w_cursor, &want_vcol, NULL, NULL);
/* use as many TABs as possible */
tab_vcol = (want_vcol / ts) * ts;
while (vcol < tab_vcol)
{
if (*ptr != TAB)
{
*ptr = TAB;
did_change = TRUE;
}
++fpos.col;
++ptr;
vcol = ((vcol + ts) / ts) * ts;
}
if (did_change)
{
/* may need to delete a number of the following spaces */
i = want_vcol - vcol;
ptr += i;
fpos.col += i;
i = curwin->w_cursor.col - fpos.col;
if (i > 0)
{
mch_memmove(ptr, ptr + i, STRLEN(ptr + i) + 1);
/* correct replace stack. */
if (State == REPLACE)
for (temp = i; --temp >= 0; )
replace_join(want_vcol - vcol);
}
curwin->w_cursor.col -= i;
}
}
return FALSE;
}
/*
* Handle CR or NL in insert mode.
* Return TRUE when out of memory.
*/
static int
ins_eol(c)
int c;
{
int i;
if (echeck_abbr(c + ABBR_OFF))
return FALSE;
stop_arrow();
/*
* Strange Vi behaviour: In Replace mode, typing a NL will not delete the
* character under the cursor. Only push a NUL on the replace stack,
* nothing to put back when the NL is deleted.
*/
if (State == REPLACE)
replace_push(NUL);
#ifdef RIGHTLEFT
# ifdef FKMAP
if (p_altkeymap && p_fkmap)
fkmap(NL);
# endif
/* NL in reverse insert will allways start in the end of
* current line. */
if (revins_on)
while (gchar_cursor() != NUL)
++curwin->w_cursor.col;
#endif
AppendToRedobuff(NL_STR);
if (has_format_option(FO_RET_COMS))
fo_do_comments = TRUE;
i = open_line(FORWARD, TRUE, FALSE, old_indent);
old_indent = 0;
fo_do_comments = FALSE;
#ifdef CINDENT
can_cindent = TRUE;
#endif
return (!i);
}
#ifdef DIGRAPHS
/*
* Handle digraph in insert mode.
* Returns character still to be inserted, or NUL when nothing remaining to be
* done.
*/
static int
ins_digraph()
{
int c;
int cc;
if (redrawing() && !char_avail())
{
edit_putchar('?', TRUE);
#ifdef SHOWCMD
add_to_showcmd_c(Ctrl('K'));
#endif
}
#ifdef USE_GUI_WIN32
dont_scroll = TRUE; /* disallow scrolling here */
#endif
/* don't map the digraph chars. This also prevents the
* mode message to be deleted when ESC is hit */
++no_mapping;
++allow_keys;
c = vgetc();
--no_mapping;
--allow_keys;
if (IS_SPECIAL(c) || mod_mask) /* special key */
{
#ifdef SHOWCMD
clear_showcmd();
#endif
insert_special(c, TRUE, FALSE);
return NUL;
}
if (c != ESC)
{
if (redrawing() && !char_avail())
{
if (charsize(c) == 1)
edit_putchar(c, TRUE);
#ifdef SHOWCMD
add_to_showcmd_c(c);
#endif
}
++no_mapping;
++allow_keys;
cc = vgetc();
--no_mapping;
--allow_keys;
if (cc != ESC)
{
AppendToRedobuff((char_u *)"26"); /* CTRL-V */
c = getdigraph(c, cc, TRUE);
#ifdef SHOWCMD
clear_showcmd();
#endif
return c;
}
}
#ifdef SHOWCMD
clear_showcmd();
#endif
return NUL;
}
#endif
/*
* Handle CTRL-E and CTRL-Y in Insert mode: copy char from other line.
* Returns the char to be inserted, or NUL if none found.
*/
static int
ins_copychar(lnum)
linenr_t lnum;
{
int c;
int temp;
char_u *ptr;
if (lnum < 1 || lnum > curbuf->b_ml.ml_line_count)
{
beep_flush();
return NUL;
}
/* try to advance to the cursor column */
temp = 0;
ptr = ml_get(lnum);
validate_virtcol();
while ((colnr_t)temp < curwin->w_virtcol && *ptr)
temp += lbr_chartabsize(ptr++, (colnr_t)temp);
if ((colnr_t)temp > curwin->w_virtcol)
--ptr;
if ((c = *ptr) == NUL)
beep_flush();
return c;
}
#ifdef SMARTINDENT
/*
* Try to do some very smart auto-indenting.
* Used when inserting a "normal" character.
*/
static void
ins_try_si(c)
int c;
{
FPOS *pos, old_pos;
char_u *ptr;
int i;
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;
set_indent(i, TRUE);
}
else if (curwin->w_cursor.col > 0)
{
/*
* 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)
{
old_pos = curwin->w_cursor;
i = get_indent();
while (curwin->w_cursor.lnum > 1)
{
ptr = skipwhite(ml_get(--(curwin->w_cursor.lnum)));
/* 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);
}
}
/*
* 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();
set_indent(0, TRUE);
}
}
#endif
/*
* Get the value that w_virtcol would have when 'list' is off.
* Unless 'cpo' contains the 'L' flag.
*/
static colnr_t
get_nolist_virtcol()
{
colnr_t virtcol;
if (curwin->w_p_list && vim_strchr(p_cpo, CPO_LISTWM) == NULL)
{
curwin->w_p_list = FALSE;
getvcol(curwin, &curwin->w_cursor, NULL, &virtcol, NULL);
curwin->w_p_list = TRUE;
return virtcol;
}
validate_virtcol();
return curwin->w_virtcol;
}