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: the long goodbye

Browse Source 
long is 32 bits on windows, while it is 64 bits on other architectures.
This makes the type suboptimal for a codebase meant to be
cross-platform. Replace it with more appropriate integer types.
This commit is contained in:
dundargoc 2023-09-29 14:58:48 +02:00 committed by dundargoc
parent c513cbf361
commit acc646ad8f
57 changed files with 362 additions and 367 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/nvim/assert.h
View File

@ -57,7 +57,7 @@
// the easiest case, when the mode is C11 (generic compiler) or Clang // the easiest case, when the mode is C11 (generic compiler) or Clang
// advertises explicit support for c_static_assert, meaning it won't warn. // advertises explicit support for c_static_assert, meaning it won't warn.
#if __STDC_VERSION__ >= 201112L || __has_feature(c_static_assert) #if __STDC_VERSION__ >= 201112 || __has_feature(c_static_assert)
# define STATIC_ASSERT_STATEMENT(cond, msg) _Static_assert(cond, msg) # define STATIC_ASSERT_STATEMENT(cond, msg) _Static_assert(cond, msg)
// if we're dealing with gcc >= 4.6 in C99 mode, we can still use // if we're dealing with gcc >= 4.6 in C99 mode, we can still use
// _Static_assert but we need to suppress warnings, this is pretty ugly. // _Static_assert but we need to suppress warnings, this is pretty ugly.

10
src/nvim/buffer.c
View File

