IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactor: format with uncrustify #15726

Browse Source
This commit is contained in:
dundargoc 2021-09-20 15:53:38 +02:00 committed by GitHub
parent 490e09c6d8
commit 30fefee684
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
10 changed files with 2210 additions and 2116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

64
src/nvim/debugger.c
View File

@ -60,9 +60,9 @@ void do_debug(char_u *cmd)
int save_ignore_script = 0; int save_ignore_script = 0;
int save_ex_normal_busy; int save_ex_normal_busy;
int n; int n;
char_u *cmdline = NULL; char_u *cmdline = NULL;
char_u *p; char_u *p;
char *tail = NULL; char *tail = NULL;
static int last_cmd = 0; static int last_cmd = 0;
#define CMD_CONT 1 #define CMD_CONT 1
#define CMD_NEXT 2 #define CMD_NEXT 2
@ -145,13 +145,16 @@ void do_debug(char_u *cmd)
p = skipwhite(cmdline); p = skipwhite(cmdline);
if (*p != NUL) { if (*p != NUL) {
switch (*p) { switch (*p) {
case 'c': last_cmd = CMD_CONT; case 'c':
last_cmd = CMD_CONT;
tail = "ont"; tail = "ont";
break; break;
case 'n': last_cmd = CMD_NEXT; case 'n':
last_cmd = CMD_NEXT;
tail = "ext"; tail = "ext";
break; break;
case 's': last_cmd = CMD_STEP; case 's':
last_cmd = CMD_STEP;
tail = "tep"; tail = "tep";
break; break;
case 'f': case 'f':
@ -164,10 +167,12 @@ void do_debug(char_u *cmd)
tail = "inish"; tail = "inish";
} }
break; break;
case 'q': last_cmd = CMD_QUIT; case 'q':
last_cmd = CMD_QUIT;
tail = "uit"; tail = "uit";
break; break;
case 'i': last_cmd = CMD_INTERRUPT; case 'i':
last_cmd = CMD_INTERRUPT;
tail = "nterrupt"; tail = "nterrupt";
break; break;
case 'b': case 'b':
@ -190,7 +195,8 @@ void do_debug(char_u *cmd)
last_cmd = CMD_DOWN; last_cmd = CMD_DOWN;
tail = "own"; tail = "own";
break; break;
default: last_cmd = 0; default:
last_cmd = 0;
} }
if (last_cmd != 0) { if (last_cmd != 0) {
// Check that the tail matches. // Check that the tail matches.
@ -366,7 +372,7 @@ void ex_debug(exarg_T *eap)
debug_break_level = debug_break_level_save; debug_break_level = debug_break_level_save;
} }
static char_u *debug_breakpoint_name = NULL; static char_u *debug_breakpoint_name = NULL;
static linenr_T debug_breakpoint_lnum; static linenr_T debug_breakpoint_lnum;
/// When debugging or a breakpoint is set on a skipped command, no debug prompt /// When debugging or a breakpoint is set on a skipped command, no debug prompt
@ -375,7 +381,7 @@ static linenr_T debug_breakpoint_lnum;
/// a skipped command decides itself that a debug prompt should be displayed, it /// a skipped command decides itself that a debug prompt should be displayed, it
/// can do so by calling dbg_check_skipped(). /// can do so by calling dbg_check_skipped().
static int debug_skipped; static int debug_skipped;
static char_u *debug_skipped_name; static char_u *debug_skipped_name;
/// Go to debug mode when a breakpoint was encountered or "ex_nesting_level" is /// Go to debug mode when a breakpoint was encountered or "ex_nesting_level" is
/// at or below the break level. But only when the line is actually /// at or below the break level. But only when the line is actually
@ -384,7 +390,7 @@ static char_u *debug_skipped_name;
/// Called from do_one_cmd() before executing a command. /// Called from do_one_cmd() before executing a command.
void dbg_check_breakpoint(exarg_T *eap) void dbg_check_breakpoint(exarg_T *eap)
{ {
char_u *p; char_u *p;
debug_skipped = false; debug_skipped = false;
if (debug_breakpoint_name != NULL) { if (debug_breakpoint_name != NULL) {
@ -474,8 +480,8 @@ static typval_T *eval_expr_no_emsg(struct debuggy *const bp)
/// @param gap either &dbg_breakp or &prof_ga /// @param gap either &dbg_breakp or &prof_ga
static int dbg_parsearg(char_u *arg, garray_T *gap) static int dbg_parsearg(char_u *arg, garray_T *gap)
{ {
char_u *p = arg; char_u *p = arg;
char_u *q; char_u *q;
struct debuggy *bp; struct debuggy *bp;
bool here = false; bool here = false;
@ -559,7 +565,7 @@ static int dbg_parsearg(char_u *arg, garray_T *gap)
void ex_breakadd(exarg_T *eap) void ex_breakadd(exarg_T *eap)
{ {
struct debuggy *bp; struct debuggy *bp;
garray_T *gap; garray_T *gap;
gap = &dbg_breakp; gap = &dbg_breakp;
if (eap->cmdidx == CMD_profile) { if (eap->cmdidx == CMD_profile) {
@ -614,7 +620,7 @@ void ex_breakdel(exarg_T *eap)
int todel = -1; int todel = -1;
bool del_all = false; bool del_all = false;
linenr_T best_lnum = 0; linenr_T best_lnum = 0;
garray_T *gap; garray_T *gap;
gap = &dbg_breakp; gap = &dbg_breakp;
if (eap->cmdidx == CMD_profdel) { if (eap->cmdidx == CMD_profdel) {
@ -712,12 +718,10 @@ void ex_breaklist(exarg_T *eap)
/// Find a breakpoint for a function or sourced file. /// Find a breakpoint for a function or sourced file.
/// Returns line number at which to break; zero when no matching breakpoint. /// Returns line number at which to break; zero when no matching breakpoint.
linenr_T linenr_T dbg_find_breakpoint(bool file, // true for a file, false for a function
dbg_find_breakpoint( char_u *fname, // file or function name
bool file, // true for a file, false for a function linenr_T after // after this line number
char_u *fname, // file or function name )
linenr_T after // after this line number
)
{ {
return debuggy_find(file, fname, after, &dbg_breakp, NULL); return debuggy_find(file, fname, after, &dbg_breakp, NULL);
} }
@ -734,18 +738,16 @@ bool has_profiling(bool file, char_u *fname, bool *fp)
} }
/// Common code for dbg_find_breakpoint() and has_profiling(). /// Common code for dbg_find_breakpoint() and has_profiling().
static linenr_T static linenr_T debuggy_find(bool file, // true for a file, false for a function
debuggy_find( char_u *fname, // file or function name
bool file, // true for a file, false for a function linenr_T after, // after this line number
char_u *fname, // file or function name garray_T *gap, // either &dbg_breakp or &prof_ga
linenr_T after, // after this line number bool *fp // if not NULL: return forceit
garray_T *gap, // either &dbg_breakp or &prof_ga )
bool *fp // if not NULL: return forceit
)
{ {
struct debuggy *bp; struct debuggy *bp;
linenr_T lnum = 0; linenr_T lnum = 0;
char_u *name = fname; char_u *name = fname;
int prev_got_int; int prev_got_int;
// Return quickly when there are no breakpoints. // Return quickly when there are no breakpoints.

32
src/nvim/decoration.c
View File

@ -1,13 +1,13 @@
// This is an open source non-commercial project. Dear PVS-Studio, please check // This is an open source non-commercial project. Dear PVS-Studio, please check
// it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com // it. PVS-Studio Static Code Analyzer for C, C++ and C#: http://www.viva64.com
#include "nvim/vim.h"
#include "nvim/lua/executor.h"
#include "nvim/extmark.h"
#include "nvim/decoration.h" #include "nvim/decoration.h"
#include "nvim/extmark.h"
#include "nvim/highlight.h"
#include "nvim/lua/executor.h"
#include "nvim/screen.h" #include "nvim/screen.h"
#include "nvim/syntax.h" #include "nvim/syntax.h"
#include "nvim/highlight.h" #include "nvim/vim.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
# include "decoration.c.generated.h" # include "decoration.c.generated.h"
@ -28,11 +28,7 @@ static PMap(uint64_t) hl_decors;
/// @param pos_start Cursor position to start the highlighting at /// @param pos_start Cursor position to start the highlighting at
/// @param pos_end Cursor position to end the highlighting at /// @param pos_end Cursor position to end the highlighting at
/// @param offset Move the whole highlighting this many columns to the right /// @param offset Move the whole highlighting this many columns to the right
void bufhl_add_hl_pos_offset(buf_T *buf, void bufhl_add_hl_pos_offset(buf_T *buf, int src_id, int hl_id, lpos_T pos_start, lpos_T pos_end,
int src_id,
int hl_id,
lpos_T pos_start,
lpos_T pos_end,
colnr_T offset) colnr_T offset)
{ {
colnr_T hl_start = 0; colnr_T hl_start = 0;
@ -172,7 +168,7 @@ bool decor_redraw_start(buf_T *buf, int top_row, DecorState *state)
ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index, ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index,
start_id, false); start_id, false);
if (!item || !item->decor) { if (!item || !item->decor) {
// TODO(bfredl): dedicated flag for being a decoration? // TODO(bfredl): dedicated flag for being a decoration?
goto next_mark; goto next_mark;
} }
Decoration *decor = item->decor; Decoration *decor = item->decor;
@ -217,14 +213,14 @@ bool decor_redraw_line(buf_T *buf, int row, DecorState *state)
return true; // TODO(bfredl): be more precise return true; // TODO(bfredl): be more precise
} }
static void decor_add(DecorState *state, int start_row, int start_col, static void decor_add(DecorState *state, int start_row, int start_col, int end_row, int end_col,
int end_row, int end_col, Decoration *decor, bool owned) Decoration *decor, bool owned)
{ {
int attr_id = decor->hl_id > 0 ? syn_id2attr(decor->hl_id) : 0; int attr_id = decor->hl_id > 0 ? syn_id2attr(decor->hl_id) : 0;
DecorRange range = { start_row, start_col, end_row, end_col, DecorRange range = { start_row, start_col, end_row, end_col,
*decor, attr_id, *decor, attr_id,
kv_size(decor->virt_text) && owned, -1 }; kv_size(decor->virt_text) && owned, -1 };
kv_pushp(state->active); kv_pushp(state->active);
size_t index; size_t index;
@ -238,8 +234,7 @@ static void decor_add(DecorState *state, int start_row, int start_col,
kv_A(state->active, index) = range; kv_A(state->active, index) = range;
} }
int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden, int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden, DecorState *state)
DecorState *state)
{ {
if (col <= state->col_until) { if (col <= state->col_until) {
return state->current; return state->current;
@ -257,7 +252,7 @@ int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden,
} }
if ((mark.id&MARKTREE_END_FLAG)) { if ((mark.id&MARKTREE_END_FLAG)) {
// TODO(bfredl): check decoration flag // TODO(bfredl): check decoration flag
goto next_mark; goto next_mark;
} }
mtpos_t endpos = marktree_lookup(buf->b_marktree, mtpos_t endpos = marktree_lookup(buf->b_marktree,
@ -266,7 +261,7 @@ int decor_redraw_col(buf_T *buf, int col, int win_col, bool hidden,
ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index, ExtmarkItem *item = map_ref(uint64_t, ExtmarkItem)(buf->b_extmark_index,
mark.id, false); mark.id, false);
if (!item || !item->decor) { if (!item || !item->decor) {
// TODO(bfredl): dedicated flag for being a decoration? // TODO(bfredl): dedicated flag for being a decoration?
goto next_mark; goto next_mark;
} }
Decoration *decor = item->decor; Decoration *decor = item->decor;
@ -355,8 +350,7 @@ bool decor_redraw_eol(buf_T *buf, DecorState *state, int *eol_attr, int eol_col)
return has_virttext; return has_virttext;
} }
void decor_add_ephemeral(int start_row, int start_col, int end_row, int end_col, void decor_add_ephemeral(int start_row, int start_col, int end_row, int end_col, Decoration *decor)
Decoration *decor)
{ {
if (end_row == -1) { if (end_row == -1) {
end_row = start_row; end_row = start_row;

114
src/nvim/diff.c
View File

@ -13,14 +13,12 @@
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include "nvim/vim.h"
#include "xdiff/xdiff.h"
#include "nvim/ascii.h" #include "nvim/ascii.h"
#include "nvim/diff.h"
#include "nvim/buffer.h" #include "nvim/buffer.h"
#include "nvim/change.h" #include "nvim/change.h"
#include "nvim/charset.h" #include "nvim/charset.h"
#include "nvim/cursor.h" #include "nvim/cursor.h"
#include "nvim/diff.h"
#include "nvim/eval.h" #include "nvim/eval.h"
#include "nvim/ex_cmds.h" #include "nvim/ex_cmds.h"
#include "nvim/ex_docmd.h" #include "nvim/ex_docmd.h"
@ -29,19 +27,21 @@
#include "nvim/mark.h" #include "nvim/mark.h"
#include "nvim/mbyte.h" #include "nvim/mbyte.h"
#include "nvim/memline.h" #include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/message.h" #include "nvim/message.h"
#include "nvim/misc1.h" #include "nvim/misc1.h"
#include "nvim/memory.h"
#include "nvim/move.h" #include "nvim/move.h"
#include "nvim/normal.h" #include "nvim/normal.h"
#include "nvim/option.h" #include "nvim/option.h"
#include "nvim/os/os.h"
#include "nvim/os/shell.h"
#include "nvim/path.h" #include "nvim/path.h"
#include "nvim/screen.h" #include "nvim/screen.h"
#include "nvim/strings.h" #include "nvim/strings.h"
#include "nvim/undo.h" #include "nvim/undo.h"
#include "nvim/vim.h"
#include "nvim/window.h" #include "nvim/window.h"
#include "nvim/os/os.h" #include "xdiff/xdiff.h"
#include "nvim/os/shell.h"
static int diff_busy = false; // using diff structs, don't change them static int diff_busy = false; // using diff structs, don't change them
static bool diff_need_update = false; // ex_diffupdate needs to be called static bool diff_need_update = false; // ex_diffupdate needs to be called
@ -72,22 +72,22 @@ static TriState diff_a_works = kNone;
// used for diff input // used for diff input
typedef struct { typedef struct {
char_u *din_fname; // used for external diff char_u *din_fname; // used for external diff
mmfile_t din_mmfile; // used for internal diff mmfile_t din_mmfile; // used for internal diff
} diffin_T; } diffin_T;
// used for diff result // used for diff result
typedef struct { typedef struct {
char_u *dout_fname; // used for external diff char_u *dout_fname; // used for external diff
garray_T dout_ga; // used for internal diff garray_T dout_ga; // used for internal diff
} diffout_T; } diffout_T;
// two diff inputs and one result // two diff inputs and one result
typedef struct { typedef struct {
diffin_T dio_orig; // original file input diffin_T dio_orig; // original file input
diffin_T dio_new; // new file input diffin_T dio_new; // new file input
diffout_T dio_diff; // diff result diffout_T dio_diff; // diff result
int dio_internal; // using internal diff int dio_internal; // using internal diff
} diffio_T; } diffio_T;
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
@ -119,7 +119,6 @@ void diff_buf_delete(buf_T *buf)
/// @param win /// @param win
void diff_buf_adjust(win_T *win) void diff_buf_adjust(win_T *win)
{ {
if (!win->w_p_diff) { if (!win->w_p_diff) {
// When there is no window showing a diff for this buffer, remove // When there is no window showing a diff for this buffer, remove
// it from the diffs. // it from the diffs.
@ -242,8 +241,7 @@ void diff_invalidate(buf_T *buf)
/// @param line2 /// @param line2
/// @param amount /// @param amount
/// @param amount_after /// @param amount_after
void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount, void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount, long amount_after)
long amount_after)
{ {
// Handle all tab pages that use the current buffer in a diff. // Handle all tab pages that use the current buffer in a diff.
FOR_ALL_TABS(tp) { FOR_ALL_TABS(tp) {
@ -267,8 +265,8 @@ void diff_mark_adjust(linenr_T line1, linenr_T line2, long amount,
/// @param line2 /// @param line2
/// @param amount /// @param amount
/// @amount_after /// @amount_after
static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1, linenr_T line2, long amount,
linenr_T line2, long amount, long amount_after) long amount_after)
{ {
if (diff_internal()) { if (diff_internal()) {
// Will update diffs before redrawing. Set _invalid to update the // Will update diffs before redrawing. Set _invalid to update the
@ -299,7 +297,7 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
diff_T *dp = tp->tp_first_diff; diff_T *dp = tp->tp_first_diff;
linenr_T last; linenr_T last;
linenr_T lnum_deleted = line1; // lnum of remaining deletion linenr_T lnum_deleted = line1; // lnum of remaining deletion
int n; int n;
int off; int off;
for (;;) { for (;;) {
@ -323,8 +321,8 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
dnext->df_lnum[i] = line1; dnext->df_lnum[i] = line1;
} else { } else {
dnext->df_lnum[i] = line1 dnext->df_lnum[i] = line1
+ (dprev->df_lnum[i] + dprev->df_count[i]) + (dprev->df_lnum[i] + dprev->df_count[i])
- (dprev->df_lnum[idx] + dprev->df_count[idx]); - (dprev->df_lnum[idx] + dprev->df_count[idx]);
} }
dnext->df_count[i] = deleted; dnext->df_count[i] = deleted;
} }
@ -509,7 +507,7 @@ static void diff_mark_adjust_tp(tabpage_T *tp, int idx, linenr_T line1,
/// @param dp /// @param dp
/// ///
/// @return The new diff block. /// @return The new diff block.
static diff_T* diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp) static diff_T * diff_alloc_new(tabpage_T *tp, diff_T *dprev, diff_T *dp)
{ {
diff_T *dnew = xmalloc(sizeof(*dnew)); diff_T *dnew = xmalloc(sizeof(*dnew));
@ -705,9 +703,9 @@ static void clear_diffout(diffout_T *dout)
static int diff_write_buffer(buf_T *buf, diffin_T *din) static int diff_write_buffer(buf_T *buf, diffin_T *din)
{ {
linenr_T lnum; linenr_T lnum;
char_u *s; char_u *s;
long len = 0; long len = 0;
char_u *ptr; char_u *ptr;
// xdiff requires one big block of memory with all the text. // xdiff requires one big block of memory with all the text.
for (lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) { for (lnum = 1; lnum <= buf->b_ml.ml_line_count; lnum++) {
@ -789,9 +787,7 @@ static int diff_write(buf_T *buf, diffin_T *din)
/// @param dio /// @param dio
/// @param idx_orig /// @param idx_orig
/// @param eap can be NULL /// @param eap can be NULL
static void diff_try_update(diffio_T *dio, static void diff_try_update(diffio_T *dio, int idx_orig, exarg_T *eap)
int idx_orig,
exarg_T *eap)
{ {
buf_T *buf; buf_T *buf;
int idx_new; int idx_new;
@ -1090,9 +1086,9 @@ static int diff_file_internal(diffio_T *diffio)
/// @return OK or FAIL /// @return OK or FAIL
static int diff_file(diffio_T *dio) static int diff_file(diffio_T *dio)
{ {
char *tmp_orig = (char *)dio->dio_orig.din_fname; char *tmp_orig = (char *)dio->dio_orig.din_fname;
char *tmp_new = (char *)dio->dio_new.din_fname; char *tmp_new = (char *)dio->dio_new.din_fname;
char *tmp_diff = (char *)dio->dio_diff.dout_fname; char *tmp_diff = (char *)dio->dio_diff.dout_fname;
if (*p_dex != NUL) { if (*p_dex != NUL) {
// Use 'diffexpr' to generate the diff file. // Use 'diffexpr' to generate the diff file.
eval_diff(tmp_orig, tmp_new, tmp_diff); eval_diff(tmp_orig, tmp_new, tmp_diff);
@ -1123,9 +1119,9 @@ static int diff_file(diffio_T *dio)
(diff_flags & DIFF_IBLANK) ? "-B " : "", (diff_flags & DIFF_IBLANK) ? "-B " : "",
(diff_flags & DIFF_ICASE) ? "-i " : "", (diff_flags & DIFF_ICASE) ? "-i " : "",
tmp_orig, tmp_new); tmp_orig, tmp_new);
append_redir(cmd, len, (char *) p_srr, tmp_diff); append_redir(cmd, len, (char *)p_srr, tmp_diff);
block_autocmds(); // Avoid ShellCmdPost stuff block_autocmds(); // Avoid ShellCmdPost stuff
(void)call_shell((char_u *) cmd, (void)call_shell((char_u *)cmd,
kShellOptFilter | kShellOptSilent | kShellOptDoOut, kShellOptFilter | kShellOptSilent | kShellOptDoOut,
NULL); NULL);
unblock_autocmds(); unblock_autocmds();
@ -1171,8 +1167,8 @@ void ex_diffpatch(exarg_T *eap)
#ifdef UNIX #ifdef UNIX
// Get the absolute path of the patchfile, changing directory below. // Get the absolute path of the patchfile, changing directory below.
fullname = FullName_save((char *)eap->arg, false); fullname = FullName_save((char *)eap->arg, false);
esc_name = vim_strsave_shellescape( esc_name =
(fullname != NULL ? (char_u *)fullname : eap->arg), true, true); vim_strsave_shellescape((fullname != NULL ? (char_u *)fullname : eap->arg), true, true);
#else #else
esc_name = vim_strsave_shellescape(eap->arg, true, true); esc_name = vim_strsave_shellescape(eap->arg, true, true);
#endif #endif
@ -1324,8 +1320,8 @@ void ex_diffsplit(exarg_T *eap)
if (bufref_valid(&old_curbuf)) { if (bufref_valid(&old_curbuf)) {
// Move the cursor position to that of the old window. // Move the cursor position to that of the old window.
curwin->w_cursor.lnum = diff_get_corresponding_line( curwin->w_cursor.lnum = diff_get_corresponding_line(old_curbuf.br_buf,
old_curbuf.br_buf, old_curwin->w_cursor.lnum); old_curwin->w_cursor.lnum);
} }
} }
// Now that lines are folded scroll to show the cursor at the same // Now that lines are folded scroll to show the cursor at the same
@ -1344,15 +1340,15 @@ void ex_diffthis(exarg_T *eap)
static void set_diff_option(win_T *wp, int value) static void set_diff_option(win_T *wp, int value)
{ {
win_T *old_curwin = curwin; win_T *old_curwin = curwin;
curwin = wp; curwin = wp;
curbuf = curwin->w_buffer; curbuf = curwin->w_buffer;
curbuf->b_ro_locked++; curbuf->b_ro_locked++;
set_option_value("diff", (long)value, NULL, OPT_LOCAL); set_option_value("diff", (long)value, NULL, OPT_LOCAL);
curbuf->b_ro_locked--; curbuf->b_ro_locked--;
curwin = old_curwin; curwin = old_curwin;
curbuf = curwin->w_buffer; curbuf = curwin->w_buffer;
} }
@ -1724,8 +1720,7 @@ static void diff_read(int idx_orig, int idx_new, diffout_T *dout)
/// @param dp /// @param dp
/// @param idx_orig /// @param idx_orig
/// @param idx_new /// @param idx_new
static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, static void diff_copy_entry(diff_T *dprev, diff_T *dp, int idx_orig, int idx_new)
int idx_new)
{ {
long off; long off;
@ -1769,7 +1764,7 @@ void diff_clear(tabpage_T *tp)
/// @return diff status. /// @return diff status.
int diff_check(win_T *wp, linenr_T lnum) int diff_check(win_T *wp, linenr_T lnum)
{ {
int idx; // index in tp_diffbuf[] for this buffer int idx; // index in tp_diffbuf[] for this buffer
diff_T *dp; diff_T *dp;
int maxcount; int maxcount;
int i; int i;
@ -1912,8 +1907,7 @@ static bool diff_equal_entry(diff_T *dp, int idx1, int idx2)
// Compare the characters at "p1" and "p2". If they are equal (possibly // Compare the characters at "p1" and "p2". If they are equal (possibly
// ignoring case) return true and set "len" to the number of bytes. // ignoring case) return true and set "len" to the number of bytes.
static bool diff_equal_char(const char_u *const p1, const char_u *const p2, static bool diff_equal_char(const char_u *const p1, const char_u *const p2, int *const len)
int *const len)
{ {
const int l = utfc_ptr2len(p1); const int l = utfc_ptr2len(p1);
@ -2537,7 +2531,7 @@ void ex_diffgetput(exarg_T *eap)
if ((curtab->tp_diffbuf[i] != curbuf) if ((curtab->tp_diffbuf[i] != curbuf)
&& (curtab->tp_diffbuf[i] != NULL) && (curtab->tp_diffbuf[i] != NULL)
&& ((eap->cmdidx != CMD_diffput) && ((eap->cmdidx != CMD_diffput)
|| MODIFIABLE(curtab->tp_diffbuf[i]))) { || MODIFIABLE(curtab->tp_diffbuf[i]))) {
EMSG(_("E101: More than two buffers in diff mode, don't know " EMSG(_("E101: More than two buffers in diff mode, don't know "
"which one to use")); "which one to use"));
return; return;
@ -2958,7 +2952,7 @@ static linenr_T diff_get_corresponding_line_int(buf_T *buf1, linenr_T lnum1)
return curwin->w_cursor.lnum; return curwin->w_cursor.lnum;
} }
baseline = (dp->df_lnum[idx1] + dp->df_count[idx1]) baseline = (dp->df_lnum[idx1] + dp->df_count[idx1])
- (dp->df_lnum[idx2] + dp->df_count[idx2]); - (dp->df_lnum[idx2] + dp->df_count[idx2]);
} }
// If we get here then the cursor is after the last diff // If we get here then the cursor is after the last diff
@ -3035,11 +3029,8 @@ linenr_T diff_lnum_win(linenr_T lnum, win_T *wp)
/// Handle an ED style diff line. /// Handle an ED style diff line.
/// Return FAIL if the line does not contain diff info. /// Return FAIL if the line does not contain diff info.
/// ///
static int parse_diff_ed(char_u *line, static int parse_diff_ed(char_u *line, linenr_T *lnum_orig, long *count_orig, linenr_T *lnum_new,
linenr_T *lnum_orig, long *count_new)
long *count_orig,
linenr_T *lnum_new,
long *count_new)
{ {
char_u *p; char_u *p;
long f1, l1, f2, l2; long f1, l1, f2, l2;
@ -3093,11 +3084,8 @@ static int parse_diff_ed(char_u *line,
/// Parses unified diff with zero(!) context lines. /// Parses unified diff with zero(!) context lines.
/// Return FAIL if there is no diff information in "line". /// Return FAIL if there is no diff information in "line".
/// ///
static int parse_diff_unified(char_u *line, static int parse_diff_unified(char_u *line, linenr_T *lnum_orig, long *count_orig,
linenr_T *lnum_orig, linenr_T *lnum_new, long *count_new)
long *count_orig,
linenr_T *lnum_new,
long *count_new)
{ {
char_u *p; char_u *p;
long oldline, oldcount, newline, newcount; long oldline, oldcount, newline, newcount;
@ -3153,7 +3141,7 @@ static int parse_diff_unified(char_u *line,
static int xdiff_out(void *priv, mmbuffer_t *mb, int nbuf) static int xdiff_out(void *priv, mmbuffer_t *mb, int nbuf)
{ {
diffout_T *dout = (diffout_T *)priv; diffout_T *dout = (diffout_T *)priv;
char_u *p; char_u *p;
// The header line always comes by itself, text lines in at least two // The header line always comes by itself, text lines in at least two
// parts. We drop the text part. // parts. We drop the text part.

32
src/nvim/digraph.c
View File

@ -6,26 +6,26 @@
/// code for digraphs /// code for digraphs
#include <assert.h> #include <assert.h>
#include <stdbool.h>
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h>
#include "nvim/vim.h"
#include "nvim/ascii.h" #include "nvim/ascii.h"
#include "nvim/digraph.h"
#include "nvim/charset.h" #include "nvim/charset.h"
#include "nvim/digraph.h"
#include "nvim/ex_cmds2.h" #include "nvim/ex_cmds2.h"
#include "nvim/ex_docmd.h" #include "nvim/ex_docmd.h"
#include "nvim/ex_getln.h" #include "nvim/ex_getln.h"
#include "nvim/getchar.h"
#include "nvim/misc1.h"
#include "nvim/mbyte.h"
#include "nvim/message.h"
#include "nvim/memory.h"
#include "nvim/garray.h" #include "nvim/garray.h"
#include "nvim/getchar.h"
#include "nvim/mbyte.h"
#include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/misc1.h"
#include "nvim/normal.h" #include "nvim/normal.h"
#include "nvim/os/input.h"
#include "nvim/screen.h" #include "nvim/screen.h"
#include "nvim/strings.h" #include "nvim/strings.h"
#include "nvim/os/input.h" #include "nvim/vim.h"
typedef int result_T; typedef int result_T;
@ -40,7 +40,7 @@ typedef struct digraph {
# include "digraph.c.generated.h" # include "digraph.c.generated.h"
#endif #endif
// digraphs added by the user // digraphs added by the user
static garray_T user_digraphs = {0, 0, (int)sizeof(digr_T), 10, NULL}; static garray_T user_digraphs = { 0, 0, (int)sizeof(digr_T), 10, NULL };
/// Note: Characters marked with XX are not included literally, because some /// Note: Characters marked with XX are not included literally, because some
/// compilers cannot handle them (Amiga SAS/C is the most picky one). /// compilers cannot handle them (Amiga SAS/C is the most picky one).
@ -49,7 +49,7 @@ static digr_T digraphdefault[] =
// digraphs for Unicode from RFC1345 // digraphs for Unicode from RFC1345
// (also work for ISO-8859-1 aka latin1) // (also work for ISO-8859-1 aka latin1)
{ {
{ 'N', 'U', 0x0a }, // LF for NUL { 'N', 'U', 0x0a }, // LF for NUL
{ 'S', 'H', 0x01 }, { 'S', 'H', 0x01 },
{ 'S', 'X', 0x02 }, { 'S', 'X', 0x02 },
{ 'E', 'X', 0x03 }, { 'E', 'X', 0x03 },
@ -1452,12 +1452,12 @@ static digr_T digraphdefault[] =
/// @return The digraph. /// @return The digraph.
int do_digraph(int c) int do_digraph(int c)
{ {
static int backspaced; // character before K_BS static int backspaced; // character before K_BS
static int lastchar; // last typed character static int lastchar; // last typed character
if (c == -1) { // init values if (c == -1) { // init values
backspaced = -1; backspaced = -1;
} else if (p_dg) { } else if (p_dg) {
if (backspaced >= 0) { if (backspaced >= 0) {
c = getdigraph(backspaced, c, false); c = getdigraph(backspaced, c, false);
} }
@ -1557,7 +1557,7 @@ static int getexactdigraph(int char1, int char2, bool meta_char)
// Search user digraphs first. // Search user digraphs first.
digr_T *dp = (digr_T *)user_digraphs.ga_data; digr_T *dp = (digr_T *)user_digraphs.ga_data;
for (int i = 0; i < user_digraphs.ga_len; ++i) { for (int i = 0; i < user_digraphs.ga_len; ++i) {
if (((int) dp->char1 == char1) && ((int) dp->char2 == char2)) { if (((int)dp->char1 == char1) && ((int)dp->char2 == char2)) {
retval = dp->result; retval = dp->result;
break; break;
} }
@ -1569,7 +1569,7 @@ static int getexactdigraph(int char1, int char2, bool meta_char)
dp = digraphdefault; dp = digraphdefault;
for (int i = 0; dp->char1 != 0; ++i) { for (int i = 0; dp->char1 != 0; ++i) {
if (((int) dp->char1 == char1) && ((int) dp->char2 == char2)) { if (((int)dp->char1 == char1) && ((int)dp->char2 == char2)) {
retval = dp->result; retval = dp->result;
break; break;
} }
@ -1821,7 +1821,7 @@ typedef struct {
/// @return NULL if OK, an error message for failure. This only needs to be /// @return NULL if OK, an error message for failure. This only needs to be
/// used when setting the option, not later when the value has already /// used when setting the option, not later when the value has already
/// been checked. /// been checked.
char_u* keymap_init(void) char_u * keymap_init(void)
{ {
curbuf->b_kmap_state &= ~KEYMAP_INIT; curbuf->b_kmap_state &= ~KEYMAP_INIT;

2094
src/nvim/eval.c
View File

File diff suppressed because it is too large Load Diff

210
src/nvim/ex_cmds2.c
View File

@ -6,58 +6,58 @@
/// Some more functions for command line commands /// Some more functions for command line commands
#include <assert.h> #include <assert.h>
#include <fcntl.h>
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <string.h> #include <string.h>
#include <fcntl.h>
#include "nvim/vim.h"
#include "nvim/ascii.h" #include "nvim/ascii.h"
#include "nvim/vim.h"
#ifdef HAVE_LOCALE_H #ifdef HAVE_LOCALE_H
# include <locale.h> # include <locale.h>
#endif #endif
#include "nvim/ex_cmds2.h" #include "nvim/api/private/defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/buffer.h" #include "nvim/buffer.h"
#include "nvim/change.h" #include "nvim/change.h"
#include "nvim/charset.h" #include "nvim/charset.h"
#include "nvim/debugger.h" #include "nvim/debugger.h"
#include "nvim/eval/userfunc.h" #include "nvim/eval/userfunc.h"
#include "nvim/ex_cmds.h" #include "nvim/ex_cmds.h"
#include "nvim/ex_cmds2.h"
#include "nvim/ex_eval.h" #include "nvim/ex_eval.h"
#include "nvim/ex_getln.h" #include "nvim/ex_getln.h"
#include "nvim/fileio.h" #include "nvim/fileio.h"
#include "nvim/garray.h"
#include "nvim/lua/executor.h"
#include "nvim/mark.h" #include "nvim/mark.h"
#include "nvim/mbyte.h" #include "nvim/mbyte.h"
#include "nvim/memline.h" #include "nvim/memline.h"
#include "nvim/memory.h"
#include "nvim/message.h" #include "nvim/message.h"
#include "nvim/misc1.h" #include "nvim/misc1.h"
#include "nvim/garray.h"
#include "nvim/memory.h"
#include "nvim/move.h" #include "nvim/move.h"
#include "nvim/normal.h" #include "nvim/normal.h"
#include "nvim/ops.h" #include "nvim/ops.h"
#include "nvim/option.h" #include "nvim/option.h"
#include "nvim/os/fs_defs.h"
#include "nvim/os/shell.h"
#include "nvim/os_unix.h" #include "nvim/os_unix.h"
#include "nvim/path.h" #include "nvim/path.h"
#include "nvim/profile.h"
#include "nvim/quickfix.h" #include "nvim/quickfix.h"
#include "nvim/regexp.h" #include "nvim/regexp.h"
#include "nvim/strings.h" #include "nvim/strings.h"
#include "nvim/undo.h" #include "nvim/undo.h"
#include "nvim/version.h" #include "nvim/version.h"
#include "nvim/window.h" #include "nvim/window.h"
#include "nvim/profile.h"
#include "nvim/os/shell.h"
#include "nvim/os/fs_defs.h"
#include "nvim/api/private/helpers.h"
#include "nvim/api/private/defs.h"
#include "nvim/lua/executor.h"
/// Growarray to store info about already sourced scripts. /// Growarray to store info about already sourced scripts.
/// Also store the dev/ino, so that we don't have to stat() each /// Also store the dev/ino, so that we don't have to stat() each
/// script when going through the list. /// script when going through the list.
typedef struct scriptitem_S { typedef struct scriptitem_S {
char_u *sn_name; char_u *sn_name;
bool file_id_valid; bool file_id_valid;
FileID file_id; FileID file_id;
bool sn_prof_on; ///< true when script is/was profiled bool sn_prof_on; ///< true when script is/was profiled
@ -115,14 +115,14 @@ struct source_cookie {
# include "ex_cmds2.c.generated.h" # include "ex_cmds2.c.generated.h"
#endif #endif
static char_u *profile_fname = NULL; static char_u *profile_fname = NULL;
/// ":profile cmd args" /// ":profile cmd args"
void ex_profile(exarg_T *eap) void ex_profile(exarg_T *eap)
{ {
static proftime_T pause_time; static proftime_T pause_time;
char_u *e; char_u *e;
int len; int len;
e = skiptowhite(eap->arg); e = skiptowhite(eap->arg);
@ -277,7 +277,7 @@ void set_context_in_profile_cmd(expand_T *xp, const char *arg)
/// Dump the profiling info. /// Dump the profiling info.
void profile_dump(void) void profile_dump(void)
{ {
FILE *fd; FILE *fd;
if (profile_fname != NULL) { if (profile_fname != NULL) {
fd = os_fopen((char *)profile_fname, "w"); fd = os_fopen((char *)profile_fname, "w");
@ -362,11 +362,11 @@ static void profile_init(scriptitem_T *si)
} }
/// Save time when starting to invoke another script or function. /// Save time when starting to invoke another script or function.
void script_prof_save( ///
proftime_T *tm // place to store wait time /// @param tm place to store wait time
) void script_prof_save(proftime_T *tm)
{ {
scriptitem_T *si; scriptitem_T *si;
if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len) { if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len) {
si = &SCRIPT_ITEM(current_sctx.sc_sid); si = &SCRIPT_ITEM(current_sctx.sc_sid);
@ -380,7 +380,7 @@ void script_prof_save(
/// Count time spent in children after invoking another script or function. /// Count time spent in children after invoking another script or function.
void script_prof_restore(proftime_T *tm) void script_prof_restore(proftime_T *tm)
{ {
scriptitem_T *si; scriptitem_T *si;
if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len) { if (current_sctx.sc_sid > 0 && current_sctx.sc_sid <= script_items.ga_len) {
si = &SCRIPT_ITEM(current_sctx.sc_sid); si = &SCRIPT_ITEM(current_sctx.sc_sid);
@ -412,9 +412,9 @@ void prof_inchar_exit(void)
/// Dump the profiling results for all scripts in file "fd". /// Dump the profiling results for all scripts in file "fd".
static void script_dump_profile(FILE *fd) static void script_dump_profile(FILE *fd)
{ {
scriptitem_T *si; scriptitem_T *si;
FILE *sfd; FILE *sfd;
sn_prl_T *pp; sn_prl_T *pp;
for (int id = 1; id <= script_items.ga_len; id++) { for (int id = 1; id <= script_items.ga_len; id++) {
si = &SCRIPT_ITEM(id); si = &SCRIPT_ITEM(id);
@ -699,7 +699,7 @@ bool check_changed_any(bool hidden, bool unload)
int i; int i;
int bufnum = 0; int bufnum = 0;
size_t bufcount = 0; size_t bufcount = 0;
int *bufnrs; int *bufnrs;
// Make a list of all buffers, with the most important ones first. // Make a list of all buffers, with the most important ones first.
FOR_ALL_BUFFERS(buf) { FOR_ALL_BUFFERS(buf) {
@ -829,7 +829,7 @@ int check_fname(void)
int buf_write_all(buf_T *buf, int forceit) int buf_write_all(buf_T *buf, int forceit)
{ {
int retval; int retval;
buf_T *old_curbuf = curbuf; buf_T *old_curbuf = curbuf;
retval = (buf_write(buf, buf->b_ffname, buf->b_fname, retval = (buf_write(buf, buf->b_ffname, buf->b_fname,
(linenr_T)1, buf->b_ml.ml_line_count, NULL, (linenr_T)1, buf->b_ml.ml_line_count, NULL,
@ -852,7 +852,7 @@ int buf_write_all(buf_T *buf, int forceit)
/// Return a pointer to the start of the next argument. /// Return a pointer to the start of the next argument.
static char_u *do_one_arg(char_u *str) static char_u *do_one_arg(char_u *str)
{ {
char_u *p; char_u *p;
bool inbacktick; bool inbacktick;
inbacktick = false; inbacktick = false;
@ -936,8 +936,8 @@ static int do_arglist(char_u *str, int what, int after, bool will_edit)
{ {
garray_T new_ga; garray_T new_ga;
int exp_count; int exp_count;
char_u **exp_files; char_u **exp_files;
char_u *p; char_u *p;
int match; int match;
int arg_escaped = true; int arg_escaped = true;
@ -1037,9 +1037,8 @@ static bool editing_arg_idx(win_T *win)
|| (win->w_buffer->b_fnum || (win->w_buffer->b_fnum
!= WARGLIST(win)[win->w_arg_idx].ae_fnum != WARGLIST(win)[win->w_arg_idx].ae_fnum
&& (win->w_buffer->b_ffname == NULL && (win->w_buffer->b_ffname == NULL
|| !(path_full_compare( || !(path_full_compare(alist_name(&WARGLIST(win)[win->w_arg_idx]),
alist_name(&WARGLIST(win)[win->w_arg_idx]), win->w_buffer->b_ffname, true, true) & kEqualFiles))));
win->w_buffer->b_ffname, true, true) & kEqualFiles))));
} }
/// Check if window "win" is editing the w_arg_idx file in its argument list. /// Check if window "win" is editing the w_arg_idx file in its argument list.
@ -1102,7 +1101,7 @@ void ex_args(exarg_T *eap)
xfree(items); xfree(items);
} }
} else if (eap->cmdidx == CMD_arglocal) { } else if (eap->cmdidx == CMD_arglocal) {
garray_T *gap = &curwin->w_alist->al_ga; garray_T *gap = &curwin->w_alist->al_ga;
// ":argslocal": make a local copy of the global argument list. // ":argslocal": make a local copy of the global argument list.
ga_grow(gap, GARGCOUNT); ga_grow(gap, GARGCOUNT);
@ -1158,7 +1157,7 @@ void ex_argument(exarg_T *eap)
void do_argfile(exarg_T *eap, int argn) void do_argfile(exarg_T *eap, int argn)
{ {
int other; int other;
char_u *p; char_u *p;
int old_arg_idx = curwin->w_arg_idx; int old_arg_idx = curwin->w_arg_idx;
if (argn < 0 || argn >= ARGCOUNT) { if (argn < 0 || argn >= ARGCOUNT) {
@ -1310,9 +1309,9 @@ void ex_argdelete(exarg_T *eap)
curwin->w_arg_idx = (int)eap->line1; curwin->w_arg_idx = (int)eap->line1;
} }
if (ARGCOUNT == 0) { if (ARGCOUNT == 0) {
curwin->w_arg_idx = 0; curwin->w_arg_idx = 0;
} else if (curwin->w_arg_idx >= ARGCOUNT) { } else if (curwin->w_arg_idx >= ARGCOUNT) {
curwin->w_arg_idx = ARGCOUNT - 1; curwin->w_arg_idx = ARGCOUNT - 1;
} }
} }
} else { } else {
@ -1325,11 +1324,11 @@ void ex_argdelete(exarg_T *eap)
void ex_listdo(exarg_T *eap) void ex_listdo(exarg_T *eap)
{ {
int i; int i;
win_T *wp; win_T *wp;
tabpage_T *tp; tabpage_T *tp;
int next_fnum = 0; int next_fnum = 0;
char_u *save_ei = NULL; char_u *save_ei = NULL;
char_u *p_shm_save; char_u *p_shm_save;
if (eap->cmdidx != CMD_windo && eap->cmdidx != CMD_tabdo) { if (eap->cmdidx != CMD_windo && eap->cmdidx != CMD_tabdo) {
// Don't do syntax HL autocommands. Skipping the syntax file is a // Don't do syntax HL autocommands. Skipping the syntax file is a
@ -1610,9 +1609,9 @@ char_u *get_arglist_name(expand_T *xp FUNC_ATTR_UNUSED, int idx)
/// ":compiler[!] {name}" /// ":compiler[!] {name}"
void ex_compiler(exarg_T *eap) void ex_compiler(exarg_T *eap)
{ {
char_u *buf; char_u *buf;
char_u *old_cur_comp = NULL; char_u *old_cur_comp = NULL;
char_u *p; char_u *p;
if (*eap->arg == NUL) { if (*eap->arg == NUL) {
// List all compiler scripts. // List all compiler scripts.
@ -1703,7 +1702,7 @@ void init_pyxversion(void)
// otherwise return 0. // otherwise return 0.
static int requires_py_version(char_u *filename) static int requires_py_version(char_u *filename)
{ {
FILE *file; FILE *file;
int requires_py_version = 0; int requires_py_version = 0;
int i, lines; int i, lines;
@ -1940,9 +1939,7 @@ static char_u *get_str_line(int c, void *cookie, int indent, bool do_concat)
return ga.ga_data; return ga.ga_data;
} }
static int source_using_linegetter(void *cookie, static int source_using_linegetter(void *cookie, LineGetter fgetline, const char *traceback_name)
LineGetter fgetline,
const char *traceback_name)
{ {
char_u *save_sourcing_name = sourcing_name; char_u *save_sourcing_name = sourcing_name;
linenr_T save_sourcing_lnum = sourcing_lnum; linenr_T save_sourcing_lnum = sourcing_lnum;
@ -1951,7 +1948,7 @@ static int source_using_linegetter(void *cookie,
sourcing_name = (char_u *)traceback_name; sourcing_name = (char_u *)traceback_name;
} else { } else {
snprintf((char *)sourcing_name_buf, sizeof(sourcing_name_buf), snprintf((char *)sourcing_name_buf, sizeof(sourcing_name_buf),
"%s called at %s:%"PRIdLINENR, traceback_name, save_sourcing_name, "%s called at %s:%" PRIdLINENR, traceback_name, save_sourcing_name,
save_sourcing_lnum); save_sourcing_lnum);
sourcing_name = sourcing_name_buf; sourcing_name = sourcing_name_buf;
} }
@ -1992,8 +1989,8 @@ static void cmd_source_buffer(const exarg_T *const eap)
} }
((char_u *)ga.ga_data)[ga.ga_len - 1] = NUL; ((char_u *)ga.ga_data)[ga.ga_len - 1] = NUL;
const GetStrLineCookie cookie = { const GetStrLineCookie cookie = {
.buf = ga.ga_data, .buf = ga.ga_data,
.offset = 0, .offset = 0,
}; };
if (curbuf->b_fname if (curbuf->b_fname
&& path_with_extension((const char *)curbuf->b_fname, "lua")) { && path_with_extension((const char *)curbuf->b_fname, "lua")) {
@ -2012,8 +2009,8 @@ static void cmd_source_buffer(const exarg_T *const eap)
int do_source_str(const char *cmd, const char *traceback_name) int do_source_str(const char *cmd, const char *traceback_name)
{ {
GetStrLineCookie cookie = { GetStrLineCookie cookie = {
.buf = (char_u *)cmd, .buf = (char_u *)cmd,
.offset = 0, .offset = 0,
}; };
return source_using_linegetter((void *)&cookie, get_str_line, traceback_name); return source_using_linegetter((void *)&cookie, get_str_line, traceback_name);
} }
@ -2033,16 +2030,16 @@ int do_source_str(const char *cmd, const char *traceback_name)
int do_source(char_u *fname, int check_other, int is_vimrc) int do_source(char_u *fname, int check_other, int is_vimrc)
{ {
struct source_cookie cookie; struct source_cookie cookie;
char_u *save_sourcing_name; char_u *save_sourcing_name;
linenr_T save_sourcing_lnum; linenr_T save_sourcing_lnum;
char_u *p; char_u *p;
char_u *fname_exp; char_u *fname_exp;
char_u *firstline = NULL; char_u *firstline = NULL;
int retval = FAIL; int retval = FAIL;
static scid_T last_current_SID = 0; static scid_T last_current_SID = 0;
static int last_current_SID_seq = 0; static int last_current_SID_seq = 0;
int save_debug_break_level = debug_break_level; int save_debug_break_level = debug_break_level;
scriptitem_T *si = NULL; scriptitem_T *si = NULL;
proftime_T wait_start; proftime_T wait_start;
bool trigger_source_post = false; bool trigger_source_post = false;
@ -2363,31 +2360,31 @@ char_u *get_scriptname(LastSet last_set, bool *should_free)
*should_free = false; *should_free = false;
switch (last_set.script_ctx.sc_sid) { switch (last_set.script_ctx.sc_sid) {
case SID_MODELINE: case SID_MODELINE:
return (char_u *)_("modeline"); return (char_u *)_("modeline");
case SID_CMDARG: case SID_CMDARG:
return (char_u *)_("--cmd argument"); return (char_u *)_("--cmd argument");
case SID_CARG: case SID_CARG:
return (char_u *)_("-c argument"); return (char_u *)_("-c argument");
case SID_ENV: case SID_ENV:
return (char_u *)_("environment variable"); return (char_u *)_("environment variable");
case SID_ERROR: case SID_ERROR:
return (char_u *)_("error handler"); return (char_u *)_("error handler");
case SID_WINLAYOUT: case SID_WINLAYOUT:
return (char_u *)_("changed window size"); return (char_u *)_("changed window size");
case SID_LUA: case SID_LUA:
return (char_u *)_("Lua"); return (char_u *)_("Lua");
case SID_API_CLIENT: case SID_API_CLIENT:
vim_snprintf((char *)IObuff, IOSIZE, vim_snprintf((char *)IObuff, IOSIZE,
_("API client (channel id %" PRIu64 ")"), _("API client (channel id %" PRIu64 ")"),
last_set.channel_id); last_set.channel_id);
return IObuff; return IObuff;
case SID_STR: case SID_STR:
return (char_u *)_("anonymous :source"); return (char_u *)_("anonymous :source");
default: default:
*should_free = true; *should_free = true;
return home_replace_save(NULL, return home_replace_save(NULL,
SCRIPT_ITEM(last_set.script_ctx.sc_sid).sn_name); SCRIPT_ITEM(last_set.script_ctx.sc_sid).sn_name);
} }
} }
@ -2403,7 +2400,7 @@ void free_scriptnames(void)
linenr_T get_sourced_lnum(LineGetter fgetline, void *cookie) linenr_T get_sourced_lnum(LineGetter fgetline, void *cookie)
{ {
return fgetline == getsourceline return fgetline == getsourceline
? ((struct source_cookie *)cookie)->sourcing_lnum ? ((struct source_cookie *)cookie)->sourcing_lnum
: sourcing_lnum; : sourcing_lnum;
} }
@ -2476,7 +2473,7 @@ char_u *getsourceline(int c, void *cookie, int indent, bool do_concat)
} }
if (line != NULL && sp->conv.vc_type != CONV_NONE) { if (line != NULL && sp->conv.vc_type != CONV_NONE) {
char_u *s; char_u *s;
// Convert the encoding of the script line. // Convert the encoding of the script line.
s = string_convert(&sp->conv, line, NULL); s = string_convert(&sp->conv, line, NULL);
@ -2502,7 +2499,7 @@ static char_u *get_one_sourceline(struct source_cookie *sp)
garray_T ga; garray_T ga;
int len; int len;
int c; int c;
char_u *buf; char_u *buf;
#ifdef USE_CRNL #ifdef USE_CRNL
int has_cr; // CR-LF found int has_cr; // CR-LF found
#endif #endif
@ -2605,8 +2602,8 @@ retry:
/// until later and we need to store the time now. /// until later and we need to store the time now.
void script_line_start(void) void script_line_start(void)
{ {
scriptitem_T *si; scriptitem_T *si;
sn_prl_T *pp; sn_prl_T *pp;
if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) { if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) {
return; return;
@ -2637,7 +2634,7 @@ void script_line_start(void)
/// Called when actually executing a function line. /// Called when actually executing a function line.
void script_line_exec(void) void script_line_exec(void)
{ {
scriptitem_T *si; scriptitem_T *si;
if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) { if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) {
return; return;
@ -2651,8 +2648,8 @@ void script_line_exec(void)
/// Called when done with a function line. /// Called when done with a function line.
void script_line_end(void) void script_line_end(void)
{ {
scriptitem_T *si; scriptitem_T *si;
sn_prl_T *pp; sn_prl_T *pp;
if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) { if (current_sctx.sc_sid <= 0 || current_sctx.sc_sid > script_items.ga_len) {
return; return;
@ -2677,8 +2674,8 @@ void script_line_end(void)
/// Without the multi-byte feature it's simply ignored. /// Without the multi-byte feature it's simply ignored.
void ex_scriptencoding(exarg_T *eap) void ex_scriptencoding(exarg_T *eap)
{ {
struct source_cookie *sp; struct source_cookie *sp;
char_u *name; char_u *name;
if (!getline_equal(eap->getline, eap->cookie, getsourceline)) { if (!getline_equal(eap->getline, eap->cookie, getsourceline)) {
EMSG(_("E167: :scriptencoding used outside of a sourced file")); EMSG(_("E167: :scriptencoding used outside of a sourced file"));
@ -2743,14 +2740,13 @@ void do_finish(exarg_T *eap, int reanimate)
bool source_finished(LineGetter fgetline, void *cookie) bool source_finished(LineGetter fgetline, void *cookie)
{ {
return getline_equal(fgetline, cookie, getsourceline) return getline_equal(fgetline, cookie, getsourceline)
&& ((struct source_cookie *)getline_cookie( && ((struct source_cookie *)getline_cookie(fgetline, cookie))->finished;
fgetline, cookie))->finished;
} }
/// ":checktime [buffer]" /// ":checktime [buffer]"
void ex_checktime(exarg_T *eap) void ex_checktime(exarg_T *eap)
{ {
buf_T *buf; buf_T *buf;
int save_no_check_timestamps = no_check_timestamps; int save_no_check_timestamps = no_check_timestamps;
no_check_timestamps = 0; no_check_timestamps = 0;
@ -2817,7 +2813,7 @@ char *get_mess_lang(void)
/// Get the language used for messages from the environment. /// Get the language used for messages from the environment.
static char_u *get_mess_env(void) static char_u *get_mess_env(void)
{ {
char_u *p; char_u *p;
p = (char_u *)os_getenv("LC_ALL"); p = (char_u *)os_getenv("LC_ALL");
if (p == NULL) { if (p == NULL) {
@ -2888,11 +2884,11 @@ void set_lang_var(void)
/// ///
void ex_language(exarg_T *eap) void ex_language(exarg_T *eap)
{ {
char *loc; char *loc;
char_u *p; char_u *p;
char_u *name; char_u *name;
int what = LC_ALL; int what = LC_ALL;
char *whatstr = ""; char *whatstr = "";
#ifdef LC_MESSAGES #ifdef LC_MESSAGES
# define VIM_LC_MESSAGES LC_MESSAGES # define VIM_LC_MESSAGES LC_MESSAGES
#else #else
@ -2931,9 +2927,9 @@ void ex_language(exarg_T *eap)
p = get_mess_env(); p = get_mess_env();
} else { } else {
#endif #endif
p = (char_u *)setlocale(what, NULL); p = (char_u *)setlocale(what, NULL);
#ifdef HAVE_WORKING_LIBINTL #ifdef HAVE_WORKING_LIBINTL
} }
#endif #endif
if (p == NULL || *p == NUL) { if (p == NULL || *p == NUL) {
p = (char_u *)"Unknown"; p = (char_u *)"Unknown";
@ -2945,13 +2941,13 @@ void ex_language(exarg_T *eap)
loc = ""; loc = "";
} else { } else {
#endif #endif
loc = setlocale(what, (char *)name); loc = setlocale(what, (char *)name);
#ifdef LC_NUMERIC #ifdef LC_NUMERIC
// Make sure strtod() uses a decimal point, not a comma. // Make sure strtod() uses a decimal point, not a comma.
setlocale(LC_NUMERIC, "C"); setlocale(LC_NUMERIC, "C");
#endif #endif
#ifndef LC_MESSAGES #ifndef LC_MESSAGES
} }
#endif #endif
if (loc == NULL) { if (loc == NULL) {
EMSG2(_("E197: Cannot set language to \"%s\""), name); EMSG2(_("E197: Cannot set language to \"%s\""), name);
@ -2999,7 +2995,7 @@ static bool did_init_locales = false;
static char_u **find_locales(void) static char_u **find_locales(void)
{ {
garray_T locales_ga; garray_T locales_ga;
char_u *loc; char_u *loc;
char *saveptr = NULL; char *saveptr = NULL;
// Find all available locales by running command "locale -a". If this // Find all available locales by running command "locale -a". If this
@ -3137,7 +3133,7 @@ static void script_host_do_range(char *name, exarg_T *eap)
/// ":drop" /// ":drop"
/// Opens the first argument in a window. When there are two or more arguments /// Opens the first argument in a window. When there are two or more arguments
/// the argument list is redefined. /// the argument list is redefined.
void ex_drop(exarg_T *eap) void ex_drop(exarg_T *eap)
{ {
bool split = false; bool split = false;
buf_T *buf; buf_T *buf;

413
src/nvim/ex_eval.c
View File

@ -7,23 +7,23 @@
/// ///
/// Functions for Ex command line for the +eval feature. /// Functions for Ex command line for the +eval feature.
#include <assert.h> #include <assert.h>
#include <stdbool.h>
#include <inttypes.h> #include <inttypes.h>
#include <limits.h> #include <limits.h>
#include <stdbool.h>
#include "nvim/vim.h"
#include "nvim/ascii.h" #include "nvim/ascii.h"
#include "nvim/debugger.h"
#include "nvim/ex_eval.h"
#include "nvim/charset.h" #include "nvim/charset.h"
#include "nvim/debugger.h"
#include "nvim/eval.h" #include "nvim/eval.h"
#include "nvim/eval/userfunc.h" #include "nvim/eval/userfunc.h"
#include "nvim/ex_cmds2.h" #include "nvim/ex_cmds2.h"
#include "nvim/ex_docmd.h" #include "nvim/ex_docmd.h"
#include "nvim/message.h" #include "nvim/ex_eval.h"
#include "nvim/memory.h" #include "nvim/memory.h"
#include "nvim/message.h"
#include "nvim/regexp.h" #include "nvim/regexp.h"
#include "nvim/strings.h" #include "nvim/strings.h"
#include "nvim/vim.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
# include "ex_eval.c.generated.h" # include "ex_eval.c.generated.h"
@ -111,8 +111,9 @@ int aborting(void)
*/ */
void update_force_abort(void) void update_force_abort(void)
{ {
if (cause_abort) if (cause_abort) {
force_abort = TRUE; force_abort = TRUE;
}
} }
/* /*
@ -248,8 +249,9 @@ bool cause_errthrow(const char_u *mesg, bool severe, bool *ignore)
*/ */
if (msg_list != NULL) { if (msg_list != NULL) {
plist = msg_list; plist = msg_list;
while (*plist != NULL) while (*plist != NULL) {
plist = &(*plist)->next; plist = &(*plist)->next;
}
elem = xmalloc(sizeof(struct msglist)); elem = xmalloc(sizeof(struct msglist));
elem->msg = vim_strsave(mesg); elem->msg = vim_strsave(mesg);
@ -257,19 +259,20 @@ bool cause_errthrow(const char_u *mesg, bool severe, bool *ignore)
elem->throw_msg = NULL; elem->throw_msg = NULL;
*plist = elem; *plist = elem;
if (plist == msg_list || severe) { if (plist == msg_list || severe) {
char_u *tmsg; char_u *tmsg;
/* Skip the extra "Vim " prefix for message "E458". */ // Skip the extra "Vim " prefix for message "E458".
tmsg = elem->msg; tmsg = elem->msg;
if (STRNCMP(tmsg, "Vim E", 5) == 0 if (STRNCMP(tmsg, "Vim E", 5) == 0
&& ascii_isdigit(tmsg[5]) && ascii_isdigit(tmsg[5])
&& ascii_isdigit(tmsg[6]) && ascii_isdigit(tmsg[6])
&& ascii_isdigit(tmsg[7]) && ascii_isdigit(tmsg[7])
&& tmsg[8] == ':' && tmsg[8] == ':'
&& tmsg[9] == ' ') && tmsg[9] == ' ') {
(*msg_list)->throw_msg = &tmsg[4]; (*msg_list)->throw_msg = &tmsg[4];
else } else {
(*msg_list)->throw_msg = tmsg; (*msg_list)->throw_msg = tmsg;
}
} }
} }
return true; return true;
@ -281,7 +284,7 @@ bool cause_errthrow(const char_u *mesg, bool severe, bool *ignore)
*/ */
static void free_msglist(struct msglist *l) static void free_msglist(struct msglist *l)
{ {
struct msglist *messages, *next; struct msglist *messages, *next;
messages = l; messages = l;
while (messages != NULL) { while (messages != NULL) {
@ -320,16 +323,18 @@ void do_errthrow(cstack_T *cstack, char_u *cmdname)
/* If no exception is to be thrown or the conversion should be done after /* If no exception is to be thrown or the conversion should be done after
* returning to a previous invocation of do_one_cmd(), do nothing. */ * returning to a previous invocation of do_one_cmd(), do nothing. */
if (msg_list == NULL || *msg_list == NULL) if (msg_list == NULL || *msg_list == NULL) {
return; return;
}
if (throw_exception(*msg_list, ET_ERROR, cmdname) == FAIL) if (throw_exception(*msg_list, ET_ERROR, cmdname) == FAIL) {
free_msglist(*msg_list); free_msglist(*msg_list);
else { } else {
if (cstack != NULL) if (cstack != NULL) {
do_throw(cstack); do_throw(cstack);
else } else {
need_rethrow = TRUE; need_rethrow = TRUE;
}
} }
*msg_list = NULL; *msg_list = NULL;
} }
@ -357,36 +362,35 @@ int do_intthrow(cstack_T *cstack)
} }
} else { } else {
#endif #endif
// Throw an interrupt exception, so that everything will be aborted // Throw an interrupt exception, so that everything will be aborted
// (except for executing finally clauses), until the interrupt exception // (except for executing finally clauses), until the interrupt exception
// is caught; if still uncaught at the top level, the script processing // is caught; if still uncaught at the top level, the script processing
// will be terminated then. - If an interrupt exception is already // will be terminated then. - If an interrupt exception is already
// being thrown, do nothing. // being thrown, do nothing.
if (current_exception) { if (current_exception) {
if (current_exception->type == ET_INTERRUPT) { if (current_exception->type == ET_INTERRUPT) {
return false; return false;
} }
// An interrupt exception replaces any user or error exception. // An interrupt exception replaces any user or error exception.
discard_current_exception(); discard_current_exception();
}
if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL) {
do_throw(cstack);
}
#ifdef THROW_TEST
} }
if (throw_exception("Vim:Interrupt", ET_INTERRUPT, NULL) != FAIL) {
do_throw(cstack);
}
#ifdef THROW_TEST
}
#endif #endif
return true; return true;
} }
// Get an exception message that is to be stored in current_exception->value. // Get an exception message that is to be stored in current_exception->value.
char_u *get_exception_string(void *value, except_type_T type, char_u *cmdname, char_u *get_exception_string(void *value, except_type_T type, char_u *cmdname, int *should_free)
int *should_free)
{ {
char_u *ret, *mesg; char_u *ret, *mesg;
char_u *p, *val; char_u *p, *val;
if (type == ET_ERROR) { if (type == ET_ERROR) {
*should_free = true; *should_free = true;
@ -434,7 +438,7 @@ char_u *get_exception_string(void *value, except_type_T type, char_u *cmdname,
} }
} else { } else {
*should_free = FALSE; *should_free = FALSE;
ret = (char_u *) value; ret = (char_u *)value;
} }
return ret; return ret;
@ -447,7 +451,7 @@ char_u *get_exception_string(void *value, except_type_T type, char_u *cmdname,
// error exception. // error exception.
static int throw_exception(void *value, except_type_T type, char_u *cmdname) static int throw_exception(void *value, except_type_T type, char_u *cmdname)
{ {
except_T *excp; except_T *excp;
int should_free; int should_free;
/* /*
@ -466,14 +470,16 @@ static int throw_exception(void *value, except_type_T type, char_u *cmdname)
excp = xmalloc(sizeof(except_T)); excp = xmalloc(sizeof(except_T));
if (type == ET_ERROR) if (type == ET_ERROR) {
/* Store the original message and prefix the exception value with /* Store the original message and prefix the exception value with
* "Vim:" or, if a command name is given, "Vim(cmdname):". */ * "Vim:" or, if a command name is given, "Vim(cmdname):". */
excp->messages = (struct msglist *)value; excp->messages = (struct msglist *)value;
}
excp->value = get_exception_string(value, type, cmdname, &should_free); excp->value = get_exception_string(value, type, cmdname, &should_free);
if (excp->value == NULL && should_free) if (excp->value == NULL && should_free) {
goto nomem; goto nomem;
}
excp->type = type; excp->type = type;
excp->throw_name = vim_strsave(sourcing_name == NULL excp->throw_name = vim_strsave(sourcing_name == NULL
@ -483,24 +489,27 @@ static int throw_exception(void *value, except_type_T type, char_u *cmdname)
if (p_verbose >= 13 || debug_break_level > 0) { if (p_verbose >= 13 || debug_break_level > 0) {
int save_msg_silent = msg_silent; int save_msg_silent = msg_silent;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = FALSE; /* display messages */ msg_silent = FALSE; // display messages
else } else {
verbose_enter(); verbose_enter();
}
++no_wait_return; ++no_wait_return;
if (debug_break_level > 0 || *p_vfile == NUL) if (debug_break_level > 0 || *p_vfile == NUL) {
msg_scroll = TRUE; /* always scroll up, don't overwrite */ msg_scroll = TRUE; // always scroll up, don't overwrite
}
smsg(_("Exception thrown: %s"), excp->value); smsg(_("Exception thrown: %s"), excp->value);
msg_puts("\n"); // don't overwrite this either msg_puts("\n"); // don't overwrite this either
if (debug_break_level > 0 || *p_vfile == NUL) if (debug_break_level > 0 || *p_vfile == NUL) {
cmdline_row = msg_row; cmdline_row = msg_row;
}
--no_wait_return; --no_wait_return;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = save_msg_silent; msg_silent = save_msg_silent;
else } else {
verbose_leave(); verbose_leave();
}
} }
current_exception = excp; current_exception = excp;
@ -521,7 +530,7 @@ fail:
*/ */
static void discard_exception(except_T *excp, bool was_finished) static void discard_exception(except_T *excp, bool was_finished)
{ {
char_u *saved_IObuff; char_u *saved_IObuff;
if (current_exception == excp) { if (current_exception == excp) {
current_exception = NULL; current_exception = NULL;
@ -535,13 +544,15 @@ static void discard_exception(except_T *excp, bool was_finished)
int save_msg_silent = msg_silent; int save_msg_silent = msg_silent;
saved_IObuff = vim_strsave(IObuff); saved_IObuff = vim_strsave(IObuff);
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = FALSE; /* display messages */ msg_silent = FALSE; // display messages
else } else {
verbose_enter(); verbose_enter();
}
++no_wait_return; ++no_wait_return;
if (debug_break_level > 0 || *p_vfile == NUL) if (debug_break_level > 0 || *p_vfile == NUL) {
msg_scroll = TRUE; /* always scroll up, don't overwrite */ msg_scroll = TRUE; // always scroll up, don't overwrite
}
smsg(was_finished ? _("Exception finished: %s") smsg(was_finished ? _("Exception finished: %s")
: _("Exception discarded: %s"), : _("Exception discarded: %s"),
excp->value); excp->value);
@ -558,10 +569,12 @@ static void discard_exception(except_T *excp, bool was_finished)
xstrlcpy((char *)IObuff, (const char *)saved_IObuff, IOSIZE); xstrlcpy((char *)IObuff, (const char *)saved_IObuff, IOSIZE);
xfree(saved_IObuff); xfree(saved_IObuff);
} }
if (excp->type != ET_INTERRUPT) if (excp->type != ET_INTERRUPT) {
xfree(excp->value); xfree(excp->value);
if (excp->type == ET_ERROR) }
if (excp->type == ET_ERROR) {
free_msglist(excp->messages); free_msglist(excp->messages);
}
xfree(excp->throw_name); xfree(excp->throw_name);
xfree(excp); xfree(excp);
} }
@ -586,7 +599,7 @@ static void catch_exception(except_T *excp)
{ {
excp->caught = caught_stack; excp->caught = caught_stack;
caught_stack = excp; caught_stack = excp;
set_vim_var_string(VV_EXCEPTION, (char *) excp->value, -1); set_vim_var_string(VV_EXCEPTION, (char *)excp->value, -1);
if (*excp->throw_name != NUL) { if (*excp->throw_name != NUL) {
if (excp->throw_lnum != 0) { if (excp->throw_lnum != 0) {
vim_snprintf((char *)IObuff, IOSIZE, _("%s, line %" PRId64), vim_snprintf((char *)IObuff, IOSIZE, _("%s, line %" PRId64),
@ -594,7 +607,7 @@ static void catch_exception(except_T *excp)
} else { } else {
vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name); vim_snprintf((char *)IObuff, IOSIZE, "%s", excp->throw_name);
} }
set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1); set_vim_var_string(VV_THROWPOINT, (char *)IObuff, -1);
} else { } else {
// throw_name not set on an exception from a command that was typed. // throw_name not set on an exception from a command that was typed.
set_vim_var_string(VV_THROWPOINT, NULL, -1); set_vim_var_string(VV_THROWPOINT, NULL, -1);
@ -603,24 +616,27 @@ static void catch_exception(except_T *excp)
if (p_verbose >= 13 || debug_break_level > 0) { if (p_verbose >= 13 || debug_break_level > 0) {
int save_msg_silent = msg_silent; int save_msg_silent = msg_silent;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = FALSE; /* display messages */ msg_silent = FALSE; // display messages
else } else {
verbose_enter(); verbose_enter();
}
++no_wait_return; ++no_wait_return;
if (debug_break_level > 0 || *p_vfile == NUL) if (debug_break_level > 0 || *p_vfile == NUL) {
msg_scroll = TRUE; /* always scroll up, don't overwrite */ msg_scroll = TRUE; // always scroll up, don't overwrite
}
smsg(_("Exception caught: %s"), excp->value); smsg(_("Exception caught: %s"), excp->value);
msg_puts("\n"); // don't overwrite this either msg_puts("\n"); // don't overwrite this either
if (debug_break_level > 0 || *p_vfile == NUL) if (debug_break_level > 0 || *p_vfile == NUL) {
cmdline_row = msg_row; cmdline_row = msg_row;
}
--no_wait_return; --no_wait_return;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = save_msg_silent; msg_silent = save_msg_silent;
else } else {
verbose_leave(); verbose_leave();
}
} }
} }
@ -634,7 +650,7 @@ static void finish_exception(except_T *excp)
} }
caught_stack = caught_stack->caught; caught_stack = caught_stack->caught;
if (caught_stack != NULL) { if (caught_stack != NULL) {
set_vim_var_string(VV_EXCEPTION, (char *) caught_stack->value, -1); set_vim_var_string(VV_EXCEPTION, (char *)caught_stack->value, -1);
if (*caught_stack->throw_name != NUL) { if (*caught_stack->throw_name != NUL) {
if (caught_stack->throw_lnum != 0) { if (caught_stack->throw_lnum != 0) {
vim_snprintf((char *)IObuff, IOSIZE, vim_snprintf((char *)IObuff, IOSIZE,
@ -644,7 +660,7 @@ static void finish_exception(except_T *excp)
vim_snprintf((char *)IObuff, IOSIZE, "%s", vim_snprintf((char *)IObuff, IOSIZE, "%s",
caught_stack->throw_name); caught_stack->throw_name);
} }
set_vim_var_string(VV_THROWPOINT, (char *) IObuff, -1); set_vim_var_string(VV_THROWPOINT, (char *)IObuff, -1);
} else { } else {
// throw_name not set on an exception from a command that was // throw_name not set on an exception from a command that was
// typed. // typed.
@ -688,7 +704,7 @@ static void report_pending(int action, int pending, void *value)
case RP_RESUME: case RP_RESUME:
mesg = _("%s resumed"); mesg = _("%s resumed");
break; break;
/* case RP_DISCARD: */ // case RP_DISCARD:
default: default:
mesg = _("%s discarded"); mesg = _("%s discarded");
break; break;
@ -708,7 +724,7 @@ static void report_pending(int action, int pending, void *value)
s = ":finish"; s = ":finish";
break; break;
case CSTP_RETURN: case CSTP_RETURN:
/* ":return" command producing value, allocated */ // ":return" command producing value, allocated
s = (char *)get_return_cmd(value); s = (char *)get_return_cmd(value);
break; break;
@ -718,30 +734,34 @@ static void report_pending(int action, int pending, void *value)
mesg, _("Exception")); mesg, _("Exception"));
mesg = (char *)concat_str(IObuff, (char_u *)": %s"); mesg = (char *)concat_str(IObuff, (char_u *)": %s");
s = (char *)((except_T *)value)->value; s = (char *)((except_T *)value)->value;
} else if ((pending & CSTP_ERROR) && (pending & CSTP_INTERRUPT)) } else if ((pending & CSTP_ERROR) && (pending & CSTP_INTERRUPT)) {
s = _("Error and interrupt"); s = _("Error and interrupt");
else if (pending & CSTP_ERROR) } else if (pending & CSTP_ERROR) {
s = _("Error"); s = _("Error");
else /* if (pending & CSTP_INTERRUPT) */ } else { // if (pending & CSTP_INTERRUPT)
s = _("Interrupt"); s = _("Interrupt");
}
} }
save_msg_silent = msg_silent; save_msg_silent = msg_silent;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = FALSE; /* display messages */ msg_silent = FALSE; // display messages
}
++no_wait_return; ++no_wait_return;
msg_scroll = TRUE; /* always scroll up, don't overwrite */ msg_scroll = TRUE; // always scroll up, don't overwrite
smsg(mesg, s); smsg(mesg, s);
msg_puts("\n"); // don't overwrite this either msg_puts("\n"); // don't overwrite this either
cmdline_row = msg_row; cmdline_row = msg_row;
--no_wait_return; --no_wait_return;
if (debug_break_level > 0) if (debug_break_level > 0) {
msg_silent = save_msg_silent; msg_silent = save_msg_silent;
}
if (pending == CSTP_RETURN) if (pending == CSTP_RETURN) {
xfree(s); xfree(s);
else if (pending & CSTP_THROW) } else if (pending & CSTP_THROW) {
xfree(mesg); xfree(mesg);
}
} }
/* /*
@ -751,11 +771,13 @@ static void report_pending(int action, int pending, void *value)
void report_make_pending(int pending, void *value) void report_make_pending(int pending, void *value)
{ {
if (p_verbose >= 14 || debug_break_level > 0) { if (p_verbose >= 14 || debug_break_level > 0) {
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_enter(); verbose_enter();
}
report_pending(RP_MAKE, pending, value); report_pending(RP_MAKE, pending, value);
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_leave(); verbose_leave();
}
} }
} }
@ -766,11 +788,13 @@ void report_make_pending(int pending, void *value)
void report_resume_pending(int pending, void *value) void report_resume_pending(int pending, void *value)
{ {
if (p_verbose >= 14 || debug_break_level > 0) { if (p_verbose >= 14 || debug_break_level > 0) {
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_enter(); verbose_enter();
}
report_pending(RP_RESUME, pending, value); report_pending(RP_RESUME, pending, value);
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_leave(); verbose_leave();
}
} }
} }
@ -781,11 +805,13 @@ void report_resume_pending(int pending, void *value)
void report_discard_pending(int pending, void *value) void report_discard_pending(int pending, void *value)
{ {
if (p_verbose >= 14 || debug_break_level > 0) { if (p_verbose >= 14 || debug_break_level > 0) {
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_enter(); verbose_enter();
}
report_pending(RP_DISCARD, pending, value); report_pending(RP_DISCARD, pending, value);
if (debug_break_level <= 0) if (debug_break_level <= 0) {
verbose_leave(); verbose_leave();
}
} }
} }
@ -808,9 +834,9 @@ void ex_if(exarg_T *eap)
int result; int result;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_idx == CSTACK_LEN - 1) if (cstack->cs_idx == CSTACK_LEN - 1) {
eap->errmsg = (char_u *)N_("E579: :if nesting too deep"); eap->errmsg = (char_u *)N_("E579: :if nesting too deep");
else { } else {
++cstack->cs_idx; ++cstack->cs_idx;
cstack->cs_flags[cstack->cs_idx] = 0; cstack->cs_flags[cstack->cs_idx] = 0;
@ -820,11 +846,13 @@ void ex_if(exarg_T *eap)
result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip); result = eval_to_bool(eap->arg, &error, &eap->nextcmd, skip);
if (!skip && !error) { if (!skip && !error) {
if (result) if (result) {
cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE; cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
} else }
/* set TRUE, so this conditional will never get active */ } else {
// set TRUE, so this conditional will never get active
cstack->cs_flags[cstack->cs_idx] = CSF_TRUE; cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
}
} }
} }
@ -884,13 +912,15 @@ void ex_else(exarg_T *eap)
skip = TRUE; skip = TRUE;
} }
/* if skipping or the ":if" was TRUE, reset ACTIVE, otherwise set it */ // if skipping or the ":if" was TRUE, reset ACTIVE, otherwise set it
if (skip || cstack->cs_flags[cstack->cs_idx] & CSF_TRUE) { if (skip || cstack->cs_flags[cstack->cs_idx] & CSF_TRUE) {
if (eap->errmsg == NULL) if (eap->errmsg == NULL) {
cstack->cs_flags[cstack->cs_idx] = CSF_TRUE; cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
skip = TRUE; /* don't evaluate an ":elseif" */ }
} else skip = TRUE; // don't evaluate an ":elseif"
} else {
cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE; cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE;
}
/* /*
* When debugging or a breakpoint was encountered, display the debug prompt * When debugging or a breakpoint was encountered, display the debug prompt
@ -917,15 +947,18 @@ void ex_else(exarg_T *eap)
* case, the parsing error will be ignored by emsg(). */ * case, the parsing error will be ignored by emsg(). */
if (!skip && !error) { if (!skip && !error) {
if (result) if (result) {
cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE; cstack->cs_flags[cstack->cs_idx] = CSF_ACTIVE | CSF_TRUE;
else } else {
cstack->cs_flags[cstack->cs_idx] = 0; cstack->cs_flags[cstack->cs_idx] = 0;
} else if (eap->errmsg == NULL) }
/* set TRUE, so this conditional will never get active */ } else if (eap->errmsg == NULL) {
// set TRUE, so this conditional will never get active
cstack->cs_flags[cstack->cs_idx] = CSF_TRUE; cstack->cs_flags[cstack->cs_idx] = CSF_TRUE;
} else }
} else {
cstack->cs_flags[cstack->cs_idx] |= CSF_ELSE; cstack->cs_flags[cstack->cs_idx] |= CSF_ELSE;
}
} }
/* /*
@ -938,9 +971,9 @@ void ex_while(exarg_T *eap)
int result; int result;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_idx == CSTACK_LEN - 1) if (cstack->cs_idx == CSTACK_LEN - 1) {
eap->errmsg = (char_u *)N_("E585: :while/:for nesting too deep"); eap->errmsg = (char_u *)N_("E585: :while/:for nesting too deep");
else { } else {
/* /*
* The loop flag is set when we have jumped back from the matching * The loop flag is set when we have jumped back from the matching
* ":endwhile" or ":endfor". When not set, need to initialise this * ":endwhile" or ":endfor". When not set, need to initialise this
@ -972,16 +1005,17 @@ void ex_while(exarg_T *eap)
fi = cstack->cs_forinfo[cstack->cs_idx]; fi = cstack->cs_forinfo[cstack->cs_idx];
error = FALSE; error = FALSE;
} else { } else {
/* Evaluate the argument and get the info in a structure. */ // Evaluate the argument and get the info in a structure.
fi = eval_for_line(eap->arg, &error, &eap->nextcmd, skip); fi = eval_for_line(eap->arg, &error, &eap->nextcmd, skip);
cstack->cs_forinfo[cstack->cs_idx] = fi; cstack->cs_forinfo[cstack->cs_idx] = fi;
} }
/* use the element at the start of the list and advance */ // use the element at the start of the list and advance
if (!error && fi != NULL && !skip) if (!error && fi != NULL && !skip) {
result = next_for_item(fi, eap->arg); result = next_for_item(fi, eap->arg);
else } else {
result = FALSE; result = FALSE;
}
if (!result) { if (!result) {
free_for_info(fi); free_for_info(fi);
@ -1003,8 +1037,9 @@ void ex_while(exarg_T *eap)
* the list, show the debug prompt at the ":endwhile"/":endfor" as * the list, show the debug prompt at the ":endwhile"/":endfor" as
* if there was a ":break" in a ":while"/":for" evaluating to * if there was a ":break" in a ":while"/":for" evaluating to
* TRUE. */ * TRUE. */
if (!skip && !error) if (!skip && !error) {
cstack->cs_flags[cstack->cs_idx] |= CSF_TRUE; cstack->cs_flags[cstack->cs_idx] |= CSF_TRUE;
}
} }
} }
} }
@ -1017,9 +1052,9 @@ void ex_continue(exarg_T *eap)
int idx; int idx;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0) if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0) {
eap->errmsg = (char_u *)N_("E586: :continue without :while or :for"); eap->errmsg = (char_u *)N_("E586: :continue without :while or :for");
else { } else {
/* Try to find the matching ":while". This might stop at a try /* Try to find the matching ":while". This might stop at a try
* conditional not in its finally clause (which is then to be executed * conditional not in its finally clause (which is then to be executed
* next). Therefore, deactivate all conditionals except the ":while" * next). Therefore, deactivate all conditionals except the ":while"
@ -1033,7 +1068,7 @@ void ex_continue(exarg_T *eap)
* Set CSL_HAD_CONT, so do_cmdline() will jump back to the * Set CSL_HAD_CONT, so do_cmdline() will jump back to the
* matching ":while". * matching ":while".
*/ */
cstack->cs_lflags |= CSL_HAD_CONT; /* let do_cmdline() handle it */ cstack->cs_lflags |= CSL_HAD_CONT; // let do_cmdline() handle it
} else { } else {
/* If a try conditional not in its finally clause is reached first, /* If a try conditional not in its finally clause is reached first,
* make the ":continue" pending for execution at the ":endtry". */ * make the ":continue" pending for execution at the ":endtry". */
@ -1073,7 +1108,7 @@ void ex_endwhile(exarg_T *eap)
{ {
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
int idx; int idx;
char_u *err; char_u *err;
int csf; int csf;
int fl; int fl;
@ -1085,24 +1120,26 @@ void ex_endwhile(exarg_T *eap)
csf = CSF_FOR; csf = CSF_FOR;
} }
if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0) if (cstack->cs_looplevel <= 0 || cstack->cs_idx < 0) {
eap->errmsg = err; eap->errmsg = err;
else { } else {
fl = cstack->cs_flags[cstack->cs_idx]; fl = cstack->cs_flags[cstack->cs_idx];
if (!(fl & csf)) { if (!(fl & csf)) {
/* If we are in a ":while" or ":for" but used the wrong endloop /* If we are in a ":while" or ":for" but used the wrong endloop
* command, do not rewind to the next enclosing ":for"/":while". */ * command, do not rewind to the next enclosing ":for"/":while". */
if (fl & CSF_WHILE) if (fl & CSF_WHILE) {
eap->errmsg = (char_u *)_("E732: Using :endfor with :while"); eap->errmsg = (char_u *)_("E732: Using :endfor with :while");
else if (fl & CSF_FOR) } else if (fl & CSF_FOR) {
eap->errmsg = (char_u *)_("E733: Using :endwhile with :for"); eap->errmsg = (char_u *)_("E733: Using :endwhile with :for");
}
} }
if (!(fl & (CSF_WHILE | CSF_FOR))) { if (!(fl & (CSF_WHILE | CSF_FOR))) {
if (!(fl & CSF_TRY)) if (!(fl & CSF_TRY)) {
eap->errmsg = e_endif; eap->errmsg = e_endif;
else if (fl & CSF_FINALLY) } else if (fl & CSF_FINALLY) {
eap->errmsg = e_endtry; eap->errmsg = e_endtry;
/* Try to find the matching ":while" and report what's missing. */ }
// Try to find the matching ":while" and report what's missing.
for (idx = cstack->cs_idx; idx > 0; --idx) { for (idx = cstack->cs_idx; idx > 0; --idx) {
fl = cstack->cs_flags[idx]; fl = cstack->cs_flags[idx];
if ((fl & CSF_TRY) && !(fl & CSF_FINALLY)) { if ((fl & CSF_TRY) && !(fl & CSF_FINALLY)) {
@ -1111,10 +1148,11 @@ void ex_endwhile(exarg_T *eap)
eap->errmsg = err; eap->errmsg = err;
return; return;
} }
if (fl & csf) if (fl & csf) {
break; break;
}
} }
/* Cleanup and rewind all contained (and unclosed) conditionals. */ // Cleanup and rewind all contained (and unclosed) conditionals.
(void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE); (void)cleanup_conditionals(cstack, CSF_WHILE | CSF_FOR, FALSE);
rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel); rewind_conditionals(cstack, idx, CSF_TRY, &cstack->cs_trylevel);
} }
@ -1130,8 +1168,9 @@ void ex_endwhile(exarg_T *eap)
*/ */
else if (cstack->cs_flags[cstack->cs_idx] & CSF_TRUE else if (cstack->cs_flags[cstack->cs_idx] & CSF_TRUE
&& !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE) && !(cstack->cs_flags[cstack->cs_idx] & CSF_ACTIVE)
&& dbg_check_skipped(eap)) && dbg_check_skipped(eap)) {
(void)do_intthrow(cstack); (void)do_intthrow(cstack);
}
/* /*
* Set loop flag, so do_cmdline() will jump back to the matching * Set loop flag, so do_cmdline() will jump back to the matching
@ -1216,13 +1255,14 @@ void do_throw(cstack_T *cstack)
* the matching catch clause or the finally clause. * the matching catch clause or the finally clause.
*/ */
if (!(cstack->cs_flags[idx] & CSF_CAUGHT)) { if (!(cstack->cs_flags[idx] & CSF_CAUGHT)) {
if (cstack->cs_flags[idx] & CSF_ACTIVE) if (cstack->cs_flags[idx] & CSF_ACTIVE) {
cstack->cs_flags[idx] |= CSF_THROWN; cstack->cs_flags[idx] |= CSF_THROWN;
else } else {
/* THROWN may have already been set for a catchable exception /* THROWN may have already been set for a catchable exception
* that has been discarded. Ensure it is reset for the new * that has been discarded. Ensure it is reset for the new
* exception. */ * exception. */
cstack->cs_flags[idx] &= ~CSF_THROWN; cstack->cs_flags[idx] &= ~CSF_THROWN;
}
} }
cstack->cs_flags[idx] &= ~CSF_ACTIVE; cstack->cs_flags[idx] &= ~CSF_ACTIVE;
cstack->cs_exception[idx] = current_exception; cstack->cs_exception[idx] = current_exception;
@ -1237,9 +1277,9 @@ void ex_try(exarg_T *eap)
int skip; int skip;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_idx == CSTACK_LEN - 1) if (cstack->cs_idx == CSTACK_LEN - 1) {
eap->errmsg = (char_u *)N_("E601: :try nesting too deep"); eap->errmsg = (char_u *)N_("E601: :try nesting too deep");
else { } else {
++cstack->cs_idx; ++cstack->cs_idx;
++cstack->cs_trylevel; ++cstack->cs_trylevel;
cstack->cs_flags[cstack->cs_idx] = CSF_TRY; cstack->cs_flags[cstack->cs_idx] = CSF_TRY;
@ -1278,7 +1318,6 @@ void ex_try(exarg_T *eap)
emsg_silent = 0; emsg_silent = 0;
} }
} }
} }
} }
@ -1291,13 +1330,13 @@ void ex_catch(exarg_T *eap)
int give_up = FALSE; int give_up = FALSE;
int skip = FALSE; int skip = FALSE;
int caught = FALSE; int caught = FALSE;
char_u *end; char_u *end;
char_u save_char = 0; char_u save_char = 0;
char_u *save_cpo; char_u *save_cpo;
regmatch_T regmatch; regmatch_T regmatch;
int prev_got_int; int prev_got_int;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
char_u *pat; char_u *pat;
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) { if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) {
eap->errmsg = (char_u *)N_("E603: :catch without :try"); eap->errmsg = (char_u *)N_("E603: :catch without :try");
@ -1309,20 +1348,23 @@ void ex_catch(exarg_T *eap)
eap->errmsg = get_end_emsg(cstack); eap->errmsg = get_end_emsg(cstack);
skip = TRUE; skip = TRUE;
} }
for (idx = cstack->cs_idx; idx > 0; --idx) for (idx = cstack->cs_idx; idx > 0; --idx) {
if (cstack->cs_flags[idx] & CSF_TRY) if (cstack->cs_flags[idx] & CSF_TRY) {
break; break;
}
}
if (cstack->cs_flags[idx] & CSF_FINALLY) { if (cstack->cs_flags[idx] & CSF_FINALLY) {
/* Give up for a ":catch" after ":finally" and ignore it. /* Give up for a ":catch" after ":finally" and ignore it.
* Just parse. */ * Just parse. */
eap->errmsg = (char_u *)N_("E604: :catch after :finally"); eap->errmsg = (char_u *)N_("E604: :catch after :finally");
give_up = TRUE; give_up = TRUE;
} else } else {
rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR, rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
&cstack->cs_looplevel); &cstack->cs_looplevel);
}
} }
if (ends_excmd(*eap->arg)) { /* no argument, catch all errors */ if (ends_excmd(*eap->arg)) { // no argument, catch all errors
pat = (char_u *)".*"; pat = (char_u *)".*";
end = NULL; end = NULL;
eap->nextcmd = find_nextcmd(eap->arg); eap->nextcmd = find_nextcmd(eap->arg);
@ -1390,7 +1432,7 @@ void ex_catch(exarg_T *eap)
prev_got_int = got_int; prev_got_int = got_int;
got_int = FALSE; got_int = FALSE;
caught = vim_regexec_nl(&regmatch, current_exception->value, caught = vim_regexec_nl(&regmatch, current_exception->value,
(colnr_T)0); (colnr_T)0);
got_int |= prev_got_int; got_int |= prev_got_int;
vim_regfree(regmatch.regprog); vim_regfree(regmatch.regprog);
} }
@ -1430,8 +1472,9 @@ void ex_catch(exarg_T *eap)
} }
} }
if (end != NULL) if (end != NULL) {
eap->nextcmd = find_nextcmd(end); eap->nextcmd = find_nextcmd(end);
}
} }
/* /*
@ -1444,28 +1487,31 @@ void ex_finally(exarg_T *eap)
int pending = CSTP_NONE; int pending = CSTP_NONE;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) {
eap->errmsg = (char_u *)N_("E606: :finally without :try"); eap->errmsg = (char_u *)N_("E606: :finally without :try");
else { } else {
if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) { if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
eap->errmsg = get_end_emsg(cstack); eap->errmsg = get_end_emsg(cstack);
for (idx = cstack->cs_idx - 1; idx > 0; --idx) for (idx = cstack->cs_idx - 1; idx > 0; --idx) {
if (cstack->cs_flags[idx] & CSF_TRY) if (cstack->cs_flags[idx] & CSF_TRY) {
break; break;
}
}
/* Make this error pending, so that the commands in the following /* Make this error pending, so that the commands in the following
* finally clause can be executed. This overrules also a pending * finally clause can be executed. This overrules also a pending
* ":continue", ":break", ":return", or ":finish". */ * ":continue", ":break", ":return", or ":finish". */
pending = CSTP_ERROR; pending = CSTP_ERROR;
} else } else {
idx = cstack->cs_idx; idx = cstack->cs_idx;
}
if (cstack->cs_flags[idx] & CSF_FINALLY) { if (cstack->cs_flags[idx] & CSF_FINALLY) {
/* Give up for a multiple ":finally" and ignore it. */ // Give up for a multiple ":finally" and ignore it.
eap->errmsg = (char_u *)N_("E607: multiple :finally"); eap->errmsg = (char_u *)N_("E607: multiple :finally");
return; return;
} }
rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR, rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
&cstack->cs_looplevel); &cstack->cs_looplevel);
/* /*
* Don't do something when the corresponding try block never got active * Don't do something when the corresponding try block never got active
@ -1517,7 +1563,7 @@ void ex_finally(exarg_T *eap)
if (pending == CSTP_ERROR || did_emsg || got_int || current_exception) { if (pending == CSTP_ERROR || did_emsg || got_int || current_exception) {
if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN) { if (cstack->cs_pending[cstack->cs_idx] == CSTP_RETURN) {
report_discard_pending(CSTP_RETURN, report_discard_pending(CSTP_RETURN,
cstack->cs_rettv[cstack->cs_idx]); cstack->cs_rettv[cstack->cs_idx]);
discard_pending_return(cstack->cs_rettv[cstack->cs_idx]); discard_pending_return(cstack->cs_rettv[cstack->cs_idx]);
} }
if (pending == CSTP_ERROR && !did_emsg) { if (pending == CSTP_ERROR && !did_emsg) {
@ -1564,7 +1610,7 @@ void ex_endtry(exarg_T *eap)
int skip; int skip;
int rethrow = FALSE; int rethrow = FALSE;
int pending = CSTP_NONE; int pending = CSTP_NONE;
void *rettv = NULL; void *rettv = NULL;
cstack_T *const cstack = eap->cstack; cstack_T *const cstack = eap->cstack;
if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) { if (cstack->cs_trylevel <= 0 || cstack->cs_idx < 0) {
@ -1585,13 +1631,13 @@ void ex_endtry(exarg_T *eap)
if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) { if (!(cstack->cs_flags[cstack->cs_idx] & CSF_TRY)) {
eap->errmsg = get_end_emsg(cstack); eap->errmsg = get_end_emsg(cstack);
/* Find the matching ":try" and report what's missing. */ // Find the matching ":try" and report what's missing.
idx = cstack->cs_idx; idx = cstack->cs_idx;
do do
--idx; --idx;
while (idx > 0 && !(cstack->cs_flags[idx] & CSF_TRY)); while (idx > 0 && !(cstack->cs_flags[idx] & CSF_TRY));
rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR, rewind_conditionals(cstack, idx, CSF_WHILE | CSF_FOR,
&cstack->cs_looplevel); &cstack->cs_looplevel);
skip = TRUE; skip = TRUE;
/* /*
@ -1656,10 +1702,11 @@ void ex_endtry(exarg_T *eap)
if (!skip) { if (!skip) {
pending = cstack->cs_pending[idx]; pending = cstack->cs_pending[idx];
cstack->cs_pending[idx] = CSTP_NONE; cstack->cs_pending[idx] = CSTP_NONE;
if (pending == CSTP_RETURN) if (pending == CSTP_RETURN) {
rettv = cstack->cs_rettv[idx]; rettv = cstack->cs_rettv[idx];
else if (pending & CSTP_THROW) } else if (pending & CSTP_THROW) {
current_exception = cstack->cs_exception[idx]; current_exception = cstack->cs_exception[idx];
}
} }
/* /*
@ -1679,8 +1726,8 @@ void ex_endtry(exarg_T *eap)
if (!skip) { if (!skip) {
report_resume_pending(pending, report_resume_pending(pending,
(pending == CSTP_RETURN) ? rettv : (pending == CSTP_RETURN) ? rettv :
(pending & CSTP_THROW) ? (void *)current_exception : NULL); (pending & CSTP_THROW) ? (void *)current_exception : NULL);
switch (pending) { switch (pending) {
case CSTP_NONE: case CSTP_NONE:
break; break;
@ -1788,7 +1835,7 @@ void enter_cleanup(cleanup_T *csp)
did_emsg = got_int = need_rethrow = false; did_emsg = got_int = need_rethrow = false;
current_exception = NULL; current_exception = NULL;
/* Report if required by the 'verbose' option or when debugging. */ // Report if required by the 'verbose' option or when debugging.
report_make_pending(pending, csp->exception); report_make_pending(pending, csp->exception);
} else { } else {
csp->pending = CSTP_NONE; csp->pending = CSTP_NONE;
@ -1815,8 +1862,9 @@ void leave_cleanup(cleanup_T *csp)
{ {
int pending = csp->pending; int pending = csp->pending;
if (pending == CSTP_NONE) /* nothing to do */ if (pending == CSTP_NONE) { // nothing to do
return; return;
}
/* If there was an aborting error, an interrupt, or an uncaught exception /* If there was an aborting error, an interrupt, or an uncaught exception
* after the corresponding call to enter_cleanup(), discard what has been * after the corresponding call to enter_cleanup(), discard what has been
@ -1832,8 +1880,9 @@ void leave_cleanup(cleanup_T *csp)
/* If an error was about to be converted to an exception when /* If an error was about to be converted to an exception when
* enter_cleanup() was called, free the message list. */ * enter_cleanup() was called, free the message list. */
if (msg_list != NULL) if (msg_list != NULL) {
free_global_msglist(); free_global_msglist();
}
} }
/* /*
* If there was no new error, interrupt, or throw between the calls * If there was no new error, interrupt, or throw between the calls
@ -1846,9 +1895,9 @@ void leave_cleanup(cleanup_T *csp)
* called, we need to rethrow it. Make it the exception currently * called, we need to rethrow it. Make it the exception currently
* being thrown. * being thrown.
*/ */
if (pending & CSTP_THROW) if (pending & CSTP_THROW) {
current_exception = csp->exception; current_exception = csp->exception;
}
/* /*
* If an error was about to be converted to an exception when * If an error was about to be converted to an exception when
* enter_cleanup() was called, let "cause_abort" take the part of * enter_cleanup() was called, let "cause_abort" take the part of
@ -1871,8 +1920,7 @@ void leave_cleanup(cleanup_T *csp)
} }
// Report if required by the 'verbose' option or when debugging. // Report if required by the 'verbose' option or when debugging.
report_resume_pending( report_resume_pending(pending, ((pending & CSTP_THROW) ? (void *)current_exception : NULL));
pending, ((pending & CSTP_THROW) ? (void *)current_exception : NULL));
} }
} }
@ -1920,7 +1968,7 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
case CSTP_RETURN: case CSTP_RETURN:
report_discard_pending(CSTP_RETURN, report_discard_pending(CSTP_RETURN,
cstack->cs_rettv[idx]); cstack->cs_rettv[idx]);
discard_pending_return(cstack->cs_rettv[idx]); discard_pending_return(cstack->cs_rettv[idx]);
cstack->cs_pending[idx] = CSTP_NONE; cstack->cs_pending[idx] = CSTP_NONE;
break; break;
@ -1948,15 +1996,17 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
*/ */
if (!(cstack->cs_flags[idx] & CSF_FINALLY)) { if (!(cstack->cs_flags[idx] & CSF_FINALLY)) {
if ((cstack->cs_flags[idx] & CSF_ACTIVE) if ((cstack->cs_flags[idx] & CSF_ACTIVE)
&& (cstack->cs_flags[idx] & CSF_CAUGHT)) && (cstack->cs_flags[idx] & CSF_CAUGHT)) {
finish_exception((except_T *)cstack->cs_exception[idx]); finish_exception((except_T *)cstack->cs_exception[idx]);
}
/* Stop at this try conditional - except the try block never /* Stop at this try conditional - except the try block never
* got active (because of an inactive surrounding conditional * got active (because of an inactive surrounding conditional
* or when the ":try" appeared after an error or interrupt or * or when the ":try" appeared after an error or interrupt or
* throw). */ * throw). */
if (cstack->cs_flags[idx] & CSF_TRUE) { if (cstack->cs_flags[idx] & CSF_TRUE) {
if (searched_cond == 0 && !inclusive) if (searched_cond == 0 && !inclusive) {
break; break;
}
stop = TRUE; stop = TRUE;
} }
} }
@ -1967,13 +2017,15 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
* If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT, * If "inclusive" is TRUE and "searched_cond" is CSF_TRY|CSF_SILENT,
* check first whether "emsg_silent" needs to be restored. */ * check first whether "emsg_silent" needs to be restored. */
if (cstack->cs_flags[idx] & searched_cond) { if (cstack->cs_flags[idx] & searched_cond) {
if (!inclusive) if (!inclusive) {
break; break;
}
stop = TRUE; stop = TRUE;
} }
cstack->cs_flags[idx] &= ~CSF_ACTIVE; cstack->cs_flags[idx] &= ~CSF_ACTIVE;
if (stop && searched_cond != (CSF_TRY | CSF_SILENT)) if (stop && searched_cond != (CSF_TRY | CSF_SILENT)) {
break; break;
}
/* /*
* When leaving a try conditional that reset "emsg_silent" on its * When leaving a try conditional that reset "emsg_silent" on its
@ -1982,7 +2034,7 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
*/ */
if ((cstack->cs_flags[idx] & CSF_TRY) if ((cstack->cs_flags[idx] & CSF_TRY)
&& (cstack->cs_flags[idx] & CSF_SILENT)) { && (cstack->cs_flags[idx] & CSF_SILENT)) {
eslist_T *elem; eslist_T *elem;
elem = cstack->cs_emsg_silent_list; elem = cstack->cs_emsg_silent_list;
cstack->cs_emsg_silent_list = elem->next; cstack->cs_emsg_silent_list = elem->next;
@ -1990,8 +2042,9 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
xfree(elem); xfree(elem);
cstack->cs_flags[idx] &= ~CSF_SILENT; cstack->cs_flags[idx] &= ~CSF_SILENT;
} }
if (stop) if (stop) {
break; break;
}
} }
return idx; return idx;
} }
@ -2001,10 +2054,12 @@ int cleanup_conditionals(cstack_T *cstack, int searched_cond, int inclusive)
*/ */
static char_u *get_end_emsg(cstack_T *cstack) static char_u *get_end_emsg(cstack_T *cstack)
{ {
if (cstack->cs_flags[cstack->cs_idx] & CSF_WHILE) if (cstack->cs_flags[cstack->cs_idx] & CSF_WHILE) {
return e_endwhile; return e_endwhile;
if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR) }
if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR) {
return e_endfor; return e_endfor;
}
return e_endif; return e_endif;
} }
@ -2016,14 +2071,15 @@ static char_u *get_end_emsg(cstack_T *cstack)
* type. * type.
* Also free "for info" structures where needed. * Also free "for info" structures where needed.
*/ */
void rewind_conditionals(cstack_T *cstack, int idx, int cond_type, void rewind_conditionals(cstack_T *cstack, int idx, int cond_type, int *cond_level)
int *cond_level)
{ {
while (cstack->cs_idx > idx) { while (cstack->cs_idx > idx) {
if (cstack->cs_flags[cstack->cs_idx] & cond_type) if (cstack->cs_flags[cstack->cs_idx] & cond_type) {
--*cond_level; --*cond_level;
if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR) }
if (cstack->cs_flags[cstack->cs_idx] & CSF_FOR) {
free_for_info(cstack->cs_forinfo[cstack->cs_idx]); free_for_info(cstack->cs_forinfo[cstack->cs_idx]);
}
--cstack->cs_idx; --cstack->cs_idx;
} }
} }
@ -2043,18 +2099,21 @@ int has_loop_cmd(char_u *p)
{ {
int len; int len;
/* skip modifiers, white space and ':' */ // skip modifiers, white space and ':'
for (;; ) { for (;; ) {
while (*p == ' ' || *p == '\t' || *p == ':') while (*p == ' ' || *p == '\t' || *p == ':') {
++p; ++p;
}
len = modifier_len(p); len = modifier_len(p);
if (len == 0) if (len == 0) {
break; break;
}
p += len; p += len;
} }
if ((p[0] == 'w' && p[1] == 'h') if ((p[0] == 'w' && p[1] == 'h')
|| (p[0] == 'f' && p[1] == 'o' && p[2] == 'r')) || (p[0] == 'f' && p[1] == 'o' && p[2] == 'r')) {
return TRUE; return TRUE;
}
return FALSE; return FALSE;
} }

1210
src/nvim/ex_getln.c
View File

File diff suppressed because it is too large Load Diff

64
src/nvim/ex_session.c
View File

@ -8,13 +8,11 @@
// :mksession // :mksession
#include <assert.h> #include <assert.h>
#include <string.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
#include <stdlib.h> #include <stdlib.h>
#include <inttypes.h> #include <string.h>
#include "nvim/vim.h"
#include "nvim/globals.h"
#include "nvim/ascii.h" #include "nvim/ascii.h"
#include "nvim/buffer.h" #include "nvim/buffer.h"
#include "nvim/cursor.h" #include "nvim/cursor.h"
@ -28,6 +26,7 @@
#include "nvim/fileio.h" #include "nvim/fileio.h"
#include "nvim/fold.h" #include "nvim/fold.h"
#include "nvim/getchar.h" #include "nvim/getchar.h"
#include "nvim/globals.h"
#include "nvim/keymap.h" #include "nvim/keymap.h"
#include "nvim/misc1.h" #include "nvim/misc1.h"
#include "nvim/move.h" #include "nvim/move.h"
@ -36,6 +35,7 @@
#include "nvim/os/os.h" #include "nvim/os/os.h"
#include "nvim/os/time.h" #include "nvim/os/time.h"
#include "nvim/path.h" #include "nvim/path.h"
#include "nvim/vim.h"
#include "nvim/window.h" #include "nvim/window.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
@ -63,7 +63,7 @@ static int put_view_curpos(FILE *fd, const win_T *wp, char *spaces)
static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin) static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin)
{ {
int n = 0; int n = 0;
win_T *wp; win_T *wp;
if (restore_size && (ssop_flags & SSOP_WINSIZE)) { if (restore_size && (ssop_flags & SSOP_WINSIZE)) {
for (wp = tab_firstwin; wp != NULL; wp = wp->w_next) { for (wp = tab_firstwin; wp != NULL; wp = wp->w_next) {
@ -105,7 +105,7 @@ static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin)
// Returns FAIL when writing the commands to "fd" fails. // Returns FAIL when writing the commands to "fd" fails.
static int ses_win_rec(FILE *fd, frame_T *fr) static int ses_win_rec(FILE *fd, frame_T *fr)
{ {
frame_T *frc; frame_T *frc;
int count = 0; int count = 0;
if (fr->fr_layout != FR_LEAF) { if (fr->fr_layout != FR_LEAF) {
@ -149,7 +149,7 @@ static int ses_win_rec(FILE *fd, frame_T *fr)
// Returns NULL when there none. // Returns NULL when there none.
static frame_T *ses_skipframe(frame_T *fr) static frame_T *ses_skipframe(frame_T *fr)
{ {
frame_T *frc; frame_T *frc;
FOR_ALL_FRAMES(frc, fr) { FOR_ALL_FRAMES(frc, fr) {
if (ses_do_frame(frc)) { if (ses_do_frame(frc)) {
@ -200,11 +200,10 @@ static int ses_do_win(win_T *wp)
/// @param flagp /// @param flagp
/// ///
/// @returns FAIL if writing fails. /// @returns FAIL if writing fails.
static int ses_arglist(FILE *fd, char *cmd, garray_T *gap, int fullname, static int ses_arglist(FILE *fd, char *cmd, garray_T *gap, int fullname, unsigned *flagp)
unsigned *flagp)
{ {
char_u *buf = NULL; char_u *buf = NULL;
char_u *s; char_u *s;
if (fprintf(fd, "%s\n%s\n", cmd, "%argdel") < 0) { if (fprintf(fd, "%s\n%s\n", cmd, "%argdel") < 0) {
return FAIL; return FAIL;
@ -297,17 +296,15 @@ static int ses_put_fname(FILE *fd, char_u *name, unsigned *flagp)
return retval; return retval;
} }
// Write commands to "fd" to restore the view of a window. /// Write commands to "fd" to restore the view of a window.
// Caller must make sure 'scrolloff' is zero. /// Caller must make sure 'scrolloff' is zero.
static int put_view( ///
FILE *fd, /// @param add_edit add ":edit" command to view
win_T *wp, /// @param flagp vop_flags or ssop_flags
int add_edit, // add ":edit" command to view /// @param current_arg_idx current argument index of the window, use -1 if unknown
unsigned *flagp, // vop_flags or ssop_flags static int put_view(FILE *fd, win_T *wp, int add_edit, unsigned *flagp, int current_arg_idx)
int current_arg_idx // current argument index of the window, use
) // -1 if unknown
{ {
win_T *save_curwin; win_T *save_curwin;
int f; int f;
int do_cursor; int do_cursor;
int did_next = false; int did_next = false;
@ -348,8 +345,8 @@ static int put_view(
// Load the file. // Load the file.
// //
if (wp->w_buffer->b_ffname != NULL if (wp->w_buffer->b_ffname != NULL
&& (!bt_nofile(wp->w_buffer) || wp->w_buffer->terminal) && (!bt_nofile(wp->w_buffer) ||
) { wp->w_buffer->terminal)) {
// Editing a file in this buffer: use ":edit file". // Editing a file in this buffer: use ":edit file".
// This may have side effects! (e.g., compressed or network file). // This may have side effects! (e.g., compressed or network file).
// //
@ -434,8 +431,8 @@ static int put_view(
// //
if ((*flagp & SSOP_FOLDS) if ((*flagp & SSOP_FOLDS)
&& wp->w_buffer->b_ffname != NULL && wp->w_buffer->b_ffname != NULL
&& (bt_normal(wp->w_buffer) || bt_help(wp->w_buffer)) && (bt_normal(wp->w_buffer) ||
) { bt_help(wp->w_buffer))) {
if (put_folds(fd, wp) == FAIL) { if (put_folds(fd, wp) == FAIL) {
return FAIL; return FAIL;
} }
@ -525,12 +522,12 @@ static int makeopens(FILE *fd, char_u *dirnow)
int only_save_windows = true; int only_save_windows = true;
int nr; int nr;
int restore_size = true; int restore_size = true;
win_T *wp; win_T *wp;
char_u *sname; char_u *sname;
win_T *edited_win = NULL; win_T *edited_win = NULL;
int tabnr; int tabnr;
win_T *tab_firstwin; win_T *tab_firstwin;
frame_T *tab_topframe; frame_T *tab_topframe;
int cur_arg_idx = 0; int cur_arg_idx = 0;
int next_arg_idx = 0; int next_arg_idx = 0;
@ -658,8 +655,7 @@ static int makeopens(FILE *fd, char_u *dirnow)
if (ses_do_win(wp) if (ses_do_win(wp)
&& wp->w_buffer->b_ffname != NULL && wp->w_buffer->b_ffname != NULL
&& !bt_help(wp->w_buffer) && !bt_help(wp->w_buffer)
&& !bt_nofile(wp->w_buffer) && !bt_nofile(wp->w_buffer)) {
) {
if (need_tabnext && put_line(fd, "tabnext") == FAIL) { if (need_tabnext && put_line(fd, "tabnext") == FAIL) {
return FAIL; return FAIL;
} }
@ -877,12 +873,12 @@ void ex_loadview(exarg_T *eap)
/// - SSOP_SLASH: filenames are written with "/" slash /// - SSOP_SLASH: filenames are written with "/" slash
void ex_mkrc(exarg_T *eap) void ex_mkrc(exarg_T *eap)
{ {
FILE *fd; FILE *fd;
int failed = false; int failed = false;
int view_session = false; // :mkview, :mksession int view_session = false; // :mkview, :mksession
int using_vdir = false; // using 'viewdir'? int using_vdir = false; // using 'viewdir'?
char *viewFile = NULL; char *viewFile = NULL;
unsigned *flagp; unsigned *flagp;
if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) { if (eap->cmdidx == CMD_mksession || eap->cmdidx == CMD_mkview) {
view_session = true; view_session = true;

93
src/nvim/extmark.c
View File

@ -29,19 +29,20 @@
// code for redrawing the line with the deleted decoration. // code for redrawing the line with the deleted decoration.
#include <assert.h> #include <assert.h>
#include "nvim/api/vim.h" #include "nvim/api/vim.h"
#include "nvim/vim.h" #include "nvim/buffer.h"
#include "nvim/charset.h"
#include "nvim/extmark.h"
#include "nvim/decoration.h"
#include "nvim/buffer_updates.h" #include "nvim/buffer_updates.h"
#include "nvim/charset.h"
#include "nvim/decoration.h"
#include "nvim/extmark.h"
#include "nvim/globals.h"
#include "nvim/lib/kbtree.h"
#include "nvim/map.h"
#include "nvim/memline.h" #include "nvim/memline.h"
#include "nvim/pos.h" #include "nvim/pos.h"
#include "nvim/globals.h"
#include "nvim/map.h"
#include "nvim/lib/kbtree.h"
#include "nvim/undo.h" #include "nvim/undo.h"
#include "nvim/buffer.h" #include "nvim/vim.h"
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
# include "extmark.c.generated.h" # include "extmark.c.generated.h"
@ -56,10 +57,9 @@ static ExtmarkNs *buf_ns_ref(buf_T *buf, uint64_t ns_id, bool put) {
/// ///
/// must not be used during iteration! /// must not be used during iteration!
/// @returns the mark id /// @returns the mark id
uint64_t extmark_set(buf_T *buf, uint64_t ns_id, uint64_t id, uint64_t extmark_set(buf_T *buf, uint64_t ns_id, uint64_t id, int row, colnr_T col, int end_row,
int row, colnr_T col, int end_row, colnr_T end_col, colnr_T end_col, Decoration *decor, bool right_gravity, bool end_right_gravity,
Decoration *decor, bool right_gravity, ExtmarkOp op)
bool end_right_gravity, ExtmarkOp op)
{ {
ExtmarkNs *ns = buf_ns_ref(buf, ns_id, true); ExtmarkNs *ns = buf_ns_ref(buf, ns_id, true);
assert(ns != NULL); assert(ns != NULL);
@ -178,9 +178,7 @@ bool extmark_del(buf_T *buf, uint64_t ns_id, uint64_t id)
// Free extmarks in a ns between lines // Free extmarks in a ns between lines
// if ns = 0, it means clear all namespaces // if ns = 0, it means clear all namespaces
bool extmark_clear(buf_T *buf, uint64_t ns_id, bool extmark_clear(buf_T *buf, uint64_t ns_id, int l_row, colnr_T l_col, int u_row, colnr_T u_col)
int l_row, colnr_T l_col,
int u_row, colnr_T u_col)
{ {
if (!map_size(buf->b_extmark_ns)) { if (!map_size(buf->b_extmark_ns)) {
return false; return false;
@ -281,10 +279,8 @@ bool extmark_clear(buf_T *buf, uint64_t ns_id,
// will be searched to the start, or end // will be searched to the start, or end
// dir can be set to control the order of the array // dir can be set to control the order of the array
// amount = amount of marks to find or -1 for all // amount = amount of marks to find or -1 for all
ExtmarkInfoArray extmark_get(buf_T *buf, uint64_t ns_id, ExtmarkInfoArray extmark_get(buf_T *buf, uint64_t ns_id, int l_row, colnr_T l_col, int u_row,
int l_row, colnr_T l_col, colnr_T u_col, int64_t amount, bool reverse)
int u_row, colnr_T u_col,
int64_t amount, bool reverse)
{ {
ExtmarkInfoArray array = KV_INITIAL_VALUE; ExtmarkInfoArray array = KV_INITIAL_VALUE;
MarkTreeIter itr[1]; MarkTreeIter itr[1];
@ -394,10 +390,9 @@ void extmark_free_all(buf_T *buf)
// Save info for undo/redo of set marks // Save info for undo/redo of set marks
static void u_extmark_set(buf_T *buf, uint64_t mark, static void u_extmark_set(buf_T *buf, uint64_t mark, int row, colnr_T col)
int row, colnr_T col)
{ {
u_header_T *uhp = u_force_get_undo_header(buf); u_header_T *uhp = u_force_get_undo_header(buf);
if (!uhp) { if (!uhp) {
return; return;
} }
@ -419,11 +414,9 @@ static void u_extmark_set(buf_T *buf, uint64_t mark,
/// ///
/// useful when we cannot simply reverse the operation. This will do nothing on /// useful when we cannot simply reverse the operation. This will do nothing on
/// redo, enforces correct position when undo. /// redo, enforces correct position when undo.
void u_extmark_copy(buf_T *buf, void u_extmark_copy(buf_T *buf, int l_row, colnr_T l_col, int u_row, colnr_T u_col)
int l_row, colnr_T l_col,
int u_row, colnr_T u_col)
{ {
u_header_T *uhp = u_force_get_undo_header(buf); u_header_T *uhp = u_force_get_undo_header(buf);
if (!uhp) { if (!uhp) {
return; return;
} }
@ -467,7 +460,6 @@ void extmark_apply_undo(ExtmarkUndoObject undo_info, bool undo)
splice.new_row, splice.new_col, splice.new_byte, splice.new_row, splice.new_col, splice.new_byte,
splice.old_row, splice.old_col, splice.old_byte, splice.old_row, splice.old_col, splice.old_byte,
kExtmarkNoUndo); kExtmarkNoUndo);
} else { } else {
extmark_splice_impl(curbuf, extmark_splice_impl(curbuf,
splice.start_row, splice.start_col, splice.start_byte, splice.start_row, splice.start_col, splice.start_byte,
@ -475,14 +467,14 @@ void extmark_apply_undo(ExtmarkUndoObject undo_info, bool undo)
splice.new_row, splice.new_col, splice.new_byte, splice.new_row, splice.new_col, splice.new_byte,
kExtmarkNoUndo); kExtmarkNoUndo);
} }
// kExtmarkSavePos // kExtmarkSavePos
} else if (undo_info.type == kExtmarkSavePos) { } else if (undo_info.type == kExtmarkSavePos) {
ExtmarkSavePos pos = undo_info.data.savepos; ExtmarkSavePos pos = undo_info.data.savepos;
if (undo) { if (undo) {
if (pos.old_row >= 0) { if (pos.old_row >= 0) {
extmark_setraw(curbuf, pos.mark, pos.old_row, pos.old_col); extmark_setraw(curbuf, pos.mark, pos.old_row, pos.old_col);
} }
// Redo // Redo
} else { } else {
if (pos.row >= 0) { if (pos.row >= 0) {
extmark_setraw(curbuf, pos.mark, pos.row, pos.col); extmark_setraw(curbuf, pos.mark, pos.row, pos.col);
@ -508,11 +500,7 @@ void extmark_apply_undo(ExtmarkUndoObject undo_info, bool undo)
// Adjust extmark row for inserted/deleted rows (columns stay fixed). // Adjust extmark row for inserted/deleted rows (columns stay fixed).
void extmark_adjust(buf_T *buf, void extmark_adjust(buf_T *buf, linenr_T line1, linenr_T line2, long amount, long amount_after,
linenr_T line1,
linenr_T line2,
long amount,
long amount_after,
ExtmarkOp undo) ExtmarkOp undo)
{ {
if (curbuf_splice_pending) { if (curbuf_splice_pending) {
@ -537,7 +525,7 @@ void extmark_adjust(buf_T *buf,
} }
if (new_row > 0) { if (new_row > 0) {
new_byte = ml_find_line_or_offset(buf, line1+new_row, NULL, true) new_byte = ml_find_line_or_offset(buf, line1+new_row, NULL, true)
- start_byte; - start_byte;
} }
extmark_splice_impl(buf, extmark_splice_impl(buf,
(int)line1-1, 0, start_byte, (int)line1-1, 0, start_byte,
@ -562,10 +550,8 @@ void extmark_adjust(buf_T *buf,
// the end column of the new region. // the end column of the new region.
// @param new_byte Byte extent of the new region. // @param new_byte Byte extent of the new region.
// @param undo // @param undo
void extmark_splice(buf_T *buf, void extmark_splice(buf_T *buf, int start_row, colnr_T start_col, int old_row, colnr_T old_col,
int start_row, colnr_T start_col, bcount_t old_byte, int new_row, colnr_T new_col, bcount_t new_byte,
int old_row, colnr_T old_col, bcount_t old_byte,
int new_row, colnr_T new_col, bcount_t new_byte,
ExtmarkOp undo) ExtmarkOp undo)
{ {
long offset = ml_find_line_or_offset(buf, start_row + 1, NULL, true); long offset = ml_find_line_or_offset(buf, start_row + 1, NULL, true);
@ -584,11 +570,9 @@ void extmark_splice(buf_T *buf,
undo); undo);
} }
void extmark_splice_impl(buf_T *buf, void extmark_splice_impl(buf_T *buf, int start_row, colnr_T start_col, bcount_t start_byte,
int start_row, colnr_T start_col, bcount_t start_byte, int old_row, colnr_T old_col, bcount_t old_byte, int new_row,
int old_row, colnr_T old_col, bcount_t old_byte, colnr_T new_col, bcount_t new_byte, ExtmarkOp undo)
int new_row, colnr_T new_col, bcount_t new_byte,
ExtmarkOp undo)
{ {
curbuf->deleted_bytes2 = 0; curbuf->deleted_bytes2 = 0;
buf_updates_send_splice(buf, start_row, start_col, start_byte, buf_updates_send_splice(buf, start_row, start_col, start_byte,
@ -612,7 +596,7 @@ void extmark_splice_impl(buf_T *buf,
new_row, new_col); new_row, new_col);
if (undo == kExtmarkUndo) { if (undo == kExtmarkUndo) {
u_header_T *uhp = u_force_get_undo_header(buf); u_header_T *uhp = u_force_get_undo_header(buf);
if (!uhp) { if (!uhp) {
return; return;
} }
@ -621,7 +605,7 @@ void extmark_splice_impl(buf_T *buf,
// TODO(bfredl): this is quite rudimentary. We merge small (within line) // TODO(bfredl): this is quite rudimentary. We merge small (within line)
// inserts with each other and small deletes with each other. Add full // inserts with each other and small deletes with each other. Add full
// merge algorithm later. // merge algorithm later.
if (old_row == 0 && new_row == 0 && kv_size(uhp->uh_extmark)) { if (old_row == 0 && new_row == 0 && kv_size(uhp->uh_extmark)) {
ExtmarkUndoObject *item = &kv_A(uhp->uh_extmark, ExtmarkUndoObject *item = &kv_A(uhp->uh_extmark,
kv_size(uhp->uh_extmark)-1); kv_size(uhp->uh_extmark)-1);
if (item->type == kExtmarkSplice) { if (item->type == kExtmarkSplice) {
@ -669,22 +653,17 @@ void extmark_splice_impl(buf_T *buf,
} }
} }
void extmark_splice_cols(buf_T *buf, void extmark_splice_cols(buf_T *buf, int start_row, colnr_T start_col, colnr_T old_col,
int start_row, colnr_T start_col, colnr_T new_col, ExtmarkOp undo)
colnr_T old_col, colnr_T new_col,
ExtmarkOp undo)
{ {
extmark_splice(buf, start_row, start_col, extmark_splice(buf, start_row, start_col,
0, old_col, old_col, 0, old_col, old_col,
0, new_col, new_col, undo); 0, new_col, new_col, undo);
} }
void extmark_move_region( void extmark_move_region(buf_T *buf, int start_row, colnr_T start_col, bcount_t start_byte,
buf_T *buf, int extent_row, colnr_T extent_col, bcount_t extent_byte, int new_row,
int start_row, colnr_T start_col, bcount_t start_byte, colnr_T new_col, bcount_t new_byte, ExtmarkOp undo)
int extent_row, colnr_T extent_col, bcount_t extent_byte,
int new_row, colnr_T new_col, bcount_t new_byte,
ExtmarkOp undo)
{ {
curbuf->deleted_bytes2 = 0; curbuf->deleted_bytes2 = 0;
// TODO(bfredl): this is not synced to the buffer state inside the callback. // TODO(bfredl): this is not synced to the buffer state inside the callback.
@ -704,7 +683,7 @@ void extmark_move_region(
if (undo == kExtmarkUndo) { if (undo == kExtmarkUndo) {
u_header_T *uhp = u_force_get_undo_header(buf); u_header_T *uhp = u_force_get_undo_header(buf);
if (!uhp) { if (!uhp) {
return; return;
} }