@ -987,7 +987,7 @@ void handle_swap_exists(bufref_T *old_curbuf)
|| old_curbuf->br_buf == curbuf) { || old_curbuf->br_buf == curbuf) {
// Block autocommands here because curwin->w_buffer is NULL. // Block autocommands here because curwin->w_buffer is NULL.
block_autocmds(); block_autocmds();
buf = buflist_new(NULL, NULL, 1L, BLN_CURBUF | BLN_LISTED); buf = buflist_new(NULL, NULL, 1, BLN_CURBUF | BLN_LISTED);
unblock_autocmds(); unblock_autocmds();
} else { } else {
buf = old_curbuf->br_buf; buf = old_curbuf->br_buf;
@ -1886,7 +1886,7 @@ buf_T *buflist_new(char *ffname_arg, char *sfname_arg, linenr_T lnum, int flags)
emsg(_("W14: Warning: List of file names overflow")); emsg(_("W14: Warning: List of file names overflow"));
if (emsg_silent == 0 && !in_assert_fails) { if (emsg_silent == 0 && !in_assert_fails) {
ui_flush(); ui_flush();
os_delay(3001L, true); // make sure it is noticed os_delay(3001, true); // make sure it is noticed
} }
top_file_num = 1; top_file_num = 1;
} }
@ -3496,9 +3496,9 @@ void get_rel_pos(win_T *wp, char *buf, int buflen)
} else if (above <= 0) { } else if (above <= 0) {
xstrlcpy(buf, _("Top"), (size_t)buflen); xstrlcpy(buf, _("Top"), (size_t)buflen);
} else { } else {
int perc = (above > 1000000L int perc = (above > 1000000
? (int)(above / ((above + below) / 100L)) ? (above / ((above + below) / 100))
: (int)(above * 100L / (above + below))); : (above * 100 / (above + below)));
char *p = buf; char *p = buf;
size_t l = (size_t)buflen; size_t l = (size_t)buflen;

18
src/nvim/change.c
View File

@ -92,7 +92,7 @@ void change_warning(buf_T *buf, int col)
(void)msg_end(); (void)msg_end();
if (msg_silent == 0 && !silent_mode && ui_active()) { if (msg_silent == 0 && !silent_mode && ui_active()) {
ui_flush(); ui_flush();
os_delay(1002L, true); // give the user time to think about it os_delay(1002, true); // give the user time to think about it
} }
buf->b_did_warn = true; buf->b_did_warn = true;
redraw_cmdline = false; // don't redraw and erase the message redraw_cmdline = false; // don't redraw and erase the message
@ -131,7 +131,7 @@ void changed(buf_T *buf)
// and don't let the emsg() set msg_scroll. // and don't let the emsg() set msg_scroll.
if (need_wait_return && emsg_silent == 0 && !in_assert_fails) { if (need_wait_return && emsg_silent == 0 && !in_assert_fails) {
ui_flush(); ui_flush();
os_delay(2002L, true); os_delay(2002, true);
wait_return(true); wait_return(true);
msg_scroll = save_msg_scroll; msg_scroll = save_msg_scroll;
} else { } else {
@ -457,7 +457,7 @@ void appended_lines(linenr_T lnum, linenr_T count)
/// Like appended_lines(), but adjust marks first. /// Like appended_lines(), but adjust marks first.
void appended_lines_mark(linenr_T lnum, int count) void appended_lines_mark(linenr_T lnum, int count)
{ {
mark_adjust(lnum + 1, (linenr_T)MAXLNUM, (linenr_T)count, 0L, kExtmarkUndo); mark_adjust(lnum + 1, (linenr_T)MAXLNUM, (linenr_T)count, 0, kExtmarkUndo);
changed_lines(curbuf, lnum + 1, 0, lnum + 1, (linenr_T)count, true); changed_lines(curbuf, lnum + 1, 0, lnum + 1, (linenr_T)count, true);
} }
@ -552,7 +552,7 @@ void changed_lines(buf_T *buf, linenr_T lnum, colnr_T col, linenr_T lnume, linen
wlnum = diff_lnum_win(lnum, wp); wlnum = diff_lnum_win(lnum, wp);
if (wlnum > 0) { if (wlnum > 0) {
buf_redraw_changed_lines_later(wp->w_buffer, wlnum, buf_redraw_changed_lines_later(wp->w_buffer, wlnum,
lnume - lnum + wlnum, 0L); lnume - lnum + wlnum, 0);
} }
} }
} }
@ -823,7 +823,7 @@ int del_char(bool fixpos)
if (*get_cursor_pos_ptr() == NUL) { if (*get_cursor_pos_ptr() == NUL) {
return FAIL; return FAIL;
} }
return del_chars(1L, fixpos); return del_chars(1, fixpos);
} }
/// Like del_bytes(), but delete characters instead of bytes. /// Like del_bytes(), but delete characters instead of bytes.
@ -1731,7 +1731,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
} }
// Postpone calling changed_lines(), because it would mess up folding // Postpone calling changed_lines(), because it would mess up folding
// with markers. // with markers.
mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1L, 0L, kExtmarkNOOP); mark_adjust(curwin->w_cursor.lnum + 1, (linenr_T)MAXLNUM, 1, 0, kExtmarkNOOP);
did_append = true; did_append = true;
} else { } else {
// In MODE_VREPLACE state we are starting to replace the next line. // In MODE_VREPLACE state we are starting to replace the next line.
@ -1822,14 +1822,14 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
saved_line = NULL; saved_line = NULL;
if (did_append) { if (did_append) {
changed_lines(curbuf, curwin->w_cursor.lnum, curwin->w_cursor.col, changed_lines(curbuf, curwin->w_cursor.lnum, curwin->w_cursor.col,
curwin->w_cursor.lnum + 1, 1L, true); curwin->w_cursor.lnum + 1, 1, true);
did_append = false; did_append = false;
// Move marks after the line break to the new line. // Move marks after the line break to the new line.
if (flags & OPENLINE_MARKFIX) { if (flags & OPENLINE_MARKFIX) {
mark_col_adjust(curwin->w_cursor.lnum, mark_col_adjust(curwin->w_cursor.lnum,
curwin->w_cursor.col + less_cols_off, curwin->w_cursor.col + less_cols_off,
1L, -less_cols, 0); 1, -less_cols, 0);
} }
// Always move extmarks - Here we move only the line where the // Always move extmarks - Here we move only the line where the
// cursor is, the previous mark_adjust takes care of the lines after // cursor is, the previous mark_adjust takes care of the lines after
@ -1847,7 +1847,7 @@ int open_line(int dir, int flags, int second_line_indent, bool *did_do_comment)
curwin->w_cursor.lnum = old_cursor.lnum + 1; curwin->w_cursor.lnum = old_cursor.lnum + 1;
} }
if (did_append) { if (did_append) {
changed_lines(curbuf, curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1L, true); changed_lines(curbuf, curwin->w_cursor.lnum, 0, curwin->w_cursor.lnum, 1, true);
// bail out and just get the final length of the line we just manipulated // bail out and just get the final length of the line we just manipulated
bcount_t extra = (bcount_t)strlen(ml_get(curwin->w_cursor.lnum)); bcount_t extra = (bcount_t)strlen(ml_get(curwin->w_cursor.lnum));
extmark_splice(curbuf, (int)curwin->w_cursor.lnum - 1, 0, extmark_splice(curbuf, (int)curwin->w_cursor.lnum - 1, 0,

4
src/nvim/charset.c
View File

@ -1167,14 +1167,14 @@ long getdigits_long(char **pp, bool strict, long def)
/// Gets a int32_t number from a string. /// Gets a int32_t number from a string.
/// ///
/// @see getdigits /// @see getdigits
int32_t getdigits_int32(char **pp, bool strict, long def) int32_t getdigits_int32(char **pp, bool strict, int32_t def)
{ {
intmax_t number = getdigits(pp, strict, def); intmax_t number = getdigits(pp, strict, def);
#if SIZEOF_INTMAX_T > 4 #if SIZEOF_INTMAX_T > 4
if (strict) { if (strict) {
assert(number >= INT32_MIN && number <= INT32_MAX); assert(number >= INT32_MIN && number <= INT32_MAX);
} else if (!(number >= INT32_MIN && number <= INT32_MAX)) { } else if (!(number >= INT32_MIN && number <= INT32_MAX)) {
return (int32_t)def; return def;
} }
#endif #endif
return (int32_t)number; return (int32_t)number;

34
src/nvim/cursor_shape.c
View File

@ -32,23 +32,23 @@ static const char e_digit_expected[] = N_("E548: Digit expected");
cursorentry_T shape_table[SHAPE_IDX_COUNT] = { cursorentry_T shape_table[SHAPE_IDX_COUNT] = {
// Values are set by 'guicursor' and 'mouseshape'. // Values are set by 'guicursor' and 'mouseshape'.
// Adjust the SHAPE_IDX_ defines when changing this! // Adjust the SHAPE_IDX_ defines when changing this!
{ "normal", 0, 0, 0, 700L, 400L, 250L, 0, 0, "n", SHAPE_CURSOR + SHAPE_MOUSE }, { "normal", 0, 0, 0, 700, 400, 250, 0, 0, "n", SHAPE_CURSOR + SHAPE_MOUSE },
{ "visual", 0, 0, 0, 700L, 400L, 250L, 0, 0, "v", SHAPE_CURSOR + SHAPE_MOUSE }, { "visual", 0, 0, 0, 700, 400, 250, 0, 0, "v", SHAPE_CURSOR + SHAPE_MOUSE },
{ "insert", 0, 0, 0, 700L, 400L, 250L, 0, 0, "i", SHAPE_CURSOR + SHAPE_MOUSE }, { "insert", 0, 0, 0, 700, 400, 250, 0, 0, "i", SHAPE_CURSOR + SHAPE_MOUSE },
{ "replace", 0, 0, 0, 700L, 400L, 250L, 0, 0, "r", SHAPE_CURSOR + SHAPE_MOUSE }, { "replace", 0, 0, 0, 700, 400, 250, 0, 0, "r", SHAPE_CURSOR + SHAPE_MOUSE },
{ "cmdline_normal", 0, 0, 0, 700L, 400L, 250L, 0, 0, "c", SHAPE_CURSOR + SHAPE_MOUSE }, { "cmdline_normal", 0, 0, 0, 700, 400, 250, 0, 0, "c", SHAPE_CURSOR + SHAPE_MOUSE },
{ "cmdline_insert", 0, 0, 0, 700L, 400L, 250L, 0, 0, "ci", SHAPE_CURSOR + SHAPE_MOUSE }, { "cmdline_insert", 0, 0, 0, 700, 400, 250, 0, 0, "ci", SHAPE_CURSOR + SHAPE_MOUSE },
{ "cmdline_replace", 0, 0, 0, 700L, 400L, 250L, 0, 0, "cr", SHAPE_CURSOR + SHAPE_MOUSE }, { "cmdline_replace", 0, 0, 0, 700, 400, 250, 0, 0, "cr", SHAPE_CURSOR + SHAPE_MOUSE },
{ "operator", 0, 0, 0, 700L, 400L, 250L, 0, 0, "o", SHAPE_CURSOR + SHAPE_MOUSE }, { "operator", 0, 0, 0, 700, 400, 250, 0, 0, "o", SHAPE_CURSOR + SHAPE_MOUSE },
{ "visual_select", 0, 0, 0, 700L, 400L, 250L, 0, 0, "ve", SHAPE_CURSOR + SHAPE_MOUSE }, { "visual_select", 0, 0, 0, 700, 400, 250, 0, 0, "ve", SHAPE_CURSOR + SHAPE_MOUSE },
{ "cmdline_hover", 0, 0, 0, 0L, 0L, 0L, 0, 0, "e", SHAPE_MOUSE }, { "cmdline_hover", 0, 0, 0, 0, 0, 0, 0, 0, "e", SHAPE_MOUSE },
{ "statusline_hover", 0, 0, 0, 0L, 0L, 0L, 0, 0, "s", SHAPE_MOUSE }, { "statusline_hover", 0, 0, 0, 0, 0, 0, 0, 0, "s", SHAPE_MOUSE },
{ "statusline_drag", 0, 0, 0, 0L, 0L, 0L, 0, 0, "sd", SHAPE_MOUSE }, { "statusline_drag", 0, 0, 0, 0, 0, 0, 0, 0, "sd", SHAPE_MOUSE },
{ "vsep_hover", 0, 0, 0, 0L, 0L, 0L, 0, 0, "vs", SHAPE_MOUSE }, { "vsep_hover", 0, 0, 0, 0, 0, 0, 0, 0, "vs", SHAPE_MOUSE },
{ "vsep_drag", 0, 0, 0, 0L, 0L, 0L, 0, 0, "vd", SHAPE_MOUSE }, { "vsep_drag", 0, 0, 0, 0, 0, 0, 0, 0, "vd", SHAPE_MOUSE },
{ "more", 0, 0, 0, 0L, 0L, 0L, 0, 0, "m", SHAPE_MOUSE }, { "more", 0, 0, 0, 0, 0, 0, 0, 0, "m", SHAPE_MOUSE },
{ "more_lastline", 0, 0, 0, 0L, 0L, 0L, 0, 0, "ml", SHAPE_MOUSE }, { "more_lastline", 0, 0, 0, 0, 0, 0, 0, 0, "ml", SHAPE_MOUSE },
{ "showmatch", 0, 0, 0, 100L, 100L, 100L, 0, 0, "sm", SHAPE_CURSOR }, { "showmatch", 0, 0, 0, 100, 100, 100, 0, 0, "sm", SHAPE_CURSOR },
}; };
/// Converts cursor_shapes into an Array of Dictionaries /// Converts cursor_shapes into an Array of Dictionaries

10
src/nvim/diff.c
View File

@ -106,9 +106,9 @@ typedef struct {
// used for recording hunks from xdiff // used for recording hunks from xdiff
typedef struct { typedef struct {
linenr_T lnum_orig; linenr_T lnum_orig;
long count_orig; int count_orig;
linenr_T lnum_new; linenr_T lnum_new;
long count_new; int count_new;
} diffhunk_T; } diffhunk_T;
// two diff inputs and one result // two diff inputs and one result
@ -771,7 +771,7 @@ static int diff_write_buffer(buf_T *buf, mmfile_t *m, linenr_T start, linenr_T e
return FAIL; return FAIL;
} }
m->ptr = ptr; m->ptr = ptr;
m->size = (long)len; m->size = (int)len;
len = 0; len = 0;
for (linenr_T lnum = start; lnum <= end; lnum++) { for (linenr_T lnum = start; lnum <= end; lnum++) {
@ -2571,7 +2571,7 @@ int diffopt_changed(void)
// recompute the scroll binding with the new option value, may // recompute the scroll binding with the new option value, may
// remove or add filler lines // remove or add filler lines
check_scrollbind((linenr_T)0, 0L); check_scrollbind(0, 0);
return OK; return OK;
} }
@ -3217,7 +3217,7 @@ bool diff_mode_buf(buf_T *buf)
/// @param count /// @param count
/// ///
/// @return FAIL if there isn't such a diff block. /// @return FAIL if there isn't such a diff block.
int diff_move_to(int dir, long count) int diff_move_to(int dir, int count)
{ {
linenr_T lnum = curwin->w_cursor.lnum; linenr_T lnum = curwin->w_cursor.lnum;
int idx = diff_buf_idx(curbuf); int idx = diff_buf_idx(curbuf);

11
src/nvim/drawline.c
View File

@ -2832,12 +2832,11 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool number_onl
} }
if (((wp->w_p_cuc if (((wp->w_p_cuc
&& (int)wp->w_virtcol >= VCOL_HLC - eol_hl_off && wp->w_virtcol >= VCOL_HLC - eol_hl_off
&& (int)wp->w_virtcol < && wp->w_virtcol < grid->cols * (ptrdiff_t)(wlv.row - startrow + 1) + v
(long)grid->cols * (wlv.row - startrow + 1) + v
&& lnum != wp->w_cursor.lnum) && lnum != wp->w_cursor.lnum)
|| draw_color_col || wlv.line_attr_lowprio || wlv.line_attr || draw_color_col || wlv.line_attr_lowprio || wlv.line_attr
|| wlv.diff_hlf != (hlf_T)0 || has_virttext)) { || wlv.diff_hlf != 0 || has_virttext)) {
int rightmost_vcol = 0; int rightmost_vcol = 0;
if (wp->w_p_cuc) { if (wp->w_p_cuc) {
@ -2881,7 +2880,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool number_onl
int col_attr = base_attr; int col_attr = base_attr;
if (wp->w_p_cuc && VCOL_HLC == (long)wp->w_virtcol) { if (wp->w_p_cuc && VCOL_HLC == wp->w_virtcol) {
col_attr = cuc_attr; col_attr = cuc_attr;
} else if (draw_color_col && VCOL_HLC == *color_cols) { } else if (draw_color_col && VCOL_HLC == *color_cols) {
col_attr = hl_combine_attr(wlv.line_attr_lowprio, mc_attr); col_attr = hl_combine_attr(wlv.line_attr_lowprio, mc_attr);
@ -2978,7 +2977,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool number_onl
&& search_attr == 0 && search_attr == 0
&& area_attr == 0 && area_attr == 0
&& wlv.filler_todo <= 0) { && wlv.filler_todo <= 0) {
if (wp->w_p_cuc && VCOL_HLC == (long)wp->w_virtcol if (wp->w_p_cuc && VCOL_HLC == wp->w_virtcol
&& lnum != wp->w_cursor.lnum) { && lnum != wp->w_cursor.lnum) {
vcol_save_attr = wlv.char_attr; vcol_save_attr = wlv.char_attr;
wlv.char_attr = hl_combine_attr(win_hl_attr(wp, HLF_CUC), wlv.char_attr); wlv.char_attr = hl_combine_attr(win_hl_attr(wp, HLF_CUC), wlv.char_attr);

18
src/nvim/edit.c
View File

@ -760,7 +760,7 @@ static int insert_handle_key(InsertState *s)
case Ctrl_A: case Ctrl_A:
// For ^@ the trailing ESC will end the insert, unless there is an // For ^@ the trailing ESC will end the insert, unless there is an
// error. // error.
if (stuff_inserted(NUL, 1L, (s->c == Ctrl_A)) == FAIL if (stuff_inserted(NUL, 1, (s->c == Ctrl_A)) == FAIL
&& s->c != Ctrl_A) { && s->c != Ctrl_A) {
return 0; // exit insert mode return 0; // exit insert mode
} }
@ -2066,7 +2066,7 @@ void insertchar(int c, int flags, int second_indent)
if (*curbuf->b_p_fex != NUL && (flags & INSCHAR_NO_FEX) == 0 if (*curbuf->b_p_fex != NUL && (flags & INSCHAR_NO_FEX) == 0
&& (force_format || virtcol > (colnr_T)textwidth)) { && (force_format || virtcol > (colnr_T)textwidth)) {
do_internal = (fex_format(curwin->w_cursor.lnum, 1L, c) != 0); do_internal = (fex_format(curwin->w_cursor.lnum, 1, c) != 0);
// It may be required to save for undo again, e.g. when setline() // It may be required to save for undo again, e.g. when setline()
// was called. // was called.
ins_need_undo = true; ins_need_undo = true;
@ -2634,7 +2634,7 @@ int cursor_up(linenr_T n, int upd_topline)
/// Move the cursor down "n" lines in window "wp". /// Move the cursor down "n" lines in window "wp".
/// Takes care of closed folds. /// Takes care of closed folds.
void cursor_down_inner(win_T *wp, long n) void cursor_down_inner(win_T *wp, int n)
{ {
linenr_T lnum = wp->w_cursor.lnum; linenr_T lnum = wp->w_cursor.lnum;
linenr_T line_count = wp->w_buffer->b_ml.ml_line_count; linenr_T line_count = wp->w_buffer->b_ml.ml_line_count;
@ -2667,7 +2667,7 @@ void cursor_down_inner(win_T *wp, long n)
} }
/// @param upd_topline When true: update topline /// @param upd_topline When true: update topline
int cursor_down(long n, int upd_topline) int cursor_down(int n, int upd_topline)
{ {
// This fails if the cursor is already in the last line. // This fails if the cursor is already in the last line.
if (n > 0 && curwin->w_cursor.lnum >= curwin->w_buffer->b_ml.ml_line_count) { if (n > 0 && curwin->w_cursor.lnum >= curwin->w_buffer->b_ml.ml_line_count) {
@ -2692,7 +2692,7 @@ int cursor_down(long n, int upd_topline)
/// @param c Command character to be inserted /// @param c Command character to be inserted
/// @param count Repeat this many times /// @param count Repeat this many times
/// @param no_esc Don't add an ESC at the end /// @param no_esc Don't add an ESC at the end
int stuff_inserted(int c, long count, int no_esc) int stuff_inserted(int c, int count, int no_esc)
{ {
char *esc_ptr; char *esc_ptr;
char *ptr; char *ptr;
@ -4099,7 +4099,7 @@ static void ins_s_left(void)
if (!end_change) { if (!end_change) {
AppendCharToRedobuff(K_S_LEFT); AppendCharToRedobuff(K_S_LEFT);
} }
(void)bck_word(1L, false, false); (void)bck_word(1, false, false);
curwin->w_set_curswant = true; curwin->w_set_curswant = true;
} else { } else {
vim_beep(BO_CRSR); vim_beep(BO_CRSR);
@ -4158,7 +4158,7 @@ static void ins_s_right(void)
if (!end_change) { if (!end_change) {
AppendCharToRedobuff(K_S_RIGHT); AppendCharToRedobuff(K_S_RIGHT);
} }
(void)fwd_word(1L, false, 0); (void)fwd_word(1, false, 0);
curwin->w_set_curswant = true; curwin->w_set_curswant = true;
} else { } else {
vim_beep(BO_CRSR); vim_beep(BO_CRSR);
@ -4175,7 +4175,7 @@ static void ins_up(bool startcol)
undisplay_dollar(); undisplay_dollar();
tpos = curwin->w_cursor; tpos = curwin->w_cursor;
if (cursor_up(1L, true) == OK) { if (cursor_up(1, true) == OK) {
if (startcol) { if (startcol) {
coladvance(getvcol_nolist(&Insstart)); coladvance(getvcol_nolist(&Insstart));
} }
@ -4223,7 +4223,7 @@ static void ins_down(bool startcol)
undisplay_dollar(); undisplay_dollar();
tpos = curwin->w_cursor; tpos = curwin->w_cursor;
if (cursor_down(1L, true) == OK) { if (cursor_down(1, true) == OK) {
if (startcol) { if (startcol) {
coladvance(getvcol_nolist(&Insstart)); coladvance(getvcol_nolist(&Insstart));
} }

12
src/nvim/eval.c
View File

@ -454,8 +454,8 @@ void eval_init(void)
set_vim_var_dict(VV_EVENT, tv_dict_alloc_lock(VAR_FIXED)); set_vim_var_dict(VV_EVENT, tv_dict_alloc_lock(VAR_FIXED));
set_vim_var_list(VV_ERRORS, tv_list_alloc(kListLenUnknown)); set_vim_var_list(VV_ERRORS, tv_list_alloc(kListLenUnknown));
set_vim_var_nr(VV_STDERR, CHAN_STDERR); set_vim_var_nr(VV_STDERR, CHAN_STDERR);
set_vim_var_nr(VV_SEARCHFORWARD, 1L); set_vim_var_nr(VV_SEARCHFORWARD, 1);
set_vim_var_nr(VV_HLSEARCH, 1L); set_vim_var_nr(VV_HLSEARCH, 1);
set_vim_var_nr(VV_COUNT1, 1); set_vim_var_nr(VV_COUNT1, 1);
set_vim_var_nr(VV_TYPE_NUMBER, VAR_TYPE_NUMBER); set_vim_var_nr(VV_TYPE_NUMBER, VAR_TYPE_NUMBER);
set_vim_var_nr(VV_TYPE_STRING, VAR_TYPE_STRING); set_vim_var_nr(VV_TYPE_STRING, VAR_TYPE_STRING);
@ -6629,14 +6629,14 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
} }
// Get the line number. // Get the line number.
pos.lnum = (linenr_T)tv_list_find_nr(l, 0L, &error); pos.lnum = (linenr_T)tv_list_find_nr(l, 0, &error);
if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count) { if (error || pos.lnum <= 0 || pos.lnum > curbuf->b_ml.ml_line_count) {
// Invalid line number. // Invalid line number.
return NULL; return NULL;
} }
// Get the column number. // Get the column number.
pos.col = (colnr_T)tv_list_find_nr(l, 1L, &error); pos.col = (colnr_T)tv_list_find_nr(l, 1, &error);
if (error) { if (error) {
return NULL; return NULL;
} }
@ -6648,7 +6648,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
} }
// We accept "$" for the column number: last column. // We accept "$" for the column number: last column.
listitem_T *li = tv_list_find(l, 1L); listitem_T *li = tv_list_find(l, 1);
if (li != NULL && TV_LIST_ITEM_TV(li)->v_type == VAR_STRING if (li != NULL && TV_LIST_ITEM_TV(li)->v_type == VAR_STRING
&& TV_LIST_ITEM_TV(li)->vval.v_string != NULL && TV_LIST_ITEM_TV(li)->vval.v_string != NULL
&& strcmp(TV_LIST_ITEM_TV(li)->vval.v_string, "$") == 0) { && strcmp(TV_LIST_ITEM_TV(li)->vval.v_string, "$") == 0) {
@ -6663,7 +6663,7 @@ pos_T *var2fpos(const typval_T *const tv, const bool dollar_lnum, int *const ret
pos.col--; pos.col--;
// Get the virtual offset. Defaults to zero. // Get the virtual offset. Defaults to zero.
pos.coladd = (colnr_T)tv_list_find_nr(l, 2L, &error); pos.coladd = (colnr_T)tv_list_find_nr(l, 2, &error);
if (error) { if (error) {
pos.coladd = 0; pos.coladd = 0;
} }

62
src/nvim/eval/funcs.c
View File

@ -983,7 +983,7 @@ static void f_count(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
int64_t idx = 0; int64_t idx = 0;
if (argvars[2].v_type != VAR_UNKNOWN if (argvars[2].v_type != VAR_UNKNOWN
&& argvars[3].v_type != VAR_UNKNOWN) { && argvars[3].v_type != VAR_UNKNOWN) {
idx = (long)tv_get_number_chk(&argvars[3], &error); idx = (int64_t)tv_get_number_chk(&argvars[3], &error);
} }
if (!error) { if (!error) {
n = count_list(argvars[0].vval.v_list, &argvars[1], idx, ic); n = count_list(argvars[0].vval.v_list, &argvars[1], idx, ic);
@ -1860,11 +1860,11 @@ static void flatten_common(typval_T *argvars, typval_T *rettv, bool make_copy)
return; return;
} }
long maxdepth; int maxdepth;
if (argvars[1].v_type == VAR_UNKNOWN) { if (argvars[1].v_type == VAR_UNKNOWN) {
maxdepth = 999999; maxdepth = 999999;
} else { } else {
maxdepth = (long)tv_get_number_chk(&argvars[1], &error); maxdepth = (int)tv_get_number_chk(&argvars[1], &error);
if (error) { if (error) {
return; return;
} }
@ -1929,7 +1929,7 @@ static void extend_list(typval_T *argvars, const char *arg_errmsg, bool is_new,
listitem_T *item; listitem_T *item;
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
long before = (long)tv_get_number_chk(&argvars[2], &error); int before = (int)tv_get_number_chk(&argvars[2], &error);
if (error) { if (error) {
return; // Type error; errmsg already given. return; // Type error; errmsg already given.
} }
@ -1937,7 +1937,7 @@ static void extend_list(typval_T *argvars, const char *arg_errmsg, bool is_new,
if (before == tv_list_len(l1)) { if (before == tv_list_len(l1)) {
item = NULL; item = NULL;
} else { } else {
item = tv_list_find(l1, (int)before); item = tv_list_find(l1, before);
if (item == NULL) { if (item == NULL) {
semsg(_(e_list_index_out_of_range_nr), (int64_t)before); semsg(_(e_list_index_out_of_range_nr), (int64_t)before);
return; return;
@ -3394,7 +3394,7 @@ static void f_indent(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
/// "index()" function /// "index()" function
static void f_index(typval_T *argvars, typval_T *rettv, EvalFuncData fptr) static void f_index(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
{ {
long idx = 0; int idx = 0;
bool ic = false; bool ic = false;
rettv->vval.v_number = -1; rettv->vval.v_number = -1;
@ -3421,7 +3421,7 @@ static void f_index(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
for (idx = start; idx < tv_blob_len(b); idx++) { for (idx = start; idx < tv_blob_len(b); idx++) {
typval_T tv; typval_T tv;
tv.v_type = VAR_NUMBER; tv.v_type = VAR_NUMBER;
tv.vval.v_number = tv_blob_get(b, (int)idx); tv.vval.v_number = tv_blob_get(b, idx);
if (tv_equal(&tv, &argvars[1], ic, false)) { if (tv_equal(&tv, &argvars[1], ic, false)) {
rettv->vval.v_number = idx; rettv->vval.v_number = idx;
return; return;
@ -3447,7 +3447,7 @@ static void f_index(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
if (error || idx == -1) { if (error || idx == -1) {
item = NULL; item = NULL;
} else { } else {
item = tv_list_find(l, (int)idx); item = tv_list_find(l, idx);
assert(item != NULL); assert(item != NULL);
} }
if (argvars[3].v_type != VAR_UNKNOWN) { if (argvars[3].v_type != VAR_UNKNOWN) {
@ -3690,11 +3690,11 @@ static void f_insert(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
return; return;
} }
long before = 0; int before = 0;
const int len = tv_blob_len(b); const int len = tv_blob_len(b);
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
before = (long)tv_get_number_chk(&argvars[2], &error); before = (int)tv_get_number_chk(&argvars[2], &error);
if (error) { if (error) {
return; // type error; errmsg already given return; // type error; errmsg already given
} }
@ -4511,7 +4511,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
colnr_T startcol = 0; colnr_T startcol = 0;
bool match = false; bool match = false;
list_T *l = NULL; list_T *l = NULL;
long idx = 0; int idx = 0;
char *tofree = NULL; char *tofree = NULL;
// Make 'cpoptions' empty, the 'l' flag should not be used here. // Make 'cpoptions' empty, the 'l' flag should not be used here.
@ -4550,7 +4550,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
li = tv_list_first(l); li = tv_list_first(l);
} else { } else {
expr = str = (char *)tv_get_string(&argvars[0]); expr = str = (char *)tv_get_string(&argvars[0]);
len = (long)strlen(str); len = (int64_t)strlen(str);
} }
char patbuf[NUMBUFLEN]; char patbuf[NUMBUFLEN];
@ -4571,7 +4571,7 @@ static void find_some_match(typval_T *const argvars, typval_T *const rettv,
if (idx == -1) { if (idx == -1) {
goto theend; goto theend;
} }
li = tv_list_find(l, (int)idx); li = tv_list_find(l, idx);
} else { } else {
if (start < 0) { if (start < 0) {
start = 0; start = 0;
@ -5414,10 +5414,10 @@ static void f_rand(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
goto theend; goto theend;
} }
typval_T *const tvx = TV_LIST_ITEM_TV(tv_list_find(l, 0L)); typval_T *const tvx = TV_LIST_ITEM_TV(tv_list_find(l, 0));
typval_T *const tvy = TV_LIST_ITEM_TV(tv_list_find(l, 1L)); typval_T *const tvy = TV_LIST_ITEM_TV(tv_list_find(l, 1));
typval_T *const tvz = TV_LIST_ITEM_TV(tv_list_find(l, 2L)); typval_T *const tvz = TV_LIST_ITEM_TV(tv_list_find(l, 2));
typval_T *const tvw = TV_LIST_ITEM_TV(tv_list_find(l, 3L)); typval_T *const tvw = TV_LIST_ITEM_TV(tv_list_find(l, 3));
if (tvx->v_type != VAR_NUMBER) { if (tvx->v_type != VAR_NUMBER) {
goto theend; goto theend;
} }
@ -5861,8 +5861,8 @@ static int list2proftime(typval_T *arg, proftime_T *tm) FUNC_ATTR_NONNULL_ALL
} }
bool error = false; bool error = false;
varnumber_T n1 = tv_list_find_nr(arg->vval.v_list, 0L, &error); varnumber_T n1 = tv_list_find_nr(arg->vval.v_list, 0, &error);
varnumber_T n2 = tv_list_find_nr(arg->vval.v_list, 1L, &error); varnumber_T n2 = tv_list_find_nr(arg->vval.v_list, 1, &error);
if (error) { if (error) {
return FAIL; return FAIL;
} }
@ -7050,8 +7050,8 @@ static int searchpair_cmn(typval_T *argvars, pos_T *match_pos)
} }
} }
retval = (int)do_searchpair(spat, mpat, epat, dir, skip, retval = do_searchpair(spat, mpat, epat, dir, skip,
flags, match_pos, lnum_stop, time_limit); flags, match_pos, lnum_stop, time_limit);
theend: theend:
p_ws = save_p_ws; p_ws = save_p_ws;
@ -7096,12 +7096,12 @@ static void f_searchpairpos(typval_T *argvars, typval_T *rettv, EvalFuncData fpt
/// @param time_limit stop after this many msec /// @param time_limit stop after this many msec
/// ///
/// @returns 0 or -1 for no match, /// @returns 0 or -1 for no match,
long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir, int do_searchpair(const char *spat, const char *mpat, const char *epat, int dir,
const typval_T *skip, int flags, pos_T *match_pos, linenr_T lnum_stop, const typval_T *skip, int flags, pos_T *match_pos, linenr_T lnum_stop,
int64_t time_limit) int64_t time_limit)
FUNC_ATTR_NONNULL_ARG(1, 2, 3) FUNC_ATTR_NONNULL_ARG(1, 2, 3)
{ {
long retval = 0; int retval = 0;
int nest = 1; int nest = 1;
bool use_skip = false; bool use_skip = false;
int options = SEARCH_KEEP; int options = SEARCH_KEEP;
@ -7147,7 +7147,7 @@ long do_searchpair(const char *spat, const char *mpat, const char *epat, int dir
.sa_tm = &tm, .sa_tm = &tm,
}; };
int n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1L, int n = searchit(curwin, curbuf, &pos, NULL, dir, pat, 1,
options, RE_SEARCH, &sia); options, RE_SEARCH, &sia);
if (n == FAIL || (firstpos.lnum != 0 && equalpos(pos, firstpos))) { if (n == FAIL || (firstpos.lnum != 0 && equalpos(pos, firstpos))) {
// didn't find it or found the first match again: FAIL // didn't find it or found the first match again: FAIL
@ -7489,7 +7489,7 @@ static void f_setpos(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
} }
/// Translate a register type string to the yank type and block length /// Translate a register type string to the yank type and block length
static int get_yank_type(char **const pp, MotionType *const yank_type, long *const block_len) static int get_yank_type(char **const pp, MotionType *const yank_type, int *const block_len)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
char *stropt = *pp; char *stropt = *pp;
@ -7507,7 +7507,7 @@ static int get_yank_type(char **const pp, MotionType *const yank_type, long *con
*yank_type = kMTBlockWise; *yank_type = kMTBlockWise;
if (ascii_isdigit(stropt[1])) { if (ascii_isdigit(stropt[1])) {
stropt++; stropt++;
*block_len = getdigits_long(&stropt, false, 0) - 1; *block_len = getdigits_int(&stropt, false, 0) - 1;
stropt--; stropt--;
} }
break; break;
@ -7523,7 +7523,7 @@ static void f_setreg(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
{ {
bool append = false; bool append = false;
long block_len = -1; int block_len = -1;
MotionType yank_type = kMTUnknown; MotionType yank_type = kMTUnknown;
rettv->vval.v_number = 1; // FAIL is default. rettv->vval.v_number = 1; // FAIL is default.
@ -7735,11 +7735,11 @@ static void f_shiftwidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
rettv->vval.v_number = 0; rettv->vval.v_number = 0;
if (argvars[0].v_type != VAR_UNKNOWN) { if (argvars[0].v_type != VAR_UNKNOWN) {
long col = (long)tv_get_number_chk(argvars, NULL); colnr_T col = (colnr_T)tv_get_number_chk(argvars, NULL);
if (col < 0) { if (col < 0) {
return; // type error; errmsg already given return; // type error; errmsg already given
} }
rettv->vval.v_number = get_sw_value_col(curbuf, (colnr_T)col); rettv->vval.v_number = get_sw_value_col(curbuf, col);
return; return;
} }
rettv->vval.v_number = get_sw_value(curbuf); rettv->vval.v_number = get_sw_value(curbuf);

4
src/nvim/eval/typval.c
View File

@ -678,7 +678,7 @@ int tv_list_assign_range(list_T *const dest, list_T *const src, const int idx1_a
listitem_T *src_li; listitem_T *src_li;
// Check whether any of the list items is locked before making any changes. // Check whether any of the list items is locked before making any changes.
long idx = idx1; int idx = idx1;
listitem_T *dest_li = first_li; listitem_T *dest_li = first_li;
for (src_li = tv_list_first(src); src_li != NULL && dest_li != NULL;) { for (src_li = tv_list_first(src); src_li != NULL && dest_li != NULL;) {
if (value_check_lock(TV_LIST_ITEM_TV(dest_li)->v_lock, varname, TV_CSTRING)) { if (value_check_lock(TV_LIST_ITEM_TV(dest_li)->v_lock, varname, TV_CSTRING)) {
@ -738,7 +738,7 @@ int tv_list_assign_range(list_T *const dest, list_T *const src, const int idx1_a
/// @param[in] maxdepth Maximum depth that will be flattened /// @param[in] maxdepth Maximum depth that will be flattened
/// ///
/// @return OK or FAIL /// @return OK or FAIL
void tv_list_flatten(list_T *list, listitem_T *first, long maxitems, long maxdepth) void tv_list_flatten(list_T *list, listitem_T *first, int64_t maxitems, int64_t maxdepth)
FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_NONNULL_ARG(1)
{ {
listitem_T *item; listitem_T *item;

2
src/nvim/eval/typval.h
View File

@ -235,7 +235,7 @@ static inline long tv_dict_len(const dict_T *d)
static inline long tv_dict_len(const dict_T *const d) static inline long tv_dict_len(const dict_T *const d)
{ {
if (d == NULL) { if (d == NULL) {
return 0L; return 0;
} }
return (long)d->dv_hashtab.ht_used; return (long)d->dv_hashtab.ht_used;
} }

2
src/nvim/eval/userfunc.c
View File

@ -2422,7 +2422,7 @@ void ex_function(exarg_T *eap)
} else { } else {
xfree(line_to_free); xfree(line_to_free);
if (eap->getline == NULL) { if (eap->getline == NULL) {
theline = getcmdline(':', 0L, indent, do_concat); theline = getcmdline(':', 0, indent, do_concat);
} else { } else {
theline = eap->getline(':', eap->cookie, indent, do_concat); theline = eap->getline(':', eap->cookie, indent, do_concat);
} }

6
src/nvim/eval/vars.c
View File

@ -1088,13 +1088,13 @@ static int do_unlet_var(lval_T *lp, char *name_end, exarg_T *eap, int deep FUNC_
/// Unlet one item or a range of items from a list. /// Unlet one item or a range of items from a list.
/// Return OK or FAIL. /// Return OK or FAIL.
static void tv_list_unlet_range(list_T *const l, listitem_T *const li_first, const long n1_arg, static void tv_list_unlet_range(list_T *const l, listitem_T *const li_first, const int n1_arg,
const bool has_n2, const long n2) const bool has_n2, const int n2)
{ {
assert(l != NULL); assert(l != NULL);
// Delete a range of List items. // Delete a range of List items.
listitem_T *li_last = li_first; listitem_T *li_last = li_first;
long n1 = n1_arg; int n1 = n1_arg;
while (true) { while (true) {
listitem_T *const li = TV_LIST_ITEM_NEXT(l, li_last); listitem_T *const li = TV_LIST_ITEM_NEXT(l, li_last);
n1++; n1++;

36
src/nvim/ex_cmds.c
View File

@ -323,7 +323,7 @@ void ex_align(exarg_T *eap)
} }
(void)set_indent(new_indent, 0); // set indent (void)set_indent(new_indent, 0); // set indent
} }
changed_lines(curbuf, eap->line1, 0, eap->line2 + 1, 0L, true); changed_lines(curbuf, eap->line1, 0, eap->line2 + 1, 0, true);
curwin->w_cursor = save_curpos; curwin->w_cursor = save_curpos;
beginline(BL_WHITE | BL_FIX); beginline(BL_WHITE | BL_FIX);
} }
@ -696,7 +696,7 @@ void ex_sort(exarg_T *eap)
mark_adjust(eap->line2 - deleted, eap->line2, MAXLNUM, -deleted, kExtmarkNOOP); mark_adjust(eap->line2 - deleted, eap->line2, MAXLNUM, -deleted, kExtmarkNOOP);
msgmore(-deleted); msgmore(-deleted);
} else if (deleted < 0) { } else if (deleted < 0) {
mark_adjust(eap->line2, MAXLNUM, -deleted, 0L, kExtmarkNOOP); mark_adjust(eap->line2, MAXLNUM, -deleted, 0, kExtmarkNOOP);
} }
if (change_occurred || deleted != 0) { if (change_occurred || deleted != 0) {
@ -783,7 +783,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
// And Finally we adjust the marks we put at the end of the file back to // And Finally we adjust the marks we put at the end of the file back to
// their final destination at the new text position -- webb // their final destination at the new text position -- webb
last_line = curbuf->b_ml.ml_line_count; last_line = curbuf->b_ml.ml_line_count;
mark_adjust_nofold(line1, line2, last_line - line2, 0L, kExtmarkNOOP); mark_adjust_nofold(line1, line2, last_line - line2, 0, kExtmarkNOOP);
disable_fold_update++; disable_fold_update++;
changed_lines(curbuf, last_line - num_lines + 1, 0, last_line + 1, num_lines, false); changed_lines(curbuf, last_line - num_lines + 1, 0, last_line + 1, num_lines, false);
@ -792,7 +792,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
int line_off = 0; int line_off = 0;
bcount_t byte_off = 0; bcount_t byte_off = 0;
if (dest >= line2) { if (dest >= line2) {
mark_adjust_nofold(line2 + 1, dest, -num_lines, 0L, kExtmarkNOOP); mark_adjust_nofold(line2 + 1, dest, -num_lines, 0, kExtmarkNOOP);
FOR_ALL_TAB_WINDOWS(tab, win) { FOR_ALL_TAB_WINDOWS(tab, win) {
if (win->w_buffer == curbuf) { if (win->w_buffer == curbuf) {
foldMoveRange(win, &win->w_folds, line1, line2, dest); foldMoveRange(win, &win->w_folds, line1, line2, dest);
@ -805,7 +805,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
line_off = -num_lines; line_off = -num_lines;
byte_off = -extent_byte; byte_off = -extent_byte;
} else { } else {
mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0L, kExtmarkNOOP); mark_adjust_nofold(dest + 1, line1 - 1, num_lines, 0, kExtmarkNOOP);
FOR_ALL_TAB_WINDOWS(tab, win) { FOR_ALL_TAB_WINDOWS(tab, win) {
if (win->w_buffer == curbuf) { if (win->w_buffer == curbuf) {
foldMoveRange(win, &win->w_folds, dest + 1, line1 - 1, line2); foldMoveRange(win, &win->w_folds, dest + 1, line1 - 1, line2);
@ -820,7 +820,7 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
curbuf->b_op_start.col = curbuf->b_op_end.col = 0; curbuf->b_op_start.col = curbuf->b_op_end.col = 0;
} }
mark_adjust_nofold(last_line - num_lines + 1, last_line, mark_adjust_nofold(last_line - num_lines + 1, last_line,
-(last_line - dest - extra), 0L, kExtmarkNOOP); -(last_line - dest - extra), 0, kExtmarkNOOP);
disable_fold_update++; disable_fold_update++;
changed_lines(curbuf, last_line - num_lines + 1, 0, last_line + 1, -extra, false); changed_lines(curbuf, last_line - num_lines + 1, 0, last_line + 1, -extra, false);
@ -861,9 +861,9 @@ int do_move(linenr_T line1, linenr_T line2, linenr_T dest)
if (dest > last_line + 1) { if (dest > last_line + 1) {
dest = last_line + 1; dest = last_line + 1;
} }
changed_lines(curbuf, line1, 0, dest, 0L, false); changed_lines(curbuf, line1, 0, dest, 0, false);
} else { } else {
changed_lines(curbuf, dest + 1, 0, line1 + num_lines, 0L, false); changed_lines(curbuf, dest + 1, 0, line1 + num_lines, 0, false);
} }
// send nvim_buf_lines_event regarding lines that were deleted // send nvim_buf_lines_event regarding lines that were deleted
@ -1243,13 +1243,13 @@ static void do_filter(linenr_T line1, linenr_T line2, exarg_T *eap, char *cmd, b
// end of each line? // end of each line?
if (read_linecount >= linecount) { if (read_linecount >= linecount) {
// move all marks from old lines to new lines // move all marks from old lines to new lines
mark_adjust(line1, line2, linecount, 0L, kExtmarkNOOP); mark_adjust(line1, line2, linecount, 0, kExtmarkNOOP);
} else { } else {
// move marks from old lines to new lines, delete marks // move marks from old lines to new lines, delete marks
// that are in deleted lines // that are in deleted lines
mark_adjust(line1, line1 + read_linecount - 1, linecount, 0L, mark_adjust(line1, line1 + read_linecount - 1, linecount, 0,
kExtmarkNOOP); kExtmarkNOOP);
mark_adjust(line1 + read_linecount, line2, MAXLNUM, 0L, mark_adjust(line1 + read_linecount, line2, MAXLNUM, 0,
kExtmarkNOOP); kExtmarkNOOP);
} }
} }
@ -2283,7 +2283,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
if (command != NULL) { if (command != NULL) {
tlnum = (linenr_T)atol(command); tlnum = (linenr_T)atol(command);
if (tlnum <= 0) { if (tlnum <= 0) {
tlnum = 1L; tlnum = 1;
} }
} }
// Add BLN_NOCURWIN to avoid a new wininfo items are associated // Add BLN_NOCURWIN to avoid a new wininfo items are associated
@ -2295,7 +2295,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
} }
goto theend; goto theend;
} }
buf = buflist_new(ffname, sfname, 0L, buf = buflist_new(ffname, sfname, 0,
BLN_CURBUF | (flags & ECMD_SET_HELP ? 0 : BLN_LISTED)); BLN_CURBUF | (flags & ECMD_SET_HELP ? 0 : BLN_LISTED));
// Autocmds may change curwin and curbuf. // Autocmds may change curwin and curbuf.
if (oldwin != NULL) { if (oldwin != NULL) {
@ -2861,16 +2861,16 @@ void ex_append(exarg_T *eap)
ml_append(lnum, theline, (colnr_T)0, false); ml_append(lnum, theline, (colnr_T)0, false);
if (empty) { if (empty) {
// there are no marks below the inserted lines // there are no marks below the inserted lines
appended_lines(lnum, 1L); appended_lines(lnum, 1);
} else { } else {
appended_lines_mark(lnum, 1L); appended_lines_mark(lnum, 1);
} }
xfree(theline); xfree(theline);
lnum++; lnum++;
if (empty) { if (empty) {
ml_delete(2L, false); ml_delete(2, false);
empty = 0; empty = 0;
} }
} }
@ -4020,10 +4020,10 @@ static int do_sub(exarg_T *eap, const proftime_T timeout, const int cmdpreview_n
*p1 = NUL; // truncate up to the CR *p1 = NUL; // truncate up to the CR
ml_append(lnum - 1, new_start, ml_append(lnum - 1, new_start,
(colnr_T)(p1 - new_start + 1), false); (colnr_T)(p1 - new_start + 1), false);
mark_adjust(lnum + 1, (linenr_T)MAXLNUM, 1L, 0L, kExtmarkNOOP); mark_adjust(lnum + 1, (linenr_T)MAXLNUM, 1, 0, kExtmarkNOOP);
if (subflags.do_ask) { if (subflags.do_ask) {
appended_lines(lnum - 1, 1L); appended_lines(lnum - 1, 1);
} else { } else {
if (first_line == 0) { if (first_line == 0) {
first_line = lnum; first_line = lnum;

18
src/nvim/ex_docmd.c
View File

@ -939,7 +939,7 @@ static char *get_loop_line(int c, void *cookie, int indent, bool do_concat)
char *line; char *line;
// First time inside the ":while"/":for": get line normally. // First time inside the ":while"/":for": get line normally.
if (cp->getline == NULL) { if (cp->getline == NULL) {
line = getcmdline(c, 0L, indent, do_concat); line = getcmdline(c, 0, indent, do_concat);
} else { } else {
line = cp->getline(c, cp->cookie, indent, do_concat); line = cp->getline(c, cp->cookie, indent, do_concat);
} }
@ -3431,7 +3431,7 @@ static linenr_T get_address(exarg_T *eap, char **ptr, cmd_addr_T addr_type, int
} }
searchcmdlen = 0; searchcmdlen = 0;
flags = silent ? 0 : SEARCH_HIS | SEARCH_MSG; flags = silent ? 0 : SEARCH_HIS | SEARCH_MSG;
if (!do_search(NULL, c, c, cmd, 1L, flags, NULL)) { if (!do_search(NULL, c, c, cmd, 1, flags, NULL)) {
curwin->w_cursor = pos; curwin->w_cursor = pos;
cmd = NULL; cmd = NULL;
goto error; goto error;
@ -3468,7 +3468,7 @@ static linenr_T get_address(exarg_T *eap, char **ptr, cmd_addr_T addr_type, int
pos.coladd = 0; pos.coladd = 0;
if (searchit(curwin, curbuf, &pos, NULL, if (searchit(curwin, curbuf, &pos, NULL,
*cmd == '?' ? BACKWARD : FORWARD, *cmd == '?' ? BACKWARD : FORWARD,
"", 1L, SEARCH_MSG, i, NULL) != FAIL) { "", 1, SEARCH_MSG, i, NULL) != FAIL) {
lnum = pos.lnum; lnum = pos.lnum;
} else { } else {
cmd = NULL; cmd = NULL;
@ -5576,13 +5576,13 @@ static void ex_read(exarg_T *eap)
} else { } else {
lnum = 1; lnum = 1;
} }
if (*ml_get(lnum) == NUL && u_savedel(lnum, 1L) == OK) { if (*ml_get(lnum) == NUL && u_savedel(lnum, 1) == OK) {
ml_delete(lnum, false); ml_delete(lnum, false);
if (curwin->w_cursor.lnum > 1 if (curwin->w_cursor.lnum > 1
&& curwin->w_cursor.lnum >= lnum) { && curwin->w_cursor.lnum >= lnum) {
curwin->w_cursor.lnum--; curwin->w_cursor.lnum--;
} }
deleted_lines_mark(lnum, 1L); deleted_lines_mark(lnum, 1);
} }
} }
redraw_curbuf_later(UPD_VALID); redraw_curbuf_later(UPD_VALID);
@ -5812,7 +5812,7 @@ static void ex_sleep(exarg_T *eap)
case 'm': case 'm':
break; break;
case NUL: case NUL:
len *= 1000L; break; len *= 1000; break;
default: default:
semsg(_(e_invarg2), eap->arg); return; semsg(_(e_invarg2), eap->arg); return;
} }
@ -5877,7 +5877,7 @@ static void ex_wincmd(exarg_T *eap)
// Pass flags on for ":vertical wincmd ]". // Pass flags on for ":vertical wincmd ]".
postponed_split_flags = cmdmod.cmod_split; postponed_split_flags = cmdmod.cmod_split;
postponed_split_tab = cmdmod.cmod_tab; postponed_split_tab = cmdmod.cmod_tab;
do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0L, xchar); do_window(*eap->arg, eap->addr_count > 0 ? eap->line2 : 0, xchar);
postponed_split_flags = 0; postponed_split_flags = 0;
postponed_split_tab = 0; postponed_split_tab = 0;
} }
@ -6630,7 +6630,7 @@ void exec_normal(bool was_typed)
static void ex_checkpath(exarg_T *eap) static void ex_checkpath(exarg_T *eap)
{ {
find_pattern_in_path(NULL, 0, 0, false, false, CHECK_PATH, 1L, find_pattern_in_path(NULL, 0, 0, false, false, CHECK_PATH, 1,
eap->forceit ? ACTION_SHOW_ALL : ACTION_SHOW, eap->forceit ? ACTION_SHOW_ALL : ACTION_SHOW,
(linenr_T)1, (linenr_T)MAXLNUM); (linenr_T)1, (linenr_T)MAXLNUM);
} }
@ -6986,7 +6986,7 @@ char *eval_vars(char *src, const char *srcstart, size_t *usedlen, linenr_T *lnum
break; break;
case SPEC_CFILE: // file name under cursor case SPEC_CFILE: // file name under cursor
result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1L, NULL); result = file_name_at_cursor(FNAME_MESS|FNAME_HYP, 1, NULL);
if (result == NULL) { if (result == NULL) {
*errormsg = ""; *errormsg = "";
return NULL; return NULL;

6
src/nvim/ex_getln.c
View File

@ -453,7 +453,7 @@ static void may_do_incsearch_highlighting(int firstc, int count, incsearch_state
ui_flush(); ui_flush();
emsg_off++; // So it doesn't beep if bad expr emsg_off++; // So it doesn't beep if bad expr
// Set the time limit to half a second. // Set the time limit to half a second.
tm = profile_setlimit(500L); tm = profile_setlimit(500);
if (!p_hls) { if (!p_hls) {
search_flags += SEARCH_KEEP; search_flags += SEARCH_KEEP;
} }
@ -2747,7 +2747,7 @@ char *getcmdline_prompt(const int firstc, const char *const prompt, const int at
int msg_silent_saved = msg_silent; int msg_silent_saved = msg_silent;
msg_silent = 0; msg_silent = 0;
char *const ret = (char *)command_line_enter(firstc, 1L, 0, false); char *const ret = (char *)command_line_enter(firstc, 1, 0, false);
if (did_save_ccline) { if (did_save_ccline) {
restore_cmdline(&save_ccline); restore_cmdline(&save_ccline);
@ -2947,7 +2947,7 @@ char *getexline(int c, void *cookie, int indent, bool do_concat)
(void)vgetc(); (void)vgetc();
} }
return getcmdline(c, 1L, indent, do_concat); return getcmdline(c, 1, indent, do_concat);
} }
bool cmdline_overstrike(void) bool cmdline_overstrike(void)

2
src/nvim/ex_session.c
View File

@ -629,7 +629,7 @@ static int makeopens(FILE *fd, char *dirnow)
&& buf->b_p_bl) { && buf->b_p_bl) {
if (fprintf(fd, "badd +%" PRId64 " ", if (fprintf(fd, "badd +%" PRId64 " ",
buf->b_wininfo == NULL buf->b_wininfo == NULL
? (int64_t)1L ? 1
: (int64_t)buf->b_wininfo->wi_mark.mark.lnum) < 0 : (int64_t)buf->b_wininfo->wi_mark.mark.lnum) < 0
|| ses_fname(fd, buf, &ssop_flags, true) == FAIL) { || ses_fname(fd, buf, &ssop_flags, true) == FAIL) {
return FAIL; return FAIL;

12
src/nvim/fileio.c
View File

@ -718,7 +718,7 @@ retry:
if (read_buffer) { if (read_buffer) {
read_buf_lnum = 1; read_buf_lnum = 1;
read_buf_col = 0; read_buf_col = 0;
} else if (read_stdin || vim_lseek(fd, (off_T)0L, SEEK_SET) != 0) { } else if (read_stdin || vim_lseek(fd, 0, SEEK_SET) != 0) {
// Can't rewind the file, give up. // Can't rewind the file, give up.
error = true; error = true;
goto failed; goto failed;
@ -880,9 +880,9 @@ retry:
// Use buffer >= 64K. Add linerest to double the size if the // Use buffer >= 64K. Add linerest to double the size if the
// line gets very long, to avoid a lot of copying. But don't // line gets very long, to avoid a lot of copying. But don't
// read more than 1 Mbyte at a time, so we can be interrupted. // read more than 1 Mbyte at a time, so we can be interrupted.
size = 0x10000L + linerest; size = 0x10000 + linerest;
if (size > 0x100000L) { if (size > 0x100000) {
size = 0x100000L; size = 0x100000;
} }
} }
@ -1531,7 +1531,7 @@ rewind_retry:
if (try_unix if (try_unix
&& !read_stdin && !read_stdin
&& (read_buffer && (read_buffer
|| vim_lseek(fd, (off_T)0L, SEEK_SET) == 0)) { || vim_lseek(fd, 0, SEEK_SET) == 0)) {
fileformat = EOL_UNIX; fileformat = EOL_UNIX;
if (set_options) { if (set_options) {
set_fileformat(EOL_UNIX, OPT_LOCAL); set_fileformat(EOL_UNIX, OPT_LOCAL);
@ -3054,7 +3054,7 @@ int buf_check_timestamp(buf_T *buf)
if (emsg_silent == 0 && !in_assert_fails) { if (emsg_silent == 0 && !in_assert_fails) {
ui_flush(); ui_flush();
// give the user some time to think about it // give the user some time to think about it
os_delay(1004L, true); os_delay(1004, true);
// don't redraw and erase the message // don't redraw and erase the message
redraw_cmdline = false; redraw_cmdline = false;

12
src/nvim/fold.c
View File

@ -650,7 +650,7 @@ void foldCreate(win_T *wp, pos_T start, pos_T end)
// We want the new fold to be closed. If it would remain open because // We want the new fold to be closed. If it would remain open because
// of using 'foldlevel', need to adjust fd_flags of containing folds. // of using 'foldlevel', need to adjust fd_flags of containing folds.
if (use_level && !closed && level < wp->w_p_fdl) { if (use_level && !closed && level < wp->w_p_fdl) {
closeFold(start, 1L); closeFold(start, 1);
} }
if (!use_level) { if (!use_level) {
wp->w_fold_manual = true; wp->w_fold_manual = true;
@ -748,7 +748,7 @@ void deleteFold(win_T *const wp, const linenr_T start, const linenr_T end, const
} }
if (last_lnum > 0) { if (last_lnum > 0) {
changed_lines(wp->w_buffer, first_lnum, (colnr_T)0, last_lnum, 0L, false); changed_lines(wp->w_buffer, first_lnum, (colnr_T)0, last_lnum, 0, false);
// send one nvim_buf_lines_event at the end // send one nvim_buf_lines_event at the end
// last_lnum is the line *after* the last line of the outermost fold // last_lnum is the line *after* the last line of the outermost fold
@ -1584,7 +1584,7 @@ static void foldCreateMarkers(win_T *wp, pos_T start, pos_T end)
// Update both changes here, to avoid all folds after the start are // Update both changes here, to avoid all folds after the start are
// changed when the start marker is inserted and the end isn't. // changed when the start marker is inserted and the end isn't.
changed_lines(buf, start.lnum, (colnr_T)0, end.lnum, 0L, false); changed_lines(buf, start.lnum, (colnr_T)0, end.lnum, 0, false);
// Note: foldAddMarker() may not actually change start and/or end if // Note: foldAddMarker() may not actually change start and/or end if
// u_save() is unable to save the buffer line, but we send the // u_save() is unable to save the buffer line, but we send the
@ -2295,7 +2295,7 @@ static linenr_T foldUpdateIEMSRecurse(garray_T *const gap, const int level,
// nested folds (with relative line numbers) down. // nested folds (with relative line numbers) down.
foldMarkAdjustRecurse(flp->wp, &fp->fd_nested, foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
(linenr_T)0, (linenr_T)MAXLNUM, (linenr_T)0, (linenr_T)MAXLNUM,
(fp->fd_top - firstlnum), 0L); (fp->fd_top - firstlnum), 0);
} else { } else {
// Will move fold down, move nested folds relatively up. // Will move fold down, move nested folds relatively up.
foldMarkAdjustRecurse(flp->wp, &fp->fd_nested, foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
@ -2367,7 +2367,7 @@ static linenr_T foldUpdateIEMSRecurse(garray_T *const gap, const int level,
fp->fd_len = startlnum - fp->fd_top; fp->fd_len = startlnum - fp->fd_top;
foldMarkAdjustRecurse(flp->wp, &fp->fd_nested, foldMarkAdjustRecurse(flp->wp, &fp->fd_nested,
fp->fd_len, (linenr_T)MAXLNUM, fp->fd_len, (linenr_T)MAXLNUM,
(linenr_T)MAXLNUM, 0L); (linenr_T)MAXLNUM, 0);
fold_changed = true; fold_changed = true;
} }
} else { } else {
@ -2861,7 +2861,7 @@ static void foldMerge(win_T *const wp, fold_T *fp1, garray_T *gap, fold_T *fp2)
// If the last nested fold in fp1 touches the first nested fold in fp2, // If the last nested fold in fp1 touches the first nested fold in fp2,
// merge them recursively. // merge them recursively.
if (foldFind(gap1, fp1->fd_len - 1, &fp3) && foldFind(gap2, 0L, &fp4)) { if (foldFind(gap1, fp1->fd_len - 1, &fp3) && foldFind(gap2, 0, &fp4)) {
foldMerge(wp, fp3, gap2, fp4); foldMerge(wp, fp3, gap2, fp4);
} }

2
src/nvim/generators/gen_options.lua
View File

@ -112,7 +112,7 @@ local value_dumpers = {
string=cstr, string=cstr,
boolean=function(v) return v and 'true' or 'false' end, boolean=function(v) return v and 'true' or 'false' end,
number=function(v) return ('%iL'):format(v) end, number=function(v) return ('%iL'):format(v) end,
['nil']=function(_) return '0L' end, ['nil']=function(_) return '0' end,
} }
local get_value = function(v) local get_value = function(v)

40
src/nvim/getchar.c
View File

@ -295,7 +295,7 @@ static void add_num_buff(buffheader_T *buf, int n)
{ {
char number[32]; char number[32];
snprintf(number, sizeof(number), "%d", n); snprintf(number, sizeof(number), "%d", n);
add_buff(buf, number, -1L); add_buff(buf, number, -1);
} }
/// Add character 'c' to buffer "buf". /// Add character 'c' to buffer "buf".
@ -327,7 +327,7 @@ static void add_char_buff(buffheader_T *buf, int c)
temp[0] = (char)c; temp[0] = (char)c;
temp[1] = NUL; temp[1] = NUL;
} }
add_buff(buf, temp, -1L); add_buff(buf, temp, -1);
} }
} }
@ -419,7 +419,7 @@ void flush_buffers(flush_buffers_T flush_typeahead)
// We have to get all characters, because we may delete the first // We have to get all characters, because we may delete the first
// part of an escape sequence. In an xterm we get one char at a // part of an escape sequence. In an xterm we get one char at a
// time and we have to get them all. // time and we have to get them all.
while (inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 10L) != 0) {} while (inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 10) != 0) {}
} }
typebuf.tb_off = MAXMAPLEN; typebuf.tb_off = MAXMAPLEN;
typebuf.tb_len = 0; typebuf.tb_len = 0;
@ -488,7 +488,7 @@ void saveRedobuff(save_redo_T *save_redo)
return; return;
} }
add_buff(&redobuff, s, -1L); add_buff(&redobuff, s, -1);
xfree(s); xfree(s);
} }
@ -507,7 +507,7 @@ void restoreRedobuff(save_redo_T *save_redo)
void AppendToRedobuff(const char *s) void AppendToRedobuff(const char *s)
{ {
if (!block_redo) { if (!block_redo) {
add_buff(&redobuff, s, -1L); add_buff(&redobuff, s, -1);
} }
} }
@ -553,7 +553,7 @@ void AppendToRedobuffLit(const char *str, int len)
// CTRL-V '0' must be inserted as CTRL-V 048. // CTRL-V '0' must be inserted as CTRL-V 048.
if (*s == NUL && c == '0') { if (*s == NUL && c == '0') {
add_buff(&redobuff, "048", 3L); add_buff(&redobuff, "048", 3);
} else { } else {
add_char_buff(&redobuff, c); add_char_buff(&redobuff, c);
} }
@ -571,7 +571,7 @@ void AppendToRedobuffSpec(const char *s)
while (*s != NUL) { while (*s != NUL) {
if ((uint8_t)(*s) == K_SPECIAL && s[1] != NUL && s[2] != NUL) { if ((uint8_t)(*s) == K_SPECIAL && s[1] != NUL && s[2] != NUL) {
// Insert special key literally. // Insert special key literally.
add_buff(&redobuff, s, 3L); add_buff(&redobuff, s, 3);
s += 3; s += 3;
} else { } else {
add_char_buff(&redobuff, mb_cptr2char_adv(&s)); add_char_buff(&redobuff, mb_cptr2char_adv(&s));
@ -600,14 +600,14 @@ void AppendNumberToRedobuff(int n)
/// K_SPECIAL must already have been escaped. /// K_SPECIAL must already have been escaped.
void stuffReadbuff(const char *s) void stuffReadbuff(const char *s)
{ {
add_buff(&readbuf1, s, -1L); add_buff(&readbuf1, s, -1);
} }
/// Append string "s" to the redo stuff buffer. /// Append string "s" to the redo stuff buffer.
/// @remark K_SPECIAL must already have been escaped. /// @remark K_SPECIAL must already have been escaped.
void stuffRedoReadbuff(const char *s) void stuffRedoReadbuff(const char *s)
{ {
add_buff(&readbuf2, s, -1L); add_buff(&readbuf2, s, -1);
} }
void stuffReadbuffLen(const char *s, ptrdiff_t len) void stuffReadbuffLen(const char *s, ptrdiff_t len)
@ -764,7 +764,7 @@ int start_redo(int count, bool old_redo)
// copy the buffer name, if present // copy the buffer name, if present
if (c == '"') { if (c == '"') {
add_buff(&readbuf2, "\"", 1L); add_buff(&readbuf2, "\"", 1);
c = read_redo(false, old_redo); c = read_redo(false, old_redo);
// if a numbered buffer is used, increment the number // if a numbered buffer is used, increment the number
@ -822,7 +822,7 @@ int start_redo_ins(void)
while ((c = read_redo(false, false)) != NUL) { while ((c = read_redo(false, false)) != NUL) {
if (vim_strchr("AaIiRrOo", c) != NULL) { if (vim_strchr("AaIiRrOo", c) != NULL) {
if (c == 'O' || c == 'o') { if (c == 'O' || c == 'o') {
add_buff(&readbuf2, NL_STR, -1L); add_buff(&readbuf2, NL_STR, -1);
} }
break; break;
} }
@ -2424,7 +2424,7 @@ static int vgetorpeek(bool advance)
int keylen = 0; int keylen = 0;
if (got_int) { if (got_int) {
// flush all input // flush all input
c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0L); c = inchar(typebuf.tb_buf, typebuf.tb_buflen - 1, 0);
// If inchar() returns true (script file was active) or we // If inchar() returns true (script file was active) or we
// are inside a mapping, get out of Insert mode. // are inside a mapping, get out of Insert mode.
@ -2503,7 +2503,7 @@ static int vgetorpeek(bool advance)
&& typebuf.tb_maplen == 0 && typebuf.tb_maplen == 0
&& (State & MODE_INSERT) && (State & MODE_INSERT)
&& (p_timeout || (keylen == KEYLEN_PART_KEY && p_ttimeout)) && (p_timeout || (keylen == KEYLEN_PART_KEY && p_ttimeout))
&& (c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len, 3, 25L)) == 0) { && (c = inchar(typebuf.tb_buf + typebuf.tb_off + typebuf.tb_len, 3, 25)) == 0) {
if (mode_displayed) { if (mode_displayed) {
unshowmode(true); unshowmode(true);
mode_deleted = true; mode_deleted = true;
@ -2688,16 +2688,16 @@ static int vgetorpeek(bool advance)
timedout = false; timedout = false;
} }
long wait_time = 0; int wait_time = 0;
if (advance) { if (advance) {
if (typebuf.tb_len == 0 || !(p_timeout || (p_ttimeout && keylen == KEYLEN_PART_KEY))) { if (typebuf.tb_len == 0 || !(p_timeout || (p_ttimeout && keylen == KEYLEN_PART_KEY))) {
// blocking wait // blocking wait
wait_time = -1L; wait_time = -1;
} else if (keylen == KEYLEN_PART_KEY && p_ttm >= 0) { } else if (keylen == KEYLEN_PART_KEY && p_ttm >= 0) {
wait_time = (long)p_ttm; wait_time = (int)p_ttm;
} else { } else {
wait_time = (long)p_tm; wait_time = (int)p_tm;
} }
} }
@ -2802,7 +2802,7 @@ int inchar(uint8_t *buf, int maxlen, long wait_time)
int retesc = false; // Return ESC with gotint. int retesc = false; // Return ESC with gotint.
const int tb_change_cnt = typebuf.tb_change_cnt; const int tb_change_cnt = typebuf.tb_change_cnt;
if (wait_time == -1L || wait_time > 100L) { if (wait_time == -1 || wait_time > 100) {
// flush output before waiting // flush output before waiting
ui_flush(); ui_flush();
} }
@ -2852,7 +2852,7 @@ int inchar(uint8_t *buf, int maxlen, long wait_time)
uint8_t dum[DUM_LEN + 1]; uint8_t dum[DUM_LEN + 1];
while (true) { while (true) {
len = os_inchar(dum, DUM_LEN, 0L, 0, NULL); len = os_inchar(dum, DUM_LEN, 0, 0, NULL);
if (len == 0 || (len == 1 && dum[0] == Ctrl_C)) { if (len == 0 || (len == 1 && dum[0] == Ctrl_C)) {
break; break;
} }
@ -2862,7 +2862,7 @@ int inchar(uint8_t *buf, int maxlen, long wait_time)
// Always flush the output characters when getting input characters // Always flush the output characters when getting input characters
// from the user and not just peeking. // from the user and not just peeking.
if (wait_time == -1L || wait_time > 10L) { if (wait_time == -1 || wait_time > 10) {
ui_flush(); ui_flush();
} }

2
src/nvim/help.c
View File

@ -838,7 +838,7 @@ void fix_help_buffer(void)
} }
linenr_T appended = lnum - lnum_start; linenr_T appended = lnum - lnum_start;
if (appended) { if (appended) {
mark_adjust(lnum_start + 1, (linenr_T)MAXLNUM, appended, 0L, kExtmarkUndo); mark_adjust(lnum_start + 1, (linenr_T)MAXLNUM, appended, 0, kExtmarkUndo);
buf_redraw_changed_lines_later(curbuf, lnum_start + 1, lnum_start + 1, appended); buf_redraw_changed_lines_later(curbuf, lnum_start + 1, lnum_start + 1, appended);
} }
break; break;

2
src/nvim/highlight_group.c
View File

@ -2288,7 +2288,7 @@ static void highlight_list_two(int cnt, int attr)
msg_puts_attr(&("N \bI \b! \b"[cnt / 11]), attr); msg_puts_attr(&("N \bI \b! \b"[cnt / 11]), attr);
msg_clr_eos(); msg_clr_eos();
ui_flush(); ui_flush();
os_delay(cnt == 99 ? 40L : (uint64_t)cnt * 50L, false); os_delay(cnt == 99 ? 40 : (uint64_t)cnt * 50, false);
} }
/// Function given to ExpandGeneric() to obtain the list of group names. /// Function given to ExpandGeneric() to obtain the list of group names.

6
src/nvim/indent.c
View File

@ -800,7 +800,7 @@ int get_breakindent_win(win_T *wp, char *line)
FUNC_ATTR_NONNULL_ALL FUNC_ATTR_NONNULL_ALL
{ {
static int prev_indent = 0; // cached indent value static int prev_indent = 0; // cached indent value
static OptInt prev_ts = 0L; // cached tabstop value static OptInt prev_ts = 0; // cached tabstop value
static int prev_fnum = 0; // cached buffer number static int prev_fnum = 0; // cached buffer number
static char *prev_line = NULL; // cached copy of "line" static char *prev_line = NULL; // cached copy of "line"
static varnumber_T prev_tick = 0; // changedtick of cached value static varnumber_T prev_tick = 0; // changedtick of cached value
@ -1018,7 +1018,7 @@ void ex_retab(exarg_T *eap)
// len is actual number of white characters used // len is actual number of white characters used
len = num_spaces + num_tabs; len = num_spaces + num_tabs;
old_len = (int)strlen(ptr); old_len = (int)strlen(ptr);
const long new_len = old_len - col + start_col + len + 1; const int new_len = old_len - col + start_col + len + 1;
if (new_len <= 0 || new_len >= MAXCOL) { if (new_len <= 0 || new_len >= MAXCOL) {
emsg_text_too_long(); emsg_text_too_long();
break; break;
@ -1083,7 +1083,7 @@ void ex_retab(exarg_T *eap)
redraw_curbuf_later(UPD_NOT_VALID); redraw_curbuf_later(UPD_NOT_VALID);
} }
if (first_line != 0) { if (first_line != 0) {
changed_lines(curbuf, first_line, 0, last_line + 1, 0L, true); changed_lines(curbuf, first_line, 0, last_line + 1, 0, true);
} }
curwin->w_p_list = save_list; // restore 'list' curwin->w_p_list = save_list; // restore 'list'

2
src/nvim/input.c
View File

@ -112,7 +112,7 @@ int get_keystroke(MultiQueue *events)
// First time: blocking wait. Second time: wait up to 100ms for a // First time: blocking wait. Second time: wait up to 100ms for a
// terminal code to complete. // terminal code to complete.
n = os_inchar(buf + len, maxlen, len == 0 ? -1L : 100L, 0, events); n = os_inchar(buf + len, maxlen, len == 0 ? -1 : 100, 0, events);
if (n > 0) { if (n > 0) {
// Replace zero and K_SPECIAL by a special key code. // Replace zero and K_SPECIAL by a special key code.
n = fix_input_buffer(buf + len, n); n = fix_input_buffer(buf + len, n);

6
src/nvim/insexpand.c
View File

@ -474,7 +474,7 @@ bool check_compl_option(bool dict_opt)
vim_beep(BO_COMPL); vim_beep(BO_COMPL);
setcursor(); setcursor();
ui_flush(); ui_flush();
os_delay(2004L, false); os_delay(2004, false);
} }
return false; return false;
} }
@ -2986,7 +2986,7 @@ static void get_next_include_file_completion(int compl_type)
((compl_type == CTRL_X_PATH_DEFINES ((compl_type == CTRL_X_PATH_DEFINES
&& !(compl_cont_status & CONT_SOL)) && !(compl_cont_status & CONT_SOL))
? FIND_DEFINE : FIND_ANY), ? FIND_DEFINE : FIND_ANY),
1L, ACTION_EXPAND, 1, MAXLNUM); 1, ACTION_EXPAND, 1, MAXLNUM);
} }
/// Get the next set of words matching "compl_pattern" in dictionary or /// Get the next set of words matching "compl_pattern" in dictionary or
@ -3208,7 +3208,7 @@ static int get_next_default_completion(ins_compl_next_state_T *st, pos_T *start_
compl_direction, compl_pattern); compl_direction, compl_pattern);
} else { } else {
found_new_match = searchit(NULL, st->ins_buf, st->cur_match_pos, found_new_match = searchit(NULL, st->ins_buf, st->cur_match_pos,
NULL, compl_direction, compl_pattern, 1L, NULL, compl_direction, compl_pattern, 1,
SEARCH_KEEP + SEARCH_NFMSG, RE_LAST, NULL); SEARCH_KEEP + SEARCH_NFMSG, RE_LAST, NULL);
} }
msg_silent--; msg_silent--;

2
src/nvim/lua/executor.c
View File

@ -619,7 +619,7 @@ static bool nlua_init_packages(lua_State *lstate, bool is_standalone)
lua_getfield(lstate, -1, "preload"); // [package, preload] lua_getfield(lstate, -1, "preload"); // [package, preload]
for (size_t i = 0; i < ARRAY_SIZE(builtin_modules); i++) { for (size_t i = 0; i < ARRAY_SIZE(builtin_modules); i++) {
ModuleDef def = builtin_modules[i]; ModuleDef def = builtin_modules[i];
lua_pushinteger(lstate, (long)i); // [package, preload, i] lua_pushinteger(lstate, (lua_Integer)i); // [package, preload, i]
lua_pushcclosure(lstate, nlua_module_preloader, 1); // [package, preload, cclosure] lua_pushcclosure(lstate, nlua_module_preloader, 1); // [package, preload, cclosure]
lua_setfield(lstate, -2, def.name); // [package, preload] lua_setfield(lstate, -2, def.name); // [package, preload]

2
src/nvim/lua/spell.c
View File

@ -80,7 +80,7 @@ int nlua_spell_check(lua_State *lstate)
lua_rawseti(lstate, -2, 2); lua_rawseti(lstate, -2, 2);
// +1 for 1-indexing // +1 for 1-indexing
lua_pushinteger(lstate, (long)pos + 1); lua_pushinteger(lstate, (lua_Integer)pos + 1);
lua_rawseti(lstate, -2, 3); lua_rawseti(lstate, -2, 3);
lua_rawseti(lstate, -2, ++no_res); lua_rawseti(lstate, -2, ++no_res);

8
src/nvim/lua/stdlib.c
View File

@ -183,8 +183,8 @@ int nlua_str_utfindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
size_t codepoints = 0, codeunits = 0; size_t codepoints = 0, codeunits = 0;
mb_utflen(s1, (size_t)idx, &codepoints, &codeunits); mb_utflen(s1, (size_t)idx, &codepoints, &codeunits);
lua_pushinteger(lstate, (long)codepoints); lua_pushinteger(lstate, (lua_Integer)codepoints);
lua_pushinteger(lstate, (long)codeunits); lua_pushinteger(lstate, (lua_Integer)codeunits);
return 2; return 2;
} }
@ -204,7 +204,7 @@ static int nlua_str_utf_pos(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
size_t clen; size_t clen;
for (size_t i = 0; i < s1_len && s1[i] != NUL; i += clen) { for (size_t i = 0; i < s1_len && s1[i] != NUL; i += clen) {
clen = (size_t)utf_ptr2len_len(s1 + i, (int)(s1_len - i)); clen = (size_t)utf_ptr2len_len(s1 + i, (int)(s1_len - i));
lua_pushinteger(lstate, (long)i + 1); lua_pushinteger(lstate, (lua_Integer)i + 1);
lua_rawseti(lstate, -2, (int)idx); lua_rawseti(lstate, -2, (int)idx);
idx++; idx++;
} }
@ -276,7 +276,7 @@ int nlua_str_byteindex(lua_State *const lstate) FUNC_ATTR_NONNULL_ALL
return luaL_error(lstate, "index out of range"); return luaL_error(lstate, "index out of range");
} }
lua_pushinteger(lstate, (long)byteidx); lua_pushinteger(lstate, (lua_Integer)byteidx);
return 1; return 1;
} }

20
src/nvim/lua/xdiff.c
View File

@ -64,12 +64,12 @@ static void lua_pushhunk(lua_State *lstate, long start_a, long count_a, long sta
lua_rawseti(lstate, -2, (signed)lua_objlen(lstate, -2) + 1); lua_rawseti(lstate, -2, (signed)lua_objlen(lstate, -2) + 1);
} }
static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb, long start_a, static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb, int start_a,
long count_a, long start_b, long count_b, bool iwhite) int count_a, int start_b, int count_b, bool iwhite)
{ {
// get the pointer to char of the start of the diff to pass it to linematch algorithm // get the pointer to char of the start of the diff to pass it to linematch algorithm
const char *diff_begin[2] = { ma->ptr, mb->ptr }; const char *diff_begin[2] = { ma->ptr, mb->ptr };
int diff_length[2] = { (int)count_a, (int)count_b }; int diff_length[2] = { count_a, count_b };
fastforward_buf_to_lnum(&diff_begin[0], (linenr_T)start_a + 1); fastforward_buf_to_lnum(&diff_begin[0], (linenr_T)start_a + 1);
fastforward_buf_to_lnum(&diff_begin[1], (linenr_T)start_b + 1); fastforward_buf_to_lnum(&diff_begin[1], (linenr_T)start_b + 1);
@ -77,12 +77,12 @@ static void get_linematch_results(lua_State *lstate, mmfile_t *ma, mmfile_t *mb,
int *decisions = NULL; int *decisions = NULL;
size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite); size_t decisions_length = linematch_nbuffers(diff_begin, diff_length, 2, &decisions, iwhite);
long lnuma = start_a, lnumb = start_b; int lnuma = start_a, lnumb = start_b;
long hunkstarta = lnuma; int hunkstarta = lnuma;
long hunkstartb = lnumb; int hunkstartb = lnumb;
long hunkcounta = 0; int hunkcounta = 0;
long hunkcountb = 0; int hunkcountb = 0;
for (size_t i = 0; i < decisions_length; i++) { for (size_t i = 0; i < decisions_length; i++) {
if (i && (decisions[i - 1] != decisions[i])) { if (i && (decisions[i - 1] != decisions[i])) {
lua_pushhunk(lstate, hunkstarta, hunkcounta, hunkstartb, hunkcountb); lua_pushhunk(lstate, hunkstarta, hunkcounta, hunkstartb, hunkcountb);
@ -110,8 +110,8 @@ static int write_string(void *priv, mmbuffer_t *mb, int nbuf)
{ {
luaL_Buffer *buf = (luaL_Buffer *)priv; luaL_Buffer *buf = (luaL_Buffer *)priv;
for (int i = 0; i < nbuf; i++) { for (int i = 0; i < nbuf; i++) {
const long size = mb[i].size; const int size = mb[i].size;
for (long total = 0; total < size; total += LUAL_BUFFERSIZE) { for (int total = 0; total < size; total += LUAL_BUFFERSIZE) {
const int tocopy = MIN((int)(size - total), LUAL_BUFFERSIZE); const int tocopy = MIN((int)(size - total), LUAL_BUFFERSIZE);
char *p = luaL_prepbuffer(buf); char *p = luaL_prepbuffer(buf);
if (!p) { if (!p) {

6
src/nvim/main.c
View File

@ -585,7 +585,7 @@ int main(int argc, char **argv)
// 'autochdir' has been postponed. // 'autochdir' has been postponed.
do_autochdir(); do_autochdir();
set_vim_var_nr(VV_VIM_DID_ENTER, 1L); set_vim_var_nr(VV_VIM_DID_ENTER, 1);
apply_autocmds(EVENT_VIMENTER, NULL, NULL, false, curbuf); apply_autocmds(EVENT_VIMENTER, NULL, NULL, false, curbuf);
TIME_MSG("VimEnter autocommands"); TIME_MSG("VimEnter autocommands");
if (use_remote_ui) { if (use_remote_ui) {
@ -610,7 +610,7 @@ int main(int argc, char **argv)
// scrollbind, sync the scrollbind now. // scrollbind, sync the scrollbind now.
if (curwin->w_p_diff && curwin->w_p_scb) { if (curwin->w_p_diff && curwin->w_p_scb) {
update_topline(curwin); update_topline(curwin);
check_scrollbind((linenr_T)0, 0L); check_scrollbind((linenr_T)0, 0);
TIME_MSG("diff scrollbinding"); TIME_MSG("diff scrollbinding");
} }
@ -1027,7 +1027,7 @@ static void command_line_scan(mparm_T *parmp)
int argv_idx; // index in argv[n][] int argv_idx; // index in argv[n][]
bool had_minmin = false; // found "--" argument bool had_minmin = false; // found "--" argument
int want_argument; // option argument with argument int want_argument; // option argument with argument
long n; int n;
argc--; argc--;
argv++; argv++;

12
src/nvim/mark.c
View File

@ -441,11 +441,11 @@ fmark_T *mark_get_motion(buf_T *buf, win_T *win, int name)
listcmd_busy = true; // avoid that '' is changed listcmd_busy = true; // avoid that '' is changed
if (name == '{' || name == '}') { // to previous/next paragraph if (name == '{' || name == '}') { // to previous/next paragraph
oparg_T oa; oparg_T oa;
if (findpar(&oa.inclusive, name == '}' ? FORWARD : BACKWARD, 1L, NUL, false)) { if (findpar(&oa.inclusive, name == '}' ? FORWARD : BACKWARD, 1, NUL, false)) {
mark = pos_to_mark(buf, NULL, win->w_cursor); mark = pos_to_mark(buf, NULL, win->w_cursor);
} }
} else if (name == '(' || name == ')') { // to previous/next sentence } else if (name == '(' || name == ')') { // to previous/next sentence
if (findsent(name == ')' ? FORWARD : BACKWARD, 1L)) { if (findsent(name == ')' ? FORWARD : BACKWARD, 1)) {
mark = pos_to_mark(buf, NULL, win->w_cursor); mark = pos_to_mark(buf, NULL, win->w_cursor);
} }
} }
@ -1064,10 +1064,10 @@ void ex_changes(exarg_T *eap)
if (got_int) { if (got_int) {
break; break;
} }
snprintf(IObuff, IOSIZE, "%c %3d %5ld %4d ", snprintf(IObuff, IOSIZE, "%c %3d %5" PRIdLINENR " %4d ",
i == curwin->w_changelistidx ? '>' : ' ', i == curwin->w_changelistidx ? '>' : ' ',
i > curwin->w_changelistidx ? i - curwin->w_changelistidx : curwin->w_changelistidx - i, i > curwin->w_changelistidx ? i - curwin->w_changelistidx : curwin->w_changelistidx - i,
(long)curbuf->b_changelist[i].mark.lnum, curbuf->b_changelist[i].mark.lnum,
curbuf->b_changelist[i].mark.col); curbuf->b_changelist[i].mark.col);
msg_outtrans(IObuff, 0); msg_outtrans(IObuff, 0);
name = mark_line(&curbuf->b_changelist[i].mark, 17); name = mark_line(&curbuf->b_changelist[i].mark, 17);
@ -1143,7 +1143,7 @@ void mark_adjust_buf(buf_T *buf, linenr_T line1, linenr_T line2, linenr_T amount
linenr_T *lp; linenr_T *lp;
static pos_T initpos = { 1, 0, 0 }; static pos_T initpos = { 1, 0, 0 };
if (line2 < line1 && amount_after == 0L) { // nothing to do if (line2 < line1 && amount_after == 0) { // nothing to do
return; return;
} }
@ -1321,7 +1321,7 @@ void mark_col_adjust(linenr_T lnum, colnr_T mincol, linenr_T lnum_amount, colnr_
int fnum = curbuf->b_fnum; int fnum = curbuf->b_fnum;
pos_T *posp; pos_T *posp;
if ((col_amount == 0L && lnum_amount == 0L) || (cmdmod.cmod_flags & CMOD_LOCKMARKS)) { if ((col_amount == 0 && lnum_amount == 0) || (cmdmod.cmod_flags & CMOD_LOCKMARKS)) {
return; // nothing to do return; // nothing to do
} }
// named marks, lower case and upper case // named marks, lower case and upper case

2
src/nvim/mbyte.c
View File

@ -2774,7 +2774,7 @@ void f_setcellwidths(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
const listitem_T *lili = tv_list_first(li_l); const listitem_T *lili = tv_list_first(li_l);
const varnumber_T n1 = TV_LIST_ITEM_TV(lili)->vval.v_number; const varnumber_T n1 = TV_LIST_ITEM_TV(lili)->vval.v_number;
if (item > 0 && n1 <= table[item - 1].last) { if (item > 0 && n1 <= table[item - 1].last) {
semsg(_(e_overlapping_ranges_for_nr), (long)n1); semsg(_(e_overlapping_ranges_for_nr), (size_t)n1);
xfree((void *)ptrs); xfree((void *)ptrs);
xfree(table); xfree(table);
return; return;

2
src/nvim/memfile.c
View File

@ -125,7 +125,7 @@ memfile_T *mf_open(char *fname, int flags)
// must be rounded up. // must be rounded up.
if (mfp->mf_fd < 0 if (mfp->mf_fd < 0
|| (flags & (O_TRUNC|O_EXCL)) || (flags & (O_TRUNC|O_EXCL))
|| (size = vim_lseek(mfp->mf_fd, 0L, SEEK_END)) <= 0) { || (size = vim_lseek(mfp->mf_fd, 0, SEEK_END)) <= 0) {
// no file or empty file // no file or empty file
mfp->mf_blocknr_max = 0; mfp->mf_blocknr_max = 0;
} else { } else {

20
src/nvim/memline.c
View File

@ -162,9 +162,9 @@ enum {
// This won't detect a 64 bit machine that only swaps a byte in the top 32 // This won't detect a 64 bit machine that only swaps a byte in the top 32
// bits, but that is crazy anyway. // bits, but that is crazy anyway.
enum { enum {
B0_MAGIC_LONG = 0x30313233L, B0_MAGIC_LONG = 0x30313233,
B0_MAGIC_INT = 0x20212223L, B0_MAGIC_INT = 0x20212223,
B0_MAGIC_SHORT = 0x10111213L, B0_MAGIC_SHORT = 0x10111213,
B0_MAGIC_CHAR = 0x55, B0_MAGIC_CHAR = 0x55,
}; };
@ -677,8 +677,8 @@ static void set_b0_fname(ZeroBlock *b0p, buf_T *buf)
buf->b_mtime_read = buf->b_mtime; buf->b_mtime_read = buf->b_mtime;
buf->b_mtime_read_ns = buf->b_mtime_ns; buf->b_mtime_read_ns = buf->b_mtime_ns;
} else { } else {
long_to_char(0L, b0p->b0_mtime); long_to_char(0, b0p->b0_mtime);
long_to_char(0L, b0p->b0_ino); long_to_char(0, b0p->b0_ino);
buf->b_mtime = 0; buf->b_mtime = 0;
buf->b_mtime_ns = 0; buf->b_mtime_ns = 0;
buf->b_mtime_read = 0; buf->b_mtime_read = 0;
@ -895,7 +895,7 @@ void ml_recover(bool checkext)
goto theend; goto theend;
} }
off_T size; off_T size;
if ((size = vim_lseek(mfp->mf_fd, (off_T)0L, SEEK_END)) <= 0) { if ((size = vim_lseek(mfp->mf_fd, 0, SEEK_END)) <= 0) {
mfp->mf_blocknr_max = 0; // no file or empty file mfp->mf_blocknr_max = 0; // no file or empty file
} else { } else {
mfp->mf_blocknr_max = size / mfp->mf_page_size; mfp->mf_blocknr_max = size / mfp->mf_page_size;
@ -932,7 +932,7 @@ void ml_recover(bool checkext)
// check date of swapfile and original file // check date of swapfile and original file
FileInfo org_file_info; FileInfo org_file_info;
FileInfo swp_file_info; FileInfo swp_file_info;
long mtime = char_to_long(b0p->b0_mtime); int mtime = (int)char_to_long(b0p->b0_mtime);
if (curbuf->b_ffname != NULL if (curbuf->b_ffname != NULL
&& os_fileinfo(curbuf->b_ffname, &org_file_info) && os_fileinfo(curbuf->b_ffname, &org_file_info)
&& ((os_fileinfo(mfp->mf_fname, &swp_file_info) && ((os_fileinfo(mfp->mf_fname, &swp_file_info)
@ -983,7 +983,7 @@ void ml_recover(bool checkext)
linenr_T lnum = 0; // append after line 0 in curbuf linenr_T lnum = 0; // append after line 0 in curbuf
linenr_T line_count = 0; linenr_T line_count = 0;
int idx = 0; // start with first index in block 1 int idx = 0; // start with first index in block 1
long error = 0; int error = 0;
buf->b_ml.ml_stack_top = 0; // -V1048 buf->b_ml.ml_stack_top = 0; // -V1048
buf->b_ml.ml_stack = NULL; buf->b_ml.ml_stack = NULL;
buf->b_ml.ml_stack_size = 0; // -V1048 buf->b_ml.ml_stack_size = 0; // -V1048
@ -1565,7 +1565,7 @@ static time_t swapfile_info(char *fname)
msg_outtrans(b0.b0_hname, 0); msg_outtrans(b0.b0_hname, 0);
} }
if (char_to_long(b0.b0_pid) != 0L) { if (char_to_long(b0.b0_pid) != 0) {
msg_puts(_("\n process ID: ")); msg_puts(_("\n process ID: "));
msg_outnum((int)char_to_long(b0.b0_pid)); msg_outnum((int)char_to_long(b0.b0_pid));
if ((process_running = swapfile_process_running(&b0, fname))) { if ((process_running = swapfile_process_running(&b0, fname))) {
@ -1636,7 +1636,7 @@ static bool swapfile_unchanged(char *fname)
} }
// process must be known and not running. // process must be known and not running.
if (char_to_long(b0.b0_pid) == 0L || swapfile_process_running(&b0, fname)) { if (char_to_long(b0.b0_pid) == 0 || swapfile_process_running(&b0, fname)) {
ret = false; ret = false;
} }

2
src/nvim/message.c
View File

@ -3719,7 +3719,7 @@ void msg_check_for_delay(bool check_msg_scroll)
&& emsg_silent == 0 && emsg_silent == 0
&& !in_assert_fails) { && !in_assert_fails) {
ui_flush(); ui_flush();
os_delay(1006L, true); os_delay(1006, true);
emsg_on_display = false; emsg_on_display = false;
if (check_msg_scroll) { if (check_msg_scroll) {
msg_scroll = false; msg_scroll = false;

8
src/nvim/mouse.c
View File

@ -452,7 +452,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, int count, bool fixindent)
if ((State & REPLACE_FLAG) && !yank_register_mline(regname)) { if ((State & REPLACE_FLAG) && !yank_register_mline(regname)) {
insert_reg(regname, true); insert_reg(regname, true);
} else { } else {
do_put(regname, NULL, BACKWARD, 1L, do_put(regname, NULL, BACKWARD, 1,
(fixindent ? PUT_FIXINDENT : 0) | PUT_CURSEND); (fixindent ? PUT_FIXINDENT : 0) | PUT_CURSEND);
// Repeat it with CTRL-R CTRL-O r or CTRL-R CTRL-P r // Repeat it with CTRL-R CTRL-O r or CTRL-R CTRL-P r
@ -710,9 +710,9 @@ popupexit:
&& which_button == MOUSE_LEFT) { && which_button == MOUSE_LEFT) {
// open or close a fold at this line // open or close a fold at this line
if (jump_flags & MOUSE_FOLD_OPEN) { if (jump_flags & MOUSE_FOLD_OPEN) {
openFold(curwin->w_cursor, 1L); openFold(curwin->w_cursor, 1);
} else { } else {
closeFold(curwin->w_cursor, 1L); closeFold(curwin->w_cursor, 1);
} }
// don't move the cursor if still in the same window // don't move the cursor if still in the same window
if (curwin == old_curwin) { if (curwin == old_curwin) {
@ -733,7 +733,7 @@ popupexit:
// When dragging the mouse above the window, scroll down. // When dragging the mouse above the window, scroll down.
if (is_drag && mouse_row < 0 && !in_status_line) { if (is_drag && mouse_row < 0 && !in_status_line) {
scroll_redraw(false, 1L); scroll_redraw(false, 1);
mouse_row = 0; mouse_row = 0;
} }

44
src/nvim/normal.c
View File

@ -695,9 +695,9 @@ static void normal_redraw_mode_message(NormalState *s)
ui_cursor_shape(); // show different cursor shape ui_cursor_shape(); // show different cursor shape
ui_flush(); ui_flush();
if (msg_scroll || emsg_on_display) { if (msg_scroll || emsg_on_display) {
os_delay(1003L, true); // wait at least one second os_delay(1003, true); // wait at least one second
} }
os_delay(3003L, false); // wait up to three seconds os_delay(3003, false); // wait up to three seconds
State = save_State; State = save_State;
msg_scroll = false; msg_scroll = false;
@ -896,8 +896,8 @@ static bool normal_get_command_count(NormalState *s)
if (s->c == K_DEL || s->c == K_KDEL) { if (s->c == K_DEL || s->c == K_KDEL) {
s->ca.count0 /= 10; s->ca.count0 /= 10;
del_from_showcmd(4); // delete the digit and ~@% del_from_showcmd(4); // delete the digit and ~@%
} else if (s->ca.count0 > 99999999L) { } else if (s->ca.count0 > 99999999) {
s->ca.count0 = 999999999L; s->ca.count0 = 999999999;
} else { } else {
s->ca.count0 = s->ca.count0 * 10 + (s->c - '0'); s->ca.count0 = s->ca.count0 * 10 + (s->c - '0');
} }
@ -1035,7 +1035,7 @@ normal_end:
restart_VIsual_select = 0; restart_VIsual_select = 0;
} }
if (restart_edit != 0 && !VIsual_active && s->old_mapped_len == 0) { if (restart_edit != 0 && !VIsual_active && s->old_mapped_len == 0) {
(void)edit(restart_edit, false, 1L); (void)edit(restart_edit, false, 1);
} }
} }
@ -1113,8 +1113,8 @@ static int normal_execute(VimState *state, int key)
// If you give a count before AND after the operator, they are // If you give a count before AND after the operator, they are
// multiplied. // multiplied.
if (s->ca.count0) { if (s->ca.count0) {
if (s->ca.opcount >= 999999999L / s->ca.count0) { if (s->ca.opcount >= 999999999 / s->ca.count0) {
s->ca.count0 = 999999999L; s->ca.count0 = 999999999;
} else { } else {
s->ca.count0 *= s->ca.opcount; s->ca.count0 *= s->ca.opcount;
} }
@ -1443,7 +1443,7 @@ static int normal_check(VimState *state)
// Scroll-binding for diff mode may have been postponed until // Scroll-binding for diff mode may have been postponed until
// here. Avoids doing it for every change. // here. Avoids doing it for every change.
if (diff_need_scrollbind) { if (diff_need_scrollbind) {
check_scrollbind(0, 0L); check_scrollbind(0, 0);
diff_need_scrollbind = false; diff_need_scrollbind = false;
} }
@ -1737,7 +1737,7 @@ static void prep_redo_cmd(cmdarg_T *cap)
/// Note that only the last argument can be a multi-byte char. /// Note that only the last argument can be a multi-byte char.
void prep_redo(int regname, int num, int cmd1, int cmd2, int cmd3, int cmd4, int cmd5) void prep_redo(int regname, int num, int cmd1, int cmd2, int cmd3, int cmd4, int cmd5)
{ {
prep_redo_num2(regname, num, cmd1, cmd2, 0L, cmd3, cmd4, cmd5); prep_redo_num2(regname, num, cmd1, cmd2, 0, cmd3, cmd4, cmd5);
} }
/// Prepare for redo of any command with extra count after "cmd2". /// Prepare for redo of any command with extra count after "cmd2".
@ -2126,7 +2126,7 @@ void do_check_scrollbind(bool check)
// resync is performed, some of the other 'scrollbind' windows may // resync is performed, some of the other 'scrollbind' windows may
// need to jump so that the current window's relative position is // need to jump so that the current window's relative position is
// visible on-screen. // visible on-screen.
check_scrollbind(curwin->w_topline - (linenr_T)curwin->w_scbind_pos, 0L); check_scrollbind(curwin->w_topline - (linenr_T)curwin->w_scbind_pos, 0);
} }
curwin->w_scbind_pos = curwin->w_topline; curwin->w_scbind_pos = curwin->w_topline;
} }
@ -2364,7 +2364,7 @@ bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_ar
// With "gD" go to line 1. // With "gD" go to line 1.
// With "gd" Search back for the start of the current function, then go // With "gd" Search back for the start of the current function, then go
// back until a blank line. If this fails go to line 1. // back until a blank line. If this fails go to line 1.
if (!locally || !findpar(&incll, BACKWARD, 1L, '{', false)) { if (!locally || !findpar(&incll, BACKWARD, 1, '{', false)) {
setpcmark(); // Set in findpar() otherwise setpcmark(); // Set in findpar() otherwise
curwin->w_cursor.lnum = 1; curwin->w_cursor.lnum = 1;
par_pos = curwin->w_cursor; par_pos = curwin->w_cursor;
@ -2381,7 +2381,7 @@ bool find_decl(char *ptr, size_t len, bool locally, bool thisblock, int flags_ar
clearpos(&found_pos); clearpos(&found_pos);
while (true) { while (true) {
t = searchit(curwin, curbuf, &curwin->w_cursor, NULL, FORWARD, t = searchit(curwin, curbuf, &curwin->w_cursor, NULL, FORWARD,
pat, 1L, searchflags, RE_LAST, NULL); pat, 1, searchflags, RE_LAST, NULL);
if (curwin->w_cursor.lnum >= old_pos.lnum) { if (curwin->w_cursor.lnum >= old_pos.lnum) {
t = false; // match after start is failure too t = false; // match after start is failure too
} }
@ -2648,13 +2648,13 @@ void scroll_redraw(int up, linenr_T count)
&& curwin->w_topfill == prev_topfill) { && curwin->w_topfill == prev_topfill) {
if (up) { if (up) {
if (curwin->w_cursor.lnum > prev_lnum if (curwin->w_cursor.lnum > prev_lnum
|| cursor_down(1L, false) == false) { || cursor_down(1, false) == false) {
break; break;
} }
} else { } else {
if (curwin->w_cursor.lnum < prev_lnum if (curwin->w_cursor.lnum < prev_lnum
|| prev_topline == 1L || prev_topline == 1
|| cursor_up(1L, false) == false) { || cursor_up(1, false) == false) {
break; break;
} }
} }
@ -3211,7 +3211,7 @@ static void nv_colon(cmdarg_T *cap)
stuffcharReadbuff('.'); stuffcharReadbuff('.');
if (cap->count0 > 1) { if (cap->count0 > 1) {
stuffReadbuff(",.+"); stuffReadbuff(",.+");
stuffnumReadbuff(cap->count0 - 1L); stuffnumReadbuff(cap->count0 - 1);
} }
} }
@ -4781,7 +4781,7 @@ static void n_swapchar(cmdarg_T *cap)
curwin->w_set_curswant = true; curwin->w_set_curswant = true;
if (did_change) { if (did_change) {
changed_lines(curbuf, startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1, changed_lines(curbuf, startpos.lnum, startpos.col, curwin->w_cursor.lnum + 1,
0L, true); 0, true);
curbuf->b_op_start = startpos; curbuf->b_op_start = startpos;
curbuf->b_op_end = curwin->w_cursor; curbuf->b_op_end = curwin->w_cursor;
if (curbuf->b_op_end.col > 0) { if (curbuf->b_op_end.col > 0) {
@ -5568,7 +5568,7 @@ static void nv_g_cmd(cmdarg_T *cap)
// "gs": Goto sleep. // "gs": Goto sleep.
case 's': case 's':
do_sleep(cap->count1 * 1000L); do_sleep(cap->count1 * 1000);
break; break;
// "ga": Display the ascii value of the character under the // "ga": Display the ascii value of the character under the
@ -5870,7 +5870,7 @@ static void set_op_var(int optype)
static void nv_lineop(cmdarg_T *cap) static void nv_lineop(cmdarg_T *cap)
{ {
cap->oap->motion_type = kMTLineWise; cap->oap->motion_type = kMTLineWise;
if (cursor_down(cap->count1 - 1L, cap->oap->op_type == OP_NOP) == false) { if (cursor_down(cap->count1 - 1, cap->oap->op_type == OP_NOP) == false) {
clearopbeep(cap->oap); clearopbeep(cap->oap);
} else if ((cap->oap->op_type == OP_DELETE } else if ((cap->oap->op_type == OP_DELETE
// only with linewise motions // only with linewise motions
@ -6083,7 +6083,7 @@ static void nv_goto(cmdarg_T *cap)
if (cap->arg) { if (cap->arg) {
lnum = curbuf->b_ml.ml_line_count; lnum = curbuf->b_ml.ml_line_count;
} else { } else {
lnum = 1L; lnum = 1;
} }
cap->oap->motion_type = kMTLineWise; cap->oap->motion_type = kMTLineWise;
setpcmark(); setpcmark();
@ -6092,8 +6092,8 @@ static void nv_goto(cmdarg_T *cap)
if (cap->count0 != 0) { if (cap->count0 != 0) {
lnum = cap->count0; lnum = cap->count0;
} }
if (lnum < 1L) { if (lnum < 1) {
lnum = 1L; lnum = 1;
} else if (lnum > curbuf->b_ml.ml_line_count) { } else if (lnum > curbuf->b_ml.ml_line_count) {
lnum = curbuf->b_ml.ml_line_count; lnum = curbuf->b_ml.ml_line_count;
} }

46
src/nvim/ops.c
View File

@ -283,7 +283,7 @@ void op_shift(oparg_T *oap, int curs_top, int amount)
} }
} }
changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0, true);
} }
/// Shift the current line one shiftwidth left (if left != 0) or right /// Shift the current line one shiftwidth left (if left != 0) or right
@ -628,7 +628,7 @@ static void block_insert(oparg_T *oap, char *s, int b_insert, struct block_def *
State = oldstate; State = oldstate;
changed_lines(curbuf, oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum + 1, 0, oap->end.lnum + 1, 0, true);
} }
/// Handle reindenting a block of lines. /// Handle reindenting a block of lines.
@ -694,7 +694,7 @@ void op_reindent(oparg_T *oap, Indenter how)
if (last_changed != 0) { if (last_changed != 0) {
changed_lines(curbuf, first_changed, 0, changed_lines(curbuf, first_changed, 0,
oap->is_VIsual ? start_lnum + oap->line_count : oap->is_VIsual ? start_lnum + oap->line_count :
last_changed + 1, 0L, true); last_changed + 1, 0, true);
} else if (oap->is_VIsual) { } else if (oap->is_VIsual) {
redraw_curbuf_later(UPD_INVERTED); redraw_curbuf_later(UPD_INVERTED);
} }
@ -720,7 +720,7 @@ int get_expr_register(void)
{ {
char *new_line; char *new_line;
new_line = getcmdline('=', 0L, 0, true); new_line = getcmdline('=', 0, 0, true);
if (new_line == NULL) { if (new_line == NULL) {
return NUL; return NUL;
} }
@ -1262,7 +1262,7 @@ int insert_reg(int regname, bool literally_arg)
char *arg; char *arg;
if (regname == '.') { // Insert last inserted text. if (regname == '.') { // Insert last inserted text.
retval = stuff_inserted(NUL, 1L, true); retval = stuff_inserted(NUL, 1, true);
} else if (get_spec_reg(regname, &arg, &allocated, true)) { } else if (get_spec_reg(regname, &arg, &allocated, true)) {
if (arg == NULL) { if (arg == NULL) {
return FAIL; return FAIL;
@ -1280,7 +1280,7 @@ int insert_reg(int regname, bool literally_arg)
if (regname == '-') { if (regname == '-') {
AppendCharToRedobuff(Ctrl_R); AppendCharToRedobuff(Ctrl_R);
AppendCharToRedobuff(regname); AppendCharToRedobuff(regname);
do_put(regname, NULL, BACKWARD, 1L, PUT_CURSEND); do_put(regname, NULL, BACKWARD, 1, PUT_CURSEND);
} else { } else {
stuffescaped(reg->y_array[i], literally); stuffescaped(reg->y_array[i], literally);
} }
@ -1354,7 +1354,7 @@ bool get_spec_reg(int regname, char **argp, bool *allocated, bool errmsg)
return false; return false;
} }
*argp = file_name_at_cursor(FNAME_MESS | FNAME_HYP | (regname == Ctrl_P ? FNAME_EXP : 0), *argp = file_name_at_cursor(FNAME_MESS | FNAME_HYP | (regname == Ctrl_P ? FNAME_EXP : 0),
1L, NULL); 1, NULL);
*allocated = true; *allocated = true;
return true; return true;
@ -1596,7 +1596,7 @@ int op_delete(oparg_T *oap)
check_cursor_col(); check_cursor_col();
changed_lines(curbuf, curwin->w_cursor.lnum, curwin->w_cursor.col, changed_lines(curbuf, curwin->w_cursor.lnum, curwin->w_cursor.col,
oap->end.lnum + 1, 0L, true); oap->end.lnum + 1, 0, true);
oap->line_count = 0; // no lines deleted oap->line_count = 0; // no lines deleted
} else if (oap->motion_type == kMTLineWise) { } else if (oap->motion_type == kMTLineWise) {
if (oap->op_type == OP_CHANGE) { if (oap->op_type == OP_CHANGE) {
@ -1936,7 +1936,7 @@ static int op_replace(oparg_T *oap, int c)
linenr_T baselnum = curwin->w_cursor.lnum; linenr_T baselnum = curwin->w_cursor.lnum;
if (after_p != NULL) { if (after_p != NULL) {
ml_append(curwin->w_cursor.lnum++, after_p, (int)after_p_len, false); ml_append(curwin->w_cursor.lnum++, after_p, (int)after_p_len, false);
appended_lines_mark(curwin->w_cursor.lnum, 1L); appended_lines_mark(curwin->w_cursor.lnum, 1);
oap->end.lnum++; oap->end.lnum++;
xfree(after_p); xfree(after_p);
} }
@ -2032,7 +2032,7 @@ static int op_replace(oparg_T *oap, int c)
curwin->w_cursor = oap->start; curwin->w_cursor = oap->start;
check_cursor(); check_cursor();
changed_lines(curbuf, oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum, oap->start.col, oap->end.lnum + 1, 0, true);
if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) { if ((cmdmod.cmod_flags & CMOD_LOCKMARKS) == 0) {
// Set "'[" and "']" marks. // Set "'[" and "']" marks.
@ -2066,7 +2066,7 @@ void op_tilde(oparg_T *oap)
did_change |= one_change; did_change |= one_change;
} }
if (did_change) { if (did_change) {
changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0, true);
} }
} else { // not block mode } else { // not block mode
if (oap->motion_type == kMTLineWise) { if (oap->motion_type == kMTLineWise) {
@ -2095,7 +2095,7 @@ void op_tilde(oparg_T *oap)
} }
if (did_change) { if (did_change) {
changed_lines(curbuf, oap->start.lnum, oap->start.col, oap->end.lnum + 1, changed_lines(curbuf, oap->start.lnum, oap->start.col, oap->end.lnum + 1,
0L, true); 0, true);
} }
} }
@ -2532,7 +2532,7 @@ int op_change(oparg_T *oap)
} }
} }
check_cursor(); check_cursor();
changed_lines(curbuf, oap->start.lnum + 1, 0, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum + 1, 0, oap->end.lnum + 1, 0, true);
xfree(ins_text); xfree(ins_text);
} }
} }
@ -3618,7 +3618,7 @@ error:
ExtmarkOp kind = (y_type == kMTLineWise && !(flags & PUT_LINE_SPLIT)) ExtmarkOp kind = (y_type == kMTLineWise && !(flags & PUT_LINE_SPLIT))
? kExtmarkUndo : kExtmarkNOOP; ? kExtmarkUndo : kExtmarkNOOP;
mark_adjust(curbuf->b_op_start.lnum + (y_type == kMTCharWise), mark_adjust(curbuf->b_op_start.lnum + (y_type == kMTCharWise),
(linenr_T)MAXLNUM, nr_lines, 0L, kind); (linenr_T)MAXLNUM, nr_lines, 0, kind);
// note changed text for displaying and folding // note changed text for displaying and folding
if (y_type == kMTCharWise) { if (y_type == kMTCharWise) {
@ -4162,7 +4162,7 @@ int do_join(size_t count, int insert_space, int save_undo, int use_formatoptions
// Only report the change in the first line here, del_lines() will report // Only report the change in the first line here, del_lines() will report
// the deleted line. // the deleted line.
changed_lines(curbuf, curwin->w_cursor.lnum, currsize, changed_lines(curbuf, curwin->w_cursor.lnum, currsize,
curwin->w_cursor.lnum + 1, 0L, true); curwin->w_cursor.lnum + 1, 0, true);
// Delete following lines. To do this we move the cursor there // Delete following lines. To do this we move the cursor there
// briefly, and then move it back. After del_lines() the cursor may // briefly, and then move it back. After del_lines() the cursor may
@ -4381,7 +4381,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
change_cnt = do_addsub(oap->op_type, &pos, 0, amount); change_cnt = do_addsub(oap->op_type, &pos, 0, amount);
disable_fold_update--; disable_fold_update--;
if (change_cnt) { if (change_cnt) {
changed_lines(curbuf, pos.lnum, 0, pos.lnum + 1, 0L, true); changed_lines(curbuf, pos.lnum, 0, pos.lnum + 1, 0, true);
} }
} else { } else {
int length; int length;
@ -4439,7 +4439,7 @@ void op_addsub(oparg_T *oap, linenr_T Prenum1, bool g_cmd)
disable_fold_update--; disable_fold_update--;
if (change_cnt) { if (change_cnt) {
changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0L, true); changed_lines(curbuf, oap->start.lnum, 0, oap->end.lnum + 1, 0, true);
} }
if (!change_cnt && oap->is_VIsual) { if (!change_cnt && oap->is_VIsual) {
@ -5026,7 +5026,7 @@ static void finish_write_reg(int name, yankreg_T *reg, yankreg_T *old_y_previous
/// @see write_reg_contents_ex /// @see write_reg_contents_ex
void write_reg_contents(int name, const char *str, ssize_t len, int must_append) void write_reg_contents(int name, const char *str, ssize_t len, int must_append)
{ {
write_reg_contents_ex(name, str, len, must_append, kMTUnknown, 0L); write_reg_contents_ex(name, str, len, must_append, kMTUnknown, 0);
} }
void write_reg_contents_lst(int name, char **strings, bool must_append, MotionType yank_type, void write_reg_contents_lst(int name, char **strings, bool must_append, MotionType yank_type,
@ -5340,7 +5340,7 @@ void cursor_pos_info(dict_T *dict)
} else { } else {
linenr_T lnum; linenr_T lnum;
int eol_size; int eol_size;
varnumber_T last_check = 100000L; varnumber_T last_check = 100000;
int line_count_selected = 0; int line_count_selected = 0;
if (get_fileformat(curbuf) == EOL_DOS) { if (get_fileformat(curbuf) == EOL_DOS) {
eol_size = 2; eol_size = 2;
@ -5393,14 +5393,14 @@ void cursor_pos_info(dict_T *dict)
if (got_int) { if (got_int) {
return; return;
} }
last_check = byte_count + 100000L; last_check = byte_count + 100000;
} }
// Do extra processing for VIsual mode. // Do extra processing for VIsual mode.
if (l_VIsual_active if (l_VIsual_active
&& lnum >= min_pos.lnum && lnum <= max_pos.lnum) { && lnum >= min_pos.lnum && lnum <= max_pos.lnum) {
char *s = NULL; char *s = NULL;
int len = 0L; int len = 0;
switch (l_VIsual_mode) { switch (l_VIsual_mode) {
case Ctrl_V: case Ctrl_V:
@ -6034,9 +6034,9 @@ void do_pending_operator(cmdarg_T *cap, int old_col, bool gui_yank)
if (opchar == 'g' && extra_opchar == '@') { if (opchar == 'g' && extra_opchar == '@') {
// also repeat the count for 'operatorfunc' // also repeat the count for 'operatorfunc'
prep_redo_num2(oap->regname, 0L, NUL, 'v', cap->count0, opchar, extra_opchar, nchar); prep_redo_num2(oap->regname, 0, NUL, 'v', cap->count0, opchar, extra_opchar, nchar);
} else { } else {
prep_redo(oap->regname, 0L, NUL, 'v', opchar, extra_opchar, nchar); prep_redo(oap->regname, 0, NUL, 'v', opchar, extra_opchar, nchar);
} }
} }
if (!redo_VIsual_busy) { if (!redo_VIsual_busy) {

10
src/nvim/os/shell.c
View File

@ -366,7 +366,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
// When running in the background, give it some time to create the temp // When running in the background, give it some time to create the temp
// file, but don't wait for it to finish. // file, but don't wait for it to finish.
if (ampersand) { if (ampersand) {
os_delay(10L, true); os_delay(10, true);
} }
xfree(command); xfree(command);
@ -401,7 +401,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
xfree(tempname); xfree(tempname);
goto notfound; goto notfound;
} }
int fseek_res = fseek(fd, 0L, SEEK_END); int fseek_res = fseek(fd, 0, SEEK_END);
if (fseek_res < 0) { if (fseek_res < 0) {
xfree(tempname); xfree(tempname);
fclose(fd); fclose(fd);
@ -417,7 +417,7 @@ int os_expand_wildcards(int num_pat, char **pat, int *num_file, char ***file, in
assert(templen <= SIZE_MAX); // NOLINT(runtime/int) assert(templen <= SIZE_MAX); // NOLINT(runtime/int)
#endif #endif
len = (size_t)templen; len = (size_t)templen;
fseek(fd, 0L, SEEK_SET); fseek(fd, 0, SEEK_SET);
buffer = xmalloc(len + 1); buffer = xmalloc(len + 1);
// fread() doesn't terminate buffer with NUL; // fread() doesn't terminate buffer with NUL;
// appropriate termination (not always NUL) is done below. // appropriate termination (not always NUL) is done below.
@ -802,9 +802,9 @@ char *get_cmd_output(char *cmd, char *infile, ShellOpts flags, size_t *ret_len)
goto done; goto done;
} }
fseek(fd, 0L, SEEK_END); fseek(fd, 0, SEEK_END);
size_t len = (size_t)ftell(fd); // get size of temp file size_t len = (size_t)ftell(fd); // get size of temp file
fseek(fd, 0L, SEEK_SET); fseek(fd, 0, SEEK_SET);
buffer = xmalloc(len + 1); buffer = xmalloc(len + 1);
size_t i = fread(buffer, 1, len, fd); size_t i = fread(buffer, 1, len, fd);

4
src/nvim/profile.c
View File

@ -301,13 +301,13 @@ void ex_profile(exarg_T *eap)
profile_fname = expand_env_save_opt(e, true); profile_fname = expand_env_save_opt(e, true);
do_profiling = PROF_YES; do_profiling = PROF_YES;
profile_set_wait(profile_zero()); profile_set_wait(profile_zero());
set_vim_var_nr(VV_PROFILING, 1L); set_vim_var_nr(VV_PROFILING, 1);
} else if (do_profiling == PROF_NONE) { } else if (do_profiling == PROF_NONE) {
emsg(_("E750: First use \":profile start {fname}\"")); emsg(_("E750: First use \":profile start {fname}\""));
} else if (strcmp(eap->arg, "stop") == 0) { } else if (strcmp(eap->arg, "stop") == 0) {
profile_dump(); profile_dump();
do_profiling = PROF_NONE; do_profiling = PROF_NONE;
set_vim_var_nr(VV_PROFILING, 0L); set_vim_var_nr(VV_PROFILING, 0);
profile_reset(); profile_reset();
} else if (strcmp(eap->arg, "pause") == 0) { } else if (strcmp(eap->arg, "pause") == 0) {
if (do_profiling == PROF_YES) { if (do_profiling == PROF_YES) {

4
src/nvim/quickfix.c
View File

@ -2084,7 +2084,7 @@ static int copy_loclist(qf_list_T *from_qfl, qf_list_T *to_qfl)
// Assign a new ID for the location list // Assign a new ID for the location list
to_qfl->qf_id = ++last_qf_id; to_qfl->qf_id = ++last_qf_id;
to_qfl->qf_changedtick = 0L; to_qfl->qf_changedtick = 0;
// When no valid entries are present in the list, qf_ptr points to // When no valid entries are present in the list, qf_ptr points to
// the first item in the list // the first item in the list
@ -3450,7 +3450,7 @@ static void qf_free(qf_list_T *qfl)
qfl->qf_ctx = NULL; qfl->qf_ctx = NULL;
callback_free(&qfl->qf_qftf_cb); callback_free(&qfl->qf_qftf_cb);
qfl->qf_id = 0; qfl->qf_id = 0;
qfl->qf_changedtick = 0L; qfl->qf_changedtick = 0;
} }
/// Adjust error list entries for changed line numbers /// Adjust error list entries for changed line numbers

46
src/nvim/regexp.c
View File

@ -227,7 +227,7 @@ static int toggle_Magic(int x)
return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, FAIL) return (semsg((m), (c) ? "" : "\\"), rc_did_emsg = true, FAIL)
#define EMSG_ONE_RET_NULL EMSG2_RET_NULL(_(e_invalid_item_in_str_brackets), reg_magic == MAGIC_ALL) #define EMSG_ONE_RET_NULL EMSG2_RET_NULL(_(e_invalid_item_in_str_brackets), reg_magic == MAGIC_ALL)
#define MAX_LIMIT (32767L << 16L) #define MAX_LIMIT (32767 << 16)
static const char e_invalid_character_after_str_at[] static const char e_invalid_character_after_str_at[]
= N_("E59: Invalid character after %s@"); = N_("E59: Invalid character after %s@");
@ -2628,11 +2628,11 @@ static void init_regexec_multi(regmmatch_T *rmp, win_T *win, buf_T *buf, linenr_
static int prevchr_len; ///< byte length of previous char static int prevchr_len; ///< byte length of previous char
static int num_complex_braces; ///< Complex \{...} count static int num_complex_braces; ///< Complex \{...} count
static uint8_t *regcode; ///< Code-emit pointer, or JUST_CALC_SIZE static uint8_t *regcode; ///< Code-emit pointer, or JUST_CALC_SIZE
static long regsize; ///< Code size. static int64_t regsize; ///< Code size.
static int reg_toolong; ///< true when offset out of range static int reg_toolong; ///< true when offset out of range
static uint8_t had_endbrace[NSUBEXP]; ///< flags, true if end of () found static uint8_t had_endbrace[NSUBEXP]; ///< flags, true if end of () found
static long brace_min[10]; ///< Minimums for complex brace repeats static int64_t brace_min[10]; ///< Minimums for complex brace repeats
static long brace_max[10]; ///< Maximums for complex brace repeats static int64_t brace_max[10]; ///< Maximums for complex brace repeats
static int brace_count[10]; ///< Current counts for complex brace repeats static int brace_count[10]; ///< Current counts for complex brace repeats
static int one_exactly = false; ///< only do one char for EXACTLY static int one_exactly = false; ///< only do one char for EXACTLY
@ -2656,9 +2656,9 @@ static int classcodes[] = {
typedef struct regstar_S { typedef struct regstar_S {
int nextb; // next byte int nextb; // next byte
int nextb_ic; // next byte reverse case int nextb_ic; // next byte reverse case
long count; int64_t count;
long minval; int64_t minval;
long maxval; int64_t maxval;
} regstar_T; } regstar_T;
// used to store input position when a BACK was encountered, so that we now if // used to store input position when a BACK was encountered, so that we now if
@ -2729,8 +2729,8 @@ static regsave_T behind_pos;
#define NEXT(p) (((*((p) + 1) & 0377) << 8) + (*((p) + 2) & 0377)) #define NEXT(p) (((*((p) + 1) & 0377) << 8) + (*((p) + 2) & 0377))
#define OPERAND(p) ((p) + 3) #define OPERAND(p) ((p) + 3)
// Obtain an operand that was stored as four bytes, MSB first. // Obtain an operand that was stored as four bytes, MSB first.
#define OPERAND_MIN(p) (((long)(p)[3] << 24) + ((long)(p)[4] << 16) \ #define OPERAND_MIN(p) (((int64_t)(p)[3] << 24) + ((int64_t)(p)[4] << 16) \
+ ((long)(p)[5] << 8) + (long)(p)[6]) + ((int64_t)(p)[5] << 8) + (int64_t)(p)[6])
// Obtain a second operand stored as four bytes. // Obtain a second operand stored as four bytes.
#define OPERAND_MAX(p) OPERAND_MIN((p) + 4) #define OPERAND_MAX(p) OPERAND_MIN((p) + 4)
// Obtain a second single-byte operand stored after a four bytes operand. // Obtain a second single-byte operand stored after a four bytes operand.
@ -3898,7 +3898,7 @@ static void reginsert(int op, uint8_t *opnd)
// Insert an operator in front of already-emitted operand. // Insert an operator in front of already-emitted operand.
// Add a number to the operator. // Add a number to the operator.
static void reginsert_nr(int op, long val, uint8_t *opnd) static void reginsert_nr(int op, int64_t val, uint8_t *opnd)
{ {
uint8_t *src; uint8_t *src;
uint8_t *dst; uint8_t *dst;
@ -3927,7 +3927,7 @@ static void reginsert_nr(int op, long val, uint8_t *opnd)
// The operator has the given limit values as operands. Also set next pointer. // The operator has the given limit values as operands. Also set next pointer.
// //
// Means relocating the operand. // Means relocating the operand.
static void reginsert_limits(int op, long minval, long maxval, uint8_t *opnd) static void reginsert_limits(int op, int64_t minval, int64_t maxval, uint8_t *opnd)
{ {
uint8_t *src; uint8_t *src;
uint8_t *dst; uint8_t *dst;
@ -5310,8 +5310,8 @@ static void bt_regfree(regprog_T *prog)
// The arguments from BRACE_LIMITS are stored here. They are actually local // The arguments from BRACE_LIMITS are stored here. They are actually local
// to regmatch(), but they are here to reduce the amount of stack space used // to regmatch(), but they are here to reduce the amount of stack space used
// (it can be called recursively many times). // (it can be called recursively many times).
static long bl_minval; static int64_t bl_minval;
static long bl_maxval; static int64_t bl_maxval;
// Save the input line and position in a regsave_T. // Save the input line and position in a regsave_T.
static void reg_save(regsave_T *save, garray_T *gap) static void reg_save(regsave_T *save, garray_T *gap)
@ -5388,9 +5388,9 @@ static void save_se_one(save_se_T *savep, uint8_t **pp)
/// Advances rex.input (and rex.lnum) to just after the matched chars. /// Advances rex.input (and rex.lnum) to just after the matched chars.
/// ///
/// @param maxcount maximum number of matches allowed /// @param maxcount maximum number of matches allowed
static int regrepeat(uint8_t *p, long maxcount) static int regrepeat(uint8_t *p, int64_t maxcount)
{ {
long count = 0; int64_t count = 0;
uint8_t *opnd; uint8_t *opnd;
int mask; int mask;
int testval = 0; int testval = 0;
@ -5756,7 +5756,7 @@ static regitem_T *regstack_push(regstate_T state, uint8_t *scan)
{ {
regitem_T *rp; regitem_T *rp;
if ((long)((unsigned)regstack.ga_len >> 10) >= p_mmp) { if ((int64_t)((unsigned)regstack.ga_len >> 10) >= p_mmp) {
emsg(_(e_pattern_uses_more_memory_than_maxmempattern)); emsg(_(e_pattern_uses_more_memory_than_maxmempattern));
return NULL; return NULL;
} }
@ -6722,7 +6722,7 @@ static bool regmatch(uint8_t *scan, proftime_T *tm, int *timed_out)
// It could match. Prepare for trying to match what // It could match. Prepare for trying to match what
// follows. The code is below. Parameters are stored in // follows. The code is below. Parameters are stored in
// a regstar_T on the regstack. // a regstar_T on the regstack.
if ((long)((unsigned)regstack.ga_len >> 10) >= p_mmp) { if ((int64_t)((unsigned)regstack.ga_len >> 10) >= p_mmp) {
emsg(_(e_pattern_uses_more_memory_than_maxmempattern)); emsg(_(e_pattern_uses_more_memory_than_maxmempattern));
status = RA_FAIL; status = RA_FAIL;
} else { } else {
@ -6759,7 +6759,7 @@ static bool regmatch(uint8_t *scan, proftime_T *tm, int *timed_out)
case BEHIND: case BEHIND:
case NOBEHIND: case NOBEHIND:
// Need a bit of room to store extra positions. // Need a bit of room to store extra positions.
if ((long)((unsigned)regstack.ga_len >> 10) >= p_mmp) { if ((int64_t)((unsigned)regstack.ga_len >> 10) >= p_mmp) {
emsg(_(e_pattern_uses_more_memory_than_maxmempattern)); emsg(_(e_pattern_uses_more_memory_than_maxmempattern));
status = RA_FAIL; status = RA_FAIL;
} else { } else {
@ -6998,7 +6998,7 @@ static bool regmatch(uint8_t *scan, proftime_T *tm, int *timed_out)
regstack_pop(&scan); regstack_pop(&scan);
regstack.ga_len -= (int)sizeof(regbehind_T); regstack.ga_len -= (int)sizeof(regbehind_T);
} else { } else {
long limit; int64_t limit;
// No match or a match that doesn't end where we want it: Go // No match or a match that doesn't end where we want it: Go
// back one character. May go to previous line once. // back one character. May go to previous line once.
@ -7479,7 +7479,7 @@ static int bt_regexec_nl(regmatch_T *rmp, uint8_t *line, colnr_T col, bool line_
rex.reg_nobreak = rmp->regprog->re_flags & RE_NOBREAK; rex.reg_nobreak = rmp->regprog->re_flags & RE_NOBREAK;
rex.reg_maxcol = 0; rex.reg_maxcol = 0;
long r = bt_regexec_both(line, col, NULL, NULL); int64_t r = bt_regexec_both(line, col, NULL, NULL);
assert(r <= INT_MAX); assert(r <= INT_MAX);
return (int)r; return (int)r;
} }
@ -12826,7 +12826,7 @@ skip_add:
const int newlen = l->len * 3 / 2 + 50; const int newlen = l->len * 3 / 2 + 50;
const size_t newsize = (size_t)newlen * sizeof(nfa_thread_T); const size_t newsize = (size_t)newlen * sizeof(nfa_thread_T);
if ((long)(newsize >> 10) >= p_mmp) { if ((int64_t)(newsize >> 10) >= p_mmp) {
emsg(_(e_pattern_uses_more_memory_than_maxmempattern)); emsg(_(e_pattern_uses_more_memory_than_maxmempattern));
depth--; depth--;
return NULL; return NULL;
@ -13117,7 +13117,7 @@ static regsubs_T *addstate_here(nfa_list_T *l, nfa_state_T *state, regsubs_T *su
const int newlen = l->len * 3 / 2 + 50; const int newlen = l->len * 3 / 2 + 50;
const size_t newsize = (size_t)newlen * sizeof(nfa_thread_T); const size_t newsize = (size_t)newlen * sizeof(nfa_thread_T);
if ((long)(newsize >> 10) >= p_mmp) { if ((int64_t)(newsize >> 10) >= p_mmp) {
emsg(_(e_pattern_uses_more_memory_than_maxmempattern)); emsg(_(e_pattern_uses_more_memory_than_maxmempattern));
return NULL; return NULL;
} }
@ -14740,7 +14740,7 @@ static int nfa_regmatch(nfa_regprog_T *prog, nfa_state_T *start, regsubs_T *subm
result = false; result = false;
win_T *wp = rex.reg_win == NULL ? curwin : rex.reg_win; win_T *wp = rex.reg_win == NULL ? curwin : rex.reg_win;
if (op == 1 && col - 1 > t->state->val && col > 100) { if (op == 1 && col - 1 > t->state->val && col > 100) {
long ts = (long)wp->w_buffer->b_p_ts; int64_t ts = (int64_t)wp->w_buffer->b_p_ts;
// Guess that a character won't use more columns than 'tabstop', // Guess that a character won't use more columns than 'tabstop',
// with a minimum of 4. // with a minimum of 4.

48
src/nvim/search.c
View File

@ -94,9 +94,9 @@ static const char e_search_hit_bottom_without_match_for_str[]
static struct spat spats[2] = { static struct spat spats[2] = {
// Last used search pattern // Last used search pattern
[0] = { NULL, true, false, 0, { '/', false, false, 0L }, NULL }, [0] = { NULL, true, false, 0, { '/', false, false, 0 }, NULL },
// Last used substitute pattern // Last used substitute pattern
[1] = { NULL, true, false, 0, { '/', false, false, 0L }, NULL } [1] = { NULL, true, false, 0, { '/', false, false, 0 }, NULL }
}; };
static int last_idx = 0; // index in spats[] for RE_LAST static int last_idx = 0; // index in spats[] for RE_LAST
@ -564,7 +564,7 @@ int searchit(win_T *win, buf_T *buf, pos_T *pos, pos_T *end_pos, Direction dir,
int extra_col; int extra_col;
int start_char_len; int start_char_len;
bool match_ok; bool match_ok;
long nmatched; int nmatched;
int submatch = 0; int submatch = 0;
bool first_match = true; bool first_match = true;
const int called_emsg_before = called_emsg; const int called_emsg_before = called_emsg;
@ -980,7 +980,7 @@ void set_search_direction(int cdir)
static void set_vv_searchforward(void) static void set_vv_searchforward(void)
{ {
set_vim_var_nr(VV_SEARCHFORWARD, (long)(spats[0].off.dir == '/')); set_vim_var_nr(VV_SEARCHFORWARD, spats[0].off.dir == '/');
} }
// Return the number of the first subpat that matched. // Return the number of the first subpat that matched.
@ -2367,9 +2367,9 @@ void showmatch(int c)
// brief pause, unless 'm' is present in 'cpo' and a character is // brief pause, unless 'm' is present in 'cpo' and a character is
// available. // available.
if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL) { if (vim_strchr(p_cpo, CPO_SHOWMATCH) != NULL) {
os_delay((uint64_t)p_mat * 100L + 8, true); os_delay((uint64_t)p_mat * 100 + 8, true);
} else if (!char_avail()) { } else if (!char_avail()) {
os_delay((uint64_t)p_mat * 100L + 9, false); os_delay((uint64_t)p_mat * 100 + 9, false);
} }
curwin->w_cursor = save_cursor; // restore cursor position curwin->w_cursor = save_cursor; // restore cursor position
*so = save_so; *so = save_so;
@ -2586,7 +2586,7 @@ int linewhite(linenr_T lnum)
/// Add the search count "[3/19]" to "msgbuf". /// Add the search count "[3/19]" to "msgbuf".
/// See update_search_stat() for other arguments. /// See update_search_stat() for other arguments.
static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool show_top_bot_msg, static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool show_top_bot_msg,
char *msgbuf, bool recompute, int maxcount, long timeout) char *msgbuf, bool recompute, int maxcount, int timeout)
{ {
searchstat_T stat; searchstat_T stat;
@ -2658,7 +2658,7 @@ static void cmdline_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, bool sh
// dirc == '/': find the next match // dirc == '/': find the next match
// dirc == '?': find the previous match // dirc == '?': find the previous match
static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchstat_T *stat, static void update_search_stat(int dirc, pos_T *pos, pos_T *cursor_pos, searchstat_T *stat,
bool recompute, int maxcount, long timeout) bool recompute, int maxcount, int timeout)
{ {
int save_ws = p_ws; int save_ws = p_ws;
bool wraparound = false; bool wraparound = false;
@ -2767,7 +2767,7 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
pos_T pos = curwin->w_cursor; pos_T pos = curwin->w_cursor;
char *pattern = NULL; char *pattern = NULL;
int maxcount = SEARCH_STAT_DEF_MAX_COUNT; int maxcount = SEARCH_STAT_DEF_MAX_COUNT;
long timeout = SEARCH_STAT_DEF_TIMEOUT; int timeout = SEARCH_STAT_DEF_TIMEOUT;
bool recompute = true; bool recompute = true;
searchstat_T stat; searchstat_T stat;
@ -2788,7 +2788,7 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
dict = argvars[0].vval.v_dict; dict = argvars[0].vval.v_dict;
di = tv_dict_find(dict, "timeout", -1); di = tv_dict_find(dict, "timeout", -1);
if (di != NULL) { if (di != NULL) {
timeout = (long)tv_get_number_chk(&di->di_tv, &error); timeout = (int)tv_get_number_chk(&di->di_tv, &error);
if (error) { if (error) {
return; return;
} }
@ -2824,21 +2824,21 @@ void f_searchcount(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
semsg(_(e_invarg2), "List format should be [lnum, col, off]"); semsg(_(e_invarg2), "List format should be [lnum, col, off]");
return; return;
} }
listitem_T *li = tv_list_find(di->di_tv.vval.v_list, 0L); listitem_T *li = tv_list_find(di->di_tv.vval.v_list, 0);
if (li != NULL) { if (li != NULL) {
pos.lnum = (linenr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error); pos.lnum = (linenr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error);
if (error) { if (error) {
return; return;
} }
} }
li = tv_list_find(di->di_tv.vval.v_list, 1L); li = tv_list_find(di->di_tv.vval.v_list, 1);
if (li != NULL) { if (li != NULL) {
pos.col = (colnr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error) - 1; pos.col = (colnr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error) - 1;
if (error) { if (error) {
return; return;
} }
} }
li = tv_list_find(di->di_tv.vval.v_list, 2L); li = tv_list_find(di->di_tv.vval.v_list, 2);
if (li != NULL) { if (li != NULL) {
pos.coladd = (colnr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error); pos.coladd = (colnr_T)tv_get_number_chk(TV_LIST_ITEM_TV(li), &error);
if (error) { if (error) {
@ -3207,10 +3207,10 @@ static int fuzzy_match_item_compare(const void *const s1, const void *const s2)
static void fuzzy_match_in_list(list_T *const l, char *const str, const bool matchseq, static void fuzzy_match_in_list(list_T *const l, char *const str, const bool matchseq,
const char *const key, Callback *const item_cb, const char *const key, Callback *const item_cb,
const bool retmatchpos, list_T *const fmatchlist, const bool retmatchpos, list_T *const fmatchlist,
const long max_matches) const int max_matches)
FUNC_ATTR_NONNULL_ARG(2, 5, 7) FUNC_ATTR_NONNULL_ARG(2, 5, 7)
{ {
long len = tv_list_len(l); int len = tv_list_len(l);
if (len == 0) { if (len == 0) {
return; return;
} }
@ -3219,7 +3219,7 @@ static void fuzzy_match_in_list(list_T *const l, char *const str, const bool mat
} }
fuzzyItem_T *const items = xcalloc((size_t)len, sizeof(fuzzyItem_T)); fuzzyItem_T *const items = xcalloc((size_t)len, sizeof(fuzzyItem_T));
long match_count = 0; int match_count = 0;
uint32_t matches[MAX_FUZZY_MATCHES]; uint32_t matches[MAX_FUZZY_MATCHES];
// For all the string items in items, get the fuzzy matching score // For all the string items in items, get the fuzzy matching score
@ -3303,7 +3303,7 @@ static void fuzzy_match_in_list(list_T *const l, char *const str, const bool mat
} }
// Copy the matching strings with a valid score to the return list // Copy the matching strings with a valid score to the return list
for (long i = 0; i < match_count; i++) { for (int i = 0; i < match_count; i++) {
if (items[i].score == SCORE_NONE) { if (items[i].score == SCORE_NONE) {
break; break;
} }
@ -3316,7 +3316,7 @@ static void fuzzy_match_in_list(list_T *const l, char *const str, const bool mat
assert(li != NULL && TV_LIST_ITEM_TV(li)->vval.v_list != NULL); assert(li != NULL && TV_LIST_ITEM_TV(li)->vval.v_list != NULL);
retlist = TV_LIST_ITEM_TV(li)->vval.v_list; retlist = TV_LIST_ITEM_TV(li)->vval.v_list;
for (long i = 0; i < match_count; i++) { for (int i = 0; i < match_count; i++) {
if (items[i].score == SCORE_NONE) { if (items[i].score == SCORE_NONE) {
break; break;
} }
@ -3327,7 +3327,7 @@ static void fuzzy_match_in_list(list_T *const l, char *const str, const bool mat
li = tv_list_find(fmatchlist, -1); li = tv_list_find(fmatchlist, -1);
assert(li != NULL && TV_LIST_ITEM_TV(li)->vval.v_list != NULL); assert(li != NULL && TV_LIST_ITEM_TV(li)->vval.v_list != NULL);
retlist = TV_LIST_ITEM_TV(li)->vval.v_list; retlist = TV_LIST_ITEM_TV(li)->vval.v_list;
for (long i = 0; i < match_count; i++) { for (int i = 0; i < match_count; i++) {
if (items[i].score == SCORE_NONE) { if (items[i].score == SCORE_NONE) {
break; break;
} }
@ -3357,7 +3357,7 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv,
Callback cb = CALLBACK_NONE; Callback cb = CALLBACK_NONE;
const char *key = NULL; const char *key = NULL;
bool matchseq = false; bool matchseq = false;
long max_matches = 0; int max_matches = 0;
if (argvars[2].v_type != VAR_UNKNOWN) { if (argvars[2].v_type != VAR_UNKNOWN) {
if (tv_check_for_nonnull_dict_arg(argvars, 2) == FAIL) { if (tv_check_for_nonnull_dict_arg(argvars, 2) == FAIL) {
return; return;
@ -3384,7 +3384,7 @@ static void do_fuzzymatch(const typval_T *const argvars, typval_T *const rettv,
semsg(_(e_invarg2), tv_get_string(&di->di_tv)); semsg(_(e_invarg2), tv_get_string(&di->di_tv));
return; return;
} }
max_matches = (long)tv_get_number_chk(&di->di_tv, NULL); max_matches = (int)tv_get_number_chk(&di->di_tv, NULL);
} }
if (tv_dict_find(d, "matchseq", -1) != NULL) { if (tv_dict_find(d, "matchseq", -1) != NULL) {
@ -3645,11 +3645,11 @@ void find_pattern_in_path(char *ptr, Direction dir, size_t len, bool whole, bool
(size_t)(incl_regmatch.endp[0] (size_t)(incl_regmatch.endp[0]
- incl_regmatch.startp[0]), - incl_regmatch.startp[0]),
FNAME_EXP|FNAME_INCL|FNAME_REL, FNAME_EXP|FNAME_INCL|FNAME_REL,
1L, p_fname); 1, p_fname);
} else { } else {
// Use text after match with 'include'. // Use text after match with 'include'.
new_fname = file_name_in_line(incl_regmatch.endp[0], 0, new_fname = file_name_in_line(incl_regmatch.endp[0], 0,
FNAME_EXP|FNAME_INCL|FNAME_REL, 1L, p_fname, FNAME_EXP|FNAME_INCL|FNAME_REL, 1, p_fname,
NULL); NULL);
} }
already_searched = false; already_searched = false;
@ -3995,7 +3995,7 @@ search_line:
} else if (action == ACTION_SHOW) { } else if (action == ACTION_SHOW) {
show_pat_in_path(line, type, did_show, action, show_pat_in_path(line, type, did_show, action,
(depth == -1) ? NULL : files[depth].fp, (depth == -1) ? NULL : files[depth].fp,
(depth == -1) ? &lnum : &files[depth].lnum, 1L); (depth == -1) ? &lnum : &files[depth].lnum, 1);
did_show = true; did_show = true;
} else { } else {
// ":psearch" uses the preview window // ":psearch" uses the preview window

2
src/nvim/search.h
View File

@ -52,7 +52,7 @@
#define RE_LAST 2 // use last used pattern if "pat" is NULL #define RE_LAST 2 // use last used pattern if "pat" is NULL
// Values for searchcount() // Values for searchcount()
#define SEARCH_STAT_DEF_TIMEOUT 40L #define SEARCH_STAT_DEF_TIMEOUT 40
#define SEARCH_STAT_DEF_MAX_COUNT 99 #define SEARCH_STAT_DEF_MAX_COUNT 99
#define SEARCH_STAT_BUF_LEN 12 #define SEARCH_STAT_BUF_LEN 12

6
src/nvim/shada.c
View File

@ -2503,9 +2503,9 @@ static ShaDaWriteResult shada_write(ShaDaWriteDef *const sd_writer, ShaDaReadDef
// Initialize history merger // Initialize history merger
for (HistoryType i = 0; i < HIST_COUNT; i++) { for (HistoryType i = 0; i < HIST_COUNT; i++) {
long num_saved = get_shada_parameter(hist_type2char(i)); int num_saved = get_shada_parameter(hist_type2char(i));
if (num_saved == -1) { if (num_saved == -1) {
num_saved = (long)p_hi; num_saved = (int)p_hi;
} }
if (num_saved > 0) { if (num_saved > 0) {
dump_history = true; dump_history = true;
@ -3338,7 +3338,6 @@ static ShaDaReadResult msgpack_read_uint64(ShaDaReadDef *const sd_reader, const
#define ID(s) s #define ID(s) s
#define BINDUP(b) xmemdupz((b).ptr, (b).size) #define BINDUP(b) xmemdupz((b).ptr, (b).size)
#define TOINT(s) ((int)(s)) #define TOINT(s) ((int)(s))
#define TOLONG(s) ((long)(s))
#define TOCHAR(s) ((char)(s)) #define TOCHAR(s) ((char)(s))
#define TOU8(s) ((uint8_t)(s)) #define TOU8(s) ((uint8_t)(s))
#define TOSIZE(s) ((size_t)(s)) #define TOSIZE(s) ((size_t)(s))
@ -3964,7 +3963,6 @@ shada_read_next_item_error:
#undef BINDUP #undef BINDUP
#undef TOCHAR #undef TOCHAR
#undef TOINT #undef TOINT
#undef TOLONG
#undef TYPED_KEY #undef TYPED_KEY
#undef INT_KEY #undef INT_KEY
#undef INTEGER_KEY #undef INTEGER_KEY

8
src/nvim/sign.c
View File

@ -1,9 +1,7 @@
// 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
//
// sign.c: functions for managing with signs // sign.c: functions for managing with signs
//
#include <inttypes.h> #include <inttypes.h>
#include <stdbool.h> #include <stdbool.h>
@ -732,8 +730,8 @@ static void sign_list_placed(buf_T *rbuf, char *sign_group)
group[0] = '\0'; group[0] = '\0';
} }
vim_snprintf(lbuf, MSG_BUF_LEN, vim_snprintf(lbuf, MSG_BUF_LEN,
_(" line=%ld id=%d%s name=%s priority=%d"), _(" line=%" PRIdLINENR " id=%d%s name=%s priority=%d"),
(long)sign->se_lnum, sign->se_id, group, sign->se_lnum, sign->se_id, group,
sign_typenr2name(sign->se_typenr), sign->se_priority); sign_typenr2name(sign->se_typenr), sign->se_priority);
msg_puts(lbuf); msg_puts(lbuf);
msg_putchar('\n'); msg_putchar('\n');
@ -1622,7 +1620,7 @@ static void sign_get_placed_in_buf(buf_T *buf, linenr_T lnum, int sign_id, const
d = tv_dict_alloc(); d = tv_dict_alloc();
tv_list_append_dict(retlist, d); tv_list_append_dict(retlist, d);
tv_dict_add_nr(d, S_LEN("bufnr"), (long)buf->b_fnum); tv_dict_add_nr(d, S_LEN("bufnr"), buf->b_fnum);
l = tv_list_alloc(kListLenMayKnow); l = tv_list_alloc(kListLenMayKnow);
tv_dict_add_list(d, S_LEN("signs"), l); tv_dict_add_list(d, S_LEN("signs"), l);

2
src/nvim/spell.c
View File

@ -2683,7 +2683,7 @@ void ex_spellrepall(exarg_T *eap)
sub_nlines = 0; sub_nlines = 0;
curwin->w_cursor.lnum = 0; curwin->w_cursor.lnum = 0;
while (!got_int) { while (!got_int) {
if (do_search(NULL, '/', '/', frompat, 1L, SEARCH_KEEP, NULL) == 0 if (do_search(NULL, '/', '/', frompat, 1, SEARCH_KEEP, NULL) == 0
|| u_save_cursor() == FAIL) { || u_save_cursor() == FAIL) {
break; break;
} }

4
src/nvim/spellsuggest.c
View File

@ -234,7 +234,7 @@ enum {
PFD_NOTSPECIAL = 0xfd, // highest value that's not special PFD_NOTSPECIAL = 0xfd, // highest value that's not special
}; };
static long spell_suggest_timeout = 5000; static int spell_suggest_timeout = 5000;
#ifdef INCLUDE_GENERATED_DECLARATIONS #ifdef INCLUDE_GENERATED_DECLARATIONS
# include "spellsuggest.c.generated.h" # include "spellsuggest.c.generated.h"
@ -806,7 +806,7 @@ static void spell_find_suggest(char *badptr, int badlen, suginfo_T *su, int maxc
spell_suggest_file(su, buf + 5); spell_suggest_file(su, buf + 5);
} else if (strncmp(buf, "timeout:", 8) == 0) { } else if (strncmp(buf, "timeout:", 8) == 0) {
// Limit the time searching for suggestions. // Limit the time searching for suggestions.
spell_suggest_timeout = atol(buf + 8); spell_suggest_timeout = atoi(buf + 8);
} else if (!did_intern) { } else if (!did_intern) {
// Use internal method once. // Use internal method once.
spell_suggest_intern(su, interactive); spell_suggest_intern(su, interactive);

8
src/nvim/statusline.c
View File

@ -558,7 +558,7 @@ void win_redr_ruler(win_T *wp)
// To avoid portability problems we use strlen() here. // To avoid portability problems we use strlen() here.
vim_snprintf(buffer, RULER_BUF_LEN, "%" PRId64 ",", vim_snprintf(buffer, RULER_BUF_LEN, "%" PRId64 ",",
(wp->w_buffer->b_ml.ml_flags & (wp->w_buffer->b_ml.ml_flags &
ML_EMPTY) ? (int64_t)0L : (int64_t)wp->w_cursor.lnum); ML_EMPTY) ? 0 : (int64_t)wp->w_cursor.lnum);
size_t len = strlen(buffer); size_t len = strlen(buffer);
col_print(buffer + len, RULER_BUF_LEN - len, col_print(buffer + len, RULER_BUF_LEN - len,
empty_line ? 0 : (int)wp->w_cursor.col + 1, empty_line ? 0 : (int)wp->w_cursor.col + 1,
@ -1514,7 +1514,7 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
num = (int)get_vim_var_nr(VV_LNUM); num = (int)get_vim_var_nr(VV_LNUM);
} }
} else { } else {
num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) ? 0L : wp->w_cursor.lnum; num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) ? 0 : wp->w_cursor.lnum;
} }
break; break;
@ -1594,8 +1594,8 @@ int build_stl_str_hl(win_T *wp, char *out, size_t outlen, char *fmt, char *opt_n
int l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL, int l = ml_find_line_or_offset(wp->w_buffer, wp->w_cursor.lnum, NULL,
false); false);
num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ? num = (wp->w_buffer->b_ml.ml_flags & ML_EMPTY) || l < 0 ?
0L : l + 1 + ((State & MODE_INSERT) == 0 && empty_line ? 0 : l + 1 + ((State & MODE_INSERT) == 0 && empty_line ?
0 : (int)wp->w_cursor.col); 0 : (int)wp->w_cursor.col);
break; break;
} }
case STL_BYTEVAL_X: case STL_BYTEVAL_X:

20
src/nvim/syntax.c
View File

@ -122,7 +122,7 @@ typedef struct state_item {
int si_end_idx; // group ID for end pattern or zero int si_end_idx; // group ID for end pattern or zero
int si_ends; // if match ends before si_m_endpos int si_ends; // if match ends before si_m_endpos
int si_attr; // attributes in this state int si_attr; // attributes in this state
long si_flags; // HL_HAS_EOL flag in this state, and int si_flags; // HL_HAS_EOL flag in this state, and
// HL_SKIP* for si_next_list // HL_SKIP* for si_next_list
int si_seqnr; // sequence number int si_seqnr; // sequence number
int si_cchar; // substitution character for conceal int si_cchar; // substitution character for conceal
@ -265,7 +265,7 @@ static lpos_T next_match_m_endpos; // position for end of next match
static lpos_T next_match_h_startpos; // pos. for highl. start of next match static lpos_T next_match_h_startpos; // pos. for highl. start of next match
static lpos_T next_match_h_endpos; // pos. for highl. end of next match static lpos_T next_match_h_endpos; // pos. for highl. end of next match
static int next_match_idx; // index of matched item static int next_match_idx; // index of matched item
static long next_match_flags; // flags for next match static int next_match_flags; // flags for next match
static lpos_T next_match_eos_pos; // end of start pattn (start region) static lpos_T next_match_eos_pos; // end of start pattn (start region)
static lpos_T next_match_eoe_pos; // pos. for end of end pattern static lpos_T next_match_eoe_pos; // pos. for end of end pattern
static int next_match_end_idx; // ID of group for end pattn or zero static int next_match_end_idx; // ID of group for end pattn or zero
@ -1209,7 +1209,7 @@ static synstate_T *store_current_state(void)
} }
for (i = 0; i < sp->sst_stacksize; i++) { for (i = 0; i < sp->sst_stacksize; i++) {
bp[i].bs_idx = CUR_STATE(i).si_idx; bp[i].bs_idx = CUR_STATE(i).si_idx;
bp[i].bs_flags = (int)CUR_STATE(i).si_flags; bp[i].bs_flags = CUR_STATE(i).si_flags;
bp[i].bs_seqnr = CUR_STATE(i).si_seqnr; bp[i].bs_seqnr = CUR_STATE(i).si_seqnr;
bp[i].bs_cchar = CUR_STATE(i).si_cchar; bp[i].bs_cchar = CUR_STATE(i).si_cchar;
bp[i].bs_extmatch = ref_extmatch(CUR_STATE(i).si_extmatch); bp[i].bs_extmatch = ref_extmatch(CUR_STATE(i).si_extmatch);
@ -1511,7 +1511,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
stateitem_T *cur_si, *sip = NULL; stateitem_T *cur_si, *sip = NULL;
int startcol; int startcol;
int endcol; int endcol;
long flags; int flags;
int cchar; int cchar;
int16_t *next_list; int16_t *next_list;
bool found_match; // found usable match bool found_match; // found usable match
@ -1884,7 +1884,7 @@ static int syn_current_attr(const bool syncing, const bool displaying, bool *con
current_attr = sip->si_attr; current_attr = sip->si_attr;
current_id = sip->si_id; current_id = sip->si_id;
current_trans_id = sip->si_trans_id; current_trans_id = sip->si_trans_id;
current_flags = (int)sip->si_flags; current_flags = sip->si_flags;
current_seqnr = sip->si_seqnr; current_seqnr = sip->si_seqnr;
current_sub_char = sip->si_cchar; current_sub_char = sip->si_cchar;
break; break;
@ -2114,7 +2114,7 @@ static void check_state_ends(void)
// handle next_list, unless at end of line and no "skipnl" or // handle next_list, unless at end of line and no "skipnl" or
// "skipempty" // "skipempty"
current_next_list = cur_si->si_next_list; current_next_list = cur_si->si_next_list;
current_next_flags = (int)cur_si->si_flags; current_next_flags = cur_si->si_flags;
if (!(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY)) if (!(current_next_flags & (HL_SKIPNL | HL_SKIPEMPTY))
&& syn_getcurline()[current_col] == NUL) { && syn_getcurline()[current_col] == NUL) {
current_next_list = NULL; current_next_list = NULL;
@ -2362,8 +2362,8 @@ static void pop_current_state(void)
/// @param end_endpos return: end of end pattern match /// @param end_endpos return: end of end pattern match
/// @param end_idx return: group ID for end pat. match, or 0 /// @param end_idx return: group ID for end pat. match, or 0
/// @param start_ext submatches from the start pattern /// @param start_ext submatches from the start pattern
static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_endpos, static void find_endpos(int idx, lpos_T *startpos, lpos_T *m_endpos, lpos_T *hl_endpos, int *flagsp,
long *flagsp, lpos_T *end_endpos, int *end_idx, reg_extmatch_T *start_ext) lpos_T *end_endpos, int *end_idx, reg_extmatch_T *start_ext)
{ {
colnr_T matchcol; colnr_T matchcol;
synpat_T *spp, *spp_skip; synpat_T *spp, *spp_skip;
@ -2700,7 +2700,7 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
} }
rmp->rmm_maxcol = (colnr_T)syn_buf->b_p_smc; rmp->rmm_maxcol = (colnr_T)syn_buf->b_p_smc;
long r = vim_regexec_multi(rmp, syn_win, syn_buf, lnum, col, syn_tm, &timed_out); int r = vim_regexec_multi(rmp, syn_win, syn_buf, lnum, col, syn_tm, &timed_out);
if (l_syn_time_on) { if (l_syn_time_on) {
pt = profile_end(pt); pt = profile_end(pt);
@ -2737,7 +2737,7 @@ static int syn_regexec(regmmatch_T *rmp, linenr_T lnum, colnr_T col, syn_time_T
/// @param cur_si item at the top of the stack /// @param cur_si item at the top of the stack
/// @param ccharp conceal substitution char /// @param ccharp conceal substitution char
static int check_keyword_id(char *const line, const int startcol, int *const endcolp, static int check_keyword_id(char *const line, const int startcol, int *const endcolp,
long *const flagsp, int16_t **const next_listp, int *const flagsp, int16_t **const next_listp,
stateitem_T *const cur_si, int *const ccharp) stateitem_T *const cur_si, int *const ccharp)
{ {
// Find first character after the keyword. First character was already // Find first character after the keyword. First character was already

4
src/nvim/tag.c
View File

@ -743,7 +743,7 @@ void do_tag(char *tag, int type, int count, int forceit, int verbose)
} }
if (ic && !msg_scrolled && msg_silent == 0) { if (ic && !msg_scrolled && msg_silent == 0) {
ui_flush(); ui_flush();
os_delay(1007L, true); os_delay(1007, true);
} }
} }
@ -3014,7 +3014,7 @@ static int jumpto_tag(const char *lbuf_arg, int forceit, int keep_help)
msg(_("E435: Couldn't find tag, just guessing!"), 0); msg(_("E435: Couldn't find tag, just guessing!"), 0);
if (!msg_scrolled && msg_silent == 0) { if (!msg_scrolled && msg_silent == 0) {
ui_flush(); ui_flush();
os_delay(1010L, true); os_delay(1010, true);
} }
} }
retval = OK; retval = OK;

30
src/nvim/textobject.c
View File

@ -571,7 +571,7 @@ static void find_first_blank(pos_T *posp)
static void findsent_forward(int count, bool at_start_sent) static void findsent_forward(int count, bool at_start_sent)
{ {
while (count--) { while (count--) {
findsent(FORWARD, 1L); findsent(FORWARD, 1);
if (at_start_sent) { if (at_start_sent) {
find_first_blank(&curwin->w_cursor); find_first_blank(&curwin->w_cursor);
} }
@ -612,7 +612,7 @@ int current_word(oparg_T *oap, int count, bool include, bool bigword)
// (" word"), or start is not on white space, and white space should // (" word"), or start is not on white space, and white space should
// not be included ("word"), find end of word. // not be included ("word"), find end of word.
if ((cls() == 0) == include) { if ((cls() == 0) == include) {
if (end_word(1L, bigword, true, true) == FAIL) { if (end_word(1, bigword, true, true) == FAIL) {
return FAIL; return FAIL;
} }
} else { } else {
@ -621,7 +621,7 @@ int current_word(oparg_T *oap, int count, bool include, bool bigword)
// space should not be included (" "), find start of word. // space should not be included (" "), find start of word.
// If we end up in the first column of the next line (single char // If we end up in the first column of the next line (single char
// word) back up to end of the line. // word) back up to end of the line.
fwd_word(1L, bigword, true); fwd_word(1, bigword, true);
if (curwin->w_cursor.col == 0) { if (curwin->w_cursor.col == 0) {
decl(&curwin->w_cursor); decl(&curwin->w_cursor);
} else { } else {
@ -653,11 +653,11 @@ int current_word(oparg_T *oap, int count, bool include, bool bigword)
return FAIL; return FAIL;
} }
if (include != (cls() != 0)) { if (include != (cls() != 0)) {
if (bck_word(1L, bigword, true) == FAIL) { if (bck_word(1, bigword, true) == FAIL) {
return FAIL; return FAIL;
} }
} else { } else {
if (bckend_word(1L, bigword, true) == FAIL) { if (bckend_word(1, bigword, true) == FAIL) {
return FAIL; return FAIL;
} }
(void)incl(&curwin->w_cursor); (void)incl(&curwin->w_cursor);
@ -668,7 +668,7 @@ int current_word(oparg_T *oap, int count, bool include, bool bigword)
return FAIL; return FAIL;
} }
if (include != (cls() == 0)) { if (include != (cls() == 0)) {
if (fwd_word(1L, bigword, true) == FAIL && count > 1) { if (fwd_word(1, bigword, true) == FAIL && count > 1) {
return FAIL; return FAIL;
} }
// If end is just past a new-line, we don't want to include // If end is just past a new-line, we don't want to include
@ -678,7 +678,7 @@ int current_word(oparg_T *oap, int count, bool include, bool bigword)
inclusive = false; inclusive = false;
} }
} else { } else {
if (end_word(1L, bigword, true, true) == FAIL) { if (end_word(1, bigword, true, true) == FAIL) {
return FAIL; return FAIL;
} }
} }
@ -737,7 +737,7 @@ int current_sent(oparg_T *oap, int count, bool include)
start_pos = curwin->w_cursor; start_pos = curwin->w_cursor;
pos = start_pos; pos = start_pos;
findsent(FORWARD, 1L); // Find start of next sentence. findsent(FORWARD, 1); // Find start of next sentence.
// When the Visual area is bigger than one character: Extend it. // When the Visual area is bigger than one character: Extend it.
if (VIsual_active && !equalpos(start_pos, VIsual)) { if (VIsual_active && !equalpos(start_pos, VIsual)) {
@ -759,12 +759,12 @@ extend:
incl(&pos); incl(&pos);
} }
if (!at_start_sent) { if (!at_start_sent) {
findsent(BACKWARD, 1L); findsent(BACKWARD, 1);
if (equalpos(curwin->w_cursor, start_pos)) { if (equalpos(curwin->w_cursor, start_pos)) {
at_start_sent = true; // exactly at start of sentence at_start_sent = true; // exactly at start of sentence
} else { } else {
// inside a sentence, go to its end (start of next) // inside a sentence, go to its end (start of next)
findsent(FORWARD, 1L); findsent(FORWARD, 1);
} }
} }
if (include) { // "as" gets twice as much as "is" if (include) { // "as" gets twice as much as "is"
@ -776,7 +776,7 @@ extend:
} }
c = gchar_cursor(); c = gchar_cursor();
if (!at_start_sent || (!include && !ascii_iswhite(c))) { if (!at_start_sent || (!include && !ascii_iswhite(c))) {
findsent(BACKWARD, 1L); findsent(BACKWARD, 1);
} }
at_start_sent = !at_start_sent; at_start_sent = !at_start_sent;
} }
@ -799,7 +799,7 @@ extend:
incl(&pos); incl(&pos);
} }
if (at_start_sent) { // in the sentence if (at_start_sent) { // in the sentence
findsent(BACKWARD, 1L); findsent(BACKWARD, 1);
} else { // in/before white before a sentence } else { // in/before white before a sentence
curwin->w_cursor = start_pos; curwin->w_cursor = start_pos;
} }
@ -826,7 +826,7 @@ extend:
find_first_blank(&start_pos); // go back to first blank find_first_blank(&start_pos); // go back to first blank
} else { } else {
start_blank = false; start_blank = false;
findsent(BACKWARD, 1L); findsent(BACKWARD, 1);
start_pos = curwin->w_cursor; start_pos = curwin->w_cursor;
} }
if (include) { if (include) {
@ -1146,7 +1146,7 @@ again:
if (do_searchpair("<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)", if (do_searchpair("<[^ \t>/!]\\+\\%(\\_s\\_[^>]\\{-}[^/]>\\|$\\|\\_s\\=>\\)",
"", "",
"</[^>]*>", BACKWARD, NULL, 0, "</[^>]*>", BACKWARD, NULL, 0,
NULL, (linenr_T)0, 0L) <= 0) { NULL, (linenr_T)0, 0) <= 0) {
curwin->w_cursor = old_pos; curwin->w_cursor = old_pos;
goto theend; goto theend;
} }
@ -1172,7 +1172,7 @@ again:
"<%.*s\\>\\%%(\\_s\\_[^>]\\{-}\\_[^/]>\\|\\_s\\?>\\)\\c", len, p); "<%.*s\\>\\%%(\\_s\\_[^>]\\{-}\\_[^/]>\\|\\_s\\?>\\)\\c", len, p);
snprintf(epat, epat_len, "</%.*s>\\c", len, p); snprintf(epat, epat_len, "</%.*s>\\c", len, p);
const int r = (int)do_searchpair(spat, "", epat, FORWARD, NULL, 0, NULL, (linenr_T)0, 0L); const int r = do_searchpair(spat, "", epat, FORWARD, NULL, 0, NULL, (linenr_T)0, 0);
xfree(spat); xfree(spat);
xfree(epat); xfree(epat);

6
src/nvim/undo.c
View File

@ -2009,7 +2009,7 @@ void undo_time(int step, bool sec, bool file, bool absolute)
} }
} }
} }
long closest_start = closest; int closest_start = closest;
int closest_seq = curbuf->b_u_seq_cur; int closest_seq = curbuf->b_u_seq_cur;
int mark; int mark;
int nomark = 0; // shut up compiler int nomark = 0; // shut up compiler
@ -2611,7 +2611,7 @@ static void u_undo_end(bool did_undo, bool absolute, bool quiet)
u_oldcount < 0 ? (int64_t)-u_oldcount : (int64_t)u_oldcount, u_oldcount < 0 ? (int64_t)-u_oldcount : (int64_t)u_oldcount,
_(msgstr), _(msgstr),
did_undo ? _("before") : _("after"), did_undo ? _("before") : _("after"),
uhp == NULL ? (int64_t)0L : (int64_t)uhp->uh_seq, uhp == NULL ? 0 : (int64_t)uhp->uh_seq,
msgbuf); msgbuf);
} }
@ -2622,7 +2622,7 @@ void undo_fmt_time(char *buf, size_t buflen, time_t tt)
struct tm curtime; struct tm curtime;
os_localtime_r(&tt, &curtime); os_localtime_r(&tt, &curtime);
size_t n; size_t n;
if (time(NULL) - tt < (60L * 60L * 12L)) { if (time(NULL) - tt < (60 * 60 * 12)) {
// within 12 hours // within 12 hours
n = strftime(buf, buflen, "%H:%M:%S", &curtime); n = strftime(buf, buflen, "%H:%M:%S", &curtime);
} else { } else {

8
src/nvim/window.c
View File

@ -4079,7 +4079,7 @@ static int win_alloc_firstwin(win_T *oldwin)
if (oldwin == NULL) { if (oldwin == NULL) {
// Very first window, need to create an empty buffer for it and // Very first window, need to create an empty buffer for it and
// initialize from scratch. // initialize from scratch.
curbuf = buflist_new(NULL, NULL, 1L, BLN_LISTED); curbuf = buflist_new(NULL, NULL, 1, BLN_LISTED);
if (curbuf == NULL) { if (curbuf == NULL) {
return FAIL; return FAIL;
} }
@ -6458,7 +6458,7 @@ void win_drag_vsep_line(win_T *dragwin, int offset)
redraw_all_later(UPD_NOT_VALID); redraw_all_later(UPD_NOT_VALID);
} }
#define FRACTION_MULT 16384L #define FRACTION_MULT 16384
// Set wp->w_fraction for the current w_wrow and w_height. // Set wp->w_fraction for the current w_wrow and w_height.
// Has no effect when the window is less than two lines. // Has no effect when the window is less than two lines.
@ -6468,7 +6468,7 @@ void set_fraction(win_T *wp)
// When cursor is in the first line the percentage is computed as if // When cursor is in the first line the percentage is computed as if
// it's halfway that line. Thus with two lines it is 25%, with three // it's halfway that line. Thus with two lines it is 25%, with three
// lines 17%, etc. Similarly for the last line: 75%, 83%, etc. // lines 17%, etc. Similarly for the last line: 75%, 83%, etc.
wp->w_fraction = (int)(wp->w_wrow * FRACTION_MULT + FRACTION_MULT / 2) / wp->w_height_inner; wp->w_fraction = (wp->w_wrow * FRACTION_MULT + FRACTION_MULT / 2) / wp->w_height_inner;
} }
} }
@ -6619,7 +6619,7 @@ void scroll_to_fraction(win_T *wp, int prev_height)
if (lnum < 1) { // can happen when starting up if (lnum < 1) { // can happen when starting up
lnum = 1; lnum = 1;
} }
wp->w_wrow = (int)(wp->w_fraction * height - 1L) / FRACTION_MULT; wp->w_wrow = (wp->w_fraction * height - 1) / FRACTION_MULT;
int line_size = plines_win_col(wp, lnum, wp->w_cursor.col) - 1; int line_size = plines_win_col(wp, lnum, wp->w_cursor.col) - 1;
int sline = wp->w_wrow - line_size; int sline = wp->w_wrow - line_size;

4
src/xdiff/xdiff.h vendored
View File

@ -69,12 +69,12 @@ extern "C" {
typedef struct s_mmfile { typedef struct s_mmfile {
char *ptr; char *ptr;
long size; int size;
} mmfile_t; } mmfile_t;
typedef struct s_mmbuffer { typedef struct s_mmbuffer {
char *ptr; char *ptr;
long size; int size;
} mmbuffer_t; } mmbuffer_t;
typedef struct s_xpparam { typedef struct s_xpparam {